/// <summary> /// Creates a test package. /// </summary> /// <param name="packageId">The id of the created package.</param> /// <param name="version">The version of the created package.</param> /// <param name="path">The directory where the package is created.</param> /// <returns>The full path of the created package file.</returns> public static string CreateTestPackage(string packageId, string version, string path, Uri licenseUrl = null) { var packageBuilder = new PackageBuilder { Id = packageId, Version = new SemanticVersion(version), Description = "Test desc" }; if (licenseUrl != null) { packageBuilder.LicenseUrl = licenseUrl; } packageBuilder.Files.Add(CreatePackageFile(@"content\test1.txt")); packageBuilder.Authors.Add("test author"); var packageFileName = string.Format("{0}.{1}.nupkg", packageId, version); var packageFileFullPath = Path.Combine(path, packageFileName); using (var fileStream = File.Create(packageFileFullPath)) { packageBuilder.Save(fileStream); } return packageFileFullPath; }
public void Burn_InstallUninstallBundleWithEmbeddedBundle() { // Build the packages. string packageA1 = new PackageBuilder(this, "A").Build().Output; string packageB1 = new PackageBuilder(this, "B").Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA1); bindPaths.Add("packageB", packageB1); // Build the embedded bundle. string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Build the parent bundle bindPaths.Add("bundleB", bundleB); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); // Test package is installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); Assert.True(MsiVerifier.IsPackageInstalled(packageB1)); // Attempt to uninstall bundleA. installerA.Uninstall(); // Test package is uninstalled. Assert.False(MsiVerifier.IsPackageInstalled(packageA1)); Assert.False(MsiVerifier.IsPackageInstalled(packageB1)); this.Complete(); }
public void CreatePackageAddsVersionStampIfFrameworkAssembliesAreUsed() { // Arrange PackageBuilder builder = new PackageBuilder() { Id = "A", Version = new Version("1.0"), Description = "Descriptions", }; builder.Authors.Add("David"); builder.FrameworkReferences.Add(new FrameworkAssemblyReference("System.Web")); var ms = new MemoryStream(); // Act Manifest.Create(builder).Save(ms); ms.Seek(0, SeekOrigin.Begin); // Assert Assert.AreEqual(@"<?xml version=""1.0"" encoding=""utf-8""?> <package xmlns=""http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd""> <metadata schemaVersion=""2""> <id>A</id> <version>1.0</version> <authors>David</authors> <owners>David</owners> <requireLicenseAcceptance>false</requireLicenseAcceptance> <description>Descriptions</description> <frameworkAssemblies> <frameworkAssembly assemblyName=""System.Web"" targetFramework="""" /> </frameworkAssemblies> </metadata> </package>", ms.ReadToEnd()); }
public void Burn_InstallUninstall() { string v2Version = "2.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageC = new PackageBuilder(this, "C") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageC", packageC); // Add the bindpath for the cab for C to enable to add it as a payload for BundleA bindPaths.Add("packageCcab", Path.Combine(Path.GetDirectoryName(packageC), "cab1.cab")); // Build the embedded bundle. string bundleBv2 = new BundleBuilder(this, "BundleBv2") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", v2Version } } }.Build().Output; // Build the parent bundle. bindPaths.Add("bundleBv2", bundleBv2); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the parent bundle that will install the embedded bundle. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageC)); // Attempt to uninstall bundleA, which will uninstall bundleB since it is a patch related bundle. installerA.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageC)); this.Complete(); }
public void Burn_CancelExecuteWhileCaching() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundle. string bundleA = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Slow the caching of package B to ensure that package A starts installing and cancels. this.SetPackageCancelExecuteAtProgress("PackageA", 50); this.SetPackageSlowCache("PackageB", 1000); // Install the bundle and hopefully it fails. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(expectedExitCode: ErrorCodes.ERROR_INSTALL_USEREXIT); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageB)); this.CleanTestArtifacts = true; }
public void Fill (PackageBuilder builder, SolutionItem selection) { store.Clear (); this.builder = builder; if (selection is SolutionFolder) { foreach (SolutionItem e in ((SolutionFolder)selection).GetAllItems ()) { if (builder.CanBuild (e)) selectedEntries [e] = e; } } else if (selection != null) { selectedEntries [selection] = selection; } if (selection != null) solution = selection.ParentSolution; else { solution = IdeApp.ProjectOperations.CurrentSelectedSolution; if (solution == null) { ReadOnlyCollection<Solution> items = IdeApp.ProjectOperations.CurrentSelectedWorkspaceItem.GetAllSolutions (); if (items.Count > 0) solution = items [0]; else return; } } AddEntry (TreeIter.Zero, solution.RootFolder); }
public void CtorWithStream() { // Arrange var builder = new PackageBuilder(); builder.Id = "Package"; builder.Version = new SemanticVersion("1.0"); builder.Authors.Add("David"); builder.Description = "This is a test package"; builder.ReleaseNotes = "This is a release note."; builder.Copyright = "Copyright"; builder.Files.AddRange(PackageUtility.CreateFiles(new[] { @"lib\40\A.dll", @"content\foo" })); var ms = new MemoryStream(); builder.Save(ms); ms.Seek(0, SeekOrigin.Begin); // Act var package = new ZipPackage(ms); // Assert Assert.Equal("Package", package.Id); Assert.Equal(new SemanticVersion("1.0"), package.Version); Assert.Equal("David", package.Authors.First()); Assert.Equal("Copyright", package.Copyright); var files = package.GetFiles().ToList(); Assert.Equal(2, files.Count); Assert.Equal(@"content\foo", files[0].Path); Assert.Equal(@"lib\40\A.dll", files[1].Path); var assemblyReferences = package.AssemblyReferences.ToList(); Assert.Equal(1, assemblyReferences.Count); Assert.Equal("A.dll", assemblyReferences[0].Name); Assert.Equal(new FrameworkName(".NETFramework", new Version("4.0")), assemblyReferences[0].TargetFramework); Assert.Equal("This is a release note.", package.ReleaseNotes); }
public void Burn_RedirectPackageCache() { const string PolicyName = "PackageCache"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; RegistryKey policy = Registry.LocalMachine.CreateSubKey(@"Software\Policies\WiX\Burn"); string currentPackageCache = null; try { currentPackageCache = policy.GetValue(PolicyName) as string; // Install the first bundle using the default package cache. policy.DeleteValue(PolicyName); BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); // Install the second bundle which has a shared package using the redirected package cache. string path = Path.Combine(Path.GetTempPath(), "Package Cache"); policy.SetValue(PolicyName, path); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // The first bundle should leave package A behind. installerA.Uninstall(); // Now make sure that the second bundle removes packages from either cache directory. installerB.Uninstall(); this.Complete(); } finally { if (!string.IsNullOrEmpty(currentPackageCache)) { policy.SetValue(PolicyName, currentPackageCache); } else { policy.DeleteValue(PolicyName); } policy.Dispose(); } }
public void Burn_PermanentInstallUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install Bundle A. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall bundleA. installerA.Uninstall(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); this.Complete(); }
public void Burn_PermanentInstallForceUninstall() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install Bundle A. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Force Uninstall Bundle A. this.SetPackageRequestedState("PackageA", Microsoft.Tools.WindowsInstallerXml.Bootstrapper.RequestState.ForceAbsent); this.SetPackageRequestedState("PackageB", Microsoft.Tools.WindowsInstallerXml.Bootstrapper.RequestState.ForceAbsent); installerA.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); this.Complete(); }
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 void ReleaseNotesAttributeIsRecognized() { // Arrange PackageBuilder builder = new PackageBuilder() { Id = "A", Version = new SemanticVersion("1.0"), Description = "Description", ReleaseNotes = "Release Notes" }; builder.Authors.Add("David"); var ms = new MemoryStream(); // Act Manifest.Create(builder).Save(ms); ms.Seek(0, SeekOrigin.Begin); // Assert Assert.Equal(@"<?xml version=""1.0""?> <package xmlns=""http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd""> <metadata> <id>A</id> <version>1.0</version> <authors>David</authors> <owners>David</owners> <requireLicenseAcceptance>false</requireLicenseAcceptance> <description>Description</description> <releaseNotes>Release Notes</releaseNotes> </metadata> </package>", ms.ReadToEnd()); }
/// <summary> /// Creates a test package. /// </summary> /// <param name="packageId">The id of the created package.</param> /// <param name="version">The version of the created package.</param> /// <param name="path">The directory where the package is created.</param> /// <returns>The full path of the created package file.</returns> public static string CreateTestPackage(string packageId, string version, string path, Uri licenseUrl = null) { var packageBuilder = new PackageBuilder { Id = packageId, Version = new SemanticVersion(version), Description = "Test desc" }; if (licenseUrl != null) { packageBuilder.LicenseUrl = licenseUrl; } var dependencies = new PackageDependency("Dummy"); packageBuilder.DependencySets.Add(new PackageDependencySet(null, new[] { dependencies })); packageBuilder.Authors.Add("test author"); var packageFileName = string.Format("{0}.{1}.nupkg", packageId, version); var packageFileFullPath = Path.Combine(path, packageFileName); using (var fileStream = File.Create(packageFileFullPath)) { packageBuilder.Save(fileStream); } return packageFileFullPath; }
public void OwnersFallsBackToAuthorsIfNoneSpecified() { // Arrange PackageBuilder builder = new PackageBuilder() { Id = "A", Version = new SemanticVersion("1.0"), Description = "Description" }; builder.Authors.Add("JohnDoe"); var ms = new MemoryStream(); // Act Manifest.Create(builder).Save(ms); ms.Seek(0, SeekOrigin.Begin); // Assert Assert.Equal(@"<?xml version=""1.0""?> <package xmlns=""http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd""> <metadata> <id>A</id> <version>1.0</version> <authors>JohnDoe</authors> <owners>JohnDoe</owners> <requireLicenseAcceptance>false</requireLicenseAcceptance> <description>Description</description> </metadata> </package>", ms.ReadToEnd()); }
public void Burn_ComponentSearchResults() { // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // PackageB will be installed if all ComponentSearches worked. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Uninstall the main bundle and add-on. installerA.Uninstall(); this.Complete(); }
public void Fill (PackageBuilder builder, SolutionFolderItem selection) { store.Clear (); this.builder = builder; if (selection is SolutionFolder) { foreach (SolutionFolderItem e in ((SolutionFolder)selection).GetAllItems ()) { if (builder.CanBuild (e)) selectedEntries [e] = e; } } else if (selection != null) { selectedEntries [selection] = selection; } if (selection != null) solution = selection.ParentSolution; else { solution = IdeApp.ProjectOperations.CurrentSelectedSolution; if (solution == null) { solution = IdeApp.ProjectOperations.CurrentSelectedWorkspaceItem.GetAllItems<Solution> ().FirstOrDefault(); if (solution == null) return; } } AddEntry (TreeIter.Zero, solution.RootFolder); }
private void GenerateArchiveDataFromPackage(PackageBuilder packageBuilder) { using (var archiveStream = new MemoryStream()) { packageBuilder.GeneratePackageArchive(archiveStream); _archiveData = archiveStream.ToArray(); } }
private string DeployPackage(string id, PackageBuilder builder) { string path = Path.Combine(_tempDir, id); builder.WritePackageInto(path); ManifestTest.CreateDotFile(path, ManifestFormat.FromPrefix(id), _handler); FileUtils.EnableWriteProtection(path); return path; }
public void GivenParentProductCategory_WhenPackageIsDefined_ThenValidationHasErrors() { var package = new PackageBuilder(this.DatabaseSession).WithName("package").Build(); var parent = new ProductCategoryBuilder(this.DatabaseSession).WithDescription("parent").WithPackage(package).Build(); var child = new ProductCategoryBuilder(this.DatabaseSession).WithDescription("child").WithParent(parent).Build(); Assert.IsTrue(new Derivation(this.DatabaseSession).Derive().HasErrors); }
private PackageBuilder GetPackageA() { if (null == this.packageA) { this.packageA = this.CreatePackage("A"); } return this.packageA; }
public void GivenLeafeProductCategory_WhenPackageIsDefined_ThenValidationHasNoErrors() { var package = new PackageBuilder(this.DatabaseSession).WithName("package").Build(); new ProductCategoryBuilder(this.DatabaseSession).WithDescription("Category").WithPackage(package).Build(); Assert.IsFalse(new Derivation(this.DatabaseSession).Derive().HasErrors); this.DatabaseSession.Rollback(); }
public void Burn_InstallUninstallAddonPatchRelatedBundle() { // Build the packages. string packageA = new PackageBuilder(this, "A").Build().Output; string packageC1 = new PackageBuilder(this, "C").Build().Output; string packageC2 = new PackageBuilder(this, "C") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", "1.0.1.0" } } }.Build().Output; string packageD = new PackageBuilder(this, "D").Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPaths = new Dictionary<string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageC", packageC1); bindPaths.Add("packageD", packageD); // Build the base and addon bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Update path to C2 and build the addon patch bundle. bindPaths["packageC"] = packageC2; string bundleE = new BundleBuilder(this, "BundleE") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", "1.0.1.0" } } }.Build().Output; // Install the base and addon bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); // Test that packages A and C1 but not D are installed. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageC1)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC2)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD)); // Install the patch to the addon. BundleInstaller installerE = new BundleInstaller(this, bundleE).Install(); // Test that packages A and C2 but not D are installed, and that C1 was upgraded. Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC1)); Assert.IsTrue(MsiVerifier.IsPackageInstalled(packageC2)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD)); // Attempt to uninstall bundleA. installerA.Uninstall(); // Test that uninstalling bundle A detected and removed bundle C, which removed bundle E (can't easily reference log). Assert.IsTrue(LogVerifier.MessageInLogFileRegex(installerA.LastLogFile, @"Detected related bundle: \{[0-9A-Za-z\-]{36}\}, type: Addon, scope: PerMachine, version: 1\.0\.0\.0, operation: Remove")); // Test that all packages are uninstalled. Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageA)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC1)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageC2)); Assert.IsFalse(MsiVerifier.IsPackageInstalled(packageD)); this.CleanTestArtifacts = true; }
public override void CopyFrom (PackageBuilder other) { base.CopyFrom (other); CommandPackageBuilder t = other as CommandPackageBuilder; if (t != null) { command = t.command; args = t.args; externalConsole = t.externalConsole; closeConsoleWhenDone = t.closeConsoleWhenDone; } }
public string GenerateSingleCustomPackage(PackageDefinition definition, string binFolderPath, string outputFolderPath, string releaseVersion, IEnumerable<string> singleDLLPackages, IEnumerable<string> customPackages, string packageNamePrefix) { // if no dependencies exist, don't create package from definition IEnumerable<ManifestDependency> dependencies = this.GenerateDependencies(definition.Dependencies, binFolderPath, releaseVersion, singleDLLPackages, customPackages, packageNamePrefix); if (!dependencies.Any()) { return String.Empty; } // Create nupkg file var packageId = packageNamePrefix + definition.Id + "." + releaseVersion; var nugetFilePath = Path.Combine(outputFolderPath, packageId + ".nupkg"); var metadata = new ManifestMetadata { Id = packageNamePrefix + definition.Id, Title = packageNamePrefix + definition.Id, Version = releaseVersion, Tags = definition.Tag, Authors = "Sitecore", Owners = "Sitecore", Description = definition.Description, RequireLicenseAcceptance = false, IconUrl = "http://www.sitecore.net/favicon.ico", DependencySets = new List<ManifestDependencySet> { new ManifestDependencySet { Dependencies = dependencies.ToList() } } }; var builder = new PackageBuilder(); builder.Populate(metadata); using (FileStream stream = File.Open(nugetFilePath, FileMode.OpenOrCreate)) { builder.Save(stream); } return nugetFilePath; }
private PackageBuilder BuildSamplePackageHierarchy() { var packageBuilder = new PackageBuilder() .AddFile("file1", "First file") .AddFile("file2", new byte[] {0}); packageBuilder.AddFolder("emptyFolder"); packageBuilder.AddFolder("sub").AddFolder("folder") .AddFile("nestedFile", "File 3\n") .AddFolder("nestedFolder").AddFile("doublyNestedFile", "File 4"); _package = packageBuilder.Hierarchy; return packageBuilder; }
public void Burn_InstallUpdatedBundleOptionalUpdateRegistration() { string v2Version = "2.0.0.0"; // Build the packages. string packageAv1 = new PackageBuilder(this, "A").Build().Output; string packageAv2 = new PackageBuilder(this, "A") { PreprocessorVariables = new Dictionary<string, string>() { { "Version", v2Version } } }.Build().Output; // Create the named bind paths to the packages. Dictionary<string, string> bindPathsv1 = new Dictionary<string, string>() { { "packageA", packageAv1 } }; Dictionary<string, string> bindPathsv2 = new Dictionary<string, string>() { { "packageA", packageAv2 } }; // Build the bundles. string bundleAv1 = new BundleBuilder(this, "BundleA") { BindPaths = bindPathsv1, Extensions = Extensions }.Build().Output; string bundleAv2 = new BundleBuilder(this, "BundleA") { BindPaths = bindPathsv2, Extensions = Extensions, PreprocessorVariables = new Dictionary<string, string>() { { "Version", v2Version } } }.Build().Output; // Initialize with first bundle. BundleInstaller installerAv1 = new BundleInstaller(this, bundleAv1).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageAv1)); // Make sure the OptionalUpdateRegistration exists. // SOFTWARE\[Manufacturer]\Updates\[ProductFamily]\[Name] using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_InstallUpdatedBundleOptionalUpdateRegistration - Bundle A")) { Assert.Equal("Y", key.GetValue("ThisVersionInstalled")); Assert.Equal("1.0.0.0", key.GetValue("PackageVersion")); } // Install second bundle which will major upgrade away v1. BundleInstaller installerAv2 = new BundleInstaller(this, bundleAv2).Install(); Assert.False(MsiVerifier.IsPackageInstalled(packageAv1)); Assert.True(MsiVerifier.IsPackageInstalled(packageAv2)); // Make sure the OptionalUpdateRegistration exists. // SOFTWARE\[Manufacturer]\Updates\[ProductFamily]\[Name] using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_InstallUpdatedBundleOptionalUpdateRegistration - Bundle A")) { Assert.Equal("Y", key.GetValue("ThisVersionInstalled")); Assert.Equal("2.0.0.0", key.GetValue("PackageVersion")); } // Uninstall the second bundle and everything should be gone. installerAv2.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageAv1)); Assert.False(MsiVerifier.IsPackageInstalled(packageAv2)); // Make sure the key is removed. using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft Corporation\Updates\~Burn_InstallUpdatedBundleOptionalUpdateRegistration - Bundle A")) { Assert.Null(key); } }
public void SetUp() { var packageBuilder = new PackageBuilder() .AddFolder("someFolder") .AddFolder("someOtherFolder") .AddFile("nestedFile1", "abc") .AddFile("nestedFile2", "123"); _sandbox = new TemporaryDirectory("0install-unit-tests"); packageBuilder.WritePackageInto(_sandbox); _someGenerator = new ManifestGenerator(_sandbox, ManifestFormat.Sha256); }
public void GivenPackage_WhenDeriving_ThenRequiredRelationsMustExist() { var builder = new PackageBuilder(this.DatabaseSession); var package = builder.Build(); Assert.IsTrue(this.DatabaseSession.Derive().HasErrors); this.DatabaseSession.Rollback(); builder.WithName("package"); package = builder.Build(); Assert.IsFalse(this.DatabaseSession.Derive().HasErrors); }
public void RemoveExcludedFilesRemovesManifestAndOtherNuGetageFiles() { // Arrange var packageBuilder = new PackageBuilder(); var files = new[] { "somefile.nuspec", @"\foo\bar\somefile.nupkg", @"\baz\1.cs" }; packageBuilder.Files.AddRange(from f in files // This almost sounds like a cuss word! select new PhysicalPackageFile { TargetPath = f }); // Act NewPackageCommand.RemoveExludedFiles(packageBuilder); // Assert Assert.Equal(@"\baz\1.cs", packageBuilder.Files.Single().Path); }
public void SingleAssemblyTest() { // Arrange string search = "foo.dll"; string target = "lib"; string root = CreateFileSystem(new File("foo.dll")); Stream manifest = GetManifest(search, target); // Act var packageBuilder = new PackageBuilder(manifest, root); // Assert Assert.Equal(packageBuilder.Files.Count, 1); Assert.Equal(packageBuilder.Files.First().Path, @"lib\foo.dll"); }
public void Enum_with_flags() { var package = new PackageBuilder("Test") .Module_Enum_Default(typeof(FlagsEnum)) .Build(); var result = RenderModule(package, $".\\{nameof(FlagsEnum)}"); Assert.Equal(@"// source: Odachi.CodeModel.Tests.FlagsEnum enum FlagsEnum { foo = 1, bar = 2, cookies = 32, combo = 33, } const names = { [FlagsEnum.foo]: 'foo', [FlagsEnum.bar]: 'bar', [FlagsEnum.cookies]: 'cookies', [FlagsEnum.combo]: 'combo', }; namespace FlagsEnum { export function create(value: any): FlagsEnum { if (typeof value !== 'number') { throw new Error(`Value '${value}' is not valid for enum FlagsEnum`); } let remainder = value; for (let k in FlagsEnum) { const v = FlagsEnum[k]; if (!FlagsEnum.hasOwnProperty(v)) { continue; } remainder = remainder & ~v; } if (remainder !== 0) { throw new Error(`Remainder '${remainder}' of '${value}' is not valid for enum FlagsEnum`); } return value as FlagsEnum; }; export function getValues(): FlagsEnum[] { return [ FlagsEnum.foo, FlagsEnum.bar, FlagsEnum.cookies, FlagsEnum.combo, ]; } export function getNames(): string[] { return [ 'foo', 'bar', 'cookies', 'combo', ]; } export function getName(value: FlagsEnum): string { const name = names[value]; if (name === undefined) { throw new Error(`Cannot get name of FlagsEnum '${value}'`); } return name; } } export default FlagsEnum; export { FlagsEnum }; ", result); }
public void Burn_UninstallUpgradedBundle() { const string expectedVersion1 = "1.0.0.0"; const string expectedVersion2 = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; string packageA1 = new PackageBuilder(this, "A") { Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Override the path for A to A1. bindPaths["packageA"] = packageA1; string bundleA1 = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // Make sure the MSIs and EXE are installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion1, actualVersion); } // Attempt to upgrade bundleA. BundleInstaller installerA1 = new BundleInstaller(this, bundleA1).Install(); // Verify packageA1 was installed and packageA was uninstalled. Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion2, actualVersion); } // Uninstall bundleA1 and verify that packageA1 is still installed. installerA1.Uninstall(); Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); // Uninstall bundleB now. // // SFBUG:3307315, or (new) 2555 - Detect for upgraded package also. installerB.Uninstall(); // Make sure the MSIs are not installed. Assert.False(MsiVerifier.IsPackageInstalled(packageB)); Assert.False(MsiVerifier.IsPackageInstalled(packageA1)); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.Null(this.GetTestRegistryRoot()); this.Complete(); }
public PackCommandRunner(PackArgs packArgs, CreateProjectFactory createProjectFactory, PackageBuilder packageBuilder) : this(packArgs, createProjectFactory) { this._packageBuilder = packageBuilder; }
public void Burn_MajorUpgradeWithSlipstream() { const string originalVersion = "1.0.0.0"; const string upgradeVersion = "2.0.0.0"; const string patchedVersion = "2.0.1.0"; // Build the packages. string originalPackageA = this.GetPackageA().Output; string upgradePackageA = new PackageBuilder(this, "A") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", upgradeVersion } }, }.Build().Output; string packageAUpdate = new PackageBuilder(this, "A") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", patchedVersion } }, NeverGetsInstalled = true }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", patchedVersion } }, TargetPaths = new string[] { upgradePackageA }, UpgradePaths = new string[] { packageAUpdate } }.Build().Output; // Create the named bind paths to the packages in the bundle. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", upgradePackageA); bindPaths.Add("patchA", patchA); string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the original MSI. MSIExec.InstallProduct(originalPackageA, MSIExec.MSIExecReturnCode.SUCCESS); Assert.True(MsiVerifier.IsPackageInstalled(originalPackageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { // Original Product A should be present. string actualVersion = root.GetValue("A") as string; Assert.Equal(originalVersion, actualVersion); } // Now install the bundle that should upgrade the MSI and apply the patch. BundleInstaller install = new BundleInstaller(this, bundleA).Install(); Assert.False(MsiVerifier.IsPackageInstalled(originalPackageA)); Assert.True(MsiVerifier.IsPackageInstalled(upgradePackageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { // Product A should've slipstreamed with its patch. string actualVersion = root.GetValue("A") as string; Assert.Equal(patchedVersion, actualVersion); } install.Uninstall(); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
private static void BuildPackage(string nuspecPath) { var repositoryPath = Path.GetDirectoryName(nuspecPath); var basePath = Path.Combine(repositoryPath, "files", Path.GetFileNameWithoutExtension(nuspecPath)); Directory.CreateDirectory(basePath); var createdFiles = new List <string>(); bool deleteDir = true; using (var fileStream = File.OpenRead(nuspecPath)) { var manifest = Manifest.ReadFrom(fileStream, validateSchema: true); var packageBuilder = new PackageBuilder(); packageBuilder.Populate(manifest.Metadata); if (!manifest.Files.IsEmpty()) { foreach (var file in manifest.Files) { string outputPath = Path.Combine(basePath, file.Source); if (File.Exists(outputPath)) { deleteDir = false; // A user created file exists. Continue to next file. continue; } createdFiles.Add(outputPath); string outputDir = Path.GetDirectoryName(outputPath); if (!Directory.Exists(outputDir)) { Directory.CreateDirectory(outputDir); } if (file.Source.StartsWith(@"lib" + Path.DirectorySeparatorChar) && (file.Source.EndsWith(".dll") && !file.Source.EndsWith("resources.dll"))) { var name = Path.GetFileNameWithoutExtension(file.Source); CreateAssembly(new PackageInfo(manifest.Metadata.Id + ":" + manifest.Metadata.Version), outputPath: outputPath); } else { File.WriteAllBytes(outputPath, new byte[0]); } } packageBuilder.PopulateFiles(basePath, manifest.Files); } string nupkgDirectory = Path.GetFullPath("packages"); Directory.CreateDirectory(nupkgDirectory); string nupkgPath = Path.Combine(nupkgDirectory, Path.GetFileNameWithoutExtension(nuspecPath)) + ".nupkg"; using (var nupkgStream = File.Create(nupkgPath)) { packageBuilder.Save(nupkgStream); } } try { if (deleteDir) { Directory.Delete(basePath, recursive: true); } else { // Delete files that we created. createdFiles.ForEach(File.Delete); } } catch { } }
public bool CanEdit(PackageBuilder target) { return(target is SourcesZipPackageBuilder); }
public PackageId CreatePackageFromTemplate(PackageId templateId, string packageName) { DocumentPackage sdkPackage = PackageBuilder.NewPackageNamed(packageName).Build(); return(CreatePackageFromTemplate(templateId, sdkPackage)); }
public void Burn_InstallPatchBundleUpgrade() { const string expectedVersion1 = "1.0.1.0"; const string expectedVersion2 = "1.0.2.0"; // Build the packages. string packageA1 = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageA2 = new PackageBuilder(this, "A") { Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion1 } }, NeverGetsInstalled = true }.Build().Output; string packageA3 = new PackageBuilder(this, "A") { Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } }, NeverGetsInstalled = true }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion1 } }, TargetPath = packageA1, UpgradePath = packageA2 }.Build().Output; string patchB = new PatchBuilder(this, "PatchB") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } }, TargetPath = packageA1, UpgradePath = packageA3 }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA1); bindPaths.Add("packageB", packageB); bindPaths.Add("patchA", patchA); bindPaths.Add("patchB", patchB); // Build the bundles. string bundleF = new BundleBuilder(this, "BundleF") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleG = new BundleBuilder(this, "BundleG") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion1 } } }.Build().Output; string bundleI = new BundleBuilder(this, "BundleI") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Install the base bundle and make sure all packages are installed. BundleInstaller installerF = new BundleInstaller(this, bundleF).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Install patch bundle and make sure all packages are installed. BundleInstaller installerG = new BundleInstaller(this, bundleG).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); Assert.True(MsiUtils.IsPatchInstalled(patchA)); // Install patch bundle upgrade and make sure all packages are installed. BundleInstaller installerI = new BundleInstaller(this, bundleI).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA1)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); Assert.True(MsiUtils.IsPatchInstalled(patchA)); Assert.True(MsiUtils.IsPatchInstalled(patchB)); // Uninstall the base bundle and make sure all packages are uninstalled. installerF.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA1)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); Assert.False(MsiUtils.IsPatchInstalled(patchA)); Assert.False(MsiUtils.IsPatchInstalled(patchB)); this.Complete(); }
public void Burn_MixedScopeUpgradedBundle() { const string upgradeVersion = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageD1 = new PackageBuilder(this, "D") { Extensions = Extensions }.Build().Output; string packageD2 = new PackageBuilder(this, "D") { Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", upgradeVersion } } }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageD", packageD1); // Build the base bundle. string bundleH1 = new BundleBuilder(this, "BundleH") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Override the path for D1 to D2 and build the upgrade bundle. bindPaths["packageD"] = packageD2; string bundleH2 = new BundleBuilder(this, "BundleH") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", upgradeVersion } } }.Build().Output; // Install the base bundle. BundleInstaller installerH1 = new BundleInstaller(this, bundleH1).Install(); // Make sure the MSIs are installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageD1)); Assert.True(LogVerifier.MessageInLogFileRegex(installerH1.LastLogFile, @"Skipping cross-scope dependency registration on package: PackageA, bundle scope: PerUser, package scope: PerMachine")); // Install the upgrade bundle. Verify the base bundle was removed. BundleInstaller installerH2 = new BundleInstaller(this, bundleH2).Install(); // Verify packageD2 was installed and packageD1 was uninstalled. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageD1)); Assert.True(MsiVerifier.IsPackageInstalled(packageD2)); Assert.True(LogVerifier.MessageInLogFileRegex(installerH2.LastLogFile, @"Skipping cross-scope dependency registration on package: PackageA, bundle scope: PerUser, package scope: PerMachine")); Assert.True(LogVerifier.MessageInLogFileRegex(installerH2.LastLogFile, @"Detected related bundle: \{[0-9A-Za-z\-]{36}\}, type: Upgrade, scope: PerUser, version: 1\.0\.0\.0, operation: MajorUpgrade")); // Uninstall the upgrade bundle now. installerH2.Uninstall(); // Verify that permanent packageA is still installed and then remove. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); MSIExec.UninstallProduct(packageA, MSIExec.MSIExecReturnCode.SUCCESS); // Make sure the MSIs were uninstalled. Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageD2)); this.Complete(); }
public void Burn_UninstallBundleWithDependent() { const string expectedVersion = "1.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the bundles. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); // Make sure the MSIs and EXE are installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion, actualVersion); } // Attempt to uninstall bundleA. installerA.Uninstall(); // Verify packageA and ExeA are still installed. Assert.True(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion, actualVersion); } // Uninstall bundleB now. installerB.Uninstall(); // Make sure the MSIs are installed. Assert.False(MsiVerifier.IsPackageInstalled(packageB)); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.Null(this.GetTestRegistryRoot()); this.Complete(); }
public void Burn_DifferentPackageRequestStates() { const string expectedVersion = "1.0.0.0"; // Build the package. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the base bundle and make sure it's installed. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion, actualVersion); } // SFBUG:3469206 - install a bundle without installing the shared package, which should not be ref-counted. this.SetPackageRequestedState("PackageA", RequestState.None); // Also don't install packageB since it has an authored dependency on packageA and would fail this test case. this.SetPackageRequestedState("PackageB", RequestState.None); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion, actualVersion); } // Uninstall the first bundle and make sure packageA is uninstalled. this.ResetPackageStates("PackageA"); installerA.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion, actualVersion); } // Uninstall the second bundle and make sure all packages are uninstalled. installerB.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.Null(root.GetValue("Version")); } this.Complete(); }
public void Burn_UninstallAddonBundle() { const string expectedVersion = "1.0.0.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA1 = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleA2 = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleF = new BundleBuilder(this, "BundleF") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; // Install the base bundle and make sure all packages are installed. BundleInstaller installerF = new BundleInstaller(this, bundleF).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // Install an addon bundle and make sure all packages are installed. BundleInstaller installerA1 = new BundleInstaller(this, bundleA1).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion, actualVersion); } // Install a second addon bundle and make sure all packages are installed. BundleInstaller installerA2 = new BundleInstaller(this, bundleA2).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion, actualVersion); } // Uninstall the base bundle and make sure all packages are uninstalled. installerF.Uninstall(); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); Assert.False(MsiVerifier.IsPackageInstalled(packageB)); Assert.Null(this.GetTestRegistryRoot()); this.Complete(); }
override public void Execute() { DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("DocumentVisibilityExample: " + DateTime.Now) .WithSigner(SignerBuilder.NewSignerWithEmail(email1) .WithCustomId(SIGNER1_ID) .WithFirstName("John1") .WithLastName("Smith1")) .WithSigner(SignerBuilder.NewSignerWithEmail(email2) .WithCustomId(SIGNER2_ID) .WithFirstName("John2") .WithLastName("Smith2")) .WithSigner(SignerBuilder.NewSignerWithEmail(email3) .WithCustomId(SIGNER3_ID) .WithFirstName("John3") .WithLastName("Smith3")) .WithDocument(DocumentBuilder.NewDocumentNamed(DOC1_NAME) .WithId(DOC1_ID) .FromStream(fileStream1, DocumentType.PDF) .WithSignature(SignatureBuilder.SignatureFor(email1) .OnPage(0) .AtPosition(100, 100))) .WithDocument(DocumentBuilder.NewDocumentNamed(DOC2_NAME) .WithId(DOC2_ID) .FromStream(fileStream2, DocumentType.PDF) .WithSignature(SignatureBuilder.SignatureFor(email2) .OnPage(0) .AtPosition(100, 100))) .WithDocument(DocumentBuilder.NewDocumentNamed(DOC3_NAME) .WithId(DOC3_ID) .FromStream(fileStream3, DocumentType.PDF) .WithSignature(SignatureBuilder.SignatureFor(email3) .OnPage(0) .AtPosition(100, 100))) .Build(); packageId = eslClient.CreatePackage(superDuperPackage); DocumentVisibility visibility = DocumentVisibilityBuilder.NewDocumentVisibility() .AddConfiguration(DocumentVisibilityConfigurationBuilder.NewDocumentVisibilityConfiguration(DOC1_ID) .WithSignerIds(new List <string> { SIGNER1_ID, SIGNER3_ID })) .AddConfiguration(DocumentVisibilityConfigurationBuilder.NewDocumentVisibilityConfiguration(DOC2_ID) .WithSignerIds(new List <string> { SIGNER2_ID, SIGNER3_ID })) .AddConfiguration(DocumentVisibilityConfigurationBuilder.NewDocumentVisibilityConfiguration(DOC3_ID) .WithSignerIds(new List <string> { SIGNER3_ID, SIGNER2_ID })) .Build(); // You can also set up a document visibility based on signer. /* * DocumentVisibility visibility = DocumentVisibilityBasedOnSignerBuilder.NewDocumentVisibilityBasedOnSigner() * .AddConfiguration(DocumentVisibilityConfigurationBasedOnSignerBuilder.NewDocumentVisibilityConfigurationBasedOnSigner(SIGNER1_ID) * .WithDocumentIds(new List<string>{ DOC1_ID })) * .AddConfiguration(DocumentVisibilityConfigurationBasedOnSignerBuilder.NewDocumentVisibilityConfigurationBasedOnSigner(SIGNER2_ID) * .WithDocumentIds(new List<string>{ DOC2_ID, DOC3_ID })) * .AddConfiguration(DocumentVisibilityConfigurationBasedOnSignerBuilder.NewDocumentVisibilityConfigurationBasedOnSigner(SIGNER3_ID) * .WithDocumentIds(new List<string>{ DOC1_ID, DOC2_ID, DOC3_ID })) * .Build(); */ eslClient.ConfigureDocumentVisibility(packageId, visibility); retrievedVisibility = eslClient.getDocumentVisibility(packageId); eslClient.SendPackage(packageId); retrievedPackage = eslClient.GetPackage(packageId); documentsForSigner1 = eslClient.GetDocuments(packageId, SIGNER1_ID); documentsForSigner2 = eslClient.GetDocuments(packageId, SIGNER2_ID); documentsForSigner3 = eslClient.GetDocuments(packageId, SIGNER3_ID); signersForDocument1 = eslClient.GetSigners(packageId, DOC1_ID); signersForDocument2 = eslClient.GetSigners(packageId, DOC2_ID); signersForDocument3 = eslClient.GetSigners(packageId, DOC3_ID); }
private TemporaryFile CreateSamplePackage() { return(new TemporaryFile(PackageBuilder.BuildSamplePackage(FileShare.PackageId, FileShare.Version.ToString()))); }
public void Pack(string nuspecPath, bool packSymbols) { try { PackageBuilder builder = new PackageBuilder(); using (var nuspecFile = File.Open(nuspecPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)) { string baseDirectoryPath = (string.IsNullOrEmpty(BaseDirectory)) ? Path.GetDirectoryName(nuspecPath) : BaseDirectory; Manifest manifest = Manifest.ReadFrom(nuspecFile, false); builder.Populate(manifest.Metadata); builder.PopulateFiles(baseDirectoryPath, manifest.Files); PathResolver.FilterPackageFiles( builder.Files, file => file.Path, packSymbols ? SymbolPackageExcludes : LibPackageExcludes); } if (packSymbols) { // Symbol packages are only valid if they contain both symbols and sources. Dictionary <string, bool> pathHasMatches = LibPackageExcludes.ToDictionary( path => path, path => PathResolver.GetMatches(builder.Files, file => file.Path, new[] { path }).Any()); if (!pathHasMatches.Values.Any(i => i)) { Log.LogMessage(LogImportance.Low, $"Nuspec {nuspecPath} does not contain symbol or source files. Not creating symbol package."); return; } foreach (var pathPair in pathHasMatches.Where(pathMatchPair => !pathMatchPair.Value)) { Log.LogMessage(LogImportance.Low, $"Nuspec {nuspecPath} does not contain any files matching {pathPair.Key}. Not creating symbol package."); return; } } // Overriding the Version from the Metadata if one gets passed in. if (!string.IsNullOrEmpty(PackageVersion)) { NuGetVersion overrideVersion; if (NuGetVersion.TryParse(PackageVersion, out overrideVersion)) { builder.Version = overrideVersion; } else { Log.LogError($"Failed to parse Package Version: '{PackageVersion}' is not a valid version."); return; } } string id = builder.Id, version = builder.Version.ToString(); if (String.IsNullOrEmpty(id)) { Log.LogError($"Nuspec {nuspecPath} does not contain a valid Id"); return; } if (String.IsNullOrEmpty(version)) { Log.LogError($"Nuspec {nuspecPath} does not contain a valid version"); return; } string nupkgOutputDirectory = OutputDirectory; if (packSymbols && !string.IsNullOrEmpty(SymbolPackageOutputDirectory)) { nupkgOutputDirectory = SymbolPackageOutputDirectory; } string nupkgExtension = packSymbols ? ".symbols.nupkg" : ".nupkg"; string nupkgPath = Path.Combine(nupkgOutputDirectory, $"{id}.{version}{nupkgExtension}"); var directory = Path.GetDirectoryName(nupkgPath); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } using (var fileStream = File.Create(nupkgPath)) { builder.Save(fileStream); } Log.LogMessage($"Created '{nupkgPath}'"); } catch (Exception e) { string packageType = packSymbols ? "symbol" : "lib"; Log.LogError($"Error when creating nuget {packageType} package from {nuspecPath}. {e}"); } }
public void GetPackages_ReturnsAllPackagesInsideDirectory() { // Arrange var fooPackage = new PackageBuilder { Id = "Foo", Version = new SemanticVersion("1.0.0"), Description = "Some description", }; fooPackage.Authors.Add("test author"); fooPackage.Files.Add( PackageUtility.CreateMockedPackageFile(@"lib\net40", "Foo.dll", "lib contents").Object); var barPackage = new PackageBuilder { Id = "Bar", Version = new SemanticVersion("1.0.0-beta1"), Description = "Some description", }; barPackage.Authors.Add("test author"); barPackage.Files.Add( PackageUtility.CreateMockedPackageFile("", "README.md", "lib contents").Object); barPackage.Files.Add( PackageUtility.CreateMockedPackageFile(@"content", "qwerty.js", "bar contents").Object); barPackage.Files.Add( PackageUtility.CreateMockedPackageFile(@"lib\net451", "test.dll", "test-dll").Object); var fileSystem = new MockFileSystem(); var fooRoot = Path.Combine("Foo", "1.0.0"); fileSystem.AddFile(Path.Combine(fooRoot, "Foo.nuspec"), @"<?xml version=""1.0""?><package><metadata><id>Foo</id><version>1.0.0</version><authors>None</authors><description>None</description></metadata></package>"); fileSystem.AddFile(Path.Combine("Foo", "1.0.0", "Foo.1.0.0.nupkg.sha512"), "Foo-sha"); fileSystem.AddFile(Path.Combine("Foo", "1.0.0", "Foo.1.0.0.nupkg"), GetPackageStream(fooPackage)); var barRoot = Path.Combine("Bar", "1.0.0-beta1"); fileSystem.AddFile(Path.Combine(barRoot, "Bar.nuspec"), @"<?xml version=""1.0""?><package><metadata><id>Bar</id><version>1.0.0.0-beta1</version><authors>None</authors><description>None</description></metadata></package>"); fileSystem.AddFile(Path.Combine("Bar", "1.0.0-beta1", "Bar.1.0.0-beta1.nupkg.sha512"), "bar-sha"); fileSystem.AddFile(Path.Combine("Bar", "1.0.0-beta1", "Bar.1.0.0-beta1.nupkg"), GetPackageStream(barPackage)); var repository = new ExpandedPackageRepository(fileSystem); // Act var packages = repository.GetPackages().ToList(); // Assert Assert.Equal(2, packages.Count); var package = packages[0]; Assert.Equal("Foo", package.Id); Assert.Equal(new SemanticVersion("1.0.0"), package.Version); var packageFile = Assert.Single(package.GetFiles()); Assert.Equal(@"lib\net40\Foo.dll", packageFile.Path); Assert.Equal(".NETFramework,Version=v4.0", packageFile.TargetFramework.FullName); package = packages[1]; Assert.Equal("Bar", package.Id); Assert.Equal(new SemanticVersion("1.0.0-beta1"), package.Version); var files = package.GetFiles().OrderBy(p => p.Path.Length).ToList(); Assert.Equal(3, files.Count); Assert.Equal(@"README.md", files[0].Path); packageFile = files[1]; Assert.Equal(@"content\qwerty.js", packageFile.Path); Assert.Null(packageFile.TargetFramework); packageFile = files[2]; Assert.Equal(@"lib\net451\test.dll", packageFile.Path); Assert.Equal(".NETFramework,Version=v4.5.1", packageFile.TargetFramework.FullName); }
public Gtk.Widget CreateEditor(PackageBuilder target) { return(new SourcesZipEditorWidget(target, null)); }
public PackageDescriptor(string kind, PackageBuilder builder) { this.kind = kind; this.builder = builder; }
override public void Execute() { DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("SignatureManipulationExample: " + DateTime.Now) .DescribedAs("This is a package created using the e-SignLive SDK") .ExpiresOn(DateTime.Now.AddMonths(100)) .WithSigner(SignerBuilder.NewSignerWithEmail(email1) .WithCustomId("signatureId1") .WithFirstName("firstName1") .WithLastName("lastName1") ) .WithSigner(SignerBuilder.NewSignerWithEmail(email2) .WithCustomId("signatureId2") .WithFirstName("firstName2") .WithLastName("lastName2") ) .WithSigner(SignerBuilder.NewSignerWithEmail(email3) .WithCustomId("signatureId3") .WithFirstName("firstName3") .WithLastName("lastName3") ) .WithDocument(DocumentBuilder.NewDocumentNamed(DOCUMENT_NAME) .WithId("documentId") .FromStream(fileStream, DocumentType.PDF) ) .Build(); packageId = eslClient.CreatePackage(superDuperPackage); signature1 = SignatureBuilder.SignatureFor(email1) .OnPage(0) .WithId(new SignatureId("signatureId1")) .AtPosition(100, 100) .Build(); signature2 = SignatureBuilder.SignatureFor(email2) .OnPage(0) .WithId(new SignatureId("signatureId2")) .AtPosition(100, 200) .Build(); signature3 = SignatureBuilder.SignatureFor(email3) .OnPage(0) .WithId(new SignatureId("signatureId3")) .AtPosition(100, 300) .Build(); modifiedSignature = SignatureBuilder.SignatureFor(email1) .OnPage(0) .WithId(new SignatureId("signatureId3")) .AtPosition(200, 400) .Build(); // Adding the signatures createdPackage = eslClient.GetPackage(packageId); eslClient.ApprovalService.AddApproval(createdPackage, documentId, signature1); eslClient.ApprovalService.AddApproval(createdPackage, documentId, signature2); eslClient.ApprovalService.AddApproval(createdPackage, documentId, signature3); addedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures; // Deleting signature for signer 1 eslClient.ApprovalService.DeleteApproval(packageId, "documentId", "signatureId1"); deletedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures; // Updating the information for the third signature createdPackage = eslClient.GetPackage(packageId); eslClient.ApprovalService.ModifyApproval(createdPackage, "documentId", modifiedSignature); modifiedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures; // Update all the signatures in the document with the provided list of signatures updatedSignature1 = SignatureBuilder.SignatureFor(email2) .OnPage(0) .AtPosition(300, 300) .WithId(new SignatureId("signatureId2")) .WithField(FieldBuilder.SignerName() .AtPosition(100, 100) .OnPage(0)) .Build(); updatedSignature2 = SignatureBuilder.SignatureFor(email3) .OnPage(0) .AtPosition(300, 500) .WithId(new SignatureId("signatureId3")) .Build(); List <Signature> signatureList = new List <Signature>(); signatureList.Add(updatedSignature1); signatureList.Add(updatedSignature2); eslClient.ApprovalService.UpdateApprovals(createdPackage, documentId, signatureList); updatedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures; }
public PackageBuilder CreateBuilder(string basePath, NuGetVersion version, string suffix, bool buildIfNeeded, PackageBuilder builder) { // Add output files Files.Clear(); builder.Files.Clear(); AddOutputFiles(builder); // Add content files if there are any. They could come from a project or nuspec file AddContentFiles(builder); // Add sources if this is a symbol package if (IncludeSymbols) { AddSourceFiles(); } var manifest = new Manifest(new ManifestMetadata(builder), Files); var manifestPath = PackCommandRunner.GetOutputPath( builder, PackArgs, IncludeSymbols, builder.Version, PackTargetArgs.NuspecOutputPath, isNupkg: false); var manifestDirectory = Path.GetDirectoryName(manifestPath); if (!Directory.Exists(manifestDirectory)) { Directory.CreateDirectory(manifestDirectory); } using (Stream stream = new FileStream(manifestPath, FileMode.Create)) { manifest.Save(stream); } builder.PopulateFiles(string.Empty, Files); return(builder); }
public void Init() { packageV1 = new TemporaryFile(PackageBuilder.BuildSamplePackage("Acme.Web", "1.0.0")); packageV2 = new TemporaryFile(PackageBuilder.BuildSamplePackage("Acme.Web", "2.0.0")); }
/// <summary> /// Exports the page. /// </summary> /// <param name="page">The page.</param> /// <param name="isRecursive">if set to <c>true</c> [should export children].</param> /// <returns>a <see cref="T:System.IO.MemoryStream"/> of the exported page package.</returns> public MemoryStream ExportPage(Page page, bool isRecursive) { // Create a temp directory to hold package contents in staging area string packageId = Guid.NewGuid().ToString(); var packageDirectory = CreatePackageDirectory(page.InternalName, packageId); var webRootPath = HttpContext.Current.Server.MapPath("~"); // Create a manifest for this page export... Manifest manifest = new Manifest(); manifest.Metadata = new ManifestMetadata(); manifest.Metadata.Authors = "PageExport"; manifest.Metadata.Version = "0.0"; manifest.Metadata.Id = packageId; manifest.Metadata.Description = (string.IsNullOrEmpty(page.Description)) ? "a page export" : page.Description; manifest.Files = new List <ManifestFile>(); // Generate the JSON from model data and write it to disk, then add it to the manifest var json = GetJson(page, isRecursive); using (var file = new StreamWriter(Path.Combine(packageDirectory.FullName, "export.json"))) { file.Write(json); } AddToManifest(manifest, packageDirectory.FullName, webRootPath, "export.json", SearchOption.TopDirectoryOnly); // * Find out from `page` which Blocks need to be packaged up (recursively if ExportChildren box is checked) // * Grab asset folders for each Block's code file uniquely (Scripts, Assets, CSS folders) // * Add them to the package manifest var blockTypes = new Dictionary <Guid, BlockType>(); var uniqueDirectories = new Dictionary <string, string>(); FindUniqueBlockTypesAndDirectories(page, isRecursive, blockTypes, uniqueDirectories); foreach (var blockType in blockTypes.Values) { var sourcePath = HttpContext.Current.Server.MapPath(blockType.Path); var directory = sourcePath.Substring(0, sourcePath.LastIndexOf(Path.DirectorySeparatorChar)); var fileName = Path.GetFileNameWithoutExtension(sourcePath); var pattern = string.Format("{0}.*", fileName); AddToManifest(manifest, directory, webRootPath, pattern, SearchOption.TopDirectoryOnly); } // Second pass through blocks. Determine which folders (by convention) need to be added // to the package manifest. foreach (var dir in uniqueDirectories.Keys) { var sourcePath = HttpContext.Current.Server.MapPath(dir); // Are there any folders present named "CSS", "Scripts" or "Assets"? AddToManifest(manifest, Path.Combine(sourcePath, "CSS"), webRootPath); AddToManifest(manifest, Path.Combine(sourcePath, "Scripts"), webRootPath); AddToManifest(manifest, Path.Combine(sourcePath, "Assets"), webRootPath); } // Save the manifest as "pageexport.nuspec" in the temp folder string basePath = packageDirectory.FullName; string manifestPath = Path.Combine(basePath, "pageexport.nuspec"); using (Stream fileStream = File.Create(manifestPath)) { manifest.Save(fileStream); } // Create a NuGet package from the manifest and 'save' it to a memory stream for the consumer... // BTW - don't use anything older than nuget 2.1 due to Manifest bug (http://nuget.codeplex.com/workitem/2813) // which will cause the PackageBuilder constructor to fail due to <Files> vs <files> being in the manifest. PackageBuilder packageBuilder = new PackageBuilder(manifestPath, basePath, NullPropertyProvider.Instance, false); var outputStream = new MemoryStream(); packageBuilder.Save(outputStream); // Clean up staging area packageDirectory.Delete(recursive: true); return(outputStream); }
public void Burn_AutomaticSlipstreamInstallUninstall() { const string originalVersion = "1.0.0.0"; const string patchedVersion = "1.0.1.0"; // Build the packages. string packageA = this.GetPackageA().Output; string packageAUpdate = this.GetPackageAv101().Output; string packageB = this.GetPackageB().Output; string packageBUpdate = new PackageBuilder(this, "B") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", patchedVersion } }, NeverGetsInstalled = true }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", patchedVersion } }, TargetPaths = new string[] { packageA, packageB }, UpgradePaths = new string[] { packageAUpdate, packageBUpdate } }.Build().Output; string patchB = new PatchBuilder(this, "PatchB") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", patchedVersion } }, TargetPaths = new string[] { packageA, packageB }, UpgradePaths = new string[] { packageAUpdate, packageBUpdate } }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); bindPaths.Add("patchA", patchA); bindPaths.Add("patchB", patchB); string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; BundleInstaller install = new BundleInstaller(this, bundleC).Install(); using (RegistryKey root = this.GetTestRegistryRoot()) { // Product A should've slipstreamed both patches. string actualVersion = root.GetValue("A") as string; Assert.Equal(patchedVersion, actualVersion); actualVersion = root.GetValue("A2") as string; Assert.Equal(patchedVersion, actualVersion); // Product B should've only slipstreamed patch B. actualVersion = root.GetValue("B") as string; Assert.Equal(originalVersion, actualVersion); actualVersion = root.GetValue("B2") as string; Assert.Equal(patchedVersion, actualVersion); } install.Uninstall(); Assert.True(null == this.GetTestRegistryRoot(), "Test registry key should have been removed during uninstall."); this.Complete(); }
public PackageId CreateTemplateFromPackage(PackageId originalPackageId, string templateName) { DocumentPackage sdkPackage = PackageBuilder.NewPackageNamed(templateName).Build(); return(CreateTemplateFromPackage(originalPackageId, sdkPackage)); }
public PackageBuilder GetPackageBuilder(IPackTaskRequest <IMSBuildItem> request) { // Load the assets JSON file produced by restore. var assetsFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName); if (!File.Exists(assetsFilePath)) { throw new PackagingException(NuGetLogCode.NU5023, string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileNotFound, assetsFilePath)); } var builder = new PackageBuilder(request.Deterministic) { Id = request.PackageId, Description = request.Description, Title = request.Title, Copyright = request.Copyright, ReleaseNotes = request.ReleaseNotes, RequireLicenseAcceptance = request.RequireLicenseAcceptance, PackageTypes = ParsePackageTypes(request) }; if (request.DevelopmentDependency) { builder.DevelopmentDependency = true; } if (request.PackageVersion != null) { NuGetVersion version; if (!NuGetVersion.TryParse(request.PackageVersion, out version)) { throw new PackagingException(NuGetLogCode.NU5024, string.Format( CultureInfo.CurrentCulture, Strings.InvalidPackageVersion, request.PackageVersion)); } builder.Version = version; } else { builder.Version = new NuGetVersion("1.0.0"); } if (request.Authors != null) { builder.Authors.AddRange(request.Authors); } if (request.Tags != null) { builder.Tags.AddRange(request.Tags); } Uri tempUri; if (Uri.TryCreate(request.LicenseUrl, UriKind.Absolute, out tempUri)) { builder.LicenseUrl = tempUri; } if (Uri.TryCreate(request.ProjectUrl, UriKind.Absolute, out tempUri)) { builder.ProjectUrl = tempUri; } if (Uri.TryCreate(request.IconUrl, UriKind.Absolute, out tempUri)) { builder.IconUrl = tempUri; } if (!string.IsNullOrEmpty(request.RepositoryUrl) || !string.IsNullOrEmpty(request.RepositoryType)) { builder.Repository = new RepositoryMetadata( request.RepositoryType, request.RepositoryUrl, request.RepositoryBranch, request.RepositoryCommit); } builder.LicenseMetadata = BuildLicenseMetadata(request); builder.Icon = request.PackageIcon; if (request.MinClientVersion != null) { Version version; if (!Version.TryParse(request.MinClientVersion, out version)) { throw new PackagingException(NuGetLogCode.NU5022, string.Format( CultureInfo.CurrentCulture, Strings.InvalidMinClientVersion, request.MinClientVersion)); } builder.MinClientVersion = version; } // The assets file is necessary for project and package references. Pack should not do any traversal, // so we leave that work up to restore (which produces the assets file). var lockFileFormat = new LockFileFormat(); var assetsFile = lockFileFormat.Read(assetsFilePath); if (assetsFile.PackageSpec == null) { throw new PackagingException(NuGetLogCode.NU5025, string.Format( CultureInfo.CurrentCulture, Strings.AssetsFileDoesNotHaveValidPackageSpec, assetsFilePath)); } var projectRefToVersionMap = new Dictionary <string, string>(PathUtility.GetStringComparerBasedOnOS()); if (request.ProjectReferencesWithVersions != null && request.ProjectReferencesWithVersions.Any()) { projectRefToVersionMap = request .ProjectReferencesWithVersions .ToDictionary(msbuildItem => msbuildItem.Identity, msbuildItem => msbuildItem.GetProperty("ProjectVersion"), PathUtility.GetStringComparerBasedOnOS()); } var nuGetFrameworkComparer = new NuGetFrameworkFullComparer(); var frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(nuGetFrameworkComparer); if (request.FrameworksWithSuppressedDependencies != null && request.FrameworksWithSuppressedDependencies.Any()) { frameworksWithSuppressedDependencies = new HashSet <NuGetFramework>(request.FrameworksWithSuppressedDependencies .Select(t => NuGetFramework.Parse(t.Identity)).ToList(), nuGetFrameworkComparer); } PopulateProjectAndPackageReferences(builder, assetsFile, projectRefToVersionMap, frameworksWithSuppressedDependencies); PopulateFrameworkAssemblyReferences(builder, request); PopulateFrameworkReferences(builder, assetsFile); return(builder); }
override public void Execute() { DocumentPackage package = PackageBuilder.NewPackageNamed(PackageName) .DescribedAs("This is a new package") .WithSigner(SignerBuilder.NewSignerWithEmail(email1) .WithFirstName("John") .WithLastName("Smith")) .WithDocument(DocumentBuilder.NewDocumentNamed(DOCUMENT_NAME) .FromStream(fileStream1, DocumentType.PDF) .WithSignature(SignatureBuilder.SignatureFor(email1) .OnPage(0) .AtPosition(500, 100) .WithField(FieldBuilder.TextField() .WithId(TEXTFIELD_ID) .WithFontSize(TEXTFIELD_FONT_SIZE) .OnPage(TEXTFIELD_PAGE) .AtPosition(500, 200)) .WithField(FieldBuilder.CheckBox() .WithId(CHECKBOX_ID) .WithValue(CHECKBOX_VALUE) .OnPage(CHECKBOX_PAGE) .AtPosition(500, 300)) .WithField(FieldBuilder.RadioButton(RADIO_GROUP_1) .WithId(RADIO_ID_1) .WithValue(false) .WithSize(RADIO_WIDTH, RADIO_HEIGHT) .OnPage(RADIO_PAGE) .AtPosition(500, 400)) .WithField(FieldBuilder.RadioButton(RADIO_GROUP_1) .WithId(RADIO_ID_2) .WithValue(true) .WithSize(RADIO_WIDTH, RADIO_HEIGHT) .OnPage(RADIO_PAGE) .AtPosition(500, 450)) .WithField(FieldBuilder.RadioButton(RADIO_GROUP_2) .WithId(RADIO_ID_3) .WithValue(true) .WithSize(RADIO_WIDTH, RADIO_HEIGHT) .OnPage(RADIO_PAGE) .AtPosition(500, 500)) .WithField(FieldBuilder.RadioButton(RADIO_GROUP_2) .WithId(RADIO_ID_4) .WithValue(false) .WithSize(RADIO_WIDTH, RADIO_HEIGHT) .OnPage(RADIO_PAGE) .AtPosition(500, 550)) .WithField(FieldBuilder.DropList() .WithId(DROP_LIST_ID) .WithValue(DROP_LIST_OPTION2) .WithFontSize(DROP_LIST_FONT_SIZE) .WithValidation(FieldValidatorBuilder.Basic() .WithOption(DROP_LIST_OPTION1) .WithOption(DROP_LIST_OPTION2) .WithOption(DROP_LIST_OPTION3)) .OnPage(DROP_LIST_PAGE) .WithSize(100, 200) .AtPosition(100, 100)) .WithField(FieldBuilder.TextArea() .WithId(TEXT_AREA_ID) .WithValue(TEXT_AREA_VALUE) .WithFontSize(TEXT_AREA_FONT_SIZE) .OnPage(TEXT_AREA_PAGE) .WithSize(400, 600) .AtPosition(200, 200)) .WithField(FieldBuilder.Label() .WithId(LABEL_ID) .WithValue(LABEL_VALUE) .WithFontSize(LABEL_FIELD_FONT_SIZE) .OnPage(LABEL_PAGE) .WithSize(100, 60) .AtPosition(220, 220)) .WithField(FieldBuilder.Datepicker() .WithId(DATEPICKER_ID) .WithName(DATEPICKER_NAME) .WithValue(DATEPICKER_VALUE) .WithFontSize(DATEPICKER_FIELD_FONT_SIZE) .OnPage(DATEPICKER_PAGE) .WithSize(100, 60) .AtPosition(150, 150) .WithValidation(FieldValidatorBuilder.DatepickerFormat(DATEPICKER_FORMAT) .Required())))) .Build(); packageId = eslClient.CreatePackage(package); eslClient.SendPackage(PackageId); retrievedPackage = eslClient.GetPackage(packageId); }
private bool BuildInternal(string projectPath) { var projectDiagnostics = new List <ICompilationMessage>(); if (!Runtime.Project.TryGetProject(projectPath, out _currentProject, projectDiagnostics)) { LogError(string.Format("Unable to locate {0}.", Runtime.Project.ProjectFileName)); return(false); } var sw = Stopwatch.StartNew(); var baseOutputPath = GetBuildOutputDir(_currentProject); var configurations = _buildOptions.Configurations.DefaultIfEmpty("Debug"); string frameworkSelectionError; var frameworks = FrameworkSelectionHelper.SelectFrameworks(_currentProject, _buildOptions.TargetFrameworks, _applicationEnvironment.RuntimeFramework, out frameworkSelectionError); if (frameworks == null) { LogError(frameworkSelectionError); return(false); } if (_buildOptions.GeneratePackages && !ScriptExecutor.Execute(_currentProject, "prepack", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); return(false); } if (!ScriptExecutor.Execute(_currentProject, "prebuild", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); return(false); } var success = true; var allDiagnostics = new List <ICompilationMessage>(); PackageBuilder packageBuilder = null; PackageBuilder symbolPackageBuilder = null; InstallBuilder installBuilder = null; SourceBuilder sourceBuilder = null; // Build all specified configurations foreach (var configuration in configurations) { if (_buildOptions.GeneratePackages) { // Create a new builder per configuration packageBuilder = new PackageBuilder(); symbolPackageBuilder = new PackageBuilder(); InitializeBuilder(_currentProject, packageBuilder); InitializeBuilder(_currentProject, symbolPackageBuilder); installBuilder = new InstallBuilder(_currentProject, packageBuilder, _buildOptions.Reports); sourceBuilder = new SourceBuilder(_currentProject, packageBuilder, _buildOptions.Reports); } var configurationSuccess = true; var outputPath = Path.Combine(baseOutputPath, configuration); // Build all target frameworks a project supports foreach (var targetFramework in frameworks) { _buildOptions.Reports.Information.WriteLine(); _buildOptions.Reports.Information.WriteLine("Building {0} for {1}", _currentProject.Name, targetFramework.ToString().Yellow().Bold()); var diagnostics = new List <ICompilationMessage>(); var context = new BuildContext(_hostServices, _applicationEnvironment, _cache, _cacheContextAccessor, _currentProject, targetFramework, configuration, outputPath); context.Initialize(_buildOptions.Reports.Quiet); if (context.Build(diagnostics)) { if (_buildOptions.GeneratePackages) { context.PopulateDependencies(packageBuilder); context.AddLibs(packageBuilder, "*.dll"); context.AddLibs(packageBuilder, "*.xml"); context.PopulateDependencies(symbolPackageBuilder); context.AddLibs(symbolPackageBuilder, "*.*"); } } else { configurationSuccess = false; } allDiagnostics.AddRange(diagnostics); WriteDiagnostics(diagnostics); } success = success && configurationSuccess; if (_buildOptions.GeneratePackages) { // Create a package per configuration string nupkg = GetPackagePath(_currentProject, outputPath); string symbolsNupkg = GetPackagePath(_currentProject, outputPath, symbols: true); if (configurationSuccess) { // Generates the application package only if this is an application packages configurationSuccess = installBuilder.Build(outputPath); success = success && configurationSuccess; } if (configurationSuccess) { configurationSuccess = sourceBuilder.Build(outputPath); success = success && configurationSuccess; } if (configurationSuccess) { foreach (var sharedFile in _currentProject.Files.SharedFiles) { var file = new PhysicalPackageFile(); file.SourcePath = sharedFile; file.TargetPath = String.Format(@"shared\{0}", Path.GetFileName(sharedFile)); packageBuilder.Files.Add(file); } var root = _currentProject.ProjectDirectory; foreach (var path in _currentProject.Files.SourceFiles) { var srcFile = new PhysicalPackageFile(); srcFile.SourcePath = path; srcFile.TargetPath = Path.Combine("src", PathUtility.GetRelativePath(root, path)); symbolPackageBuilder.Files.Add(srcFile); } using (var fs = File.Create(nupkg)) { packageBuilder.Save(fs); _buildOptions.Reports.Quiet.WriteLine("{0} -> {1}", _currentProject.Name, Path.GetFullPath(nupkg)); } if (symbolPackageBuilder.Files.Any()) { using (var fs = File.Create(symbolsNupkg)) { symbolPackageBuilder.Save(fs); _buildOptions.Reports.Quiet.WriteLine("{0} -> {1}", _currentProject.Name, Path.GetFullPath(symbolsNupkg)); } } } } } if (!success) { return(false); } if (!ScriptExecutor.Execute(_currentProject, "postbuild", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); return(false); } if (_buildOptions.GeneratePackages && !ScriptExecutor.Execute(_currentProject, "postpack", GetScriptVariable)) { LogError(ScriptExecutor.ErrorMessage); return(false); } sw.Stop(); if (projectDiagnostics.Any()) { // Add a new line to separate the project diagnostics information from compilation diagnostics _buildOptions.Reports.Information.WriteLine(); projectDiagnostics.ForEach(d => LogWarning(d.FormattedMessage)); } allDiagnostics.AddRange(projectDiagnostics); WriteSummary(allDiagnostics); _buildOptions.Reports.Information.WriteLine("Time elapsed {0}", sw.Elapsed); return(success); }
protected override void ProcessRecord() { _path = string.IsNullOrEmpty(_path) ? _literalPath : _path; // Get the .psd1 file or .ps1 file // Returns the name of the file or the name of the directory, depending on path var pkgFileOrDir = new DirectoryInfo(_path); string moduleManifestOrScriptPath; if (isScript) { moduleManifestOrScriptPath = pkgFileOrDir.FullName; pkgName = pkgFileOrDir.Name.Remove(pkgFileOrDir.Name.Length - 4); } else { moduleManifestOrScriptPath = System.IO.Path.Combine(_path, pkgFileOrDir.Name + ".psd1"); // Validate that there's a module manifest if (!File.Exists(moduleManifestOrScriptPath)) { var message = String.Format("No file with a .psd1 extension was found in {0}. Please specify a path to a valid modulemanifest.", moduleManifestOrScriptPath); var ex = new ArgumentException(message); var moduleManifestNotFound = new ErrorRecord(ex, "moduleManifestNotFound", ErrorCategory.ObjectNotFound, null); this.ThrowTerminatingError(moduleManifestNotFound); } pkgName = pkgFileOrDir.Name; } FileInfo moduleFileInfo; moduleFileInfo = new FileInfo(moduleManifestOrScriptPath); // if there's no specified destination path to publish the nupkg, we'll just create a temp folder and delete it later string outputDir = !string.IsNullOrEmpty(_destinationPath) ? _destinationPath : System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid().ToString()); if (!Directory.Exists(outputDir)) { Directory.CreateDirectory(outputDir); } // if user does not specify that they want to use a nuspec they've created, we'll create a nuspec var dependencies = new Hashtable(); if (string.IsNullOrEmpty(_nuspec)) { _nuspec = createNuspec(outputDir, moduleFileInfo); } else { // Read the nuspec passed in to pull out the dependency information XDocument doc = XDocument.Load(_nuspec); // ex: <version>2.2.1</version> var versionNode = doc.Descendants("version"); NuGetVersion.TryParse(versionNode.FirstOrDefault().Value, out NuGetVersion version); if (version == null) { var message = "Version is not specified in the .nuspec provided. Please provide a valid version in the .nuspec."; var ex = new ArgumentException(message); var versionNotFound = new ErrorRecord(ex, "versionNotFound", ErrorCategory.NotSpecified, null); this.ThrowTerminatingError(versionNotFound); } // ex: <dependency id="Carbon" version="2.9.2" /> var dependencyNode = doc.Descendants("dependency"); foreach (var dep in dependencyNode) { dependencies.Add(dep.Attribute("id"), dep.Attribute("version")); } } // find repository var r = new RespositorySettings(); var repositoryUrl = r.Read(new[] { _repository }); if (!repositoryUrl.Any()) { var message = String.Format("The resource repository '{0}' is not a registered. Please run 'Register-PSResourceRepository' in order to publish to this repository.", _repository); var ex = new ArgumentException(message); var repositoryNotFound = new ErrorRecord(ex, "repositoryNotFound", ErrorCategory.ObjectNotFound, null); this.ThrowTerminatingError(repositoryNotFound); } if (!_skipDependenciesCheck) { // Check to see that all dependencies are in the repository var findHelper = new FindHelper(); foreach (var dependency in dependencies.Keys) { // Need to make individual calls since we're look for exact version numbers or ranges. var depName = new[] { (string)dependency }; var depVersion = (string)dependencies[dependency]; var type = new[] { "module", "script" }; var repository = new[] { _repository }; // Search for and return the dependency if it's in the repository. var dependencyFound = findHelper.beginFindHelper(depName, type, depVersion, true, null, null, repository, _credential, false, false); if (!dependencyFound.Any()) { var message = String.Format("Dependency {0} was not found in repository {1}. Make sure the dependency is published to the repository before publishing this module.", depName, _repository); var ex = new ArgumentException(message); // System.ArgumentException vs PSArgumentException var dependencyNotFound = new ErrorRecord(ex, "DependencyNotFound", ErrorCategory.ObjectNotFound, null); this.ThrowTerminatingError(dependencyNotFound); } } } if (isScript) { File.Copy(_path, System.IO.Path.Combine(outputDir, pkgName + ".ps1"), true); } else { // Create subdirectory structure in temp folder foreach (string dir in System.IO.Directory.GetDirectories(_path, "*", System.IO.SearchOption.AllDirectories)) { var dirName = dir.Substring(_path.Length).Trim(PathSeparators); System.IO.Directory.CreateDirectory(System.IO.Path.Combine(outputDir, dirName)); } // Copy files over to temp folder foreach (string fileNamePath in System.IO.Directory.GetFiles(_path, "*", System.IO.SearchOption.AllDirectories)) { var fileName = fileNamePath.Substring(_path.Length).Trim(PathSeparators); System.IO.File.Copy(fileNamePath, System.IO.Path.Combine(outputDir, fileName)); } } var outputDirectory = System.IO.Path.Combine(outputDir, "nupkg"); // Pack the module or script into a nupkg given a nuspec. var builder = new PackageBuilder(); var runner = new PackCommandRunner( new PackArgs { CurrentDirectory = outputDir, OutputDirectory = outputDirectory, Path = _nuspec, Exclude = _exclude, Symbols = false, Logger = NullLogger.Instance }, MSBuildProjectFactory.ProjectCreator, builder); runner.BuildPackage(); // Push the nupkg to the appropriate repository // Pkg version is parsed from .ps1 file or .psd1 file var fullNupkgPath = System.IO.Path.Combine(outputDirectory, pkgName + "." + pkgVersion.ToNormalizedString() + ".nupkg"); var repoURL = repositoryUrl.First().Properties["Url"].Value.ToString(); var publishLocation = repoURL.EndsWith("/v2", StringComparison.OrdinalIgnoreCase) ? repoURL + "/package" : repoURL; var settings = NuGet.Configuration.Settings.LoadDefaultSettings(null, null, null); NuGet.Common.ILogger log = new NuGetLogger(); PushRunner.Run( Settings.LoadDefaultSettings(root: null, configFileName: null, machineWideSettings: null), new PackageSourceProvider(settings), fullNupkgPath, publishLocation, _APIKey, // api key null, // symbols source null, // symbols api key 0, // timeout false, // disable buffering false, // no symbols // Skip duplicate: if a package and version already exists, skip it and continue with the next package in the push, if any. false, // no skip duplicate false, // enable server endpoint log).GetAwaiter().GetResult(); }
public void Burn_InstallUpgradeSlipstreamBundle() { const string expectedVersion1 = "1.0.0.0"; const string expectedVersion2 = "1.0.1.0"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageA1 = new PackageBuilder(this, "A") { Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } }, NeverGetsInstalled = true }.Build().Output; string patchA = new PatchBuilder(this, "PatchA") { PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } }, TargetPath = packageA, UpgradePath = packageA1 }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("patchA", patchA); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleC = new BundleBuilder(this, "BundleC") { BindPaths = bindPaths, Extensions = Extensions, PreprocessorVariables = new Dictionary <string, string>() { { "Version", expectedVersion2 } } }.Build().Output; // Install the base bundle and make sure it's installed. BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); using (RegistryKey root = this.GetTestRegistryRoot()) { string actualVersion = root.GetValue("Version") as string; Assert.Equal(expectedVersion1, actualVersion); } // Install the upgrade bundle with a slipstreamed patch and make sure the patch is installed. // SFBUG:3387046 - Uninstalling bundle registers a dependency on a package BundleInstaller installerC = new BundleInstaller(this, bundleC).Install(); Assert.True(MsiUtils.IsPatchInstalled(patchA)); // BundleC doesn't carry the EXE, so make sure it's removed. using (RegistryKey root = this.GetTestRegistryRoot()) { Assert.Null(root.GetValue("Version")); } // Repair the upgrade bundle to make sure it does not prompt for source. // SFBUG:3386927 - MSIs get removed from cache during upgrade installerC.Repair(); // Uninstall the slipstream bundle and make sure both packages are uninstalled. installerC.Uninstall(); Assert.False(MsiUtils.IsPatchInstalled(patchA)); Assert.False(MsiVerifier.IsPackageInstalled(packageA)); this.Complete(); }
public void Burn_RedirectPackageCache() { const string PolicyName = "PackageCache"; // Build the packages. string packageA = new PackageBuilder(this, "A") { Extensions = Extensions }.Build().Output; string packageB = new PackageBuilder(this, "B") { Extensions = Extensions }.Build().Output; // Create the named bind paths to the packages. Dictionary <string, string> bindPaths = new Dictionary <string, string>(); bindPaths.Add("packageA", packageA); bindPaths.Add("packageB", packageB); // Build the bundles. string bundleA = new BundleBuilder(this, "BundleA") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; string bundleB = new BundleBuilder(this, "BundleB") { BindPaths = bindPaths, Extensions = Extensions }.Build().Output; RegistryKey policy = Registry.LocalMachine.CreateSubKey(@"Software\Policies\WiX\Burn"); string currentPackageCache = null; try { currentPackageCache = policy.GetValue(PolicyName) as string; // Install the first bundle using the default package cache. policy.DeleteValue(PolicyName); BundleInstaller installerA = new BundleInstaller(this, bundleA).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); // Install the second bundle which has a shared package using the redirected package cache. string path = Path.Combine(Path.GetTempPath(), "Package Cache"); policy.SetValue(PolicyName, path); BundleInstaller installerB = new BundleInstaller(this, bundleB).Install(); Assert.True(MsiVerifier.IsPackageInstalled(packageA)); Assert.True(MsiVerifier.IsPackageInstalled(packageB)); // The first bundle should leave package A behind. installerA.Uninstall(); // Now make sure that the second bundle removes packages from either cache directory. installerB.Uninstall(); this.Complete(); } finally { if (!string.IsNullOrEmpty(currentPackageCache)) { policy.SetValue(PolicyName, currentPackageCache); } else { policy.DeleteValue(PolicyName); } policy.Dispose(); } }