public SupressedFileSystemWatcher(ServerPackageRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
_repository = repository;
// Lock the repository.
bool lockTaken = false;
try
{
Monitor.Enter(_repository._syncLock, ref lockTaken);
}
catch
{
if (lockTaken)
{
Monitor.Exit(_repository._syncLock);
}
throw;
}
// Suppress the file system events.
_repository._isFileSystemWatcherSuppressed = true;
}
public void ServerPackageRepositoryReadsDerivedData()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
var package = new PackageBuilder() { Id = "Test", Version = new System.Version("1.0"), Description = "Description" };
var mockFile = new Mock<IPackageFile>();
mockFile.Setup(m => m.Path).Returns("foo");
mockFile.Setup(m => m.GetStream()).Returns(new MemoryStream());
package.Files.Add(mockFile.Object);
package.Authors.Add("Test Author");
var memoryStream = new MemoryStream();
package.Save(memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
mockProjectSystem.Object.AddFile("foo.nupkg");
mockProjectSystem.Setup(c => c.OpenFile(It.IsAny<string>())).Returns(() => new MemoryStream(memoryStream.ToArray()));
var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object);
serverRepository.HashProvider = GetHashProvider();
// Act
var packages = serverRepository.GetPackagesWithDerivedData();
// Assert
byte[] data = memoryStream.ToArray();
Assert.AreEqual(data.Length, packages.Single().PackageSize);
CollectionAssert.AreEquivalent(data.Select(Invert).ToArray(), Convert.FromBase64String(packages.Single().PackageHash));
Assert.AreEqual(data.Length, packages.Single().PackageSize);
}
public override void Load()
{
IServerPackageRepository packageRepository = new ServerPackageRepository(PackageUtility.PackagePhysicalPath);
Bind <IHashProvider>().To <CryptoHashProvider>();
Bind <IServerPackageRepository>().ToConstant(packageRepository);
}
public void ServerPackageRepositoryRemovePackage()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
_packageStreams = new Dictionary<string, MemoryStream>();
AddPackage(mockProjectSystem, "test", "1.11");
AddPackage(mockProjectSystem, "test", "1.9");
AddPackage(mockProjectSystem, "test", "2.0-alpha");
var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object);
serverRepository.HashProvider = GetHashProvider();
var package = CreatePackage("test", "1.11");
var package2 = CreatePackage("test", "2.0-alpha");
// call to cache the first time
var packages = serverRepository.GetPackagesWithDerivedData();
// Act
serverRepository.RemovePackage(package);
serverRepository.RemovePackage(package2);
packages = serverRepository.GetPackagesWithDerivedData();
// Assert
Assert.Equal(1, packages.Count());
Assert.Equal(1, packages.Where(p => p.IsLatestVersion).Count());
Assert.Equal("1.9", packages.Where(p => p.IsLatestVersion).First().Version);
Assert.Equal(1, packages.Where(p => p.IsAbsoluteLatestVersion).Count());
Assert.Equal("1.9", packages.Where(p => p.IsAbsoluteLatestVersion).First().Version);
}
public override void Load()
{
IServerPackageRepository packageRepository = new ServerPackageRepository(PackageUtility.PackagePhysicalPath);
Bind<IHashProvider>().To<CryptoHashProvider>();
Bind<IServerPackageRepository>().ToConstant(packageRepository);
Bind<PackageService>().ToSelf();
Bind<IPackageAuthenticationService>().To<PackageAuthenticationService>();
}
public override void Load()
{
IServerPackageRepository packageRepository = new ServerPackageRepository(PackageUtility.PackagePhysicalPath);
Bind <IHashProvider>().To <CryptoHashProvider>();
Bind <IServerPackageRepository>().ToConstant(packageRepository);
Bind <PackageService>().ToSelf();
Bind <IPackageAuthenticationService>().To <PackageAuthenticationService>();
}
public ServerPackageRepository CreateServerPackageRepository(string path, Action<ExpandedPackageRepository> setupRepository = null, Func<string, bool, bool> getSetting = null)
{
var fileSystem = new PhysicalFileSystem(path);
var expandedPackageRepository = new ExpandedPackageRepository(fileSystem);
if (setupRepository != null)
{
setupRepository(expandedPackageRepository);
}
var serverRepository = new ServerPackageRepository(
fileSystem,
runBackgroundTasks: false,
innerRepository: expandedPackageRepository,
logger: new Logging.NullLogger(),
getSetting: getSetting);
serverRepository.GetPackages(); // caches the files
return serverRepository;
}
public void ServerPackageRepositorySearch()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
_packageStreams = new Dictionary<string, MemoryStream>();
AddPackage(mockProjectSystem, "test", "1.0");
AddPackage(mockProjectSystem, "test2", "1.0");
AddPackage(mockProjectSystem, "test3", "1.0-alpha");
AddPackage(mockProjectSystem, "test4", "2.0");
var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object);
serverRepository.HashProvider = GetHashProvider();
// Act
var valid = serverRepository.Search("test3", true);
var invalid = serverRepository.Search("test3", false);
// Assert
Assert.Equal("test3", valid.First().Id);
Assert.Equal(0, invalid.Count());
}
public void ServerPackageRepositoryEmptyRepo()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
_packageStreams = new Dictionary<string, MemoryStream>();
var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object);
serverRepository.HashProvider = GetHashProvider();
var package = CreatePackage("test", "1.0");
// Act
var findPackage = serverRepository.FindPackage("test", new SemanticVersion("1.0"));
var findPackagesById = serverRepository.FindPackagesById("test");
var getMetadataPackage = serverRepository.GetMetadataPackage(package);
var getPackages = serverRepository.GetPackages().ToList();
var getPackagesWithDerivedData = serverRepository.GetPackagesWithDerivedData().ToList();
var getUpdates = serverRepository.GetUpdates(Enumerable.Empty<IPackageName>(), true, true, Enumerable.Empty<FrameworkName>(), Enumerable.Empty<IVersionSpec>());
var search = serverRepository.Search("test", true).ToList();
var source = serverRepository.Source;
// Assert
Assert.Null(findPackage);
Assert.Empty(findPackagesById);
Assert.Null(getMetadataPackage);
Assert.Empty(getPackages);
Assert.Null(getMetadataPackage);
Assert.Empty(getPackagesWithDerivedData);
Assert.Empty(getUpdates);
Assert.Empty(search);
Assert.NotEmpty(source);
}
public void ServerPackageRepositoryIsLatestOnlyPreRel()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
_packageStreams = new Dictionary<string, MemoryStream>();
AddPackage(mockProjectSystem, "test", "2.0-alpha");
AddPackage(mockProjectSystem, "test", "2.1-alpha");
AddPackage(mockProjectSystem, "test", "2.2-beta");
var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object);
serverRepository.HashProvider = GetHashProvider();
// Act
var packages = serverRepository.GetPackagesWithDerivedData();
// Assert
Assert.Equal(0, packages.Where(p => p.IsLatestVersion).Count());
}
public void ServerPackageRepositoryMultipleIds()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
_packageStreams = new Dictionary<string, MemoryStream>();
AddPackage(mockProjectSystem, "test", "0.9");
AddPackage(mockProjectSystem, "test", "1.0");
AddPackage(mockProjectSystem, "test2", "1.0");
AddPackage(mockProjectSystem, "test3", "1.0-alpha");
AddPackage(mockProjectSystem, "test4", "2.0");
var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object);
serverRepository.HashProvider = GetHashProvider();
// Act
var packages = serverRepository.GetPackagesWithDerivedData();
// Assert
Assert.Equal(4, packages.Where(p => p.IsAbsoluteLatestVersion).Count());
Assert.Equal(3, packages.Where(p => p.IsLatestVersion).Count());
Assert.Equal(1, packages.Where(p => !p.IsAbsoluteLatestVersion).Count());
Assert.Equal(2, packages.Where(p => !p.IsLatestVersion).Count());
}
public void ServerPackageRepositoryFindPackage()
{
// Arrange
var mockProjectSystem = new Mock<MockProjectSystem>() { CallBase = true };
_packageStreams = new Dictionary<string, MemoryStream>();
AddPackage(mockProjectSystem, "test", "1.0");
AddPackage(mockProjectSystem, "test2", "1.0");
AddPackage(mockProjectSystem, "test3", "1.0-alpha");
AddPackage(mockProjectSystem, "test4", "2.0");
var serverRepository = new ServerPackageRepository(new DefaultPackagePathResolver(mockProjectSystem.Object), mockProjectSystem.Object);
serverRepository.HashProvider = GetHashProvider();
// Act
var valid = serverRepository.FindPackage("test", new SemanticVersion("1.0"));
var invalid = serverRepository.FindPackage("bad", new SemanticVersion("1.0"));
// Assert
Assert.Equal("test", valid.Id);
Assert.Null(invalid);
}
public void ServerPackageRepositorySearchUnlisted()
{
var tempPath = Path.GetTempPath();
var workingDirectory = Path.Combine(tempPath, Guid.NewGuid().ToString());
try
{
// Arrange
// create the server repo, from a directory containing a package.
Func<string, bool, bool> settingsFunc = (key, defaultValue) =>
{
if (key == "enableDelisting")
{
return true;
}
return defaultValue;
};
CreateDirectory(workingDirectory);
var packageFile = CreatePackage("test1", "1.0", workingDirectory);
var fileSystem = new PhysicalFileSystem(workingDirectory);
var serverRepository = new ServerPackageRepository(
new DefaultPackagePathResolver(fileSystem),
fileSystem,
settingsFunc)
{
HashProvider = GetHashProvider().Object
};
var packages = serverRepository.Search("test1", true).ToList();
Assert.Equal(1, packages.Count);
Assert.Equal("test1", packages[0].Id);
Assert.Equal("1.0", packages[0].Version.ToString());
// delist the package
serverRepository.RemovePackage("test1", new SemanticVersion("1.0"));
// verify that the package is not returned by search
packages = serverRepository.Search("test1", true).ToList();
Assert.Equal(0, packages.Count);
// Act: search with includeDelisted=true
packages = serverRepository.Search(
"test1",
targetFrameworks: Enumerable.Empty<string>(),
allowPrereleaseVersions: true,
includeDelisted: true).ToList();
// Verify
Assert.Equal(1, packages.Count);
Assert.Equal("test1", packages[0].Id);
Assert.Equal("1.0", packages[0].Version.ToString());
}
finally
{
// Cleanup
DeleteDirectory(workingDirectory);
}
}
public override void Load()
{
IServerPackageRepository packageRepository = new ServerPackageRepository(PackageUtility.PackagePhysicalPath);
Bind<IHashProvider>().To<CryptoHashProvider>();
Bind<IServerPackageRepository>().ToConstant(packageRepository);
}
