added test for command executed event

NzbDrone.Core.Test/Messaging/Commands/CommandEqualityComparerFixture.cs

@@ -0,0 +1,75 @@
+using FluentAssertions;
+using NUnit.Framework;
+using NzbDrone.Core.IndexerSearch;
+using NzbDrone.Core.MediaFiles.Commands;
+using NzbDrone.Core.Messaging.Commands;
+
+namespace NzbDrone.Core.Test.Messaging.Commands
+{
+    [TestFixture]
+    public class CommandEqualityComparerFixture
+    {
+        [Test]
+        public void should_return_true_when_there_are_no_properties()
+        {
+            var command1 = new DownloadedEpisodesScanCommand();
+            var command2 = new DownloadedEpisodesScanCommand();
+
+            CommandEqualityComparer.Instance.Equals(command1, command2).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_when_single_property_matches()
+        {
+            var command1 = new EpisodeSearchCommand { EpisodeId = 1 };
+            var command2 = new EpisodeSearchCommand { EpisodeId = 1 };
+
+            CommandEqualityComparer.Instance.Equals(command1, command2).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_true_when_multiple_properties_match()
+        {
+            var command1 = new SeasonSearchCommand { SeriesId = 1, SeasonNumber = 1 };
+            var command2 = new SeasonSearchCommand { SeriesId = 1, SeasonNumber = 1 };
+
+            CommandEqualityComparer.Instance.Equals(command1, command2).Should().BeTrue();
+        }
+
+        [Test]
+        public void should_return_false_when_single_property_doesnt_match()
+        {
+            var command1 = new EpisodeSearchCommand { EpisodeId = 1 };
+            var command2 = new EpisodeSearchCommand { EpisodeId = 2 };
+
+            CommandEqualityComparer.Instance.Equals(command1, command2).Should().BeFalse();
+        }
+
+        [Test]
+        public void should_return_false_when_only_one_property_matches()
+        {
+            var command1 = new SeasonSearchCommand { SeriesId = 1, SeasonNumber = 1 };
+            var command2 = new SeasonSearchCommand { SeriesId = 1, SeasonNumber = 2 };
+
+            CommandEqualityComparer.Instance.Equals(command1, command2).Should().BeFalse();
+        }
+
+        [Test]
+        public void should_return_false_when_no_properties_match()
+        {
+            var command1 = new SeasonSearchCommand { SeriesId = 1, SeasonNumber = 1 };
+            var command2 = new SeasonSearchCommand { SeriesId = 2, SeasonNumber = 2 };
+
+            CommandEqualityComparer.Instance.Equals(command1, command2).Should().BeFalse();
+        }
+
+        [Test]
+        public void should_return_false_when_only_one_has_properties()
+        {
+            var command1 = new SeasonSearchCommand();
+            var command2 = new SeasonSearchCommand { SeriesId = 2, SeasonNumber = 2 };
+
+            CommandEqualityComparer.Instance.Equals(command1, command2).Should().BeFalse();
+        }
+    }
+}

NzbDrone.Core.Test/Messaging/Commands/CommandExecutorFixture.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using Moq;
+using NUnit.Framework;
+using NzbDrone.Common;
+using NzbDrone.Core.Messaging.Commands;
+using NzbDrone.Core.Messaging.Commands.Tracking;
+using NzbDrone.Core.Messaging.Events;
+using NzbDrone.Test.Common;
+
+namespace NzbDrone.Core.Test.Messaging.Commands
+{
+    [TestFixture]
+    public class CommandExecutorFixture : TestBase<CommandExecutor>
+    {
+        private Mock<IExecute<CommandA>> _executorA;
+        private Mock<IExecute<CommandB>> _executorB;
+
+        [SetUp]
+        public void Setup()
+        {
+            _executorA = new Mock<IExecute<CommandA>>();
+            _executorB = new Mock<IExecute<CommandB>>();
+
+            Mocker.GetMock<IServiceFactory>()
+                  .Setup(c => c.Build(typeof(IExecute<CommandA>)))
+                  .Returns(_executorA.Object);
+
+            Mocker.GetMock<IServiceFactory>()
+                  .Setup(c => c.Build(typeof(IExecute<CommandB>)))
+                  .Returns(_executorB.Object);
+
+
+            Mocker.GetMock<ITrackCommands>()
+                  .Setup(c => c.FindExisting(It.IsAny<Command>()))
+                  .Returns<Command>(null);
+        }
+
+        [Test]
+        public void should_publish_command_to_executor()
+        {
+            var commandA = new CommandA();
+
+            Subject.PublishCommand(commandA);
+
+            _executorA.Verify(c => c.Execute(commandA), Times.Once());
+        }
+
+        [Test]
+        public void should_publish_command_by_with_optional_arg_using_name()
+        {
+            Mocker.GetMock<IServiceFactory>().Setup(c => c.GetImplementations(typeof(Command)))
+                  .Returns(new List<Type> { typeof(CommandA), typeof(CommandB) });
+
+            Subject.PublishCommand(typeof(CommandA).FullName);
+            _executorA.Verify(c => c.Execute(It.IsAny<CommandA>()), Times.Once());
+        }
+
+
+        [Test]
+        public void should_not_publish_to_incompatible_executor()
+        {
+            var commandA = new CommandA();
+
+            Subject.PublishCommand(commandA);
+
+            _executorA.Verify(c => c.Execute(commandA), Times.Once());
+            _executorB.Verify(c => c.Execute(It.IsAny<CommandB>()), Times.Never());
+        }
+
+        [Test]
+        public void broken_executor_should_throw_the_exception()
+        {
+            var commandA = new CommandA();
+
+            _executorA.Setup(c => c.Execute(It.IsAny<CommandA>()))
+                       .Throws(new NotImplementedException());
+
+            Assert.Throws<NotImplementedException>(() => Subject.PublishCommand(commandA));
+        }
+
+
+        [Test]
+        public void broken_executor_should_publish_executed_event()
+        {
+            var commandA = new CommandA();
+
+            _executorA.Setup(c => c.Execute(It.IsAny<CommandA>()))
+                       .Throws(new NotImplementedException());
+
+            Assert.Throws<NotImplementedException>(() => Subject.PublishCommand(commandA));
+
+            VerifyEventPublished<CommandExecutedEvent>();
+        }
+
+        [Test]
+        public void should_publish_executed_event_on_success()
+        {
+            var commandA = new CommandA();
+            Subject.PublishCommand(commandA);
+
+            VerifyEventPublished<CommandExecutedEvent>();
+        }
+    }
+
+    public class CommandA : Command
+    {
+        public CommandA(int id = 0)
+        {
+        }
+    }
+
+    public class CommandB : Command
+    {
+
+        public CommandB()
+        {
+        }
+    }
+
+}

NzbDrone.Core.Test/Messaging/Commands/CommandFixture.cs

@@ -0,0 +1,19 @@
+using FluentAssertions;
+using NUnit.Framework;
+using NzbDrone.Core.Update.Commands;
+
+namespace NzbDrone.Core.Test.Messaging.Commands
+{
+    [TestFixture]
+    public class CommandFixture
+    {
+        [Test]
+        public void default_values()
+        {
+            var command = new ApplicationUpdateCommand();
+
+            command.Id.Should().NotBe(0);
+            command.Name.Should().Be("ApplicationUpdate");
+        }
+    }
+}

NzbDrone.Core.Test/NzbDrone.Core.Test.csproj

@@ -147,6 +147,9 @@
     <Compile Include="MediaFiles\ImportApprovedEpisodesFixture.cs" />
     <Compile Include="MediaFiles\MediaFileTableCleanupServiceFixture.cs" />
     <Compile Include="MediaFiles\MediaFileRepositoryFixture.cs" />
+    <Compile Include="Messaging\Commands\CommandEqualityComparerFixture.cs" />
+    <Compile Include="Messaging\Commands\CommandExecutorFixture.cs" />
+    <Compile Include="Messaging\Commands\CommandFixture.cs" />
     <Compile Include="MetadataSourceTests\TraktProxyFixture.cs" />
     <Compile Include="NotificationTests\NotificationServiceFixture.cs" />
     <Compile Include="NotificationTests\Xbmc\GetJsonVersionFixture.cs" />