public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
null,
null,
new Mock<IVsCommonOperations>().Object,
new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
// Act
cmdlet.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
}
public void InstallPackageCmdletSpecifiesInstallOperationDuringExecution()
{
// Arrange
var repo = new MockPackageRepository();
var vsPackageManager = new MockVsPackageManager(repo);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
null,
null,
new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
// Act
cmdlet.Execute();
// Assert
Assert.Equal(RepositoryOperationNames.Install, repo.LastOperation);
}
public void InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
null,
null,
new Mock <IVsCommonOperations>().Object,
new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.IgnoreDependencies = new SwitchParameter(true);
// Act
cmdlet.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
Assert.True(vsPackageManager.IgnoreDependencies);
}
public void UninstallPackageCmdletPassesForceSwitchCorrectly()
{
// Arrange
var id = "my-id";
var version = new SemanticVersion("2.8");
var forceSwitch = true;
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var uninstallCmdlet = new Mock <UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsCommonOperations>().Object)
{
CallBase = true
};
uninstallCmdlet.Object.Id = id;
uninstallCmdlet.Object.Version = version;
uninstallCmdlet.Object.Force = new SwitchParameter(forceSwitch);
// Act
uninstallCmdlet.Object.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
Assert.True(vsPackageManager.ForceRemove);
}
public void InstallPackageCmdletUsesPackageManangerWithSourceIfSpecified()
{
// Arrange
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
var vsPackageManager = new MockVsPackageManager();
var sourceVsPackageManager = new MockVsPackageManager();
var mockPackageRepository = new MockPackageRepository();
var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource"));
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(It.Is <string>(s => s == "somesource"))).Returns(mockPackageRepository);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), true)).Returns(sourceVsPackageManager);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock <IVsCommonOperations>().Object);
cmdlet.Source = "somesource";
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
// Act
cmdlet.Execute();
// Assert
Assert.Same(sourceVsPackageManager, cmdlet.PackageManager);
}
public void UpdatePackageCmdletDoNotInvokeProductUpdateCheckWhenSourceIsNotHttpAddress()
{
// Arrange
string source = "ftp://bing.com";
var productUpdateService = new Mock <IProductUpdateService>();
var sourceRepository = new Mock <IPackageRepository>();
sourceRepository.Setup(p => p.Source).Returns(source);
var vsPackageManager = new MockVsPackageManager(sourceRepository.Object);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager);
var sourceProvider = GetPackageSourceProvider(new PackageSource(source, "bing"));
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object);
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.IgnoreDependencies = new SwitchParameter(isPresent: true);
cmdlet.Source = source;
cmdlet.ProjectName = "foo";
// Act
cmdlet.Execute();
// Assert
productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Never());
}
public void InstallPackageCmdletDoNotInvokeProductUpdateCheckWhenSourceIsNotHttpAddress()
{
// Arrange
string source = "ftp://bing.com";
var productUpdateService = new Mock <IProductUpdateService>();
var sourceRepository = new Mock <IPackageRepository>();
sourceRepository.Setup(p => p.Source).Returns(source);
var vsPackageManager = new MockVsPackageManager(sourceRepository.Object);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <string>())).Returns(vsPackageManager);
var cmdlet = new Mock <InstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, productUpdateService.Object)
{
CallBase = true
};
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
cmdlet.Object.IgnoreDependencies = new SwitchParameter(true);
cmdlet.Object.Source = source;
// Act
cmdlet.Object.Execute();
// Assert
productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Never());
}
public void UpdatePackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var mockPackageRepository = new MockPackageRepository();
var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource"));
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(It.Is <string>(s => s == "somesource"))).Returns(mockPackageRepository);
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.ProjectName = "foo";
// Act
cmdlet.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
}
public void InstallPackageCmdletInvokeProductUpdateCheckWhenSourceIsHttpAddressAndSourceNameIsSpecified()
{
// Arrange
string source = "http://bing.com";
string sourceName = "bing";
var productUpdateService = new Mock <IProductUpdateService>();
var sourceRepository = new Mock <IPackageRepository>();
sourceRepository.Setup(p => p.Source).Returns(source);
var vsPackageManager = new MockVsPackageManager(sourceRepository.Object);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var sourceProvider = GetPackageSourceProvider(new PackageSource(source, sourceName));
packageRepositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object);
packageManagerFactory.Setup(m => m.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, packageRepositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.IgnoreDependencies = new SwitchParameter(true);
cmdlet.Source = sourceName;
// Act
cmdlet.Execute();
// Assert
productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Once());
}
public void SafeUpdatePackageDoNotUpdateToUnlistedPackage(string versionA1, string versionA2)
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", versionA1);
var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false);
var sharedRepository = new MockSharedPackageRepository();
sharedRepository.AddPackage(packageA1);
var packageRepository = new MockPackageRepository {
packageA1, packageA2
};
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManagerWithProjects(),
packageRepository,
sharedRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Safe = true;
cmdlet.Execute();
// Assert
Assert.True(sharedRepository.Contains(packageA1));
Assert.False(sharedRepository.Contains(packageA2));
}
public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
null,
null,
new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
// Act
cmdlet.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
}
public void UpdatePackageWithProjectManagerSetOperationToUpdate()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository);
var project = TestUtils.GetProject("project runway", projectFiles: new[] { "dotnetjunky.cs" });
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(defaultProjectName: "project runway", projects: new[] { project }),
sourceRepository,
new Mock <IFileSystemProvider>().Object,
projectSystem,
localRepository,
new Mock <IDeleteOnRestartManager>().Object,
new Mock <VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project, projectManager);
var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" });
localRepository.AddPackage(package);
projectRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("phuong", "2.0", new[] { "hello" });
sourceRepository.AddPackage(package2);
// Act
packageManager.UpdatePackage(
projectManager,
"phuong",
new SemanticVersion("2.0"),
updateDependencies: true,
allowPrereleaseVersions: true,
logger: NullLogger.Instance);
// Assert
Assert.Equal("Update", sourceRepository.LastOperation);
Assert.Equal("phuong", sourceRepository.LastMainPackageId);
Assert.Equal("2.0", sourceRepository.LastMainPackageVersion);
}
public void UpdatePackageCmdletPassesIgnoreDependencySwitchCorrectly()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true };
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
// Act
cmdlet.Object.Execute();
// Assert
Assert.AreEqual("my-id", vsPackageManager.PackageId);
Assert.AreEqual(new Version("2.8"), vsPackageManager.Version);
Assert.IsTrue(vsPackageManager.UpdateDependencies);
}
public void UninstallPackageCmdletPassesRemoveDependencyCorrectly()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var uninstallCmdlet = new Mock<UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object) { CallBase = true };
uninstallCmdlet.Object.Id = "my-id";
uninstallCmdlet.Object.Version = new SemanticVersion("2.8");
uninstallCmdlet.Object.RemoveDependencies = new SwitchParameter(true);
// Act
uninstallCmdlet.Object.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
Assert.True(vsPackageManager.RemoveDependencies);
}
public void UninstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var id = "my-id";
var version = new SemanticVersion("2.8");
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var uninstallCmdlet = new Mock<UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsCommonOperations>().Object) { CallBase = true };
uninstallCmdlet.Object.Id = id;
uninstallCmdlet.Object.Version = version;
// Act
uninstallCmdlet.Object.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
}
public void UpdatePackageCmdletSpecifiesUpdateOperationDuringExecution()
{
// Arrange
var mockPackageRepository = new MockPackageRepository();
var vsPackageManager = new MockVsPackageManager(mockPackageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource"));
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(It.Is<string>(s => s == "somesource"))).Returns(mockPackageRepository);
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.ProjectName = "foo";
// Act
cmdlet.Execute();
// Assert
Assert.Equal(RepositoryOperationNames.Update, mockPackageRepository.LastOperation);
}
public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new Mock <InstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null)
{
CallBase = true
};
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
// Act
cmdlet.Object.Execute();
// Assert
Assert.AreEqual("my-id", vsPackageManager.PackageId);
Assert.AreEqual(new Version("2.8"), vsPackageManager.Version);
}
public void UpdatePackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var mockPackageRepository = new MockPackageRepository();
var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource"));
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(It.Is<string>(s => s == "somesource"))).Returns(mockPackageRepository);
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock<IVsCommonOperations>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.ProjectName = "foo";
// Act
cmdlet.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
}
public void UpdatePackageCmdletPassesIgnoreDependencySwitchCorrectly()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new Mock <UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null)
{
CallBase = true
};
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
// Act
cmdlet.Object.Execute();
// Assert
Assert.AreEqual("my-id", vsPackageManager.PackageId);
Assert.AreEqual(new Version("2.8"), vsPackageManager.Version);
Assert.IsTrue(vsPackageManager.UpdateDependencies);
}
public void InstallPackageCmdletUsesPackageManangerWithSourceIfSpecified()
{
// Arrange
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
var vsPackageManager = new MockVsPackageManager();
var sourceVsPackageManager = new MockVsPackageManager();
var mockPackageRepository = new MockPackageRepository();
var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource"));
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(It.Is<string>(s => s == "somesource"))).Returns(mockPackageRepository);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true)).Returns(sourceVsPackageManager);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Source = "somesource";
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
// Act
cmdlet.Execute();
// Assert
Assert.Same(sourceVsPackageManager, cmdlet.PackageManager);
}
public void UpdatePackageCmdletInvokeProductUpdateCheckWhenSourceIsHttpAddress()
{
// Arrange
string source = "http://bing.com";
var productUpdateService = new Mock<IProductUpdateService>();
var sourceRepository = new Mock<IPackageRepository>();
sourceRepository.Setup(p => p.Source).Returns(source);
var vsPackageManager = new MockVsPackageManager(sourceRepository.Object);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<string>())).Returns(vsPackageManager);
var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, productUpdateService.Object) { CallBase = true };
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
cmdlet.Object.IgnoreDependencies = new SwitchParameter(isPresent: true);
cmdlet.Object.Source = source;
// Act
cmdlet.Object.Execute();
// Assert
productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Once());
}
public void InstallPackageCmdletUsesPackageManangerWithSourceIfSpecified()
{
// Arrange
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
var vsPackageManager = new MockVsPackageManager();
var sourceVsPackageManager = new MockVsPackageManager();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
packageManagerFactory.Setup(m => m.CreatePackageManager("somesource")).Returns(sourceVsPackageManager);
var cmdlet = new Mock <InstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null)
{
CallBase = true
};
cmdlet.Object.Source = "somesource";
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
// Act
cmdlet.Object.Execute();
// Assert
Assert.AreSame(sourceVsPackageManager, cmdlet.Object.PackageManager);
}
public void UpdatePackageCmdletSpecifiesUpdateOperationDuringExecution()
{
// Arrange
var mockPackageRepository = new MockPackageRepository();
var vsPackageManager = new MockVsPackageManager(mockPackageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource"));
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(It.Is <string>(s => s == "somesource"))).Returns(mockPackageRepository);
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.ProjectName = "foo";
// Act
cmdlet.Execute();
// Assert
Assert.Equal(RepositoryOperationNames.Update, mockPackageRepository.LastOperation);
}
public void UninstallPackageCmdletPassesRemoveDependencyCorrectly()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var uninstallCmdlet = new Mock <UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null)
{
CallBase = true
};
uninstallCmdlet.Object.Id = "my-id";
uninstallCmdlet.Object.Version = new Version("2.8");
uninstallCmdlet.Object.RemoveDependencies = new SwitchParameter(true);
// Act
uninstallCmdlet.Object.Execute();
// Assert
Assert.AreEqual("my-id", vsPackageManager.PackageId);
Assert.AreEqual(new Version("2.8"), vsPackageManager.Version);
Assert.IsTrue(vsPackageManager.RemoveDependencies);
}
public void UninstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var id = "my-id";
var version = new SemanticVersion("2.8");
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var uninstallCmdlet = new Mock <UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object)
{
CallBase = true
};
uninstallCmdlet.Object.Id = id;
uninstallCmdlet.Object.Version = version;
// Act
uninstallCmdlet.Object.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
}
public void InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
null,
null,
new Mock<IVsCommonOperations>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.IgnoreDependencies = new SwitchParameter(true);
// Act
cmdlet.Execute();
// Assert
Assert.Equal("my-id", vsPackageManager.PackageId);
Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version);
Assert.True(vsPackageManager.IgnoreDependencies);
}
public void InstallPackageCmdletSpecifiesInstallOperationDuringExecution()
{
// Arrange
var repo = new MockPackageRepository();
var vsPackageManager = new MockVsPackageManager(repo);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
null,
null,
new Mock<IVsCommonOperations>().Object,
new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
// Act
cmdlet.Execute();
// Assert
Assert.Equal(RepositoryOperationNames.Install, repo.LastOperation);
}
public void InstallPackageCmdletDoNotInvokeProductUpdateCheckWhenSourceIsNotHttpAddressAndSourceNameIsSpecified()
{
// Arrange
string source = "ftp://bing.com";
string sourceName = "BING";
var productUpdateService = new Mock<IProductUpdateService>();
var sourceRepository = new Mock<IPackageRepository>();
sourceRepository.Setup(p => p.Source).Returns(source);
var vsPackageManager = new MockVsPackageManager(sourceRepository.Object);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager);
var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>();
var sourceProvider = GetPackageSourceProvider(new PackageSource(source, sourceName));
packageRepositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, packageRepositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.IgnoreDependencies = new SwitchParameter(true);
cmdlet.Source = sourceName;
// Act
cmdlet.Execute();
// Assert
productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Never());
}
public void InstallPackageCmdletFallsbackToCacheWhenNetworkIsUnavailable()
{
// Arrange
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
var vsPackageManager = new MockVsPackageManager();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var sourceVsPackageManager = new MockVsPackageManager();
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true)).Returns(sourceVsPackageManager);
var userSettings = new Mock<ISettings>();
userSettings.Setup(s => s.GetSettingValues("packageSources", true)).Returns(new[]
{
new SettingValue("one", @"\\LetsHopeThisDirectory\IsNotAvaialble", false),
});
userSettings.Setup(s => s.GetValues("activePackageSource"))
.Returns(new[] { new KeyValuePair<string, string>("one", @"\\LetsHopeThisDirectory\IsNotAvaialble") });
var provider = new VsPackageSourceProvider(userSettings.Object, CreateDefaultSourceProvider(userSettings.Object), new
Mock<IVsShellInfo>().Object);
var activeSource = provider.ActivePackageSource;
//Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(),
packageManagerFactory.Object, repositoryFactory.Object,
provider, null, null,
new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, false);
cmdlet.Id = "my-id";
cmdlet.Execute();
// Assert
Assert.Equal(cmdlet.Source, NuGet.MachineCache.Default.Source);
}
public void ReinstallOnePackageInOneProjectSetOperationToUpdate()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository);
var project = TestUtils.GetProject("project runway", projectFiles: new[] { "dotnetjunky.cs" });
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(defaultProjectName: "project runway", projects: new[] { project }),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project, projectManager);
var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" });
localRepository.AddPackage(package);
projectRepository.AddPackage(package);
sourceRepository.AddPackage(package);
// Act
packageManager.ReinstallPackage(
projectManager,
"phuong",
updateDependencies: true,
allowPrereleaseVersions: true,
logger: NullLogger.Instance);
// Assert
Assert.Equal("Reinstall", sourceRepository.LastOperation);
Assert.Equal("phuong", sourceRepository.LastMainPackageId);
}
public void FallbackToCacheDoesntHappenWhenAggregateIsUsedAndLocalSourceIsAvailable()
{
// Arrange
string localdrive = System.Environment.GetEnvironmentVariable("TEMP");
var userSettings = new Mock<ISettings>();
userSettings.Setup(s => s.GetSettingValues("packageSources", true)).Returns(new[]
{
new SettingValue("one", @"\\LetsHopeThisDirectory\IsNotAvaialble", false),
new SettingValue("two", localdrive, false),
new SettingValue("three", @"http://SomeHttpSource/NotAvailable", false),
});
userSettings.Setup(s => s.GetValues("activePackageSource"))
.Returns(new[] { new KeyValuePair<string, string>("All", @"(All)"),
});
var provider = new VsPackageSourceProvider(userSettings.Object, CreateDefaultSourceProvider(userSettings.Object), new
Mock<IVsShellInfo>().Object);
var activeSource = provider.ActivePackageSource;
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
var vsPackageManager = new MockVsPackageManager();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var sourceVsPackageManager = new MockVsPackageManager();
packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true)).Returns(sourceVsPackageManager);
//Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(),
packageManagerFactory.Object, repositoryFactory.Object,
provider, null, null,
new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, false);
cmdlet.Id = "my-id";
cmdlet.Execute();
// Assert
Assert.NotEqual(cmdlet.Source, NuGet.MachineCache.Default.Source);
}
public void SafeUpdatePackageDoNotUpdateToUnlistedPackageWithPrerelease(string versionA1, string versionA2)
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", versionA1);
var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false);
var sharedRepository = new MockSharedPackageRepository();
sharedRepository.AddPackage(packageA1);
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManagerWithProjects(),
packageRepository,
sharedRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Safe = true;
cmdlet.Execute();
// Assert
Assert.False(sharedRepository.Contains(packageA2));
}
public void UpdatePackageUpdateToUnlistedPackageIfVersionIsSet(string versionA1, string versionA2)
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", versionA1);
var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false);
var localRepository = new Mock<MockPackageRepository>() { CallBase = true };
var sharedRepository = localRepository.As<ISharedPackageRepository>();
localRepository.Object.AddPackage(packageA1);
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManagerWithProjects(),
packageRepository,
sharedRepository.Object);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion(versionA2);
cmdlet.Execute();
// Assert
Assert.False(localRepository.Object.Contains(packageA1));
Assert.True(localRepository.Object.Contains(packageA2));
}
public void ReinstallPackagesSkipRestallingForOneProjectButProceedWithTheOther()
{
// Arrange
var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var localRepository = localRepositoryMock.Object;
var sourceRepository = new MockPackageRepository();
var projectSystem1 = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0"));
var pathResolver1 = new DefaultPackagePathResolver(projectSystem1);
var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository);
var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1);
var projectSystem2 = new MockProjectSystem(new FrameworkName(".NETCore, Version=v4.5"));
var pathResolver2 = new DefaultPackagePathResolver(projectSystem2);
var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository);
var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2);
var project1 = TestUtils.GetProject("Project1");
var project2 = TestUtils.GetProject("Project2");
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(projects: new[] { project1, project2 }),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem2,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project1, projectManager1);
packageManager.RegisterProjectManager(project2, projectManager2);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "net30\\content.txt", "silverlight40\\content4.txt" },
new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "winrt45\\hello.txt", "sl4-wp71\\world.txt" },
new[] { "lib\\winrt45\\comma.dll", "lib\\sl4-wp71\\dude.dll" });
sourceRepository.Add(packageA);
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
// install package A -> project 1
// and package B -> project 2
packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
// now change project's target framework to silverlight
projectSystem1.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0"));
projectSystem2.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0, Profile=WindowsPhone71"));
localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version));
localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version));
var logger = new Mock<ILogger>();
logger.Setup(s => s.Log(
MessageLevel.Warning,
"Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.",
"B 2.0",
"Project2")
).Verifiable();
// Act
packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: logger.Object, eventListener: NullPackageOperationEventListener.Instance);
// Assert
logger.Verify();
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.FileExists("content4.txt"));
Assert.False(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(projectSystem1.ReferenceExists("refsl.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectSystem2.FileExists("hello.txt"));
Assert.False(projectSystem2.FileExists("world.txt"));
Assert.True(projectSystem2.ReferenceExists("comma.dll"));
Assert.False(projectSystem2.ReferenceExists("dude.dll"));
}
public void UpdatePackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var vsPackageManager = new MockVsPackageManager();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true };
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
// Act
cmdlet.Object.Execute();
// Assert
Assert.AreEqual("my-id", vsPackageManager.PackageId);
Assert.AreEqual(new Version("2.8"), vsPackageManager.Version);
}
public void UpdatePackageCmdletUsesPackageManangerWithSourceIfSpecified()
{
// Arrange
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
var vsPackageManager = new MockVsPackageManager();
var sourceVsPackageManager = new MockVsPackageManager();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager);
packageManagerFactory.Setup(m => m.CreatePackageManager("somesource")).Returns(sourceVsPackageManager);
var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true };
cmdlet.Object.Source = "somesource";
cmdlet.Object.Id = "my-id";
cmdlet.Object.Version = new Version("2.8");
// Act
cmdlet.Object.Execute();
// Assert
Assert.AreSame(sourceVsPackageManager, cmdlet.Object.PackageManager);
}
public void ReinstallPackagesRestoresPackageInAllProjectsWithNewContentIfSourcePackageChanges()
{
// Arrange
var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var localRepository = localRepositoryMock.Object;
var sourceRepository = new MockPackageRepository();
var projectSystem1 = new MockProjectSystem();
var pathResolver1 = new DefaultPackagePathResolver(projectSystem1);
var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository);
var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1);
var projectSystem2 = new MockProjectSystem();
var pathResolver2 = new DefaultPackagePathResolver(projectSystem2);
var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository);
var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2);
var project1 = TestUtils.GetProject("Project1");
var project2 = TestUtils.GetProject("Project2");
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(projects: new[] { project1, project2 }),
sourceRepository,
new Mock<IFileSystemProvider>().Object,
projectSystem2,
localRepository,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project1, projectManager1);
packageManager.RegisterProjectManager(project2, projectManager2);
var packageA = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "content.txt" },
new[] { "lib\\ref.dll" });
var packageA2 = PackageUtility.CreatePackage(
"A",
"1.2-alpha",
new[] { "foo.txt" },
new[] { "lib\\bar.dll" });
var packageB = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "hello.txt" },
new[] { "lib\\comma.dll" });
var packageB2 = PackageUtility.CreatePackage(
"B",
"2.0",
new[] { "world.txt" },
new[] { "lib\\dude.dll" });
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
// install package A -> project 1
// and package B -> project 2
packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null);
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectSystem2.FileExists("hello.txt"));
Assert.True(projectSystem2.ReferenceExists("comma.dll"));
// now change the package A and B to different packages
sourceRepository.RemovePackage(packageA);
sourceRepository.RemovePackage(packageB);
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageB2);
localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version));
localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version));
// Act
packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance, eventListener: NullPackageOperationEventListener.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha")));
Assert.False(projectSystem1.FileExists("content.txt"));
Assert.True(projectSystem1.FileExists("foo.txt"));
Assert.False(projectSystem1.ReferenceExists("ref.dll"));
Assert.True(projectSystem1.ReferenceExists("bar.dll"));
Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0")));
Assert.False(projectSystem2.FileExists("hello.txt"));
Assert.True(projectSystem2.FileExists("world.txt"));
Assert.False(projectSystem2.ReferenceExists("comma.dll"));
Assert.True(projectSystem2.ReferenceExists("dude.dll"));
}
public void UpdatePackageCmdletInvokeProductUpdateCheckWhenSourceIsHttpAddress()
{
// Arrange
string source = "http://bing.com";
var productUpdateService = new Mock<IProductUpdateService>();
var sourceRepository = new Mock<IPackageRepository>();
sourceRepository.Setup(p => p.Source).Returns(source);
var vsPackageManager = new MockVsPackageManager(sourceRepository.Object);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(c => c.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager);
var mockPackageRepository = new MockPackageRepository();
var sourceProvider = GetPackageSourceProvider(new PackageSource(source));
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object);
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "my-id";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.IgnoreDependencies = new SwitchParameter(isPresent: true);
cmdlet.Source = source;
cmdlet.ProjectName = "foo";
// Act
cmdlet.Execute();
// Assert
productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Once());
}