Beispiel #1
0
        public void preparing_updates_calls_proper_subsystems_publishes_msg_at_the_end()
        {
            // return the same - might stop working if some of the code is gonna be put to verify download };
            var modulePacakge = new ModulePackage {
                ModuleManifest = _moduleManifest
            };

            ModulesRepository.Setup(x => x.GetModule(It.Is <string>(y => y == _moduleName)))
            .Returns(modulePacakge)
            .Verifiable("This package should be downloaded");

            EventAggregator.Setup(x => x.Publish(It.IsAny <NomadUpdatesReadyMessage>()))
            .Callback <NomadUpdatesReadyMessage>(msg =>
            {
                Assert.IsFalse(msg.Error);
                Assert.AreEqual(1, msg.ModuleManifests.Count);
                Assert.AreSame(modulePacakge.ModuleManifest,
                               msg.ModuleManifests[0]);
            })
            .Returns(null)
            .Verifiable("This message should be published upon exit");

            NomadUpdater.PrepareUpdate(new List <ModuleManifest>()
            {
                _moduleManifest
            });

            EventAggregator.Verify();
            ModulesRepository.Verify();
            Assert.AreEqual(UpdaterStatus.Prepared, NomadUpdater.Status);
        }
Beispiel #2
0
        public void publishes_avaliable_modules_message_when_everything_is_ok()
        {
            const string assembly   = "test_assembly.dll";
            var          moduleInfo = new ModuleInfo(assembly);

            var moduleManifest = new ModuleManifest
            {
                ModuleName    = assembly,
                ModuleVersion = new Version("0.0.0.0")
            };

            var updateManifest = new ModuleManifest
            {
                ModuleName    = assembly,
                ModuleVersion = new Version("0.0.0.1")
            };

            ModuleDiscovery.Setup(x => x.GetModules()).Returns(new List <ModuleInfo>
            {
                moduleInfo
            });

            // FIXME: this should use internal manifest factory
            ModuleManifestFactory.Setup(x => x.GetManifest(It.Is <ModuleInfo>(y => y == moduleInfo)))
            .Returns(moduleManifest);


            EventAggregator.Setup(x => x.Publish(It.IsAny <NomadAvailableUpdatesMessage>()))
            .Callback <NomadAvailableUpdatesMessage>(msg =>
            {
                Assert.AreEqual(1,
                                msg.AvailableUpdates.
                                Count);
                Assert.AreEqual(updateManifest,
                                msg.AvailableUpdates.
                                First());
            })
            .Returns(null)
            .Verifiable("Message was not published");

            ModulesRepository
            .Setup(x => x.GetAvailableModules())
            .Returns(new AvailableModules
            {
                Manifests = new List <ModuleManifest> {
                    updateManifest
                }
            })
            .Verifiable("Get Avaliable modules has not been called");

            NomadUpdater.CheckUpdates();

            ModulesRepository.Verify();
            EventAggregator.Verify();
        }