Example #1
0
            public void PackageAvailableFromLocal_InstallSucceeds()
            {
                // arrange
                var package              = new MockPackage();
                var mockLocalRepository  = new MockPackageRepository();
                var mockRemoteRepository = new MockPackageRepository();

                mockLocalRepository.AddPackage(package);

                var mockPackageManager = new Mock <IPackageManager>();
                var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);

                mockProjectManager.Setup(pm => pm.AddPackageReference(package, It.IsAny <bool>(), It.IsAny <bool>())).Verifiable();

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
                Dependencies.NuGetProjectSystemFactory  = MockGenerator.CreateProjectSystemFactory();

                // act
                NuGetCore core     = new NuGetCore();
                var       warnings = core.InstallPackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", MockPackage.DefaultVersion.ToString());

                // assert
                mockProjectManager.Verify();
            }
            public void DoesNotReturnPackagesFromLocal()
            {
                var packageA = new MockPackage {
                    Id = "A"
                };
                var packageB = new MockPackage {
                    Id = "B"
                };
                var packageAB = new MockPackage {
                    Id = "AB"
                };

                var mockRemoteRepo = new MockPackageRepository();

                mockRemoteRepo.AddPackage(packageA);
                mockRemoteRepo.AddPackage(packageB);
                var mockLocalRepo = new MockPackageRepository();

                mockLocalRepo.AddPackage(packageAB);

                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(mockRemoteRepo, mockLocalRepo).Object);

                // act
                var project = new WebNuGetProject(new string[] { "http://dummyFeed" }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var results = project.GetRemotePackages("A");

                Assert.Equal(new IPackage[] { packageA }, results);
            }
Example #3
0
            public void DontSpecifyVersion_UpdatesToLatestPackage()
            {
                var latestPackage = new MockPackage {
                    Version = new SemanticVersion("3.0")
                };
                var mockLocalRepository  = new MockPackageRepository();
                var mockRemoteRepository = new MockPackageRepository();

                mockLocalRepository.AddPackage(new MockPackage());
                mockRemoteRepository.AddPackage(new MockPackage {
                    Version = new SemanticVersion("2.0")
                });
                mockRemoteRepository.AddPackage(latestPackage);

                var mockPackageManager = MockGenerator.CreateMockPackageManager(mockRemoteRepository, mockLocalRepository);
                var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);

                mockProjectManager.Setup(pm => pm.UpdatePackageReference(latestPackage.Id, latestPackage.Version, It.IsAny <bool>(), It.IsAny <bool>())).Verifiable();

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
                Dependencies.NuGetProjectSystemFactory  = MockGenerator.CreateProjectSystemFactory();

                // act
                NuGetCore core     = new NuGetCore();
                var       warnings = core.UpdatePackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", null);

                // assert
                mockProjectManager.Verify();
            }
            public void UninstallOldPackageFails_HandleGracefully()
            {
                var oldPackage = new MockPackage();
                var package    = new MockPackage {
                    Version = new SemanticVersion("2.0")
                };

                var mockRepository = new MockPackageRepository();

                mockRepository.AddPackage(oldPackage);

                var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);

                mockPackageMan.Setup(packMan => packMan.UninstallPackage(oldPackage, It.IsAny <bool>(), It.IsAny <bool>()))
                .Throws(new InvalidOperationException("Dummy message"));
                mockPackageMan.SetupProperty(packMan => packMan.Logger, new TestEasy.NuGet.WebNuGetProject.ErrorLogger());
                var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project  = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var             warnings = project.UpdatePackage(package);

                // assert
                Assert.Contains("Package MockPackage.1.0 could not be uninstalled: Dummy message", warnings);
            }
            public void RemoveFromPackageManagerAfterRemovingFromProjectManager()
            {
                var  package = new MockPackage();
                bool calledProjectManager = false;
                bool calledPackageManagerAfterProjectManager = false;

                var mockPackageMan = new Mock <IPackageManager>()
                {
                    DefaultValue = DefaultValue.Mock
                };

                mockPackageMan.Setup(packMan => packMan.UninstallPackage(package, It.IsAny <bool>(), It.IsAny <bool>()))
                .Callback(() => calledPackageManagerAfterProjectManager = calledProjectManager);

                var mockProjectMan = new Mock <IProjectManager>()
                {
                    DefaultValue = DefaultValue.Mock
                };

                mockProjectMan.Setup(projMan => projMan.RemovePackageReference(It.IsAny <IPackage>(), false, true))
                .Callback(() => calledProjectManager = true);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project  = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var             warnings = project.UninstallPackage(package, true);

                // assert
                Assert.True(calledPackageManagerAfterProjectManager);
            }
Example #6
0
            public void PackageAvailableFromLocal_UpdateSucceeds()
            {
                // arrange
                var targetPackage = new MockPackage()
                {
                    Version = new SemanticVersion("2.0")
                };
                var mockLocalRepository  = new MockPackageRepository();
                var mockRemoteRepository = new MockPackageRepository();

                mockLocalRepository.AddPackage(new MockPackage());
                mockLocalRepository.AddPackage(targetPackage);

                var mockPackageManager = MockGenerator.CreateMockPackageManager(mockRemoteRepository, mockLocalRepository);
                var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);

                mockProjectManager.Setup(pm => pm.UpdatePackageReference(targetPackage.Id, targetPackage.Version, It.IsAny <bool>(), It.IsAny <bool>())).Verifiable();

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
                Dependencies.NuGetProjectSystemFactory  = MockGenerator.CreateProjectSystemFactory();

                // act
                NuGetCore core     = new NuGetCore();
                var       warnings = core.UpdatePackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", "2.0");

                // assert
                mockProjectManager.Verify();
            }
            public void InstallNewPackageToPackageManagerBeforeProjectManager()
            {
                var package        = new MockPackage();
                var mockRepository = new MockPackageRepository();

                mockRepository.AddPackage(package);
                bool calledPackageManager = false;
                bool calledProjectManagerAfterPackageManager = false;

                var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);

                mockPackageMan.Setup(packMan => packMan.InstallPackage(package, It.IsAny <bool>(), It.IsAny <bool>()))
                .Callback(() => calledPackageManager = true);

                var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);

                mockProjectMan.Setup(projMan => projMan.UpdatePackageReference(package.Id, package.Version, It.IsAny <bool>(), It.IsAny <bool>()))
                .Callback(() => calledProjectManagerAfterPackageManager = calledPackageManager);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project  = new WebNuGetProject(new string[] {}, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var             warnings = project.UpdatePackage(package);

                // assert
                Assert.True(calledProjectManagerAfterPackageManager);
            }
            public void InstallNewPackageToPackageManagerBeforeProjectManager()
            {
                var package = new MockPackage();
                var mockRepository = new MockPackageRepository();
                mockRepository.AddPackage(package);
                bool calledPackageManager = false;
                bool calledProjectManagerAfterPackageManager = false;

                var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);
                mockPackageMan.Setup(packMan => packMan.InstallPackage(package, It.IsAny<bool>(), It.IsAny<bool>()))
                    .Callback(() => calledPackageManager = true);

                var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);
                mockProjectMan.Setup(projMan => projMan.UpdatePackageReference(package.Id, package.Version, It.IsAny<bool>(), It.IsAny<bool>()))
                    .Callback(() => calledProjectManagerAfterPackageManager = calledPackageManager);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project = new WebNuGetProject(new string[] {}, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var warnings = project.UpdatePackage(package);

                // assert
                Assert.True(calledProjectManagerAfterPackageManager);
            }
            public void OrderedByDownloadCountFirst()
            {
                var packageA = new MockPackage {
                    Id = "A", DownloadCount = 1
                };
                var packageB = new MockPackage {
                    Id = "B", DownloadCount = 2
                };

                var mockRepo = new MockPackageRepository();

                mockRepo.AddPackage(packageA);
                mockRepo.AddPackage(packageB);

                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(mockRepo, new MockPackageRepository()).Object);

                // act
                var project = new WebNuGetProject(new string[] { "http://dummyFeed" }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var results = project.GetRemotePackages("");

                Assert.Equal(new IPackage[] { packageB, packageA }, results);

                packageA.DownloadCount = 2;

                results = project.GetRemotePackages("");
                Assert.Equal(new IPackage[] { packageA, packageB }, results);
            }
            public void OldVersionOfPackageUninstalled()
            {
                var oldPackage = new MockPackage();
                var package    = new MockPackage {
                    Version = new SemanticVersion("2.0")
                };

                var mockRepository = new MockPackageRepository();

                mockRepository.AddPackage(oldPackage);

                var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);

                mockPackageMan.Setup(packMan => packMan.UninstallPackage(oldPackage, It.IsAny <bool>(), It.IsAny <bool>()))
                .Verifiable();
                var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project  = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var             warnings = project.UpdatePackage(package);

                // assert
                mockPackageMan.Verify();
            }
Example #11
0
        public void PackageFileConstructorNullPath()
        {
            IPackage    ownerPackage = new MockPackage("someLocation");
            string      path         = string.Empty;
            PackageFile target       = new PackageFile(ownerPackage, path);

            Assert.Fail("A ArgumentNullException exception should have been thrown");
        }
        public void PropertyVersionGet_ShoudReturnProperValue()
        {
            //Arrange
            string name = "valid name";

            var versionMock      = new Mock <IVersion>();
            var dependenciesMock = new Mock <ICollection <IPackage> >();

            var sut = new MockPackage(name, versionMock.Object, dependenciesMock.Object);

            //Act
            var result = sut.Version;

            //Assert
            Assert.AreEqual(versionMock.Object, result);
        }
        public void PropertyURL_ShoudBeProperlyAssigned()
        {
            //Arrange
            string name = "valid name";

            var versionMock      = new Mock <IVersion>();
            var dependenciesMock = new Mock <ICollection <IPackage> >();

            var sut = new MockPackage(name, versionMock.Object, dependenciesMock.Object);

            //Act
            sut.Url = "valid url";
            string expectedOutput = "valid url";

            //Assert
            Assert.AreEqual(expectedOutput, sut.Url);
        }
        public void PropertyNameSet_ShoudAssigvaluesProperly()
        {
            //Arrange
            string name = "valid name";

            var versionMock      = new Mock <IVersion>();
            var dependenciesMock = new Mock <ICollection <IPackage> >();

            var sut = new MockPackage(name, versionMock.Object, dependenciesMock.Object);

            //Act
            sut.Name = "other name";
            var    result         = sut.Name;
            string expectedOutput = "other name";

            //Assert
            Assert.AreEqual(expectedOutput, result);
        }
Example #15
0
        public static void MyClassInitialize(TestContext testContext)
        {
            string temp = System.IO.Path.GetTempPath();

            temp = System.IO.Path.Combine(temp, "PackageFileTestTemp");
            System.IO.Directory.CreateDirectory(temp);

            string filename = "TestFile.txt";

            TempFileRelative = filename;
            TempFile         = System.IO.Path.Combine(temp, filename);

            TempPackage = new MockPackage(temp);

            using (var stream = new System.IO.StreamWriter(TempFile))
            {
                stream.WriteLine("New file FTW!");
            }
        }
            public void EmptySearchTerms_ReturnsAllLocalPackages()
            {
                var packageA = new MockPackage {
                    Id = "A"
                };
                var packageB = new MockPackage {
                    Id = "B"
                };

                var mockRepo = new MockPackageRepository();

                mockRepo.AddPackage(packageA);
                mockRepo.AddPackage(packageB);

                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(new MockPackageRepository(), mockRepo).Object);

                // act
                var project = new WebNuGetProject(new string[] { "http://dummyFeed" }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var results = project.GetInstalledPackages("");

                Assert.Equal(new IPackage[] { packageA, packageB }, results);
            }
            public void OldVersionOfPackageUninstalled()
            {
                var oldPackage = new MockPackage();
                var package = new MockPackage { Version = new SemanticVersion("2.0") };

                var mockRepository = new MockPackageRepository();
                mockRepository.AddPackage(oldPackage);

                var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);
                mockPackageMan.Setup(packMan => packMan.UninstallPackage(oldPackage, It.IsAny<bool>(), It.IsAny<bool>()))
                    .Verifiable();
                var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var warnings = project.UpdatePackage(package);

                // assert
                mockPackageMan.Verify();
            }
Example #18
0
            public void PackageAvailableFromLocal_InstallSucceeds()
            {
                // arrange
                var package = new MockPackage();
                var mockLocalRepository = new MockPackageRepository();
                var mockRemoteRepository = new MockPackageRepository();
                mockLocalRepository.AddPackage(package);

                var mockPackageManager = new Mock<IPackageManager>();
                var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);
                mockProjectManager.Setup(pm => pm.AddPackageReference(package, It.IsAny<bool>(), It.IsAny<bool>())).Verifiable();

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
                Dependencies.NuGetProjectSystemFactory = MockGenerator.CreateProjectSystemFactory();

                // act
                NuGetCore core = new NuGetCore();
                var warnings = core.InstallPackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", MockPackage.DefaultVersion.ToString());

                // assert
                mockProjectManager.Verify();
            }
            public void UninstallOldPackageFails_HandleGracefully()
            {
                var oldPackage = new MockPackage();
                var package = new MockPackage { Version = new SemanticVersion("2.0") };

                var mockRepository = new MockPackageRepository();
                mockRepository.AddPackage(oldPackage);

                var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);
                mockPackageMan.Setup(packMan => packMan.UninstallPackage(oldPackage, It.IsAny<bool>(), It.IsAny<bool>()))
                    .Throws(new InvalidOperationException("Dummy message"));
                mockPackageMan.SetupProperty(packMan => packMan.Logger, new TestEasy.NuGet.WebNuGetProject.ErrorLogger());
                var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var warnings = project.UpdatePackage(package);

                // assert
                Assert.Contains("Package MockPackage.1.0 could not be uninstalled: Dummy message", warnings);
            }
Example #20
0
            public void DontSpecifyVersion_UpdatesToLatestPackage()
            {
                var latestPackage = new MockPackage { Version = new SemanticVersion("3.0") };
                var mockLocalRepository = new MockPackageRepository();
                var mockRemoteRepository = new MockPackageRepository();
                mockLocalRepository.AddPackage(new MockPackage());
                mockRemoteRepository.AddPackage(new MockPackage { Version = new SemanticVersion("2.0") });
                mockRemoteRepository.AddPackage(latestPackage);

                var mockPackageManager = MockGenerator.CreateMockPackageManager(mockRemoteRepository, mockLocalRepository);
                var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);
                mockProjectManager.Setup(pm => pm.UpdatePackageReference(latestPackage.Id, latestPackage.Version, It.IsAny<bool>(), It.IsAny<bool>())).Verifiable();

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
                Dependencies.NuGetProjectSystemFactory = MockGenerator.CreateProjectSystemFactory();

                // act
                NuGetCore core = new NuGetCore();
                var warnings = core.UpdatePackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", null);

                // assert
                mockProjectManager.Verify();
            }
            public void DoesNotReturnPackagesFromLocal()
            {
                var packageA = new MockPackage { Id = "A" };
                var packageB = new MockPackage { Id = "B" };
                var packageAB = new MockPackage { Id = "AB" };
                
                var mockRemoteRepo = new MockPackageRepository();
                mockRemoteRepo.AddPackage(packageA);
                mockRemoteRepo.AddPackage(packageB);
                var mockLocalRepo = new MockPackageRepository();
                mockLocalRepo.AddPackage(packageAB);

                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(mockRemoteRepo, mockLocalRepo).Object);

                // act
                var project = new WebNuGetProject(new string[] { "http://dummyFeed" }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var results = project.GetRemotePackages("A");

                Assert.Equal(new IPackage[] { packageA }, results);
            }
            public void OrderedByDownloadCountFirst()
            {
                var packageA = new MockPackage { Id = "A", DownloadCount = 1 };
                var packageB = new MockPackage { Id = "B", DownloadCount = 2 };

                var mockRepo = new MockPackageRepository();
                mockRepo.AddPackage(packageA);
                mockRepo.AddPackage(packageB);

                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(mockRepo, new MockPackageRepository()).Object);

                // act
                var project = new WebNuGetProject(new string[] { "http://dummyFeed" }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var results = project.GetRemotePackages("");

                Assert.Equal(new IPackage[] { packageB, packageA }, results);

                packageA.DownloadCount = 2;

                results = project.GetRemotePackages("");
                Assert.Equal(new IPackage[] { packageA, packageB}, results);

            }
            public void EmptySearchTerms_ReturnsAllLocalPackages()
            {
                var packageA = new MockPackage { Id = "A" };
                var packageB = new MockPackage { Id = "B" };

                var mockRepo = new MockPackageRepository();
                mockRepo.AddPackage(packageA);
                mockRepo.AddPackage(packageB);

                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(new MockPackageRepository(), mockRepo).Object);

                // act
                var project = new WebNuGetProject(new string[] {"http://dummyFeed"}, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var results = project.GetInstalledPackages("");

                Assert.Equal(new IPackage[] { packageA, packageB}, results);
            }
            public void RemoveFromPackageManagerAfterRemovingFromProjectManager()
            {
                var package = new MockPackage();
                bool calledProjectManager = false;
                bool calledPackageManagerAfterProjectManager = false;

                var mockPackageMan = new Mock<IPackageManager>() { DefaultValue = DefaultValue.Mock };
                mockPackageMan.Setup(packMan => packMan.UninstallPackage(package, It.IsAny<bool>(), It.IsAny<bool>()))
                    .Callback(() => calledPackageManagerAfterProjectManager = calledProjectManager);

                var mockProjectMan = new Mock<IProjectManager>() { DefaultValue = DefaultValue.Mock };
                mockProjectMan.Setup(projMan => projMan.RemovePackageReference(It.IsAny<IPackage>(), false, true))
                    .Callback(() => calledProjectManager = true);

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);

                // act
                WebNuGetProject project = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
                var warnings = project.UninstallPackage(package, true);

                // assert
                Assert.True(calledPackageManagerAfterProjectManager);
            }
Example #25
0
            public void PackageAvailableFromRemote_UpdateSucceeds()
            {
                // arrange
                var updatedPackage = new MockPackage { Version = new SemanticVersion("2.0") };
                var mockLocalRepository = new MockPackageRepository();
                var mockRemoteRepository = new MockPackageRepository();
                mockLocalRepository.AddPackage(new MockPackage());
                mockRemoteRepository.AddPackage(updatedPackage);

                var mockPackageManager = MockGenerator.CreateMockPackageManager(mockRemoteRepository, mockLocalRepository);
                var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);
                mockProjectManager.Setup(pm => pm.UpdatePackageReference(updatedPackage.Id, updatedPackage.Version, It.IsAny<bool>(), It.IsAny<bool>())).Verifiable();

                Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
                Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
                Dependencies.NuGetProjectSystemFactory = MockGenerator.CreateProjectSystemFactory();

                // act
                NuGetCore core = new NuGetCore();
                var warnings = core.UpdatePackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", "2.0");

                // assert
                mockProjectManager.Verify();
            }