public class EnableArtistTrackActionSpecs
{
    private readonly Playlist playlistFake;
    private readonly ArtistTrack trackToEnable;
 
    public EnableArtistTrackActionSpecs()
    {
        playlistFake = new Playlist();
        trackToEnable = MockRepository.GenerateStub<ArtistTrack>();
    }
 
    private ArtistTrackEnabler GetArtistTrackEnabler(IPlaylistRepository playlists)
    {
        ArtistTrackEnabler.FileDoesNotExist = (track) =>
        {
            return false;
        };
 
        return new ArtistTrackEnabler(playlists); 
    }
 
    [Test]
    public void Execute_GivenDisabledArtistTrack_ShouldMeetEnabledCriteria()
    {
        IPlaylistRepository playlists = MockRepository.GenerateStub<IPlaylistRepository>();
        ArtistTrackEnabler sut = GetArtistTrackEnabler(playlists);
 
        int initialTrackCount = playlistFake.Tracks.Count;
 
        sut.Enable(trackToEnable, playlistFake);
 
        int resultingTrackCount = playlistFake.Tracks.Count;
 
        Assert.AreEqual(initialTrackCount + 1, resultingTrackCount);
    }
 
    [Test]
    public void Execute_GivenDisabledArtistTrack_ShouldCallUpdateOnPlaylistRepository()
    {
        IPlaylistRepository playlists = MockRepository.GenerateMock<IPlaylistRepository>();
        ArtistTrackEnabler sut = GetArtistTrackEnabler(playlists);
 
        sut.Enable(trackToEnable, playlistFake);
 
        playlists.AssertWasCalled(p => p.Update(playlistFake));
    }
 
    [Test]
    public void Execute_GivenTrackWhereFileDoesNotExist_ShouldNotAddTrackToPlaylist()
    {
        ArtistTrackEnabler sut = GetArtistTrackEnabler(null);
 
        ArtistTrackEnabler.FileDoesNotExist = (track) =>
        {
            return true;
        };
 
        int initialTrackCount = playlistFake.Tracks.Count;
 
        sut.Enable(trackToEnable, playlistFake);
 
        int resultingTrackCount = playlistFake.Tracks.Count;
 
        Assert.AreEqual(initialTrackCount, resultingTrackCount);            
    }
}
 
public class ArtistTrackEnabler
{
    private readonly IPlaylistRepository playlists;
 
    public ArtistTrackEnabler()
        : this(IoC.Resolve<IPlaylistRepository>())
    {
        
    }
 
    public static Func<ArtistTrack, bool> FileDoesNotExist = (track) =>
    {
        var pathToFile = Locate.File(track.FileName)
            .Of(FileType.Audio).In(Location.Local)
            .For(track.Artist);
 
        return !File.Exists(pathToFile);
    };
 
    public ArtistTrackEnabler(IPlaylistRepository playlists)
    {
        this.playlists = playlists;
    }
 
    public void Enable(ArtistTrack track, Playlist playlist)
    {
        if (TrackDoesNotPassEnablingCriteria(track))
            return;
 
        playlist.Add(track);
        playlists.Update(playlist);
    }
 
    public virtual bool TrackDoesNotPassEnablingCriteria(ArtistTrack track)
    {
        if (FileDoesNotExist(track))
            return true;
 
        // Going to be adding more here... Specification pattern and inject criteria?
        return false;
    }
}