The smallest first step I can think of for this story is to add the add button to the songs window and make sure it opens the add song window. I don't really know how to do this, so I start by having a look at the production code where I expect to create and open the window.
public class SongsShower { // ... public void Show() { View.Songs = new ReadOnlyCollection<Song>( new List<Song>()); View.OnCloseButtonClick += View.CloseView; View.OnAddButtonClick += OnAddButtonClick; View.ShowView(); } private void OnAddButtonClick() { var view = new AddSongView(); view.ShowView(); } }There will probably be an event, called OnAddButtonClick, on the view that is raised when the button is clicked. I subscribe to it in the same way as I subscribe to the OnCloseButtonClick event but add a method with the same name as the event to handle it. The method creates the view and shows it.
The problem with this code is that I create an AddSongView, something that should be done in production, but not when running the tests. In the tests I would like an AddSongViewFake to be created. I won't even mention the possibility of using if to specify the behavior, since we know by now that that's not a good thing.
With the SongsView, I created the view in the setup code and injected it into the Application class constructor. I can't do that for the AddSongView, though, since the view should not be created until the user clicks the add button. So I have to find a different solution for this view.
What I will do is to inject the behavior, just like I've done before with the showAction and closeAction. But this time, instead of passing a delegate, I will use a Factory class that creates the view for me. When running the tests, the factory will create the fake view, and otherwise the real view.
public class SongsShower { private IAddSongViewFactory AddSongViewFactory { get; set; } // ... private void OnAddButtonClick() { var view = AddSongViewFactory.Create(); view.ShowView(); } }The factory is an interface that has different implementations in test and production, just like the views.
public interface IAddSongViewFactory { IAddSongView Create(); }Now I just have to pass the factory into the SongsShower in some way. I need to have a look at what classes I have to see what I can do.
When running the tests I want a fake factory, and this I can create in the ApplicationFake. The real one I can create in Program. This means that I need to pass the factory though the Application class to the SongsShower.
I revert the sketched code and then I create the factory and pass it in to the SongsShower.
public class ApplicationFake { // ... public void Start(Action<SongsViewFake> showAction) { var addSongViewFactory = new AddSongViewFactoryFake(); var view = new SongsViewFake(showAction); var application = new Application(view, CloseAction, addSongViewFactory); application.Start(); } } public class AddSongViewFactoryFake : IAddSongViewFactory { ... } public static class Program { [STAThread] public static void Main() { // ... var songsView = new SongsView(); Action<ApplicationContext> closeAction = ac => ac.ExitThread(); var addSongViewFactory = new AddSongViewFactory(); var application = new Application(songsView, closeAction, addSongViewFactory); // ... } } public class AddSongViewFactory : IAddSongViewFactory { ... } public class Application : ApplicationContext { // ... private IAddSongViewFactory AddSongViewFactory { get; set; } public Application(ISongsView view, Action<ApplicationContext> closeAction, IAddSongViewFactory addSongViewFactory) { // ... AddSongViewFactory = addSongViewFactory; } public void Start() { View.OnViewClosed += () => CloseAction( this ); new SongsShower(View, AddSongViewFactory).Show(); } } public class SongsShower { private IAddSongViewFactory AddSongViewFactory { get; set; } // ... public SongsShower(ISongsView view, IAddSongViewFactory addSongViewFactory) { View = view; AddSongViewFactory = addSongViewFactory; } // ... }The code still compiles and the tests are green. And now that I have wired up the customization of what view is created, I start looking at what the new test should look like.
[Test] public void Click_add_button_opens_add_song_window() { Application .Start(view => { var hasBeenShown = false; view.ClickAddButton(addView => { hasBeenShown = true; }); Assert.That(hasBeenShown, Is.True); view.ClickCloseButton(); }); }The pattern is the same as when verifying that the songs window opens, that is, set the variable hasBeenShown to true in the showAction. The ClickAddButton() method takes a showAction parameter that specifies what should happen when the AddSongViewFake is shown, just like the Start() method does for the SongsViewFake.
Next, I add the ClickAddButton() method to the fake and raise an OnAddButtonClick event in it.
public class SongsViewFake : ISongsView { public event Action OnAddButtonClick; // ... public void ClickAddButton(Action<AddSongViewFake> showAction) { OnAddButtonClick.Raise(); } }This looks good, except for that I don't use the showAction parameter. In some way, the parameter should be passed on from the SongsViewFake into the AddSongViewFake so that it can execute it in its ShowView() method. The AddSongViewFake is created by the AddSongViewFactoryFake, so that's probably a good candidate for handling the passing of showAction. And lucky for me, both the SongsViewFake and the AddSongViewFactoryFake are created by the ApplicationFake, so it is easy to connect the two.
Did I just use the word luck? I think I did… As we shall see, I will be lucky with these kinds of things most of the time, so luck is probably not the correct word. Rather, constantly improving the design, using the tests as a guide and protection, the pieces almost always line up in a pleasant way.
public class ApplicationFake { // ... public void Start(Action<SongsViewFake> showAction) { var addSongViewFactory = new AddSongViewFactoryFake(); var view = new SongsViewFake(showAction, addSongViewFactory); var application = new Application(view, CloseAction, addSongViewFactory); application.Start(); } }I pass the factory into the SongsViewFake, and now it can tell the factory what showAction to use when creating the AddSongViewFake.
public class AddSongViewFactoryFake : IAddSongViewFactory { public Action<AddSongViewFake> ShowAction { get; set; } public IAddSongView Create() { return new AddSongViewFake(ShowAction); } } public class SongsViewFake : ISongsView { public AddSongViewFactoryFake AddSongViewFactory { get; set; } // ... public SongsViewFake(Action<SongsViewFake> showAction, AddSongViewFactoryFake addSongViewFactory) { AddSongViewFactory = addSongViewFactory; // ... } // ... public void ClickAddButton(Action<AddSongViewFake> showAction) { AddSongViewFactory.ShowAction = showAction; OnAddButtonClick.Raise(); } }And implementing the AddSongViewFake I follow the same pattern as the SongsViewFake.
public class AddSongViewFake : IAddSongView { private Action<AddSongViewFake> ShowAction { get; set; } public AddSongViewFake(Action<AddSongViewFake> showAction) { ShowAction = showAction; } public void ShowView() { ShowAction( this ); } }The code compiles, so I can run the new test, and it fails for what is by now a well-known reason.
There are no subscribers to the event, so I start by subscribing to the event.
public class SongsShower { // ... public void Show() { View.Songs = new ReadOnlyCollection<Song>( new List<Song>()); View.OnCloseButtonClick += View.CloseView; View.OnAddButtonClick += OnAddButtonClick; View.ShowView(); } private void OnAddButtonClick() { } }And now I get another failure message.
Just as expected: the view is never opened. Finally, I create and show the view.
public class SongsShower { // ... private void OnAddButtonClick() { var view = AddSongViewFactory.Create(); view.ShowView(); } }And the test is green. Now the only thing left to do is to write the code in the real views.
public partial class SongsView : Form, ISongsView { public event Action OnAddButtonClick; // ... private void AddButtonClick( object sender, EventArgs e) { OnAddButtonClick.Raise(); } } public class AddSongViewFactory : IAddSongViewFactory { public IAddSongView Create() { return new AddSongView(); } } public partial class AddSongView : Form, IAddSongView { public AddSongView() { InitializeComponent(); } public void ShowView() { ShowDialog(); } }Running the application works fine. The add song window opens when clicking the add button, just as expected.
As always when adding new features, things happen with the code that I don't like. Here are a few things.
- I don't like the
hasBeenShownflag. The tests that include it are ugly, and I would like to see what I can do about it. - The
Applicationclass has a reference toAddSongViewFactoryonly to pass it on as a parameter toSongsShower. - There's an asymmetry in the views. The
AddSongViewhas a factory while theSongsViewdoes not. On the other hand,SongsViewhasSongsShowerwhileAddSongViewdoes not.
Since I can't take care of these things all at once, I write them down on small index cards, one item per card. I find it to be a very handy way to keep track of my todo tasks. It allows me to prioritize the tasks, give one to a colleague and put it on the Scrum/Kanban/whatever board. Also, when I'm done with a task I can throw the card away. If I write all todos on the same paper I can check an item as done, but it will always be there together with my unfinished tasks until the day I can throw the whole paper away.
I check in my code, getting ready for the next challenge, which is the first todo note.