public void FallbackRepositoryRetursNullIfPrimaryRepositoryDoesNotHaveDependencyAndDependencyResolverThrows()
{
// Arrange
var package = PackageUtility.CreatePackage("M1", "1.0");
var dependencyResolver = new Mock <IPackageRepository>(MockBehavior.Strict);
dependencyResolver.As <IDependencyResolver>()
.Setup(c => c.ResolveDependency(It.IsAny <PackageDependency>(), It.IsAny <IPackageConstraintProvider>(), false, It.IsAny <bool>(), DependencyVersion.Lowest))
.Throws(new Exception("Connection failure."));
var aggregateRepository = new AggregateRepository(new[] { dependencyResolver.Object })
{
IgnoreFailingRepositories = true
};
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(package);
var fallbackRepository = new FallbackRepository(primaryRepository, aggregateRepository);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec {
MinVersion = new SemanticVersion("1.0.1")
}), false, false);
// Assert
Assert.Null(resolvedPackage);
}
public void FallbackRepositoryCallsPackagesFindPackageOnThePrimaryRepository()
{
// Arrange
var primaryRepository = new Mock <IPackageRepository>(MockBehavior.Strict);
IPackage package = PackageUtility.CreatePackage("A", "1.0");
primaryRepository.As <IPackageLookup>().Setup(p => p.FindPackage("A", new SemanticVersion("1.0"))).Returns(package).Verifiable();
var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository());
// Act
IPackage foundPackage = fallbackRepository.FindPackage("A", new SemanticVersion("1.0"));
// Assert
primaryRepository.VerifyAll();
Assert.Same(package, foundPackage);
}
public void ExistsReturnsTrueIfPrimaryRepositoryContainsPackage()
{
// Arrange
IPackage package = PackageUtility.CreatePackage("A", "1.0");
var primaryRepository = new Mock <IPackageRepository>(MockBehavior.Strict);
primaryRepository.As <IPackageLookup>()
.Setup(s => s.Exists("A", new SemanticVersion("1.0")))
.Returns(true)
.Verifiable();
var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository());
// Act
var exists = fallbackRepository.Exists("A", new SemanticVersion("1.0"));
// Assert
Assert.True(exists);
primaryRepository.Verify();
}
public void FallbackRepositoryDoesNotQueryDependencyResolverIfPrimaryRepositoryContainsRequiredDependency()
{
// Arrange
var package = PackageUtility.CreatePackage("M1", "1.0");
var dependencyResolver = new Mock <IPackageRepository>(MockBehavior.Strict);
dependencyResolver.As <IDependencyResolver>()
.Setup(c => c.ResolveDependency(It.IsAny <PackageDependency>(), It.IsAny <IPackageConstraintProvider>(), false, It.IsAny <bool>(), DependencyVersion.Lowest))
.Throws(new Exception("This method should not be called."));
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(package);
var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver.Object);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M1"), false, false);
// Assert
Assert.Same(package, resolvedPackage);
}
public void FallbackRepositoryUsesDependencyResolverIfPrimaryRepositoryDoesNotHaveRequiredDependency()
{
// Arrange
IPackage packageA10 = PackageUtility.CreatePackage("M1", "1.0"), packageA11 = PackageUtility.CreatePackage("M2", "1.1");
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(packageA10);
var dependencyResolver = new MockPackageRepository();
dependencyResolver.AddPackage(packageA11);
var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec {
MinVersion = new SemanticVersion("1.0.1")
}), false, false);
// Assert
Assert.Same(resolvedPackage, packageA11);
}
public void CreateFallbackRepositoryUsesResolvedSourceNameWhenEnsuringRepositoryIsNotAlreadyListedInAggregate()
{
// Arrange
var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var mockSourceProvider = new Mock <IVsPackageSourceProvider>();
var mockRepository1 = new MockPackageRepository();
var mockRepository2 = new MockPackageRepository("http://redirected");
var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 });
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var aggregateSource = AggregatePackageSource.Instance;
mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0"));
mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2"));
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource });
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s =>
{
switch (s)
{
case "Source1": return(mockRepository1);
case "Source2": return(mockRepository2);
default: return(null);
}
});
var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, machineWideSettings: null);
// Act
FallbackRepository repository = (FallbackRepository)packageManagerFactory.CreateFallbackRepository(mockRepository2);
// Assert
var dependencyResolver = (AggregateRepository)repository.DependencyResolver;
Assert.Equal(2, dependencyResolver.Repositories.Count());
}
public void CreateFallbackRepositoryDoesNotThrowWhenIteratingOverFailingRepositories()
{
// Arrange
var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>();
var mockSourceProvider = new Mock <IVsPackageSourceProvider>();
var mockRepository1 = new MockPackageRepository();
var mockRepository2 = new MockPackageRepository("http://redirected");
var source1 = new PackageSource("Source1");
var source2 = new PackageSource("Source2");
var source3 = new PackageSource("SourceBad");
var aggregateSource = AggregatePackageSource.Instance;
mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source3, source2, aggregateSource });
mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s =>
{
switch (s)
{
case "Source1": return(mockRepository1);
case "Source2": return(mockRepository2);
case "SourceBad": throw new InvalidOperationException();
default: return(null);
}
});
var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, machineWideSettings: null);
// Act
FallbackRepository repository = (FallbackRepository)packageManagerFactory.CreateFallbackRepository(mockRepository2);
// Assert
var dependencyResolver = (AggregateRepository)repository.DependencyResolver;
Assert.Equal(2, dependencyResolver.Repositories.Count());
}
public void ExistsReturnsTrueIfPrimaryRepositoryContainsPackage()
{
// Arrange
IPackage package = PackageUtility.CreatePackage("A", "1.0");
var primaryRepository = new Mock<IPackageRepository>(MockBehavior.Strict);
primaryRepository.As<IPackageLookup>()
.Setup(s => s.Exists("A", new SemanticVersion("1.0")))
.Returns(true)
.Verifiable();
var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository());
// Act
var exists = fallbackRepository.Exists("A", new SemanticVersion("1.0"));
// Assert
Assert.True(exists);
primaryRepository.Verify();
}
public void FallbackRepositoryCallsPackagesFindPackageOnThePrimaryRepository()
{
// Arrange
var primaryRepository = new Mock<IPackageRepository>(MockBehavior.Strict);
IPackage package = PackageUtility.CreatePackage("A", "1.0");
primaryRepository.As<IPackageLookup>().Setup(p => p.FindPackage("A", new SemanticVersion("1.0"))).Returns(package).Verifiable();
var fallbackRepository = new FallbackRepository(primaryRepository.Object, new MockPackageRepository());
// Act
IPackage foundPackage = fallbackRepository.FindPackage("A", new SemanticVersion("1.0"));
// Assert
primaryRepository.VerifyAll();
Assert.Same(package, foundPackage);
}
public void FallbackRepositoryUsesDependencyResolverIfPrimaryRepositoryDoesNotHaveRequiredDependency()
{
// Arrange
IPackage packageA10 = PackageUtility.CreatePackage("M1", "1.0"), packageA11 = PackageUtility.CreatePackage("M2", "1.1");
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(packageA10);
var dependencyResolver = new MockPackageRepository();
dependencyResolver.AddPackage(packageA11);
var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec { MinVersion = new SemanticVersion("1.0.1") }), false, false);
// Assert
Assert.Same(resolvedPackage, packageA11);
}
public void FallbackRepositoryRetursNullIfPrimaryRepositoryDoesNotHaveDependencyAndDependencyResolverThrows()
{
// Arrange
var package = PackageUtility.CreatePackage("M1", "1.0");
var dependencyResolver = new Mock<IPackageRepository>(MockBehavior.Strict);
dependencyResolver.As<IDependencyResolver>()
.Setup(c => c.ResolveDependency(It.IsAny<PackageDependency>(), It.IsAny<IPackageConstraintProvider>(), false, It.IsAny<bool>()))
.Throws(new Exception("Connection failure."));
var aggregateRepository = new AggregateRepository(new[] { dependencyResolver.Object }) { IgnoreFailingRepositories = true };
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(package);
var fallbackRepository = new FallbackRepository(primaryRepository, aggregateRepository);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M2", new VersionSpec { MinVersion = new SemanticVersion("1.0.1") }), false, false);
// Assert
Assert.Null(resolvedPackage);
}
public void FallbackRepositoryDoesNotQueryDependencyResolverIfPrimaryRepositoryContainsRequiredDependency()
{
// Arrange
var package = PackageUtility.CreatePackage("M1", "1.0");
var dependencyResolver = new Mock<IPackageRepository>(MockBehavior.Strict);
dependencyResolver.As<IDependencyResolver>()
.Setup(c => c.ResolveDependency(It.IsAny<PackageDependency>(), It.IsAny<IPackageConstraintProvider>(), false, It.IsAny<bool>()))
.Throws(new Exception("This method should not be called."));
var primaryRepository = new MockPackageRepository();
primaryRepository.AddPackage(package);
var fallbackRepository = new FallbackRepository(primaryRepository, dependencyResolver.Object);
// Act
var resolvedPackage = fallbackRepository.ResolveDependency(new PackageDependency("M1"), false, false);
// Assert
Assert.Same(package, resolvedPackage);
}
