ChessTDD 33: Scenario Housekeeping
Having fixed some bugs in the last few episodes, it would have been nice to make some progress with functionality, but there was housekeeping to be done first. I did some refactoring for board setup using the tables, compacting methods, and made the implementation of the moves checker correct. This will put me on much more sustainable ground as I go forward implementing game scenarios.
What I accomplish in this clip:
- Fixed incorrect/incomplete implementation of checking for moves.
- Refactored BuildBoardFromTable method.
Here are some lessons to take away:
- When you make a test go red, don’t then take the opportunity to do a refactoring — even a small or inconsequential one. Â Go back to green and then do it. Â You want to be taking actions in batches as small as possible. Â Doing 2 things at once is a recipe for confusing cause and effect.
- I’m not sure how others feel about this, but I did something in this video that I do from time to time. Â I had a green test covering an implementation that was too permissive — too easy to get right. Â So I altered the test temporarily to green in a situation where it should have been red. Â I then modified the production code to get the expected red, then reverted the test and verified that it was green. Â This is the equivalent of writing another test, framed in the negative, and then taking that test from red to green. Â I shortcutted that process because I didn’t want that other test to be left around when I was done.
- I consider baking the names of types into class, method, and variable names to be a bad practice. Â You might change the type they use and forget to update the name accordingly, and you’re also leaking implementation details.
- A refactoring may well never seem perfect to you. Â If you make sure it seems cleaner or better as compared to where it was, that’s progress. Â Stick a pin it it and make a note to revisit later. Â Not only is this good for avoiding diminishing returns on a given day’s effort, but it also removes you from the problem so that you can better assess readability later.

I use the CollectionAssert class quite a bit, so I understand your struggles with it. The confusion arises when you give it an IEnumerable when it expects an ICollection. Although I never really understood it, this may be one of those covariant/contravariant issues.
For AreEquivalent(), think sets — the order isn’t important. For AreEqual(), the order must match.
Also, I think you meant “indices” instead of “indeces”. 🙂 Thanks for sharing!
Investigating that (the problem with comparing those two different types) might make for an interesting blog post 😀 You ought to dig into it (I say selfishly).