public void TestUpdate_WhenProjectsHaveBeenAdded_RaisesContentViewModelChanged()
        {
            var numContentViewModelChanged = 0;
            var pullRequestListViewModel   = new PullRequestListViewModel();
            var singleProjectViewModel     = new SingleProjectViewModel(pullRequestListViewModel, pullRequestListViewModel);

            singleProjectViewModel.Model = null;
            var noProjectsViewModel = Substitute.For <INoProjectsViewModel>();
            var tfProject           = Substitute.For <ITfProject>();

            tfProject.Approved.Returns(new ConcurrentDictionary <int, IPullRequest>());
            tfProject.Unapproved.Returns(new ConcurrentDictionary <int, IPullRequest>());
            _monitor.Projects.Returns(new[] { tfProject });
            _monitor.Status.Returns(MonitorStatus.UpdateSuccessful);
            var systemUnderTest = new MonitorWindowViewModel(_monitor, noProjectsViewModel, singleProjectViewModel,
                                                             new FirstUpdateViewModel(), _couldNotReachServerViewModel, new UnrecognisedErrorViewModel());

            systemUnderTest.PropertyChanged += (sender, args) =>
            {
                if (args.PropertyName == nameof(MonitorWindowViewModel.ContentViewModel))
                {
                    numContentViewModelChanged++;
                }
            };

            systemUnderTest.Update();

            Assert.That(numContentViewModelChanged, Is.EqualTo(1));
        }
Exemplo n.º 2
0
        public void ShowWindow()
        {
            MonitorWindow window;

            var t = new Thread(() =>
            {
                var gitPullRequests = new ConcurrentDictionary <int, IPullRequest>();
                for (int i = 0; i < 5; i++)
                {
                    var pullRequest = Substitute.For <IPullRequest>();
                    pullRequest.Id.Returns(i);
                    pullRequest.Title.Returns("Test pull request");
                    pullRequest.AuthorDisplayName.Returns("Alan Develo");
                    var repo = Substitute.For <ITfGitRepository>();
                    repo.Name.Returns("test-repo.git");
                    pullRequest.Repository.Returns(repo);
                    gitPullRequests.AddOrUpdate(i, pullRequest, (j, request) => request);
                }

                var project = Substitute.For <ITfProject>();
                project.Unapproved.Returns(gitPullRequests);
                project.Approved.Returns(gitPullRequests);

                var singleProjectViewModel = new SingleProjectViewModel(new PullRequestListViewModel(), new PullRequestListViewModel());

                var monitor = Substitute.For <IMonitor>();
                monitor.Projects.Returns(new[] { project });
                monitor.Status.Returns(MonitorStatus.UpdateSuccessful);

                var monitorViewModel = new MonitorWindowViewModel(monitor,
                                                                  Substitute.For <INoProjectsViewModel>(), singleProjectViewModel,
                                                                  new FirstUpdateViewModel(), new CouldNotReachServerViewModel(
                                                                      Substitute.For <IApplicationActions>(), Substitute.For <IAppSettings>()),
                                                                  new UnrecognisedErrorViewModel());
                monitorViewModel.Update();
                window = new MonitorWindow
                {
                    WindowStyle = WindowStyle.SingleBorderWindow,
                    DataContext = monitorViewModel
                };

                window.Closed += (sender, args) => System.Windows.Threading.Dispatcher.ExitAllFrames();

                window.Show();

                System.Windows.Threading.Dispatcher.Run();
            });

            t.SetApartmentState(ApartmentState.STA);
            t.Start();
            t.Join();
        }
        public void TestUpdate_WhenMonitorStatusIsNoProjects_UpdatesNoProjectsViewModelOnly()
        {
            var singleProjectViewModel = new SingleProjectViewModel(new PullRequestListViewModel(), new PullRequestListViewModel());
            var noProjectsViewModel    = Substitute.For <INoProjectsViewModel>();

            _monitor.Status.Returns(MonitorStatus.NoProjects);
            var systemUnderTest = new MonitorWindowViewModel(_monitor, noProjectsViewModel, singleProjectViewModel,
                                                             new FirstUpdateViewModel(), _couldNotReachServerViewModel, new UnrecognisedErrorViewModel());

            systemUnderTest.Update();

            noProjectsViewModel.Received().Update();
            Assert.That(singleProjectViewModel.Approved.Model, Is.Null);
            Assert.That(singleProjectViewModel.Unapproved.Model, Is.Null);
        }
        public void TestContentViewModel_WhenMonitorStatusIsUpdateSuccessful_ReturnsSingleProjectViewModel()
        {
            var singleProjectViewModel = new SingleProjectViewModel(new PullRequestListViewModel(), new PullRequestListViewModel());

            _monitor.Projects.Returns(new ObservableCollection <ITfProject> {
                Substitute.For <ITfProject>()
            });
            _monitor.Status.Returns(MonitorStatus.UpdateSuccessful);

            var systemUnderTest = new MonitorWindowViewModel(_monitor,
                                                             new NoProjectsViewModel(Substitute.For <IApplicationActions>()), singleProjectViewModel,
                                                             new FirstUpdateViewModel(), _couldNotReachServerViewModel, new UnrecognisedErrorViewModel());

            Assert.That(systemUnderTest.ContentViewModel, Is.EqualTo(singleProjectViewModel));
        }
        public void TestUpdate_WhenMonitorStatusIsUpdateSuccessful_UpdatesSingleProjectViewModelOnly()
        {
            var noProjectsViewModel    = Substitute.For <INoProjectsViewModel>();
            var singleProjectViewModel = new SingleProjectViewModel(new PullRequestListViewModel(), new PullRequestListViewModel());

            var tfProject            = Substitute.For <ITfProject>();
            var approvedDictionary   = new ConcurrentDictionary <int, IPullRequest>();
            var unapprovedDictionary = new ConcurrentDictionary <int, IPullRequest>();

            tfProject.Approved.Returns(approvedDictionary);
            tfProject.Unapproved.Returns(unapprovedDictionary);
            _monitor.Projects.Returns(new[] { tfProject });
            _monitor.Status.Returns(MonitorStatus.UpdateSuccessful);

            var systemUnderTest = new MonitorWindowViewModel(_monitor,
                                                             noProjectsViewModel, singleProjectViewModel,
                                                             new FirstUpdateViewModel(), _couldNotReachServerViewModel, new UnrecognisedErrorViewModel());

            systemUnderTest.Update();

            noProjectsViewModel.DidNotReceive().Update();
            Assert.That(singleProjectViewModel.Approved.Model, Is.EqualTo(approvedDictionary));
            Assert.That(singleProjectViewModel.Unapproved.Model, Is.EqualTo(unapprovedDictionary));
        }
        public void TestApprovalNeeded_ForNewInstance_IsNotNull()
        {
            var systemUnderTest = new SingleProjectViewModel(new PullRequestListViewModel(), new PullRequestListViewModel());

            Assert.That(systemUnderTest.Unapproved, Is.Not.Null);
        }