public void EnsurePackageDownloadsUsesInMemoryCachedInstanceOnceDownloaded()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var mockRepository = new MockPackageCacheRepository(true);
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()))
.Callback(() => mockRepository.AddPackage(zipPackage))
.Verifiable();
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny <Stream>())).Returns <Stream>((stream) => new byte[] { 1, 2, 3, 4 });
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = Convert.ToBase64String(new byte[] { 1, 2, 3, 4 }),
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
DownloadUrl = uri
};
// Act
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
// Assert
Assert.Equal(zipPackage, servicePackage._package);
packageDownloader.Verify(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()), Times.Once());
Assert.True(mockRepository.Exists(zipPackage));
}
public void EnsurePackageDownloadsPackageIfCacheIsInvalid()
{
// Arrange
byte[] hashBytes1 = new byte[] { 1, 2, 3, 4 }, hashBytes2 = new byte[] { 3, 4, 5, 6 };
string hash1 = Convert.ToBase64String(hashBytes1), hash2 = Convert.ToBase64String(hashBytes2);
var zipPackage1 = PackageUtility.CreatePackage("A", "1.2");
var zipPackage2 = PackageUtility.CreatePackage("A", "1.2");
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny <byte[]>())).Returns(hashBytes1);
var mockRepository = new Mock <IPackageRepository>(MockBehavior.Strict);
var lookup = mockRepository.As <IPackageLookup>();
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
lookup.Setup(s => s.Exists("A", new SemanticVersion("1.2")))
.Returns(true);
mockRepository.Setup(s => s.AddPackage(zipPackage2)).Verifiable();
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>()))
.Returns(zipPackage2)
.Verifiable();
var context = new Mock <IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny <object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = hash1,
PackageHashAlgorithm = "SHA512",
HashProvider = hashProvider.Object,
Downloader = packageDownloader.Object,
Context = context.Object
};
// Act 1
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 1
Assert.Equal(zipPackage1, servicePackage._package);
context.Verify(c => c.GetReadStreamUri(It.IsAny <object>()), Times.Never());
// Act 2
servicePackage.PackageHash = hash2;
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 2
Assert.Equal(zipPackage2, servicePackage._package);
mockRepository.Verify();
context.Verify();
packageDownloader.Verify();
}
public void EnsurePackageDownloadsUsesMachineCacheIfAvailable()
{
// Arrange
var hashBytes = new byte[] { 1, 2, 3, 4 };
var hash = Convert.ToBase64String(hashBytes);
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny <Stream>())).Returns(hashBytes);
var mockRepository = new MockPackageCacheRepository();
mockRepository.Add(zipPackage);
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = hash,
HashProvider = hashProvider.Object,
};
// Act
servicePackage.EnsurePackage(mockRepository);
// Assert
Assert.Equal(zipPackage, servicePackage._package);
}
public void EnsurePackageDownloadsThePackageIfItIsNotCachedInMemoryOnInMachineCache()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var mockRepository = new MockPackageCacheRepository();
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()))
.Callback(() => mockRepository.AddPackage(zipPackage))
.Verifiable();
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
var context = new Mock <IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny <object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "NEWHASH",
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
Context = context.Object
};
// Act
servicePackage.EnsurePackage(mockRepository);
// Assert
context.Verify();
packageDownloader.Verify();
Assert.True(mockRepository.Exists(zipPackage));
}
public void EnsurePackageDownloadUpdatesIdAndVersion()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("Abc", "1.0");
var uri = new Uri("http://nuget.org");
var mockRepository = new MockPackageCacheRepository(true);
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()))
.Callback(() => mockRepository.AddPackage(zipPackage))
.Verifiable();
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny <Stream>())).Returns <Stream>((stream) => new byte[] { 1, 2, 3, 4 });
var servicePackage = new DataServicePackage
{
Id = "abc",
Version = "1.0.0",
PackageHash = Convert.ToBase64String(new byte[] { 1, 2, 3, 4 }),
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
DownloadUrl = uri
};
// Act
servicePackage.EnsurePackage(mockRepository);
// Assert
// servicePackage should have been updated to match zipPackage
Assert.Equal("Abc", servicePackage.Id);
Assert.Equal("1.0", servicePackage.Version);
}
public void EnsurePackageDownloadsThePackageIfItIsNotCachedInMemoryOnInMachineCache()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>()))
.Returns(zipPackage)
.Verifiable();
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
var mockRepository = new MockPackageRepository();
var context = new Mock<IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny<object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "NEWHASH",
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
Context = context.Object
};
// Act
servicePackage.EnsurePackage(mockRepository);
// Assert
context.Verify();
packageDownloader.Verify();
Assert.True(mockRepository.Exists(zipPackage));
}
public void EnsurePackageDownloadsUsesInMemoryCachedInstanceOnceDownloaded()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>()))
.Returns(zipPackage)
.Verifiable();
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
var mockRepository = new MockPackageRepository();
var context = new Mock <IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny <object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "NEWHASH",
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
Context = context.Object
};
// Act
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
// Assert
Assert.Equal(zipPackage, servicePackage._package);
context.Verify(s => s.GetReadStreamUri(It.IsAny <object>()), Times.Once());
packageDownloader.Verify(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>()), Times.Once());
Assert.True(mockRepository.Exists(zipPackage));
}
public void EnsurePackageStorePackageInMemoryIfMachineCacheIsNotAvailable()
{
// Arrange
var uri = new Uri("http://nuget.org");
var mockRepository = new Mock <MockPackageRepository>().As <IPackageCacheRepository>();
mockRepository.Setup(s => s.InvokeOnPackage(It.IsAny <string>(), It.IsAny <SemanticVersion>(), It.IsAny <Action <Stream> >())).Returns(false);
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()))
.Callback(new Action <Uri, IPackageMetadata, Stream>(
(url, metadata, stream) => PackageUtility.CreateSimplePackageStream("A", "1.2").CopyTo(stream)))
.Verifiable();
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
byte[] hash1 = new byte[] { 1, 2, 3, 4 };
hashProvider.Setup(h => h.CalculateHash(It.IsAny <Stream>())).Returns <Stream>((stream) => hash1);
var context = new Mock <IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny <object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = Convert.ToBase64String(hash1),
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
Context = context.Object
};
// Act
servicePackage.EnsurePackage(mockRepository.Object);
// Assert
context.Verify();
packageDownloader.Verify();
var foundPackage = servicePackage._package;
Assert.NotNull(foundPackage);
Assert.True(foundPackage is ZipPackage);
}
public void EnsurePackageDownloadsFailsIfHashIsIncorrect()
{
// Arrange
byte[] hashBytes1 = new byte[] { 1, 2, 3, 4 };
string hash1 = Convert.ToBase64String(hashBytes1);
MemoryStream stream1 = new MemoryStream(new byte[] { 1 });
var mockPackage = new Mock<IPackage>(MockBehavior.Strict) { CallBase = true };
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Listed).Returns(true);
mockPackage.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
mockPackage.Setup(m => m.GetStream()).Returns(stream1);
var zipPackage1 = mockPackage.Object;
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny<Stream>())).Returns<Stream>((stream) => hashBytes1);
var mockRepository = new Mock<IPackageCacheRepository>(MockBehavior.Strict);
var lookup = mockRepository.As<IPackageLookup>();
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
lookup.Setup(s => s.Exists("A", new SemanticVersion("1.2")))
.Returns(true);
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(() =>
{
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
})
.Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "IMPOSSIBLEHASH",
PackageHashAlgorithm = "SHA512",
HashProvider = hashProvider.Object,
Downloader = packageDownloader.Object,
DownloadUrl = uri
};
mockRepository.Setup(s => s.InvokeOnPackage("A", new SemanticVersion("1.2"), It.IsAny<Action<Stream>>()))
.Callback(() =>
{
using (var stream = new MemoryStream())
{
packageDownloader.Object.DownloadPackage(servicePackage.DownloadUrl, servicePackage, stream);
}
})
.Returns(true);
// Act & Assert
Assert.Throws(typeof(InvalidOperationException), () => servicePackage.EnsurePackage(mockRepository.Object));
}
public void EnsurePackageDownloadsUsesMachineCacheIfAvailable()
{
// Arrange
var hashBytes = new byte[] { 1, 2, 3, 4 };
var hash = Convert.ToBase64String(hashBytes);
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny<Stream>())).Returns(hashBytes);
var mockRepository = new MockPackageCacheRepository();
mockRepository.Add(zipPackage);
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = hash,
HashProvider = hashProvider.Object,
};
// Act
servicePackage.EnsurePackage(mockRepository);
// Assert
Assert.Equal(zipPackage, servicePackage._package);
}
public void EnsurePackageStorePackageInMemoryIfMachineCacheIsNotAvailable()
{
// Arrange
var uri = new Uri("http://nuget.org");
var mockRepository = new Mock<MockPackageRepository>().As<IPackageCacheRepository>();
mockRepository.Setup(s => s.InvokeOnPackage(It.IsAny<string>(), It.IsAny<SemanticVersion>(), It.IsAny<Action<Stream>>())).Returns(false);
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(new Action<Uri, IPackageMetadata, Stream>(
(url, metadata, stream) => PackageUtility.CreateSimplePackageStream("A", "1.2").CopyTo(stream)))
.Verifiable();
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
byte[] hash1 = new byte[] { 1, 2, 3, 4 };
hashProvider.Setup(h => h.CalculateHash(It.IsAny<Stream>())).Returns<Stream>((stream) => hash1);
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = Convert.ToBase64String(hash1),
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
DownloadUrl = uri
};
// Act
servicePackage.EnsurePackage(mockRepository.Object);
// Assert
packageDownloader.Verify();
var foundPackage = servicePackage._package;
Assert.NotNull(foundPackage);
Assert.True(foundPackage is ZipPackage);
}
public void EnsurePackageDownloadsFailsIfHashIsIncorrect()
{
// Arrange
byte[] hashBytes1 = new byte[] { 1, 2, 3, 4 };
string hash1 = Convert.ToBase64String(hashBytes1);
MemoryStream stream1 = new MemoryStream(new byte[] { 1 });
var mockPackage = new Mock <IPackage>(MockBehavior.Strict)
{
CallBase = true
};
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Listed).Returns(true);
mockPackage.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
mockPackage.Setup(m => m.GetStream()).Returns(stream1);
var zipPackage1 = mockPackage.Object;
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny <Stream>())).Returns <Stream>((stream) => hashBytes1);
var mockRepository = new Mock <IPackageCacheRepository>(MockBehavior.Strict);
var lookup = mockRepository.As <IPackageLookup>();
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
lookup.Setup(s => s.Exists("A", new SemanticVersion("1.2")))
.Returns(true);
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()))
.Callback(() =>
{
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
})
.Verifiable();
var context = new Mock <IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny <object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "IMPOSSIBLEHASH",
PackageHashAlgorithm = "SHA512",
HashProvider = hashProvider.Object,
Downloader = packageDownloader.Object,
Context = context.Object
};
mockRepository.Setup(s => s.InvokeOnPackage("A", new SemanticVersion("1.2"), It.IsAny <Action <Stream> >()))
.Callback(() =>
{
using (var stream = new MemoryStream())
{
packageDownloader.Object.DownloadPackage(servicePackage.DownloadUrl, servicePackage, stream);
}
})
.Returns(true);
// Act & Assert
Assert.Throws(typeof(InvalidOperationException), () => servicePackage.EnsurePackage(mockRepository.Object));
}
public void EnsurePackageDownloadsPackageIfCacheIsInvalid()
{
// Arrange
byte[] hashBytes1 = new byte[] { 1, 2, 3, 4 };
byte[] hashBytes2 = new byte[] { 3, 4, 5, 6 };
string hash1 = Convert.ToBase64String(hashBytes1);
string hash2 = Convert.ToBase64String(hashBytes2);
MemoryStream stream1 = new MemoryStream(new byte[] { 1 });
MemoryStream stream2 = new MemoryStream(new byte[] { 2 });
var mockPackage = new Mock <IPackage>(MockBehavior.Strict)
{
CallBase = true
};
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Listed).Returns(true);
mockPackage.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
mockPackage.Setup(m => m.GetStream()).Returns(stream1);
var zipPackage1 = mockPackage.Object;
var mockPackage2 = new Mock <IPackage>(MockBehavior.Strict)
{
CallBase = true
};
mockPackage2.Setup(m => m.Id).Returns("A");
mockPackage2.Setup(m => m.Listed).Returns(true);
mockPackage2.Setup(m => m.Version).Returns(new SemanticVersion("1.2"));
mockPackage2.Setup(m => m.GetStream()).Returns(stream2);
var zipPackage2 = mockPackage2.Object;
var hashProvider = new Mock <IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny <Stream>())).Returns <Stream>((stream) =>
{
if (stream == stream1)
{
return(hashBytes1);
}
else if (stream == stream2)
{
return(hashBytes2);
}
return(null);
});
var mockRepository = new Mock <IPackageCacheRepository>(MockBehavior.Strict);
var lookup = mockRepository.As <IPackageLookup>();
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
lookup.Setup(s => s.Exists("A", new SemanticVersion("1.2")))
.Returns(true);
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock <PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny <IPackageMetadata>(), It.IsAny <Stream>()))
.Callback(() =>
{
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage2);
})
.Verifiable();
var context = new Mock <IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny <object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = hash1,
PackageHashAlgorithm = "SHA512",
HashProvider = hashProvider.Object,
Downloader = packageDownloader.Object,
Context = context.Object
};
mockRepository.Setup(s => s.InvokeOnPackage("A", new SemanticVersion("1.2"), It.IsAny <Action <Stream> >()))
.Callback(() =>
{
using (var stream = new MemoryStream())
{
packageDownloader.Object.DownloadPackage(servicePackage.DownloadUrl, servicePackage, stream);
}
})
.Returns(true);
// Act 1
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 1
Assert.Equal(zipPackage1, servicePackage._package);
context.Verify(c => c.GetReadStreamUri(It.IsAny <object>()), Times.Never());
// Act 2
servicePackage.PackageHash = hash2;
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 2
Assert.Equal(zipPackage2, servicePackage._package);
context.Verify();
packageDownloader.Verify();
}
public void EnsurePackageDownloadUpdatesIdAndVersion()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("Abc", "1.0");
var uri = new Uri("http://nuget.org");
var mockRepository = new MockPackageCacheRepository(true);
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(() => mockRepository.AddPackage(zipPackage))
.Verifiable();
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny<Stream>())).Returns<Stream>((stream) => new byte[] { 1, 2, 3, 4 });
var servicePackage = new DataServicePackage
{
Id = "abc",
Version = "1.0.0",
PackageHash = Convert.ToBase64String(new byte[] { 1, 2, 3, 4 }),
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
DownloadUrl = uri
};
// Act
servicePackage.EnsurePackage(mockRepository);
// Assert
// servicePackage should have been updated to match zipPackage
Assert.Equal("Abc", servicePackage.Id);
Assert.Equal("1.0", servicePackage.Version);
}
public void EnsurePackageStorePackageInMemoryIfMachineCacheIsNotAvailable()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var mockRepository = new Mock<MockPackageRepository>().As<IPackageCacheRepository>();
mockRepository.Setup(s => s.CreatePackageStream(It.IsAny<string>(), It.IsAny<SemanticVersion>())).Returns((Stream)null);
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(new Action<Uri, IPackageMetadata, Stream>(
(url, metadata, stream) => PackageUtility.CreateSimplePackageStream("A", "1.2").CopyTo(stream)))
.Verifiable();
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
var context = new Mock<IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny<object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "NEWHASH",
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
Context = context.Object
};
// Act
servicePackage.EnsurePackage(mockRepository.Object);
// Assert
context.Verify();
packageDownloader.Verify();
var foundPackage = servicePackage._package;
Assert.NotNull(foundPackage);
Assert.True(foundPackage is ZipPackage);
}
public void EnsurePackageDownloadsUsesInMemoryCachedInstanceOnceDownloaded()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var mockRepository = new MockPackageCacheRepository();
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(() => mockRepository.AddPackage(zipPackage))
.Verifiable();
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
var context = new Mock<IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny<object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = "NEWHASH",
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
Context = context.Object
};
// Act
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
// Assert
Assert.Equal(zipPackage, servicePackage._package);
context.Verify(s => s.GetReadStreamUri(It.IsAny<object>()), Times.Once());
packageDownloader.Verify(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()), Times.Once());
Assert.True(mockRepository.Exists(zipPackage));
}
public void EnsurePackageDownloadsUsesInMemoryCachedInstanceOnceDownloaded()
{
// Arrange
var zipPackage = PackageUtility.CreatePackage("A", "1.2");
var uri = new Uri("http://nuget.org");
var mockRepository = new MockPackageCacheRepository(true);
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(() => mockRepository.AddPackage(zipPackage))
.Verifiable();
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny<Stream>())).Returns<Stream>((stream) => new byte[] { 1, 2, 3, 4 });
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = Convert.ToBase64String(new byte[] { 1, 2, 3, 4 }),
Downloader = packageDownloader.Object,
HashProvider = hashProvider.Object,
DownloadUrl = uri
};
// Act
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
servicePackage.EnsurePackage(mockRepository);
// Assert
Assert.Equal(zipPackage, servicePackage._package);
packageDownloader.Verify(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()), Times.Once());
Assert.True(mockRepository.Exists(zipPackage));
}
public void EnsurePackageDownloadsPackageIfCacheIsInvalid()
{
// Arrange
byte[] hashBytes1 = new byte[] { 1, 2, 3, 4 };
byte[] hashBytes2 = new byte[] { 3, 4, 5, 6 };
string hash1 = Convert.ToBase64String(hashBytes1);
string hash2 = Convert.ToBase64String(hashBytes2);
var zipPackage1 = PackageUtility.CreatePackage("A", "1.2");
var zipPackage2 = PackageUtility.CreatePackage("B", "1.2");
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny<Stream>())).Returns(hashBytes1);
var mockRepository = new Mock<IPackageCacheRepository>(MockBehavior.Strict);
var lookup = mockRepository.As<IPackageLookup>();
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
lookup.Setup(s => s.Exists("A", new SemanticVersion("1.2")))
.Returns(true);
mockRepository.Setup(s => s.CreatePackageStream("A", new SemanticVersion("1.2")))
.Returns(new MemoryStream());
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(() =>
{
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage2);
})
.Verifiable();
var context = new Mock<IDataServiceContext>();
context.Setup(c => c.GetReadStreamUri(It.IsAny<object>())).Returns(uri).Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = hash1,
PackageHashAlgorithm = "SHA512",
HashProvider = hashProvider.Object,
Downloader = packageDownloader.Object,
Context = context.Object
};
// Act 1
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 1
Assert.Equal(zipPackage1, servicePackage._package);
context.Verify(c => c.GetReadStreamUri(It.IsAny<object>()), Times.Never());
// Act 2
servicePackage.PackageHash = hash2;
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 2
Assert.Equal(zipPackage2, servicePackage._package);
context.Verify();
packageDownloader.Verify();
}
public void EnsurePackageDownloadsPackageIfCacheIsInvalid()
{
// Arrange
byte[] hashBytes1 = new byte[] { 1, 2, 3, 4 };
byte[] hashBytes2 = new byte[] { 3, 4, 5, 6 };
string hash1 = Convert.ToBase64String(hashBytes1);
string hash2 = Convert.ToBase64String(hashBytes2);
MemoryStream stream1 = new MemoryStream(new byte[] { 1 });
MemoryStream stream2 = new MemoryStream(new byte[] { 2 });
var mockPackage = new Mock<IPackage>(MockBehavior.Strict) { CallBase = true };
mockPackage.Setup(m => m.Id).Returns("A");
mockPackage.Setup(m => m.Listed).Returns(true);
mockPackage.Setup(m => m.Version).Returns(new SemanticVersion("1.0"));
mockPackage.Setup(m => m.GetStream()).Returns(stream1);
var zipPackage1 = mockPackage.Object;
var mockPackage2 = new Mock<IPackage>(MockBehavior.Strict) { CallBase = true };
mockPackage2.Setup(m => m.Id).Returns("A");
mockPackage2.Setup(m => m.Listed).Returns(true);
mockPackage2.Setup(m => m.Version).Returns(new SemanticVersion("1.2"));
mockPackage2.Setup(m => m.GetStream()).Returns(stream2);
var zipPackage2 = mockPackage2.Object;
var hashProvider = new Mock<IHashProvider>(MockBehavior.Strict);
hashProvider.Setup(h => h.CalculateHash(It.IsAny<Stream>())).Returns<Stream>((stream) =>
{
if (stream == stream1)
{
return hashBytes1;
}
else if (stream == stream2)
{
return hashBytes2;
}
return null;
});
var mockRepository = new Mock<IPackageCacheRepository>(MockBehavior.Strict);
var lookup = mockRepository.As<IPackageLookup>();
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage1);
lookup.Setup(s => s.Exists("A", new SemanticVersion("1.2")))
.Returns(true);
var uri = new Uri("http://nuget.org");
var packageDownloader = new Mock<PackageDownloader>();
packageDownloader.Setup(d => d.DownloadPackage(uri, It.IsAny<IPackageMetadata>(), It.IsAny<Stream>()))
.Callback(() =>
{
lookup.Setup(s => s.FindPackage("A", new SemanticVersion("1.2")))
.Returns(zipPackage2);
})
.Verifiable();
var servicePackage = new DataServicePackage
{
Id = "A",
Version = "1.2",
PackageHash = hash1,
PackageHashAlgorithm = "SHA512",
HashProvider = hashProvider.Object,
Downloader = packageDownloader.Object,
DownloadUrl = uri
};
mockRepository.Setup(s => s.InvokeOnPackage("A", new SemanticVersion("1.2"), It.IsAny<Action<Stream>>()))
.Callback(() =>
{
using (var stream = new MemoryStream())
{
packageDownloader.Object.DownloadPackage(servicePackage.DownloadUrl, servicePackage, stream);
}
})
.Returns(true);
// Act 1
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 1
Assert.Equal(zipPackage1, servicePackage._package);
// Act 2
servicePackage.PackageHash = hash2;
servicePackage.EnsurePackage(mockRepository.Object);
// Assert 2
Assert.Equal(zipPackage2, servicePackage._package);
packageDownloader.Verify();
}
