Beispiel #1
0
        public void UpdatePackageFromInstalled()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var installed = PackageFactory.Create("update", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installed);

                var remote = PackageFactory.Create("update", new Version(2, 0));
                this.PackageManager.RemotePackages.Add(remote);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, installed.Id);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.UpdateButton, PackageViewModelAction.Update);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsDetailsPaneVisible, "The details page should be shown.");
                Assert.Equal <PackageViewModelAction>(PackageViewModelAction.Update, buttonBarViewModel.NuGetViewModel.PackageAction);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.YesButton);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsLicensePageVisible, "The license page should be shown.");

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.AcceptButton);

                var installedPackage = this.PackageManager.InstalledPackages.FirstOrDefault();
                Assert.Equal(remote, installedPackage);
            }
        }
Beispiel #2
0
 private void ClickButton(TemporaryDispatcherThread thread, ButtonBarViewModel viewModel, ButtonViewModel button, object parameter = null)
 {
     Assert.True(button.Command.CanExecute(parameter), "The button should be enabled.");
     Assert.True(viewModel.ActionButtons.Contains(button), "The button should be visible.");
     thread.Invoke(() => { button.Command.Execute(parameter); });
     viewModel.NuGetViewModel.WaitUntilComplete();
 }
Beispiel #3
0
        public void DeclineEula()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var package = PackageFactory.Create("install");
                this.PackageManager.RemotePackages.Add(package);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_All, package.Id);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.InstallButton, PackageViewModelAction.InstallOrUninstall);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsDetailsPaneVisible, "The details page should be shown.");
                Assert.Equal <PackageViewModelAction>(PackageViewModelAction.InstallOrUninstall, buttonBarViewModel.NuGetViewModel.PackageAction);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.YesButton);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsLicensePageVisible, "The license page should be shown.");

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.DeclineButton);

                Assert.False(buttonBarViewModel.NuGetViewModel.IsDetailsPaneVisible, "The details page should not be shown.");
                Assert.False(buttonBarViewModel.NuGetViewModel.IsLicensePageVisible, "The license page should not be shown.");

                Assert.False(this.PackageManager.InstalledPackages.Any(), "Nothing should be installed.");
            }
        }
Beispiel #4
0
        public void UpdateAllPackagesFromUpdates()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var installed1 = PackageFactory.Create("update1", new Version(1, 0));
                var installed2 = PackageFactory.Create("update2", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installed1);
                this.PackageManager.InstalledPackages.Add(installed2);

                var remote1 = PackageFactory.Create("update1", new Version(2, 0));
                var remote2 = PackageFactory.Create("update2", new Version(2, 0));
                this.PackageManager.RemotePackages.Add(remote1);
                this.PackageManager.RemotePackages.Add(remote2);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Updated, installed1.Id);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.UpdateAllButton, PackageViewModelAction.UpdateAll);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsLicensePageVisible, "The license page should be shown.");
                Assert.Equal <PackageViewModelAction>(PackageViewModelAction.UpdateAll, buttonBarViewModel.NuGetViewModel.PackageAction);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.AcceptButton);

                var installedPackages = this.PackageManager.InstalledPackages.ToArray();
                Assert.Equal(remote1, installedPackages[0]);
                Assert.Equal(remote2, installedPackages[1]);
            }
        }
Beispiel #5
0
 public ChangeBrowserViewModel()
 {
     ButtonBarViewModel      = new ButtonBarViewModel(this);
     ChangeListViewModel     = new ChangeListViewModel(this, new ChangeRepository());
     ChangeDetailsViewModel  = new ChangeDetailsViewModel(new GitService(), VisualStudioWorkspaceService.Instance);
     GerritSettingsViewModel = new GerritSettingsViewModel();
 }
 public void NoPackageSelected()
 {
     using (var thread = new TemporaryDispatcherThread())
     {
         ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
         Assert.Equal(new ButtonViewModel[] { buttonBarViewModel.CloseButton }, buttonBarViewModel.ActionButtons);
     }
 }
Beispiel #7
0
        public void UpdateAllPackagesFromUpdatesAndInstallAnotherPackage()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var installed1 = PackageFactory.Create("update1", new Version(1, 0));
                var installed2 = PackageFactory.Create("update2", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installed1);
                this.PackageManager.InstalledPackages.Add(installed2);

                var remote1 = PackageFactory.Create("update1", new Version(2, 0));
                var remote2 = PackageFactory.Create("update2", new Version(2, 0));
                var remote3 = PackageFactory.Create("install1", new Version(1, 0));
                this.PackageManager.RemotePackages.Add(remote1);
                this.PackageManager.RemotePackages.Add(remote2);
                this.PackageManager.RemotePackages.Add(remote3);

                // Perform UpdateAll now

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Updated, installed1.Id);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.UpdateAllButton, PackageViewModelAction.UpdateAll);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsLicensePageVisible, "The license page should be shown.");
                Assert.True(buttonBarViewModel.NuGetViewModel.IsUpdatingAll, "Updating all should be true");
                Assert.False(buttonBarViewModel.NuGetViewModel.NotUpdatingAll, "Not Updating all should be false");
                Assert.Equal <PackageViewModelAction>(PackageViewModelAction.UpdateAll, buttonBarViewModel.NuGetViewModel.PackageAction);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.AcceptButton);

                // Perform Install Now
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_All, remote3.Id);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.InstallButton, PackageViewModelAction.InstallOrUninstall);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsDetailsPaneVisible, "The details page should be shown.");
                Assert.Equal <PackageViewModelAction>(PackageViewModelAction.InstallOrUninstall, buttonBarViewModel.NuGetViewModel.PackageAction);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.YesButton);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsLicensePageVisible, "The license page should be shown.");
                Assert.False(buttonBarViewModel.NuGetViewModel.IsUpdatingAll, "Updating all should be false");
                Assert.True(buttonBarViewModel.NuGetViewModel.NotUpdatingAll, "Not Updating all should be true");
                Assert.Equal <PackageViewModelAction>(PackageViewModelAction.InstallOrUninstall, buttonBarViewModel.NuGetViewModel.PackageAction);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.AcceptButton);

                var installedPackages = this.PackageManager.InstalledPackages.ToArray();
                Assert.Equal(remote1, installedPackages[0]);
                Assert.Equal(remote2, installedPackages[1]);
                Assert.Equal(remote3, installedPackages[2]);
            }
        }
        public void InstalledPackageSelectedInstalledFilter()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var package = PackageFactory.Create("installed");
                this.PackageManager.InstalledPackages.Add(package);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, package.Id);

                Assert.Equal(
                    new ButtonViewModel[] { buttonBarViewModel.UninstallButton, buttonBarViewModel.CloseButton },
                    buttonBarViewModel.ActionButtons);
            }
        }
Beispiel #9
0
        public void SelectMandatoryPackage()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                this.PackageManager.SupportsEnableDisable = true;

                var installed = PackageFactory.Create("WebMatrixExtensionsGallery", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installed);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, installed.Id);

                Assert.False(buttonBarViewModel.NuGetViewModel.UninstallCommand.CanExecute(null), "The uninstall command should be disabled");
                Assert.True(buttonBarViewModel.NuGetViewModel.DisableCommand.CanExecute(null), "The disable command should be enabled");
            }
        }
        public void UpdateAllNotShownWhenOnly1PackageHasUpdates()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var installedPackage1 = PackageFactory.Create("update1", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installedPackage1);

                var remotePackage1 = PackageFactory.Create("update1", new Version(2, 0));
                this.PackageManager.RemotePackages.Add(remotePackage1);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Updated, installedPackage1.Id);

                Assert.False(buttonBarViewModel.ActionButtons.Contains(buttonBarViewModel.UpdateAllButton));
                Assert.True(buttonBarViewModel.ActionButtons.Contains(buttonBarViewModel.UpdateButton));
            }
        }
        public void DisablablePackageSelected()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                this.PackageManager.SupportsEnableDisable = true;

                var installedPackage = PackageFactory.Create("disable", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installedPackage);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, installedPackage.Id);

                Assert.Equal(
                    new ButtonViewModel[] { buttonBarViewModel.DisableButton, buttonBarViewModel.UninstallButton, buttonBarViewModel.CloseButton },
                    buttonBarViewModel.ActionButtons);
            }
        }
        public void UpdatablePackageSelectedUpdatesFilter()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var installedPackage = PackageFactory.Create("update", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installedPackage);

                var remotePackage = PackageFactory.Create("update", new Version(2, 0));
                this.PackageManager.RemotePackages.Add(remotePackage);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Updated, installedPackage.Id);

                Assert.Equal(
                    new ButtonViewModel[] { buttonBarViewModel.UpdateButton, buttonBarViewModel.UninstallButton, buttonBarViewModel.CloseButton },
                    buttonBarViewModel.ActionButtons);
            }
        }
Beispiel #13
0
        public void UninstallPackageFromInstalled()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var package = PackageFactory.Create("uninstall");
                this.PackageManager.InstalledPackages.Add(package);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, package.Id);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.UninstallButton);
                Assert.True(buttonBarViewModel.NuGetViewModel.IsUninstallPageVisible, "The uninstall page should be shown.");

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.YesButton);

                Assert.False(this.PackageManager.InstalledPackages.Any(), "The package should be uninstalled");
            }
        }
        public void UninstallPageButtons()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                var package = PackageFactory.Create("installed");
                this.PackageManager.InstalledPackages.Add(package);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, package.Id);

                Assert.True(buttonBarViewModel.UninstallButton.Command.CanExecute(null));
                thread.Invoke(() => { buttonBarViewModel.UninstallButton.Command.Execute(null); });
                buttonBarViewModel.NuGetViewModel.WaitUntilComplete();

                Assert.Equal(
                    new ButtonViewModel[] { buttonBarViewModel.YesButton, buttonBarViewModel.NoButton },
                    buttonBarViewModel.ActionButtons);
            }
        }
Beispiel #15
0
        public void PrereleaseFilterVisibilityForExtensionsGallery()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                this.PackageManager.SupportsEnableDisable = true;

                var installed = PackageFactory.Create("update", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installed);

                var remote = PackageFactory.Create("update", new Version(2, 0));
                this.PackageManager.RemotePackages.Add(remote);

                installed = PackageFactory.Create("disable", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installed);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, installed.Id);

                buttonBarViewModel.NuGetViewModel.ShouldShowPrereleaseFilter = false;

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.DisableButton);

                // At this point, there are 2 packages installed; 1 has an update and 1 is disabled

                // Select All Filter and check that the prerelease filter is visible
                this.SelectFilter(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_All);
                Assert.NotEqual <Visibility>(buttonBarViewModel.NuGetViewModel.ShowPrereleaseFilter, Visibility.Visible);

                // Select Disabled Filter and check that the prerelease filter is NOT visible
                this.SelectFilter(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Disabled);
                Assert.NotEqual <Visibility>(buttonBarViewModel.NuGetViewModel.ShowPrereleaseFilter, Visibility.Visible);

                // Select Updates Filter and check that the prerelease filter is visible
                this.SelectFilter(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Updated);
                Assert.NotEqual <Visibility>(buttonBarViewModel.NuGetViewModel.ShowPrereleaseFilter, Visibility.Visible);

                // Select Installed Filter and check that the prerelease filter is NOT visible
                this.SelectFilter(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed);
                Assert.NotEqual <Visibility>(buttonBarViewModel.NuGetViewModel.ShowPrereleaseFilter, Visibility.Visible);
            }
        }
Beispiel #16
0
        public void EnablePackage()
        {
            using (var thread = new TemporaryDispatcherThread())
            {
                this.PackageManager.SupportsEnableDisable = true;

                var installed = PackageFactory.Create("enable", new Version(1, 0));
                this.PackageManager.InstalledPackages.Add(installed);
                this.PackageManager.DisabledPackages.Add(installed);

                ButtonBarViewModel buttonBarViewModel = this.CreateViewModel(thread);
                this.SelectPackage(thread, buttonBarViewModel.NuGetViewModel, Resources.Filter_Installed, installed.Id);

                this.ClickButton(thread, buttonBarViewModel, buttonBarViewModel.EnableButton);

                Assert.False(buttonBarViewModel.NuGetViewModel.IsDetailsPaneVisible, "The details page should not be shown.");
                Assert.False(buttonBarViewModel.NuGetViewModel.IsLicensePageVisible, "The license page should not be shown.");

                Assert.False(this.PackageManager.DisabledPackages.Any(), "No packages should be disabled.");
            }
        }
        /// <summary>
        /// Creates a NuGetViewModel and ButtonBarViewModel for testing
        /// </summary>
        private ButtonBarViewModel CreateViewModel(TemporaryDispatcherThread thread)
        {
            ButtonBarViewModel buttonBarViewModel = null;
            NuGetViewModel     nuGetViewModel     = null;

            thread.Invoke(() =>
            {
                nuGetViewModel = new NuGetViewModel(
                    this.Descriptor.Object,
                    this.Host.Object,
                    this.PackageSourcesViewModel,
                    (uri, site) => this.PackageManager,
                    this.ReadonlyDestination,
                    thread.Scheduler);

                buttonBarViewModel = new ButtonBarViewModel(nuGetViewModel, this.CloseCommand);
            });
            nuGetViewModel.WaitUntilComplete();

            return(buttonBarViewModel);
        }
Beispiel #18
0
 private void ClickButton(TemporaryDispatcherThread thread, ButtonBarViewModel viewModel, ButtonViewModel button, object parameter = null)
 {
     Assert.True(button.Command.CanExecute(parameter), "The button should be enabled.");
     Assert.True(viewModel.ActionButtons.Contains(button), "The button should be visible.");
     thread.Invoke(() => { button.Command.Execute(parameter); });
     viewModel.NuGetViewModel.WaitUntilComplete();
 }
Beispiel #19
0
        /// <summary>
        /// Creates a NuGetViewModel and ButtonBarViewModel for testing
        /// </summary>
        private ButtonBarViewModel CreateViewModel(TemporaryDispatcherThread thread)
        {
            ButtonBarViewModel buttonBarViewModel = null;
            NuGetViewModel nuGetViewModel = null;
            thread.Invoke(() =>
            {
                nuGetViewModel = new NuGetViewModel(
                    this.Descriptor.Object,
                    this.Host.Object,
                    this.PackageSourcesViewModel,
                    (uri, site) => this.PackageManager,
                    this.ReadonlyDestination,
                    thread.Scheduler);

                buttonBarViewModel = new ButtonBarViewModel(nuGetViewModel, this.CloseCommand);
            });
            nuGetViewModel.WaitUntilComplete();

            return buttonBarViewModel;
        }