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 InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0-a");
var packageRepository = new MockPackageRepository {
packageA
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// packageA is not installed yet.
Assert.False(packageManager.LocalRepository.IsSolutionReferenced(packageA.Id, packageA.Version));
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert: packageA is installed.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", versionB, listed: false);
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable();
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion(versionA))).Returns(true);
sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion(versionB))).Returns(true);
var packageRepository = new MockPackageRepository {
packageA, packageB
};
var recentPackageRepository = new Mock <IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify();
}
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec {
MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true
}) });
var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false);
var sharedRepository = new Mock <ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB2)).Verifiable();
var packageRepository = new MockPackageRepository {
packageA, packageB1, packageB2
};
var recentPackageRepository = new Mock <IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify();
sharedRepository.Verify(s => s.AddPackage(packageB1), Times.Never());
}
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 InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0-a");
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-a"))).Returns(true);
var packageRepository = new MockPackageRepository {
packageA
};
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(
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.Execute();
// Assert
sharedRepository.Verify();
}
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 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);
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 InstallPackageCmdletCreatesPackageManagerWithFallbackFlagSet()
{
// Arrange
var productUpdateService = new Mock <IProductUpdateService>();
var fallbackRepo = new Mock <IVsPackageManager>();
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(c => c.CreatePackageManager()).Returns(fallbackRepo.Object).Verifiable();
packageManagerFactory.Setup(c => c.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Throws(new Exception());
var repoA = new MockPackageRepository();
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, GetPackageSourceProvider(new PackageSource("A")), null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "P1";
cmdlet.Source = "A";
// Act
cmdlet.Execute();
// Assert
// If we've come this far, P1 is successfully installed.
Assert.True(true);
}
public void InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec {
MinVersion = new SemanticVersion("0.5")
}) });
var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.2", listed: false);
var sharedRepository = new Mock <ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB1)).Verifiable();
var packageRepository = new MockPackageRepository {
packageA, packageB1, packageB2
};
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(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.Execute();
// Assert
sharedRepository.Verify();
sharedRepository.Verify(s => s.AddPackage(packageB2), Times.Never());
}
public void InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0");
var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false);
var packageRepository = new MockPackageRepository {
packageA1, packageA2
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion("1.0.0-ReleaseCandidate");
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert: the unlisted prerelease packageA2 is installed.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA2, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
public SitecoreShipHttpHandler()
{
// TODO move this construction logic out of here ...
var aboutCommand = new AboutCommand();
var installPackageCommand = new InstallPackageCommand();
var installUploadPackageCommand = new InstallUploadPackageCommand();
var latestVersionCommand = new LatestVersionCommand();
var invokePublishingCommand = new InvokePublishingCommand();
var publishingLastCompletedCommand = new PublishingLastCompletedCommand();
var unhandledCommand = new UnhandledCommand();
aboutCommand.SetSuccessor(installPackageCommand);
installPackageCommand.SetSuccessor(installUploadPackageCommand);
installUploadPackageCommand.SetSuccessor(latestVersionCommand);
latestVersionCommand.SetSuccessor(invokePublishingCommand);
invokePublishingCommand.SetSuccessor(publishingLastCompletedCommand);
publishingLastCompletedCommand.SetSuccessor(unhandledCommand);
_commandChain = aboutCommand;
}
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", versionB, listed: false);
var packageRepository = new MockPackageRepository {
packageA, packageB
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(2, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion);
}
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 InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec {
MinVersion = new SemanticVersion("0.5")
}) });
var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.2", listed: false);
var packageRepository = new MockPackageRepository {
packageA, packageB1, packageB2
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert: packageA and packageB1 are installed. packageB1 is picked because
// packageB2 is unlisted.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(2, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB1, installedPackages[1], PackageEqualityComparer.IdAndVersion);
}
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec {
MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true
}) });
var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false);
var packageRepository = new MockPackageRepository {
packageA, packageB1, packageB2
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert: packageA and packageB2 are installed.
// packageB1 is not picked because it cannot be used as a dependency of packageA
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(2, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion);
}
public void InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0");
var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false);
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA2));
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-ReleaseCandidate"))).Returns(true);
var packageRepository = new MockPackageRepository {
packageA1, packageA2
};
var recentPackageRepository = new Mock <IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion("1.0.0-ReleaseCandidate");
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never());
sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Once());
}
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 InstallPackageCmdletThrowsWhenSolutionIsClosed()
{
// Arrange
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns((IVsPackageManager)null);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(isSolutionOpen: false), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
// Act and Assert
ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.GetResults(),
"The current environment doesn't have a solution open.");
}
public void InstallPackageCmdletThrowsWhenSolutionIsClosed()
{
// Arrange
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns((IVsPackageManager)null);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(isSolutionOpen: false), packageManagerFactory.Object, null, null, null, null, new Mock <IVsCommonOperations>().Object);
// Act and Assert
ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.GetResults(),
"The current environment doesn't have a solution open.");
}
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageC = PackageUtility.CreatePackage("C", "2.0.0");
var mockRepository = new Mock <IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable();
var packageRepository = new AggregateRepository(new[] {
new MockPackageRepository {
packageA
},
mockRepository.Object,
new MockPackageRepository {
packageB
},
new MockPackageRepository {
packageC
},
});
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Execute();
cmdlet.Id = "C";
cmdlet.Execute();
// Assert
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(3, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageC, installedPackages[2], PackageEqualityComparer.IdAndVersion);
mockRepository.Verify();
}
public void InstallPackageCmdletOpenReadmeFileFromPackageIfItIsPresent()
{
// Arrange
var packageA = new Mock <IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock <IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA.Object)).Verifiable();
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true);
var packageRepository = new MockPackageRepository {
packageA.Object
};
var recentPackageRepository = new Mock <IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object,
recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock <IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
new Mock <IHttpClientEvents>().Object,
null,
fileOperations.Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
}
public void InstallPackageCmdletOpenReadmeFileFromPackageIfItIsPresent()
{
// Arrange
var packageA = new Mock <IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock <IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
packageA.Setup(p => p.GetStream()).Returns(new MemoryStream());
var packageRepository = new MockPackageRepository {
packageA.Object
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock <IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
new Mock <IHttpClientEvents>().Object,
null,
fileOperations.Object,
new Mock <IDeleteOnRestartManager>().Object,
true);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
}
public void InstallPackageCmdletThrowsWhenSolutionIsClosed()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0");
var packageRepository = new MockPackageRepository { packageA };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
((MockSolutionManager2)packageManager.SolutionManager).IsSolutionOpen = false;
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
// Act and Assert
ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.GetResults(),
"The current environment doesn't have a solution open.");
}
public void InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent()
{
// Arrange
var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict);
var packageRepository = new MockPackageRepository {
PackageUtility.CreatePackage("A", "1.0.0-a")
};
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock <IDeleteOnRestartManager>().Object, null);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
// Assert
ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.Execute(), "Unable to find package 'A'.");
}
public void InstallPackageCmdletThrowsWhenSolutionIsClosed()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0");
var packageRepository = new MockPackageRepository {
packageA
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
((MockSolutionManager2)packageManager.SolutionManager).IsSolutionOpen = false;
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true);
// Act and Assert
ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.GetResults(),
"The current environment doesn't have a solution open.");
}
public void InstallPackageCmdletCreatesFallbackRepository()
{
// Arrange
var productUpdateService = new Mock <IProductUpdateService>();
IPackageRepository repoA = new MockPackageRepository(), repoB = new MockPackageRepository();
var package = NuGet.Test.PackageUtility.CreatePackage("P1", dependencies: new[] { new PackageDependency("P2") });
repoA.AddPackage(package);
repoB.AddPackage(NuGet.Test.PackageUtility.CreatePackage("P2"));
var sharedRepo = new Mock <ISharedPackageRepository>();
var recentRepo = new Mock <IRecentPackageRepository>();
var repositoryFactory = new Mock <IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA);
repositoryFactory.Setup(c => c.CreateRepository("B")).Returns(repoB);
var sourceProvider = GetPackageSourceProvider(new PackageSource("A"), new PackageSource("B"));
var fileSystemProvider = new Mock <IFileSystemProvider>();
fileSystemProvider.Setup(c => c.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem());
var repositorySettings = new Mock <IRepositorySettings>();
repositorySettings.Setup(c => c.RepositoryPath).Returns(String.Empty);
var solutionManager = new Mock <ISolutionManager>();
var packageManagerFactory = new Mock <VsPackageManagerFactory>(solutionManager.Object, repositoryFactory.Object, sourceProvider, fileSystemProvider.Object, repositorySettings.Object, null, new Mock <VsPackageInstallerEvents>().Object);
packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny <string>())).Returns(new MockFileSystem());
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object);
cmdlet.Id = "P1";
cmdlet.Source = "A";
// Act
cmdlet.Execute();
// Assert
// If we've come this far, P1 is successfully installed.
Assert.True(true);
}
private async void InstallPackageAsync()
{
try
{
ILibrary selectedPackage = SelectedPackage;
_isInstalling = true;
InstallPackageCommand.CanExecute(null);
Manifest manifest = await Manifest.FromFileAsync(_configFileName, _deps, CancellationToken.None).ConfigureAwait(false);
string targetPath = _targetPath;
if (!string.IsNullOrEmpty(_configFileName))
{
Uri configContainerUri = new Uri(_configFileName, UriKind.Absolute);
Uri targetUri = new Uri(targetPath, UriKind.Absolute);
targetPath = configContainerUri.MakeRelativeUri(targetUri).ToString();
}
manifest.AddLibrary(new LibraryInstallationState
{
LibraryId = PackageId,
ProviderId = selectedPackage.ProviderId,
DestinationPath = targetPath,
Files = SelectedFiles.ToList()
});
await manifest.SaveAsync(_configFileName, CancellationToken.None).ConfigureAwait(false);
EnvDTE.Project project = VsHelpers.DTE.SelectedItems.Item(1)?.ProjectItem?.ContainingProject;
project?.AddFileToProject(_configFileName);
await LibraryHelpers.RestoreAsync(_configFileName).ConfigureAwait(false);
_dispatcher.Invoke(() =>
{
_closeDialog(true);
});
}
catch { }
}
private static void ParseArguments(string[] args)
{
if (args == null || args.Length == 0)
{
DisplayHelpMessage();
}
if (args.Length == 2)
{
if (args[0] == "Install")
{
var command = new InstallPackageCommand(_logger, _fileSystem, _apiClient);
command.ExecuteAsync(args[1]);
}
}
if (args.Length > 2)
{
_logger.LogError("Too many arguments provided.");
DisplayHelpMessage();
}
}
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 InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var packageA28 = PackageUtility.CreatePackage("A", "2.8");
var packageA31 = PackageUtility.CreatePackage("A", "3.1");
var packageRepository = new MockPackageRepository {
packageA28, packageA31
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
null,
null,
new Mock <IVsCommonOperations>().Object,
new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.Execute();
// Assert: version 2.8 is installed.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA28, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
public void InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0.0");
var packageRepository = new MockPackageRepository {
packageA, packageB
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock <IVsPackageSourceProvider>().Object,
null,
null,
new Mock <IVsCommonOperations>().Object,
new Mock <IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IgnoreDependencies = new SwitchParameter(true);
cmdlet.Execute();
// Assert: only packageA is installed. packageB is not.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
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 InstallPackageCmdletOpenReadmeFileFromPackageIfItIsPresent()
{
// Arrange
var packageA = new Mock<IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock<IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
packageA.Setup(p => p.GetStream()).Returns(new MemoryStream());
var packageRepository = new MockPackageRepository { packageA.Object };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock<IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
new Mock<IHttpClientEvents>().Object,
null,
fileOperations.Object,
new Mock<IDeleteOnRestartManager>().Object,
true);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
}
public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified()
{
// Arrange
var packageA28 = PackageUtility.CreatePackage("A", "2.8");
var packageA31 = PackageUtility.CreatePackage("A", "3.1");
var packageRepository = new MockPackageRepository { packageA28, packageA31 };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
null,
null,
new Mock<IVsCommonOperations>().Object,
new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion("2.8");
cmdlet.Execute();
// Assert: version 2.8 is installed.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA28, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
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 InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0");
var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA2));
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-ReleaseCandidate"))).Returns(true);
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(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("1.0.0-ReleaseCandidate");
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never());
sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Once());
}
public void InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent()
{
// Arrange
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
var packageRepository = new MockPackageRepository { PackageUtility.CreatePackage("A", "1.0.0-a") };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, null);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
// Assert
ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.Execute(), "Unable to find package 'A'.");
}
public void InstallPackageCmdletCreatesFallbackRepository()
{
// Arrange
var productUpdateService = new Mock<IProductUpdateService>();
IPackageRepository repoA = new MockPackageRepository(), repoB = new MockPackageRepository();
var package = NuGet.Test.PackageUtility.CreatePackage("P1", dependencies: new[] { new PackageDependency("P2") });
repoA.AddPackage(package);
repoB.AddPackage(NuGet.Test.PackageUtility.CreatePackage("P2"));
var sharedRepo = new Mock<ISharedPackageRepository>();
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA);
repositoryFactory.Setup(c => c.CreateRepository("B")).Returns(repoB);
var sourceProvider = GetPackageSourceProvider(new PackageSource("A"), new PackageSource("B"));
var fileSystemProvider = new Mock<IFileSystemProvider>();
fileSystemProvider.Setup(c => c.GetFileSystem(It.IsAny<string>(), It.IsAny<bool>())).Returns(new MockFileSystem());
var repositorySettings = new Mock<IRepositorySettings>();
repositorySettings.Setup(c => c.RepositoryPath).Returns(String.Empty);
var solutionManager = new Mock<ISolutionManager>();
var packageManagerFactory = new Mock<VsPackageManagerFactory>(solutionManager.Object, repositoryFactory.Object, sourceProvider, fileSystemProvider.Object, repositorySettings.Object, new Mock<VsPackageInstallerEvents>().Object);
packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny<string>())).Returns(new MockFileSystem());
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "P1";
cmdlet.Source = "A";
// Act
cmdlet.Execute();
// Assert
// If we've come this far, P1 is successfully installed.
Assert.True(true);
}
public void InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0");
var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false);
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion("1.0.0-ReleaseCandidate");
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert: the unlisted prerelease packageA2 is installed.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA2, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", versionB, listed: false);
var packageRepository = new MockPackageRepository { packageA, packageB };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(2, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion);
}
public async Task <ActionResult <string> > Install(InstallPackageCommand command)
{
return(await Mediator.Send(command));
}
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageC = PackageUtility.CreatePackage("C", "2.0.0");
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable();
var packageRepository = new AggregateRepository(new[] {
new MockPackageRepository {
packageA
},
mockRepository.Object,
new MockPackageRepository {
packageB
},
new MockPackageRepository {
packageC
},
});
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Execute();
cmdlet.Id = "C";
cmdlet.Execute();
// Assert
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(3, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageC, installedPackages[2], PackageEqualityComparer.IdAndVersion);
mockRepository.Verify();
}
public void InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency2()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("0.5") }) });
var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.2-alpha", listed: true);
var packageB3 = PackageUtility.CreatePackage("B", "1.0.2", listed: false);
var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2, packageB3 };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.DependencyVersion = DependencyVersion.HighestPatch;
cmdlet.Execute();
// Assert: packageA and packageB2 are installed.
// packageB1 is not picked because packageB2's version is later.
// packageB3 is not picked because it's unlisted.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(2, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion);
}
public void InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("0.5")})});
var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.2", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB1)).Verifiable();
var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 };
var recentPackageRepository = new Mock<IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
sharedRepository.Verify();
sharedRepository.Verify(s => s.AddPackage(packageB2), Times.Never());
}
public void InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0-a");
var packageRepository = new MockPackageRepository { packageA };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// packageA is not installed yet.
Assert.False(packageManager.LocalRepository.IsSolutionReferenced(packageA.Id, packageA.Version));
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert: packageA is installed.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
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 InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0.0");
var packageRepository = new MockPackageRepository { packageA, packageB };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
null,
null,
new Mock<IVsCommonOperations>().Object,
new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IgnoreDependencies = new SwitchParameter(true);
cmdlet.Execute();
// Assert: only packageA is installed. packageB is not.
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
public void InstallPackageCmdletCreatesPackageManagerWithFallbackFlagSet()
{
// Arrange
var productUpdateService = new Mock<IProductUpdateService>();
var fallbackRepo = new Mock<IVsPackageManager>();
var packageManagerFactory = new Mock<IVsPackageManagerFactory>();
packageManagerFactory.Setup(c => c.CreatePackageManager()).Returns(fallbackRepo.Object).Verifiable();
packageManagerFactory.Setup(c => c.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Throws(new Exception());
var repoA = new MockPackageRepository();
var repositoryFactory = new Mock<IPackageRepositoryFactory>();
repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA);
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, GetPackageSourceProvider(new PackageSource("A")), null, productUpdateService.Object, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "P1";
cmdlet.Source = "A";
// Act
cmdlet.Execute();
// Assert
// If we've come this far, P1 is successfully installed.
Assert.True(true);
}
public void InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0-a");
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.SetupSet(s => s.PackageSaveMode = PackageSaveModes.Nupkg);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-a"))).Returns(true);
var packageRepository = new MockPackageRepository { packageA };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
new Mock<IHttpClientEvents>().Object,
null,
new Mock<IVsCommonOperations>().Object,
new Mock<IDeleteOnRestartManager>().Object,
true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify();
}
public void InstallPackageWithoutSettingVersionDoNotInstallUnlistedPackage()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0.0", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA1));
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var recentPackageRepository = new Mock<IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Once());
sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Never());
}
public void InstallPackageCmdletOnlyOpenReadmeFileFromTheRootPackage()
{
// Arrange
// A --> B
var packageA = new Mock<IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var depSet = new PackageDependencySet(null, new[] { new PackageDependency("B") });
packageA.Setup(p => p.DependencySets).Returns(new[] { depSet });
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock<IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
var packageB = new Mock<IPackage>();
packageB.Setup(p => p.Id).Returns("B");
packageB.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var readmeB = new Mock<IPackageFile>();
readmeB.Setup(f => f.Path).Returns("readMe.txt");
readmeB.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageB.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readmeB.Object });
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA.Object));
sharedRepository.Setup(s => s.AddPackage(packageB.Object));
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true);
sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion("1.0"))).Returns(true);
var packageRepository = new MockPackageRepository { packageA.Object, packageB.Object };
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManagerWithProjects("foo"),
packageRepository,
new Mock<IFileSystemProvider>().Object,
new MockFileSystem(),
sharedRepository.Object,
new Mock<IDeleteOnRestartManager>().Object,
new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock<IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
new Mock<IHttpClientEvents>().Object,
null,
fileOperations.Object,
new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("B.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Never());
}
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", versionB, listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable();
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion(versionA))).Returns(true);
sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion(versionB))).Returns(true);
var packageRepository = new MockPackageRepository { packageA, packageB };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(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.Execute();
// Assert
sharedRepository.Verify();
}
private async Task InstallPackageAsync()
{
try
{
bool isLibraryInstallationStateValid = await IsLibraryInstallationStateValidAsync().ConfigureAwait(false);
if (isLibraryInstallationStateValid)
{
ILibrary selectedPackage = SelectedPackage;
InstallPackageCommand.CanExecute(null);
Manifest manifest = await Manifest.FromFileAsync(_configFileName, _deps, CancellationToken.None).ConfigureAwait(false);
string targetPath = _targetPath;
if (!string.IsNullOrEmpty(_configFileName))
{
Uri configContainerUri = new Uri(_configFileName, UriKind.Absolute);
Uri targetUri = new Uri(targetPath, UriKind.Absolute);
targetPath = configContainerUri.MakeRelativeUri(targetUri).ToString();
}
if (String.IsNullOrEmpty(manifest.Version))
{
manifest.Version = Manifest.SupportedVersions.Max().ToString();
}
(string name, string version) = LibraryIdToNameAndVersionConverter.Instance.GetLibraryNameAndVersion(PackageId, SelectedProvider.Id);
LibraryInstallationState libraryInstallationState = new LibraryInstallationState
{
Name = name,
Version = version,
ProviderId = selectedPackage.ProviderId,
DestinationPath = InstallationFolder.DestinationFolder,
};
_isInstalling = true;
// When "Include all files" option is checked, we don't want to write out the files to libman.json.
// We will only list the files when user chose to install specific files.
if (LibraryFilesToInstall == FileSelectionType.ChooseSpecificFilesToInstall)
{
libraryInstallationState.Files = SelectedFiles.ToList();
}
manifest.AddLibrary(libraryInstallationState);
await Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (!File.Exists(_configFileName))
{
await manifest.SaveAsync(_configFileName, CancellationToken.None);
if (_project != null)
{
await _project.AddFileToProjectAsync(_configFileName);
}
}
RunningDocumentTable rdt = new RunningDocumentTable(Shell.ServiceProvider.GlobalProvider);
string configFilePath = Path.GetFullPath(_configFileName);
IVsTextBuffer textBuffer = rdt.FindDocument(configFilePath) as IVsTextBuffer;
_dispatcher.Invoke(() =>
{
_closeDialog(true);
});
// The file isn't open. So we'll write to disk directly
if (textBuffer == null)
{
manifest.AddLibrary(libraryInstallationState);
await manifest.SaveAsync(_configFileName, CancellationToken.None).ConfigureAwait(false);
Telemetry.TrackUserTask("Invoke-RestoreFromAddClientLibrariesDialog");
await _libraryCommandService.RestoreAsync(_configFileName, CancellationToken.None).ConfigureAwait(false);
}
else
{
// libman.json file is open, so we will write to the textBuffer.
InsertIntoTextBuffer(textBuffer, libraryInstallationState, manifest);
// Save manifest file so we can restore library files.
rdt.SaveFileIfDirty(configFilePath);
}
}
}
catch (Exception ex)
{
Telemetry.TrackException(nameof(InstallPackageAsync), ex);
}
}
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true }) });
var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB2)).Verifiable();
var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(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.Execute();
// Assert
sharedRepository.Verify();
sharedRepository.Verify(s => s.AddPackage(packageB1), Times.Never());
}
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true }) });
var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false);
var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 };
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert: packageA and packageB2 are installed.
// packageB1 is not picked because it cannot be used as a dependency of packageA
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(2, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion);
}
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 InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0-a");
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.SetupSet(s => s.PackageSaveMode = PackageSaveModes.Nupkg);
var packageRepository = new MockPackageRepository { packageA1 };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, null);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
// Assert
ExceptionAssert.Throws<NotImplementedException>(() => cmdlet.Execute(), "WriteWarning");
sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never());
}
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageC = PackageUtility.CreatePackage("C", "2.0.0");
var sharedRepository = new Mock<ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageC)).Verifiable();
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable();
var packageRepository = new AggregateRepository(new[] {
new MockPackageRepository {
packageA
},
mockRepository.Object,
new MockPackageRepository {
packageB
},
new MockPackageRepository {
packageC
},
});
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Execute();
cmdlet.Id = "C";
cmdlet.Execute();
// Assert
sharedRepository.Verify();
mockRepository.Verify();
}
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);
}
