public void Should_FirePropertyChanged_When_RefeshAsyncCompleted()
        {
            var modalmock    = MoqFactory.Create <IModalService>();
            var endpointMock = MoqFactory.Create <IWuEndpoint>(MockBehavior.Loose);
            var uovm         = new UpdateOverviewViewModel(modalmock.Object, endpointMock.Object);

            endpointMock.Setup(e => e.Updates).Returns(new[] { new UpdateDescription() });
            endpointMock.Setup(e => e.Settings).Returns(new WuSettings(0, 0, 0, false, true));
            endpointMock.Setup(e => e.FQDN).Returns("mock1");

            List <string> propertiesToFire = new List <string>()
            {
                nameof(uovm.Hostname),
                nameof(uovm.AutoAcceptEulas),
                nameof(uovm.AutoSelectUpdates),
                nameof(uovm.Updates)
            };

            uovm.PropertyChanged += (s, e) => {
                if (propertiesToFire.Contains(e.PropertyName))
                {
                    propertiesToFire.Remove(e.PropertyName);
                }
                else
                {
                    Assert.Fail($"Property changed event for unexpected property {e.PropertyName} was fired.");
                }
            };

            uovm.RefreshAsync().Wait();
            Assert.IsFalse(propertiesToFire.Any());
        }
Пример #2
0
        async void Refresh()
        {
            lock (_loadingLock)
            {
                if (_isLoading)
                {
                    return;
                }
                _isLoading = true;
            }

            UpdateGrid.IsEnabled = false;
            Loading.BeginLoadingIndication();
            try
            {
                DataContext = null;
                await Model.RefreshAsync();

                DataContext = Model;
            }
            finally
            {
                lock (_loadingLock)
                {
                    _isLoading = false;
                }
                UpdateGrid.IsEnabled = true;
                Loading.StopLoadingIndication();
            }
        }
        public void Should_UpdateSettingsProperties_When_RefeshAsync()
        {
            var modalmock    = MoqFactory.Create <IModalService>();
            var endpointMock = MoqFactory.Create <IWuEndpoint>(MockBehavior.Loose);
            var uovm         = new UpdateOverviewViewModel(modalmock.Object, endpointMock.Object);

            endpointMock.Setup(e => e.Updates).Returns(new[] { new UpdateDescription() });
            endpointMock.Setup(e => e.Settings).Returns(new WuSettings(0, 0, 0, false, true));
            uovm.RefreshAsync().Wait();
            Assert.IsFalse(uovm.AutoAcceptEulas);
            Assert.IsTrue(uovm.AutoSelectUpdates);

            endpointMock.Setup(e => e.Settings).Returns(new WuSettings(0, 0, 0, true, false));
            uovm.RefreshAsync().Wait();
            Assert.IsTrue(uovm.AutoAcceptEulas);
            Assert.IsFalse(uovm.AutoSelectUpdates);
        }
        public void Should_DisplayMessageBox_When_RefeshAsyncFailed()
        {
            var modalmock    = MoqFactory.Create <IModalService>(MockBehavior.Loose);
            var endpointMock = MoqFactory.Create <IWuEndpoint>(MockBehavior.Loose);
            var uovm         = new UpdateOverviewViewModel(modalmock.Object, endpointMock.Object);

            endpointMock.Setup(e => e.RefreshSettingsAsync()).Throws(new Exception());
            uovm.RefreshAsync().Wait();

            modalmock.Verify(m => m.ShowMessageBox(It.IsAny <string>(), It.IsAny <string>(), MessageType.Error));
        }
        public void Should_UpdateHostnameProperty_When_RefeshAsync()
        {
            var modalmock    = MoqFactory.Create <IModalService>();
            var endpointMock = MoqFactory.Create <IWuEndpoint>(MockBehavior.Loose);
            var uovm         = new UpdateOverviewViewModel(modalmock.Object, endpointMock.Object);

            endpointMock.Setup(e => e.Updates).Returns(new[] { new UpdateDescription() });
            endpointMock.Setup(e => e.Settings).Returns(new WuSettings(0, 0, 0, false, true));
            endpointMock.Setup(e => e.FQDN).Returns("mock1");
            Assert.IsNull(uovm.Hostname);
            uovm.RefreshAsync().Wait();
            Assert.AreEqual("mock1", uovm.Hostname);
        }
        public void Should_UpdateAvailableUpdatesProperty_When_RefeshAsync()
        {
            var modalmock    = MoqFactory.Create <IModalService>();
            var endpointMock = MoqFactory.Create <IWuEndpoint>(MockBehavior.Loose);

            endpointMock.Setup(e => e.Updates).Returns(new[] { new UpdateDescription()
                                                               {
                                                                   Title = "update1", ID = "update1"
                                                               }, new UpdateDescription()
                                                               {
                                                                   Title = "update2", ID = "update2"
                                                               } });
            endpointMock.Setup(e => e.Settings).Returns(new WuSettings(0, 0, 0, false, false));

            var uovm = new UpdateOverviewViewModel(modalmock.Object, endpointMock.Object);

            Assert.IsNull(uovm.Updates);

            uovm.RefreshAsync().Wait();

            Assert.AreEqual(2, uovm.Updates.Count());
            Assert.IsNotNull(uovm.Updates.Single(u => u.ID.Equals("update1")));
            Assert.IsNotNull(uovm.Updates.Single(u => u.ID.Equals("update2")));
        }