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 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 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 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 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 UninstallPackageCmdletWhenIdAndVersionAreSpecified()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageRepository = new MockPackageRepository {
packageA
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
InstallPackage("A", packageManager);
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(new[] { packageA }, installedPackages, PackageEqualityComparer.IdAndVersion);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var cmdlet = new UninstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock <IVsCommonOperations>().Object,
new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion("1.1");
// Act and Assert
ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.GetResults(),
"Unable to find package 'A'.");
}
public void UpdatePackageUpdateToUnlistedPackageIfVersionIsSet(string versionA1, string versionA2)
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", versionA1);
var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false);
var packageRepository = new MockPackageRepository {
packageA1, packageA2
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
InstallPackage(packageA1.Id, packageA1.Version, packageManager);
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(new[] { packageA1 }, installedPackages, PackageEqualityComparer.IdAndVersion);
var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new UpdatePackageCommand(packageManager.SolutionManager, 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.GetResults();
// Assert: packageA1 is updated to packageA2.
installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(new[] { packageA2 }, installedPackages, PackageEqualityComparer.IdAndVersion);
}
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 });
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 UninstallPackageCmdletPassesForceSwitchCorrectly()
{
// Arrange
var packageA = PackageUtility.CreatePackage(
"A", "1.0",
dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0");
var packageRepository = new MockPackageRepository {
packageA, packageB
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
InstallPackage("A", packageManager);
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion);
// Act
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var cmdlet = new UninstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock <IVsCommonOperations>().Object,
new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "B";
// Assert: packageB cannot be uninstalled without -Force
ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.Execute(),
"Unable to uninstall 'B 1.0' because 'A 1.0' depends on it.");
// Assert: packageB can be uninstalled with -Force
cmdlet.Force = new SwitchParameter(true);
cmdlet.Execute();
installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(1, installedPackages.Count);
Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion);
}
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.");
}
private void InstallPackage(string id, MockVsPackageManager2 packageManager)
{
var projectManager = packageManager.GetProjectManager(packageManager.SolutionManager.GetProject("default"));
// Resolve the package to install
IPackage package = PackageRepositoryHelper.ResolvePackage(
packageManager.SourceRepository,
packageManager.LocalRepository,
id,
version: null,
allowPrereleaseVersions: false);
// Resolve operations
var resolver = new ActionResolver();
resolver.AddOperation(PackageAction.Install, package, projectManager);
var actions = resolver.ResolveActions();
var actionExecutor = new ActionExecutor();
actionExecutor.Execute(actions);
}
public void UninstallPackageCmdletWithRemoveDependencySwitch()
{
// Arrange
var packageA = PackageUtility.CreatePackage(
"A", "1.0",
dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0");
var packageRepository = new MockPackageRepository {
packageA, packageB
};
var packageManager = new MockVsPackageManager2(
@"c:\solution",
packageRepository);
InstallPackage("A", packageManager);
var installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion);
// Act
var packageManagerFactory = new Mock <IVsPackageManagerFactory>();
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var cmdlet = new UninstallPackageCommand(
packageManager.SolutionManager,
packageManagerFactory.Object,
null,
new Mock <IVsCommonOperations>().Object,
new Mock <IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.RemoveDependencies = new SwitchParameter(true);
cmdlet.Execute();
// Assert: both packageA & packageB are uninstalled
installedPackages = packageManager.LocalRepository.GetPackages().ToList();
Assert.Equal(0, installedPackages.Count);
}
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);
}
