public void CallAddPackageWillAddNuspecWhichHasReferencesData()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.AddPackage(PackageUtility.CreatePackage("A",
"1.0",
assemblyReferences: new[] { "lib\\net40\\A.dll", "lib\\B.dll" }));
// Assert
Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
Manifest manifest = Manifest.ReadFrom(manifestContentStream, validateSchema: true);
Assert.Equal(2, manifest.Metadata.ReferenceSets.Count);
var set1 = manifest.Metadata.ReferenceSets[0];
Assert.Equal(".NETFramework4.0", set1.TargetFramework);
Assert.Equal(1, set1.References.Count);
Assert.Equal("A.dll", set1.References[0].File);
var set2 = manifest.Metadata.ReferenceSets[1];
Assert.Null(set2.TargetFramework);
Assert.Equal(1, set2.References.Count);
Assert.Equal("B.dll", set2.References[0].File);
}
public void GetRepositoryPathsRemovesInvalidOrNonExistantPathsAndReturnsRelativePaths()
{
// Arrange
var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
fileSystem.Setup(m => m.FileExists(@"A\packages.config")).Returns(true);
fileSystem.Setup(m => m.FileExists(@"c:\foo\packages.config")).Returns(true);
fileSystem.Setup(m => m.FileExists(@"..\..\packages.config")).Returns(true);
fileSystem.Object.AddFile("repositories.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""B\packages.config"" />
<repository path=""c:\foo\packages.config"" />
<repository path=""..\..\packages.config"" />
<repository path="""" />
<repository />
</repositories>");
fileSystem.Setup(m => m.Root).Returns(@"c:\foo\bar\baz\");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object);
// Act
var paths = repository.GetRepositoryPaths().ToList();
// Assert
Assert.Equal(2, paths.Count);
Assert.Equal(@"A\packages.config", paths[0]);
Assert.Equal(@"..\..\packages.config", paths[1]);
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""c:\foo\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
}
public override void ExecuteCommand()
{
if (!String.IsNullOrEmpty(Arguments[0]))
{
var solutionFile = new FileInfo(Arguments[0]);
if (solutionFile.Exists && solutionFile.Extension == ".sln")
{
var solutionRoot = solutionFile.Directory;
var sharedPackagesRepository = new SharedPackageRepository(Path.Combine(solutionRoot.FullName, "packages"));
var solution = new Solution(solutionFile.FullName);
var simpleProjectObjects = solution.Projects;
Console.WriteLine("Processing {0} projects in solution {1}...", simpleProjectObjects.Count, solutionFile.Name);
foreach (var simpleProject in simpleProjectObjects)
{
var manifestDependencies = new List<ManifestDependency>();
var projectPath = Path.Combine(solutionFile.Directory.FullName, simpleProject.RelativePath);
if (File.Exists(projectPath))
{
Console.WriteLine();
Console.WriteLine("Processing Project: {0}", simpleProject.ProjectName);
var projectFileInfo = new FileInfo(projectPath);
var project = new Project(projectPath,new Dictionary<string, string>(),null,new ProjectCollection());
var assemblyOutput = project.GetPropertyValue("AssemblyName");
var references = project.GetItems("Reference");
var resolvedMappings = ResolveReferenceMappings(references, projectFileInfo);
if (resolvedMappings != null && resolvedMappings.Any())
{
UpdateProjectFileReferenceHintPaths(solutionRoot, project, projectPath, resolvedMappings, references);
var projectReferences = ParseProjectReferences(project);
CreateNuGetScaffolding(sharedPackagesRepository, manifestDependencies, resolvedMappings, projectFileInfo, project, projectReferences);
}
//Create nuspec regardless of whether we have added dependencies
if (NuSpec)
{
CreateAndOutputNuSpecFile(assemblyOutput, manifestDependencies);
}
Console.WriteLine("Project completed!");
}
else
{
Console.WriteWarning("Project: {0} was not found on disk", simpleProject.ProjectName);
}
}
Console.WriteLine("Complete!");
}
else
{
Console.WriteError("Could not find solution file : {0}", solutionFile);
}
}
}
public void CallAddPackageWillNotCreatePackageConfigEntryToPackageConfig()
{
// Arrange
var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem);
// Act
repository.AddPackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(configFileSystem.FileExists("packages.config"));
}
public void CallRemovePackageWillRemoveNupkgFile(string id, string version, string unexpectedPath)
{
// Arrange
var fileSystem = new MockFileSystem("x:\root");
fileSystem.AddFile(unexpectedPath);
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.RemovePackage(PackageUtility.CreatePackage(id, version));
// Assert
Assert.False(fileSystem.FileExists(unexpectedPath));
}
private RepositoryInfo GetRepositoryInfo()
{
// Update the path if it needs updating
string path = _repositorySettings.RepositoryPath;
if (_repositoryInfo == null || !_repositoryInfo.Path.Equals(path)) {
IFileSystem fileSystem = _fileSystemProvider.GetFileSystem(path);
ISharedPackageRepository repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem);
_repositoryInfo = new RepositoryInfo(path, fileSystem, repository);
}
return _repositoryInfo;
}
public void CallAddPackageWillAddNupkgFileButNoNuspecFile(string id, string version, string nuspecPath, string nupkgPath)
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.AddPackage(PackageUtility.CreatePackage(id, version));
// Assert
Assert.False(fileSystem.FileExists(nuspecPath));
Assert.True(fileSystem.FileExists(nupkgPath));
}
public void RegisterRepositoryAddsRelativePathToRepositoriesConfig()
{
// Arrange
var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object);
// Act
repository.RegisterRepository(@"c:\foo\packages\packages.config");
// Assert
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""packages\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
}
private void UpdatePackages(IMSBuildProjectSystem project, string repositoryPath = null, IPackageRepository sourceRepository = null)
{
// Resolve the repository path
repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root);
var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath);
var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem);
// Create the local and source repositories
var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem);
var localRepository = new PackageReferenceRepository(project, project.ProjectName, sharedPackageRepository);
sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
Console.WriteLine(LocalizedResourceManager.GetString("UpdatingProject"), project.ProjectName);
UpdatePackages(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, localRepository, pathResolver, project);
project.Save();
}
private void RefreshInstalledPlugins()
{
var pluginDescriptors = new List <BasePluginDescriptor>();
var fileNames = new List <string>();
AppHost.Plugins.GetAssemblies(fileNames, false, true, false);
pluginDescriptors.AddRange(fileNames.Select(GetAssemblyPluginDescriptor).Where(p => p != null));
var repository = new SharedPackageRepository(AppHost.Plugins.PackageFolder);
pluginDescriptors.AddRange(repository.GetPackages().Select(p => new PackagePluginDescriptor(repository, p)).OfType <BasePluginDescriptor>());
pluginDescriptors.Sort((x, y) => string.Compare(x.Title, y.Title, StringComparison.InvariantCultureIgnoreCase));
installedPlugins.Clear();
installedPlugins.AddRange(pluginDescriptors);
}
public void CallAddPackageWillNotCreatePackageConfigEntryToPackageConfig()
{
// Arrange
var fileSystem = new Mock <MockFileSystem>()
{
CallBase = true
};
fileSystem.Setup(m => m.Root).Returns(@"x:\foo\");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem);
// Act
repository.AddPackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(configFileSystem.FileExists("packages.config"));
}
private void ExecuteInitScripts()
{
// Fix for Bug 1426 Disallow ExecuteInitScripts from being executed concurrently by multiple threads.
lock (_initScriptsLock)
{
if (!_solutionManager.IsSolutionOpen)
{
return;
}
IRepositorySettings repositorySettings = ServiceLocator.GetInstance <IRepositorySettings>();
Debug.Assert(repositorySettings != null);
if (repositorySettings == null)
{
return;
}
try
{
var localRepository = new SharedPackageRepository(repositorySettings.RepositoryPath);
// invoke init.ps1 files in the order of package dependency.
// if A -> B, we invoke B's init.ps1 before A's.
var sorter = new PackageSorter(targetFramework: null);
var sortedPackages = sorter.GetPackagesByDependencyOrder(localRepository);
foreach (var package in sortedPackages)
{
string installPath = localRepository.PathResolver.GetInstallPath(package);
AddPathToEnvironment(Path.Combine(installPath, "tools"));
Runspace.ExecuteScript(installPath, "tools\\init.ps1", package);
}
}
catch (Exception ex)
{
// if execution of Init scripts fails, do not let it crash our console
ReportError(ex);
ExceptionHelper.WriteToActivityLog(ex);
}
}
}
public void RemovingAllSolutionLevelPackageDeletesConfigFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage = PackageUtility.CreatePackage("SolutionLevel", tools: new[] { "Install.ps1" });
configFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""SolutionLevel"" version=""1.0"" />
</packages>");
// Act
repository.RemovePackage(solutionPackage);
// Assert
Assert.True(configFileSystem.Deleted.Contains("packages.config"));
}
public void AddPackageAddSolutionLevelPackageDependingOnAnotherSolutionLevelPackage()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage1 = PackageUtility.CreatePackage("SolutionLevel1", tools: new[] { "Install.ps1" });
var solutionPackage2 = PackageUtility.CreatePackage("SolutionLevel2", tools: new[] { "Install.ps1" }, dependencies: new[] { new PackageDependency("SolutionLevel1") });
// Act
repository.AddPackage(solutionPackage1);
repository.AddPackage(solutionPackage2);
// Assert
var packageReferences = repository.PackageReferenceFile.GetPackageReferences()
.Select(p => p.Id).OrderBy(id => id).ToArray();
Assert.Equal(new [] { "SolutionLevel1", "SolutionLevel2" }, packageReferences);
}
public void AddedNuspecDoesNotAddReferencesSectionIfNotPresent()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var package = PackageUtility.CreatePackage("A", "1.0", content: new[] { "A.txt", "scripts\\b.txt" });
repository.AddPackage(package);
// Assert
Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
Manifest manifest = Manifest.ReadFrom(manifestContentStream, validateSchema: true);
Assert.Equal(0, manifest.Metadata.ReferenceSets.Count);
}
public void FindPackagesByIdReturnsAnUnzippedInstanceIfANuspecIsAvailableAndAZipPackageOtherwise()
{
// Arrange
string manifestContent = @"<?xml version=""1.0""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"">
<metadata>
<id>One</id>
<version>1.0-alpha</version>
<authors>test</authors>
<description>My package description.</description>
</metadata>
<files />
</package>";
var fileSystem = new MockFileSystem("x:\root");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nuspec", manifestContent.AsStream());
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nupkg", Stream.Null);
var packageStream = GetPackageStream("One", "1.0.0");
fileSystem.AddFile("one.1.0\\one.1.0.nupkg", packageStream);
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var packages = repository.FindPackagesById("one").ToList();
// Assert
Assert.Equal(2, packages.Count);
var package = packages[0];
Assert.IsType <UnzippedPackage>(package);
Assert.Equal("One", package.Id);
Assert.Equal(new SemanticVersion("1.0.0-alpha"), package.Version);
package = packages[1];
Assert.IsType <ZipPackage>(package);
Assert.Equal("One", package.Id);
Assert.Equal(new SemanticVersion("1.0.0"), package.Version);
}
private IEnumerable <PackageDependency> GetReferences(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null)
{
// Get the msbuild project
project = project ?? NugetUpdateTask.GetMSBuildProject(packagesConfigPath);
// Resolve the repository path
repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root);
var sharedRepositoryFileSystem = new PhysicalFileSystem(repositoryPath);
var pathResolver = new DefaultPackagePathResolver(sharedRepositoryFileSystem);
// Create the local and source repositories
var sharedPackageRepository = new SharedPackageRepository(pathResolver, sharedRepositoryFileSystem, sharedRepositoryFileSystem);
var localRepository = new PackageReferenceRepository(project, sharedPackageRepository);
sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
IPackageConstraintProvider constraintProvider = localRepository;
return(GetReferences(localRepository, sharedRepositoryFileSystem, sharedPackageRepository, sourceRepository, constraintProvider, pathResolver, project));
}
public void RegisterRepositoryAddsRelativePathToRepositoriesConfig()
{
// Arrange
var fileSystem = new Mock <MockFileSystem>()
{
CallBase = true
};
fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, new MockFileSystem());
// Act
repository.RegisterRepository(@"c:\foo\packages\packages.config");
// Assert
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""packages\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
}
private RepositoryInfo GetRepositoryInfo()
{
// Update the path if it needs updating
string path = _repositorySettings.RepositoryPath;
string configFolderPath = _repositorySettings.ConfigFolderPath;
if (_repositoryInfo == null ||
!_repositoryInfo.Path.Equals(path, StringComparison.OrdinalIgnoreCase) ||
!_repositoryInfo.ConfigFolderPath.Equals(configFolderPath, StringComparison.OrdinalIgnoreCase) ||
_solutionManager.IsSourceControlBound != _repositoryInfo.IsSourceControlBound)
{
IFileSystem fileSystem = _fileSystemProvider.GetFileSystem(path);
IFileSystem configSettingsFileSystem = GetConfigSettingsFileSystem(configFolderPath);
ISharedPackageRepository repository = new SharedPackageRepository(
new DefaultPackagePathResolver(fileSystem), fileSystem, configSettingsFileSystem);
_repositoryInfo = new RepositoryInfo(path, configFolderPath, fileSystem, repository);
}
return(_repositoryInfo);
}
private void UpdatePackages(string packagesConfigPath, IMSBuildProjectSystem project = null, string repositoryPath = null, IPackageRepository sourceRepository = null)
{
// Get the msbuild project
project = project ?? GetMSBuildProject(packagesConfigPath);
// Resolve the repository path
repositoryPath = repositoryPath ?? GetRepositoryPath(project.Root);
var pathResolver = new DefaultPackagePathResolver(repositoryPath);
// Create the local and source repositories
var sharedPackageRepository = new SharedPackageRepository(repositoryPath);
var localRepository = new PackageReferenceRepository(project, sharedPackageRepository);
sourceRepository = sourceRepository ?? AggregateRepositoryHelper.CreateAggregateRepositoryFromSources(RepositoryFactory, SourceProvider, Source);
IPackageConstraintProvider constraintProvider = localRepository;
Console.WriteLine(NuGetResources.UpdatingProject, project.ProjectName);
UpdatePackages(localRepository, sharedPackageRepository, sourceRepository, constraintProvider, pathResolver, project);
project.Save();
}
public void CallRemovePackageWillRemoveTheWholePackageDirectory()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("A.2.0\\A.2.0.nupkg");
fileSystem.AddFile("A.2.0\\A.2.0.nuspec");
fileSystem.AddFile("A.2.0\\random");
fileSystem.AddFile("A.2.0\\content\\file.txt");
fileSystem.AddFile("A.2.0\\readme.txt");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.RemovePackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nupkg"));
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nuspec"));
Assert.False(fileSystem.DirectoryExists("A.2.0"));
}
protected virtual IPackageManager CreatePackageManager(IFileSystem packagesFolderFileSystem, bool useSideBySidePaths, bool checkDowngrade = true)
{
var repository = CreateRepository();
var pathResolver = new DefaultPackagePathResolver(packagesFolderFileSystem, useSideBySidePaths);
var localRepository = new SharedPackageRepository(
pathResolver,
packagesFolderFileSystem,
configSettingsFileSystem: NullFileSystem.Instance);
if (EffectivePackageSaveMode != PackageSaveModes.None)
{
localRepository.PackageSaveMode = EffectivePackageSaveMode;
}
var packageManager = new PackageManager(repository, pathResolver, packagesFolderFileSystem, localRepository)
{
Logger = Console,
CheckDowngrade = checkDowngrade
};
return(packageManager);
}
public void CallAddPackageWillNotAddEntryToPackageConfigWhenPackageConfigAlreadyExists()
{
// Arrange
var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
var configFileSystem = new MockFileSystem();
configFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""2.0"" />
</packages>");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem);
// Act
repository.AddPackage(PackageUtility.CreatePackage("B", "1.0"));
// Assert
Assert.True(configFileSystem.FileExists("packages.config"));
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""2.0"" />
</packages>", configFileSystem.ReadAllText("packages.config"));
}
public void GetPackagesDoesNotReturnDuplicatedPackagesIfBothNuspecAndNupkgFilesArePresent()
{
// Arrange
var packageStream = PackageUtility.CreateSimplePackageStream("one", "1.0.0-alpha");
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nupkg", packageStream);
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nuspec", "rubbish".AsStream());
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var packages = repository.GetPackages().ToList();
// Assert
Assert.Equal(1, packages.Count);
Assert.True(packages[0] is OptimizedZipPackage);
Assert.Equal("one", packages[0].Id);
Assert.Equal(new SemanticVersion("1.0.0-alpha"), packages[0].Version);
}
public void FindPackageReturnOptimizedZipPackageObject()
{
// Arrange
var packageStream = PackageUtility.CreateSimplePackageStream("one", "1.0.0-alpha");
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nupkg", packageStream);
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nuspace", "rubbish".AsStream());
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
IPackage package = repository.FindPackage("one", new SemanticVersion("1.0.0-alpha"));
// Assert
Assert.True(package is OptimizedZipPackage);
Assert.Equal("one", package.Id);
Assert.Equal(new SemanticVersion("1.0.0-alpha"), package.Version);
Assert.Equal("Test description", package.Description);
}
public void UnregisterRepositoryUseTheStoreFileSystemAndDeleteRepositoryConfig()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\");
var storeFileSystem = new MockFileSystem("y:\\");
storeFileSystem.AddFile("repositories.config",
@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""project1\path"" />
</repositories>");
var configFileSystem = new MockFileSystem("z:\\");
var resolver = new DefaultPackagePathResolver(fileSystem);
var repository = new SharedPackageRepository(resolver, fileSystem, storeFileSystem, configFileSystem);
// Act
repository.UnregisterRepository("x:\\project1\\path");
// Assert
Assert.False(storeFileSystem.FileExists("repositories.config"));
}
public void RegisterRepositoryUseTheStoreFileSystem()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\");
var storeFileSystem = new MockFileSystem("y:\\");
var configFileSystem = new MockFileSystem("z:\\");
var resolver = new DefaultPackagePathResolver(fileSystem);
var repository = new SharedPackageRepository(resolver, fileSystem, storeFileSystem, configFileSystem);
// Act
repository.RegisterRepository("x:\\project1\\path");
// Assert
Assert.True(storeFileSystem.FileExists("repositories.config"));
string content = storeFileSystem.ReadAllText("repositories.config");
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""project1\path"" />
</repositories>", content);
}
public void RegisterRepositoryDoesNotAddRelativePathToRepositoriesConfigIfExists()
{
// Arrange
var fileSystem = new MockFileSystem(@"x:\foo");
fileSystem.AddFile("repositories.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""B\packages.config"" />
</repositories>");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, new MockFileSystem());
var packageReferenceFile = new PackageReferenceFile(new MockFileSystem(), @"x:\foo\A\packages.config");
// Act
repository.RegisterRepository(packageReferenceFile);
// Assert
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""B\packages.config"" />
</repositories>", fileSystem.ReadAllText("repositories.config"));
}
public void CallRemovePackageWillDeletePackageConfigWhenThereIsNoMoreEntry()
{
// Arrange
var fileSystem = new Mock <MockFileSystem>()
{
CallBase = true
};
fileSystem.Setup(m => m.Root).Returns(@"c:\foo\");
var configFileSystem = new MockFileSystem();
configFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""2.0"" />
</packages>");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem);
// Act
repository.RemovePackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(configFileSystem.FileExists("packages.config"));
}
public void CallAddPackageWillAddNuspecWhichHasReferencesData()
{
// Arrange
var fileSystem = new MockFileSystem("x:\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.AddPackage(PackageUtility.CreatePackage("A",
"1.0",
assemblyReferences: new [] { "net40\\A.dll", "sl45\\B.dll", "A.dll", "win8\\C.dll" }));
// Assert
Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
Manifest manifest = Manifest.ReadFrom(manifestContentStream);
Assert.Equal(3, manifest.Metadata.References.Count);
Assert.Equal("A.dll", manifest.Metadata.References[0].File);
Assert.Equal("B.dll", manifest.Metadata.References[1].File);
Assert.Equal("C.dll", manifest.Metadata.References[2].File);
}
private void NugetifySolution(FileInfo solutionFile)
{
Console.WriteLine("Loading projects from solution {0}", solutionFile.Name);
var existingSolutionPackagesRepo = new SharedPackageRepository(Path.Combine(solutionFile.Directory.FullName, "packages"));
using (var solutionAdapter = new CachingSolutionLoader(solutionFile, GetMsBuildProperties(solutionFile), Console))
{
var projectAdapters = solutionAdapter.GetProjects();
Console.WriteLine("Processing {0} projects...", projectAdapters.Count);
foreach (var projectAdapter in projectAdapters)
{
Console.WriteLine();
Console.WriteLine("Processing project: {0}", projectAdapter.ProjectName);
NugetifyProject(projectAdapter, solutionFile.Directory, existingSolutionPackagesRepo);
Console.WriteLine("Project completed!");
}
}
Console.WriteLine("Complete!");
}
public void CallAddPackageWillAddNuspecWhichHasReferencesData()
{
// Arrange
var fileSystem = new MockFileSystem("x:\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.AddPackage(PackageUtility.CreatePackage("A",
"1.0",
assemblyReferences: new [] { "net40\\A.dll", "sl45\\B.dll", "A.dll", "win8\\C.dll" }));
// Assert
Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
Manifest manifest = Manifest.ReadFrom(manifestContentStream);
Assert.Equal(3, manifest.Metadata.References.Count);
Assert.Equal("A.dll", manifest.Metadata.References[0].File);
Assert.Equal("B.dll", manifest.Metadata.References[1].File);
Assert.Equal("C.dll", manifest.Metadata.References[2].File);
}
public void CallAddPackageWillAddNuspecWithReferencesPreserved()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var package = PackageUtility.CreatePackage("A", "1.0", content: new[] { "A.txt", "scripts\\b.txt" });
var mockedPackage = Mock.Get(package);
mockedPackage.Setup(m => m.PackageAssemblyReferences).Returns(
new PackageReferenceSet[] {
new PackageReferenceSet(new FrameworkName(".NETFramework, Version=4.0"), new [] { "A.dll" }),
new PackageReferenceSet(null, new [] { "B.dll" }),
});
// Act
repository.AddPackage(package);
// Assert
Assert.False(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nupkg"));
}
public void CallRemovePackageWillDeleteNuspecAndNupkgFileBeforeDeletingTheWholePackageDirectory()
{
// Arrange
var fileSystem = new MockFileSystemWithDeleteVerification();
fileSystem.AddFile("A.2.0\\A.2.0.nupkg");
fileSystem.AddFile("A.2.0\\A.2.0.nuspec");
fileSystem.AddFile("A.2.0\\random");
fileSystem.AddFile("A.2.0\\content\\file.txt");
fileSystem.AddFile("A.2.0\\readme.txt");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.RemovePackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nupkg"));
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nuspec"));
Assert.False(fileSystem.DirectoryExists("A.2.0"));
Assert.True(fileSystem.IsFileDeleted("A.2.0\\A.2.0.nupkg"));
Assert.True(fileSystem.IsFileDeleted("A.2.0\\A.2.0.nuspec"));
}
public void FindPackagesByIdAlwaysReturnsOptimizedZipPackageEvenIfNuspecIfPresent()
{
// Arrange
string manifestContent = @"<?xml version=""1.0""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"">
<metadata>
<id>One</id>
<version>1.0.0-alpha</version>
<authors>test</authors>
<description>My package description.</description>
</metadata>
<files />
</package>";
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nuspec", manifestContent.AsStream());
var packageStream = PackageUtility.CreateSimplePackageStream("One", "1.0.0-alpha");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nupkg", packageStream);
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var packages = repository.FindPackagesById("one").ToList();
// Assert
Assert.Equal(1, packages.Count);
var package = packages[0];
Assert.True(package is OptimizedZipPackage);
Assert.Equal("One", package.Id);
Assert.Equal(new SemanticVersion("1.0.0-alpha"), package.Version);
}
public void CallAddPackageWillAddNuspecWithReferencesPreserved()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var package = PackageUtility.CreatePackage("A", "1.0", content: new[] { "A.txt", "scripts\\b.txt" });
var mockedPackage = Mock.Get(package);
mockedPackage.Setup(m => m.PackageAssemblyReferences).Returns(
new PackageReferenceSet[] {
new PackageReferenceSet(new FrameworkName(".NETFramework, Version=4.0"), new [] { "A.dll" }),
new PackageReferenceSet(null, new [] { "B.dll" }),
});
// Act
repository.AddPackage(package);
// Assert
Assert.False(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nupkg"));
}
public void GetRepositoryPathsRemovesInvalidOrNonExistantPathsAndReturnsRelativePaths()
{
// Arrange
var fileSystem = new Mock <MockFileSystem>()
{
CallBase = true
};
fileSystem.Setup(m => m.FileExists(@"A\packages.config")).Returns(true);
fileSystem.Setup(m => m.FileExists(@"c:\foo\packages.config")).Returns(true);
fileSystem.Setup(m => m.FileExists(@"..\..\packages.config")).Returns(true);
fileSystem.Object.AddFile("repositories.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""B\packages.config"" />
<repository path=""c:\foo\packages.config"" />
<repository path=""..\..\packages.config"" />
<repository path="""" />
<repository />
</repositories>");
fileSystem.Setup(m => m.Root).Returns(@"c:\foo\bar\baz\");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, new MockFileSystem());
// Act
var paths = repository.GetRepositoryPaths().ToList();
// Assert
Assert.Equal(2, paths.Count);
Assert.Equal(@"A\packages.config", paths[0]);
Assert.Equal(@"..\..\packages.config", paths[1]);
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""A\packages.config"" />
<repository path=""c:\foo\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
}
public void RepositoryPathsAreSavedInAlphabeticalOrder()
{
// Arrange
var fileSystem = new Mock <MockFileSystem>()
{
CallBase = true
};
fileSystem.Setup(m => m.Root).Returns(@"x:\foo\");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, new MockFileSystem());
// Act
repository.RegisterRepository(@"x:\foo\z\packages\packages.config");
repository.RegisterRepository(@"x:\foo\X\packages\packages.config");
repository.RegisterRepository(@"x:\foo\a\packages\packages.config");
// Assert
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""a\packages\packages.config"" />
<repository path=""X\packages\packages.config"" />
<repository path=""z\packages\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
}
public void CallAddPackageWillAddNuspecWithReferencesPreserved()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var package = PackageUtility.CreatePackage("A", "1.0", content: new[] { "A.txt", "scripts\\b.txt" });
var mockedPackage = Mock.Get(package);
mockedPackage.Setup(m => m.PackageAssemblyReferences).Returns(
new PackageReferenceSet[] {
new PackageReferenceSet(new FrameworkName(".NETFramework, Version=4.0"), new [] { "A.dll" }),
new PackageReferenceSet(null, new [] { "B.dll" }),
});
repository.AddPackage(package);
// Assert
Assert.True(fileSystem.FileExists("A.1.0\\A.1.0.nuspec"));
Stream manifestContentStream = fileSystem.OpenFile("A.1.0\\A.1.0.nuspec");
Manifest manifest = Manifest.ReadFrom(manifestContentStream, validateSchema: true);
Assert.Equal(2, manifest.Metadata.ReferenceSets.Count);
var set1 = manifest.Metadata.ReferenceSets[0];
Assert.Equal(".NETFramework4.0", set1.TargetFramework);
Assert.Equal(1, set1.References.Count);
Assert.Equal("A.dll", set1.References[0].File);
var set2 = manifest.Metadata.ReferenceSets[1];
Assert.Null(set2.TargetFramework);
Assert.Equal(1, set2.References.Count);
Assert.Equal("B.dll", set2.References[0].File);
}
public void AddPackageReferenceEntryAddsReferenceToPackagesConfigFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage = PackageUtility.CreatePackage("SolutionLevel", tools: new[] { "Install.ps1" });
// Act
repository.AddPackageReferenceEntry(solutionPackage.Id, solutionPackage.Version);
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""SolutionLevel"" version=""1.0"" />
</packages>", configFileSystem.ReadAllText("packages.config"));
}
public void AddPackageDoesNotAddEntryToSolutionConfigFileForProjectLevelPackage()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage = PackageUtility.CreatePackage("SolutionLevel", content: new[] { "file.txt" });
// Act
repository.AddPackage(solutionPackage);
// Assert
Assert.False(configFileSystem.FileExists("packages.config"));
}
public void AddPackageDoesNotAddReferencesToMetadataPackagesToSolutionConfigFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage = PackageUtility.CreatePackage("MetadataPackage", dependencies: new [] { new PackageDependency("A") }, tools: new[] { "Install.ps1" });
// Act
repository.AddPackage(solutionPackage);
// Assert
Assert.False(configFileSystem.FileExists("packages.config"));
}
public void AddPackageAddSolutionLevelPackageDependingOnProjectLevelPackage()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage = PackageUtility.CreatePackage("SolutionLevel2", tools: new[] { "Install.ps1" }, dependencies: new[] { new PackageDependency("ProjectLevel1") });
// Act
repository.AddPackage(solutionPackage);
// Assert
var packageReferences = repository.PackageReferenceFile.GetPackageReferences().ToArray();
Assert.True(packageReferences.IsEmpty());
}
public void AddPackageAddSolutionLevelPackageDependingOnAnotherSolutionLevelPackage()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage1 = PackageUtility.CreatePackage("SolutionLevel1", tools: new[] { "Install.ps1" });
var solutionPackage2 = PackageUtility.CreatePackage("SolutionLevel2", tools: new[] { "Install.ps1" }, dependencies: new[] { new PackageDependency("SolutionLevel1")});
// Act
repository.AddPackage(solutionPackage1);
repository.AddPackage(solutionPackage2);
// Assert
var packageReferences = repository.PackageReferenceFile.GetPackageReferences()
.Select(p => p.Id).OrderBy(id => id).ToArray();
Assert.Equal(new [] { "SolutionLevel1", "SolutionLevel2" }, packageReferences);
}
public void AddPackageAddReferencesToSolutionLevelPackagesToSolutionConfigFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage = PackageUtility.CreatePackage("SolutionLevel", tools: new[] { "Install.ps1" });
// Act
repository.AddPackage(solutionPackage);
// Assert
Assert.True(configFileSystem.FileExists("packages.config"));
}
/// <summary>
/// </summary>
private int Run(Assembly integrationAgentAssembly, string integrationAgentExeFileName, string integrationAgentExeDirectory, string[] args)
{
var parameters = Program.ParseArguments(args);
var fileVersion = FileVersionInfo.GetVersionInfo(integrationAgentAssembly.Location).FileVersion;
if (parameters.ShowVersion || parameters.ShowHelp)
{
Console.WriteLine("IntegrationAgent v" + fileVersion);
}
if (parameters.ShowHelp)
{
Program.ShowHelp();
}
if (parameters.ShowVersion || parameters.ShowHelp)
{
return(0);
}
// Verify that assembly is signed and uses the correct key
var traceWriter = Program.CreateTraceWriter(parameters.TraceLevel);
traceWriter(TraceLevel.Verbose, "Checking assembly strong name.");
if (!integrationAgentAssembly.HasValidStrongName())
{
traceWriter(TraceLevel.Error, "Unsigned assembly!");
return(1);
}
traceWriter(TraceLevel.Verbose, "Verifying assembly signature.");
if (!integrationAgentAssembly.PublicKeyTokenEqualsTo(Token.Bytes))
{
traceWriter(TraceLevel.Error, "Invalid assembly!");
return(2);
}
// If no JSON config file name provided as paramter uses the application name
traceWriter(TraceLevel.Verbose, "Looking for JSON config file.");
var configFile = Path.Combine(integrationAgentExeDirectory, Path.GetFileNameWithoutExtension(integrationAgentExeFileName) + ".json");
if (!string.IsNullOrEmpty(parameters.Config))
{
if (!parameters.Config.EndsWith(".json"))
{
parameters.Config = parameters.Config + ".json";
}
configFile = Path.Combine(integrationAgentExeDirectory, parameters.Config);
}
// Check and reads the configuration file
var configuration = new Configuration();
if (File.Exists(configFile))
{
traceWriter(TraceLevel.Verbose, "Reading the JSON config file.");
var configJson = File.ReadAllText(configFile);
var jsonSerializer = new JavaScriptSerializer();
configuration = jsonSerializer.Deserialize <Configuration>(configJson) ?? configuration;
traceWriter(TraceLevel.Verbose, "JSON config file loaded.");
}
// Merges config file and command line parameters. Command line paramters have precedence.
configuration.package = parameters.Package ?? configuration.package;
configuration.token = parameters.Token ?? configuration.token;
configuration.repository = parameters.Repository ?? configuration.repository;
configuration.repositoryUsername = parameters.RepositoryUsername ?? configuration.repositoryUsername;
configuration.repositoryPassword = parameters.RepositoryPassword ?? configuration.repositoryPassword;
traceWriter(TraceLevel.Verbose, "Checking input parameters.");
if (string.IsNullOrWhiteSpace(configuration.package) && string.IsNullOrEmpty(configuration.token))
{
traceWriter(TraceLevel.Error, "Invalid configuration!");
return(3);
}
// Initializes NuGet repositories
traceWriter(TraceLevel.Verbose, "Initializing NuGet repositories.");
var nugetRepository = new DataServicePackageRepository(new Uri(NuGetRepository));
var aggregateRepository = new AggregateRepository(new[] { nugetRepository });
if (Uri.IsWellFormedUriString(configuration.repository, UriKind.Absolute))
{
if (!string.IsNullOrWhiteSpace(configuration.repositoryUsername) &&
!string.IsNullOrWhiteSpace(configuration.repositoryPassword))
{
HttpClient.DefaultCredentialProvider = new NugetCredentialProvider(
configuration.repositoryUsername, configuration.repositoryPassword);
}
var client = new HttpClient(new Uri(configuration.repository));
var customRepository = new DataServicePackageRepository(client);
aggregateRepository = new AggregateRepository(new[] { customRepository, nugetRepository });
}
// Perform auto-update if not disabled
if (!parameters.DisableUpdates)
{
traceWriter(TraceLevel.Verbose, "Checking for self update.");
var integrationAgentAssemblyName = integrationAgentAssembly.GetName();
var version = new SemanticVersion(integrationAgentAssemblyName.Version);
var package = aggregateRepository
.GetUpdates(new[] { new PackageName(integrationAgentAssemblyName.Name, version) }, includePrerelease: false, includeAllVersions: false)
.OrderBy(p => p.Version)
.LastOrDefault();
if (package != null && package.Version > version)
{
traceWriter(TraceLevel.Verbose, "Newer version found. Updating files.");
var filename = Path.GetFileName(integrationAgentExeFileName);
var file = package.GetFiles().FirstOrDefault(f => !string.IsNullOrEmpty(f.Path) && Path.GetFileName(f.Path).Equals(filename, StringComparison.OrdinalIgnoreCase));
if (file != null)
{
File.Delete(integrationAgentExeFileName + ".bak");
File.Move(integrationAgentExeFileName, integrationAgentExeFileName + ".bak");
using (Stream fromStream = file.GetStream(), toStream = File.Create(integrationAgentExeFileName))
{
fromStream.CopyTo(toStream);
}
Process.Start(integrationAgentExeFileName, string.Join(" ", args) + " -disableupdates");
Environment.Exit(0);
}
}
else
{
traceWriter(TraceLevel.Verbose, "Version is up to date.");
}
}
// Install the package to run including its dependencies
traceWriter(TraceLevel.Verbose, "Checking for execution package.");
var packagesPath = Path.Combine(integrationAgentExeDirectory, "packages");
var remotePackage = aggregateRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault();
var localRepository = new SharedPackageRepository(packagesPath);
if (!localRepository.Exists(remotePackage))
{
traceWriter(TraceLevel.Verbose, "Execution package not found localy. Installing remote.");
var packageManager = new PackageManager(aggregateRepository, packagesPath);
packageManager.InstallPackage(remotePackage, ignoreDependencies: false, allowPrereleaseVersions: false);
}
var localPackage = localRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault();
if (localPackage == null)
{
traceWriter(TraceLevel.Error, "Package not found!");
return(4);
}
// Build a dictionary list of assemblies based on assembly fully qualified name for dynamically resolving from the loaded package
traceWriter(TraceLevel.Verbose, "Resolving execution package dependencies.");
var allAssemblies = localRepository
.GetPackages()
.ToArray()
.SelectMany(p => p.AssemblyReferences.Select(a =>
{
var path = Path.Combine(packagesPath, p.Id + "." + p.Version, a.Path);
var aname = AssemblyName.GetAssemblyName(path);
return(new { key = aname.FullName, value = path });
}))
.DistinctBy(i => i.key)
.ToDictionary(i => i.key, i => i.value);
AppDomain.CurrentDomain.AssemblyResolve += (sender, eventArgs) =>
{
var aname = new AssemblyName(eventArgs.Name);
if (allAssemblies.ContainsKey(aname.FullName))
{
return(Assembly.LoadFile(allAssemblies[aname.FullName]));
}
return(null);
};
// Run the package export delegate if found
var assemblies = localPackage.AssemblyReferences.Select(a => new AssemblyCatalog(Path.Combine(packagesPath, localPackage.Id + "." + localPackage.Version, a.Path)));
using (var catalog = new AggregateCatalog(assemblies))
using (var container = new CompositionContainer(catalog))
{
traceWriter(TraceLevel.Verbose, "Resolving execution package entry point.");
container.SatisfyImportsOnce(this);
if (this.RunAssembly == null)
{
traceWriter(TraceLevel.Error, "Execution package extry point not found!");
return(5);
}
traceWriter(TraceLevel.Verbose, "Invoking execution package extry point.");
this.RunAssembly(configuration.token, traceWriter);
traceWriter(TraceLevel.Verbose, "Execution package finished successfully.");
return(0);
}
}
public void GetPackagesDoesNotReturnDuplicatedPackagesIfBothNuspecAndNupkgFilesArePresent()
{
// Arrange
var packageStream = PackageUtility.CreateSimplePackageStream("one", "1.0.0-alpha");
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nupkg", packageStream);
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nuspec", "rubbish".AsStream());
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var packages = repository.GetPackages().ToList();
// Assert
Assert.Equal(1, packages.Count);
Assert.True(packages[0] is OptimizedZipPackage);
Assert.Equal("one", packages[0].Id);
Assert.Equal(new SemanticVersion("1.0.0-alpha"), packages[0].Version);
}
public void FindPackageReturnOptimizedZipPackageObject()
{
// Arrange
var packageStream = PackageUtility.CreateSimplePackageStream("one", "1.0.0-alpha");
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nupkg", packageStream);
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nuspace", "rubbish".AsStream());
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
IPackage package = repository.FindPackage("one", new SemanticVersion("1.0.0-alpha"));
// Assert
Assert.True(package is OptimizedZipPackage);
Assert.Equal("one", package.Id);
Assert.Equal(new SemanticVersion("1.0.0-alpha"), package.Version);
Assert.Equal("Test description", package.Description);
}
public void ExistDoesNotCheckForPresenceOfManifestFileUnderDirectory(string id, string version, string path)
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.CreateDirectory(path);
fileSystem.AddFile(path + "\\" + path + ".nuspec");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
bool exists = repository.Exists(id, new SemanticVersion(version));
// Assert
Assert.True(exists);
}
public void UnregisterRepositoryUseTheStoreFileSystem()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\");
var storeFileSystem = new MockFileSystem("y:\\");
storeFileSystem.AddFile("repositories.config",
@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""project1\path"" />
<repository path=""..\one\two"" />
</repositories>");
var configFileSystem = new MockFileSystem("z:\\");
var resolver = new DefaultPackagePathResolver(fileSystem);
var repository = new SharedPackageRepository(resolver, fileSystem, storeFileSystem, configFileSystem);
// Act
repository.UnregisterRepository("x:\\project1\\path");
// Assert
Assert.True(storeFileSystem.FileExists("repositories.config"));
string content = storeFileSystem.ReadAllText("repositories.config");
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""..\one\two"" />
</repositories>", content);
}
public void CallRemovePackageWillDeletePackageConfigWhenThereIsNoMoreEntry()
{
// Arrange
var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
fileSystem.Setup(m => m.Root).Returns(@"x:\foo\");
var configFileSystem = new MockFileSystem();
configFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""A"" version=""2.0"" />
</packages>");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, configFileSystem);
// Act
repository.RemovePackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(configFileSystem.FileExists("packages.config"));
}
public void RemovingAllSolutionLevelPackageDeletesConfigFile()
{
// Arrange
var fileSystem = new MockFileSystem();
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
var solutionPackage = PackageUtility.CreatePackage("SolutionLevel", tools: new[] { "Install.ps1" });
configFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<packages>
<package id=""SolutionLevel"" version=""1.0"" />
</packages>");
// Act
repository.RemovePackage(solutionPackage);
// Assert
Assert.True(configFileSystem.Deleted.Contains("packages.config"));
}
public void FindPackagesByIdAlwaysReturnsOptimizedZipPackageEvenIfNuspecIfPresent()
{
// Arrange
string manifestContent = @"<?xml version=""1.0""?>
<package xmlns=""http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"">
<metadata>
<id>One</id>
<version>2.0-alpha</version>
<authors>test</authors>
<description>My package description.</description>
</metadata>
<files />
</package>";
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nuspec", manifestContent.AsStream());
var packageStream = PackageUtility.CreateSimplePackageStream("One", "1.0.0-alpha");
fileSystem.AddFile("one.1.0.0-alpha\\one.1.0.0-alpha.nupkg", packageStream);
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
var packages = repository.FindPackagesById("one").ToList();
// Assert
Assert.Equal(1, packages.Count);
var package = packages[0];
Assert.True(package is OptimizedZipPackage);
Assert.Equal("One", package.Id);
Assert.Equal(new SemanticVersion("1.0.0-alpha"), package.Version);
}
public void CallRemovePackageWillRemoveTheWholePackageDirectory()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\root");
fileSystem.AddFile("A.2.0\\A.2.0.nupkg");
fileSystem.AddFile("A.2.0\\A.2.0.nuspec");
fileSystem.AddFile("A.2.0\\random");
fileSystem.AddFile("A.2.0\\content\\file.txt");
fileSystem.AddFile("A.2.0\\readme.txt");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.RemovePackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nupkg"));
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nuspec"));
Assert.False(fileSystem.DirectoryExists("A.2.0"));
}
/// <summary>
/// Performs the NuGet package resolution.
/// </summary>
public override bool Execute()
{
var analyzers = new List <ITaskItem>();
var references = new List <ITaskItem>();
var copyLocals = new List <ITaskItem>();
if (PackagesConfigs == null || PackagesConfigs.Length == 0)
{
Log.LogError("PackagesConfigs property not specified.");
return(false);
}
if (PackagesConfigs.Any(pc => string.IsNullOrWhiteSpace(pc.ItemSpec)))
{
Log.LogError("A PackagesConfigs element was not specified.");
}
ITaskItem packagesConfigNotFound = PackagesConfigs.FirstOrDefault(pc => !File.Exists(pc.ItemSpec));
if (packagesConfigNotFound != default(ITaskItem))
{
Log.LogError("File '{0}' not found.", packagesConfigNotFound.ItemSpec);
return(false);
}
var targetFrameworks = new List <FrameworkName>();
var targetFramework = new FrameworkName(TargetFramework);
if (targetFramework.Identifier == ".NETPortable")
{
// Let's convert
var folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), @"Reference Assemblies\Microsoft\Framework\.NETPortable", "v" + targetFramework.Version, "Profile", targetFramework.Profile, "SupportedFrameworks");
if (Directory.Exists(folder))
{
foreach (var framework in Directory.EnumerateFiles(folder, "*.xml"))
{
var xml = XDocument.Load(framework).Root;
targetFrameworks.Add(new FrameworkName(xml.Attribute("Identifier").Value, Version.Parse(xml.Attribute("MinimumVersion").Value)));
}
}
else
{
// If the portable profile doesn't exist lets fallback to the default for Profile7.
targetFrameworks.Add(new FrameworkName(".NETFramework", new Version(4, 5)));
targetFrameworks.Add(new FrameworkName(".NETCore", new Version(4, 5)));
}
}
else
{
targetFrameworks.Add(targetFramework);
}
var context = AssetResolutionContext.Empty
.WithTargetFrameworks(new FrameworkNameSet(targetFrameworks))
.WithArchitecture(Platform ?? "")
.WithAssemblyAssetTypes()
.RegisterProperty("ProjectType", new LanguagePropertyDefinition())
.SetProperty("ProjectType", Language)
.RegisterProperty("DesignTimeOnly", new AnythingGoesPropertyDefinition())
.SetProperty("DesignTimeOnly", "true")
.RegisterAssetType("Analyzer");
var platformNames = new List <PlatformName>();
PlatformName singularPlatformName;
if (PlatformName.TryParse(TargetPlatformMoniker, out singularPlatformName))
{
platformNames.Add(singularPlatformName);
}
if (platformNames.Any())
{
context = context.WithTargetPlatforms(new PlatformNameSet(platformNames));
}
var resolver = new AssetResolver(context);
var packagesConfigs = (from packageConfig in PackagesConfigs select new PackageReferenceFile(Path.GetFullPath(packageConfig.ItemSpec))).ToArray();
var succeeded = true;
var repository = new SharedPackageRepository(PackageRoot);
foreach (var packageReference in GetPackageReferences(packagesConfigs))
{
IPackage package;
if (!repository.TryFindPackage(packageReference.Id, packageReference.Version, out package))
{
Log.LogError("Unable to find nupkg for {0}.", packageReference.Id);
succeeded = false;
continue;
}
var packageDescription = packageReference.Id + "." + packageReference.Version.ToString();
var manifest = ManifestDeclaration.Parse(Path.Combine(PackageRoot, packageDescription), package);
// If there are no assets we cannot
if (!manifest.Groups.Any())
{
Log.LogMessage("no assets for " + packageDescription);
continue;
}
try
{
Log.LogMessage("resolving assets for " + packageDescription);
var assets = resolver.Resolve(manifest);
foreach (var asset in assets)
{
switch (asset.Type)
{
case "Analyzer":
analyzers.Add(new TaskItem(asset.Value));
Log.LogMessage("resolved analyzer: " + asset.Value);
break;
case WellKnownAssetType.ReferenceOnly:
{
var taskItem = new TaskItem(asset.Value);
taskItem.SetMetadata("NuGetPackageId", packageReference.Id);
taskItem.SetMetadata("NuGetPackageVersion", packageReference.Version.ToString());
taskItem.SetMetadata("ReferenceGrouping", packageReference.Id + ",Version=" + packageReference.Version.Version);
taskItem.SetMetadata("ReferenceGroupingDisplayName", packageReference.Id);
taskItem.SetMetadata("Private", "false");
references.Add(taskItem);
Log.LogMessage("resolved reference: " + asset.Value);
break;
}
case WellKnownAssetType.CopyLocal:
{
var taskItem = new TaskItem(asset.Value);
taskItem.SetMetadata("CopyToOutputDirectory", "PreserveNewest");
copyLocals.Add(taskItem);
Log.LogMessage("resolved copylocal: " + asset.Value);
break;
}
}
}
}
catch (AssetResolutionException ex)
{
Log.LogWarning("Unable to resolve the assets of {0}: {1}", packageReference.Id, ex.Message);
}
}
ResolvedAnalyzers = analyzers.ToArray();
ResolvedReferences = references.ToArray();
ResolvedCopyLocal = copyLocals.ToArray();
return(succeeded);
}
public void RepositoryPathsAreSavedInAlphabeticalOrder()
{
// Arrange
var fileSystem = new Mock<MockFileSystem>() { CallBase = true };
fileSystem.Setup(m => m.Root).Returns(@"x:\foo\");
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem.Object), fileSystem.Object, new MockFileSystem());
// Act
repository.RegisterRepository(@"x:\foo\z\packages\packages.config");
repository.RegisterRepository(@"x:\foo\X\packages\packages.config");
repository.RegisterRepository(@"x:\foo\a\packages\packages.config");
// Assert
Assert.Equal(@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""a\packages\packages.config"" />
<repository path=""X\packages\packages.config"" />
<repository path=""z\packages\packages.config"" />
</repositories>", fileSystem.Object.ReadAllText("repositories.config"));
}
public void CallRemovePackageWillDeleteNuspecAndNupkgFileBeforeDeletingTheWholePackageDirectory()
{
// Arrange
var fileSystem = new MockFileSystemWithDeleteVerification();
fileSystem.AddFile("A.2.0\\A.2.0.nupkg");
fileSystem.AddFile("A.2.0\\A.2.0.nuspec");
fileSystem.AddFile("A.2.0\\random");
fileSystem.AddFile("A.2.0\\content\\file.txt");
fileSystem.AddFile("A.2.0\\readme.txt");
var configFileSystem = new MockFileSystem();
var repository = new SharedPackageRepository(new DefaultPackagePathResolver(fileSystem), fileSystem, configFileSystem);
// Act
repository.RemovePackage(PackageUtility.CreatePackage("A", "2.0"));
// Assert
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nupkg"));
Assert.False(fileSystem.FileExists("A.2.0\\A.2.0.nuspec"));
Assert.False(fileSystem.DirectoryExists("A.2.0"));
Assert.True(fileSystem.IsFileDeleted("A.2.0\\A.2.0.nupkg"));
Assert.True(fileSystem.IsFileDeleted("A.2.0\\A.2.0.nuspec"));
}
public void UnregisterRepositoryUseTheStoreFileSystemAndDeleteRepositoryConfig()
{
// Arrange
var fileSystem = new MockFileSystem("x:\\");
var storeFileSystem = new MockFileSystem("y:\\");
storeFileSystem.AddFile("repositories.config",
@"<?xml version=""1.0"" encoding=""utf-8""?>
<repositories>
<repository path=""project1\path"" />
</repositories>");
var configFileSystem = new MockFileSystem("z:\\");
var resolver = new DefaultPackagePathResolver(fileSystem);
var repository = new SharedPackageRepository(resolver, fileSystem, storeFileSystem, configFileSystem);
// Act
repository.UnregisterRepository("x:\\project1\\path");
// Assert
Assert.False(storeFileSystem.FileExists("repositories.config"));
}
/// <summary>
/// Initialize NugetStore using <paramref name="rootDirectory"/> as location of the local copies,
/// and a configuration file <paramref name="configFile"/> as well as an override configuration
/// file <paramref name="overrideFile"/> where all settings of <paramref name="overrideFile"/> also
/// presents in <paramref name="configFile"/> take precedence.
/// </summary>
/// <param name="rootDirectory">The location of the Nuget store.</param>
/// <param name="configFile">The configuration file name for the Nuget store, or <see cref="DefaultConfig"/> if not specified.</param>
/// <param name="overrideFile">The override configuration file name for the Nuget store, or <see cref="OverrideConfig"/> if not specified.</param>
public NugetStore(string rootDirectory, string configFile = DefaultConfig, string overrideFile = OverrideConfig)
{
if (rootDirectory == null)
{
throw new ArgumentNullException(nameof(rootDirectory));
}
if (configFile == null)
{
throw new ArgumentNullException(nameof(configFile));
}
if (overrideFile == null)
{
throw new ArgumentNullException(nameof(overrideFile));
}
// First try the override file with custom settings
var configFileName = overrideFile;
var configFilePath = Path.Combine(rootDirectory, configFileName);
if (!File.Exists(configFilePath))
{
// Override file does not exist, fallback to default config file
configFileName = configFile;
configFilePath = Path.Combine(rootDirectory, configFileName);
if (!File.Exists(configFilePath))
{
throw new ArgumentException($"Invalid installation. Configuration file [{configFile}] not found", nameof(configFile));
}
}
var rootFileSystem = new PhysicalFileSystem(rootDirectory);
RootDirectory = rootFileSystem.Root;
settings = new Settings(rootFileSystem, configFileName, false);
InstallPath = settings.GetValue(ConfigurationConstants.Config, RepositoryPathKey, true);
if (!string.IsNullOrEmpty(InstallPath))
{
InstallPath = InstallPath.Replace('/', Path.DirectorySeparatorChar);
}
var mainPackageList = settings.GetValue(ConfigurationConstants.Config, MainPackagesKey, false);
if (string.IsNullOrWhiteSpace(mainPackageList))
{
throw new InvalidOperationException($"Invalid configuration. Expecting [{MainPackagesKey}] in config");
}
MainPackageIds = mainPackageList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
VsixPluginId = settings.GetValue(ConfigurationConstants.Config, VsixPluginKey, false);
if (string.IsNullOrWhiteSpace(VsixPluginId))
{
throw new InvalidOperationException($"Invalid configuration. Expecting [{VsixPluginKey}] in config");
}
RepositoryPath = settings.GetValue(ConfigurationConstants.Config, RepositoryPathKey, false);
if (string.IsNullOrWhiteSpace(RepositoryPath))
{
RepositoryPath = DefaultGamePackagesDirectory;
}
// Setup NugetCachePath in the cache folder
CacheDirectory = Path.Combine(rootDirectory, "Cache");
Environment.SetEnvironmentVariable("NuGetCachePath", CacheDirectory);
var packagesFileSystem = new PhysicalFileSystem(InstallPath);
PathResolver = new PackagePathResolver(packagesFileSystem);
var packageSourceProvider = new PackageSourceProvider(settings);
SourceRepository = packageSourceProvider.CreateAggregateRepository(new PackageRepositoryFactory(), true);
var localRepo = new SharedPackageRepository(PathResolver, packagesFileSystem, rootFileSystem);
manager = new NuGet.PackageManager(SourceRepository, PathResolver, packagesFileSystem, localRepo);
manager.PackageInstalling += OnPackageInstalling;
manager.PackageInstalled += OnPackageInstalled;
manager.PackageUninstalling += OnPackageUninstalling;
manager.PackageUninstalled += OnPackageUninstalled;
}