public void load_packages_by_assembly()
{
var includes = new PackageManifest();
new FileSystem().PersistToFile(includes, theApplicationDirectory, PackageManifest.FILE);
var links = new LinkManifest();
links.AddLink("../TestPackage1");
new FileSystem().PersistToFile(links, theApplicationDirectory, LinkManifest.FILE);
var assemblyLoader = new AssemblyLoader(new PackagingDiagnostics());
assemblyLoader.AssemblyFileLoader = file => Assembly.Load(Path.GetFileNameWithoutExtension(file));
var package = linkedFolderReader.Load(new PackageLog()).Single();
assemblyLoader.LoadAssembliesFromPackage(package);
assemblyLoader
.Assemblies
.Single()
.GetName()
.Name
.ShouldEqual("TestPackage1");
}
private void BtnCreate_Click(object sender, RoutedEventArgs e)
{
if (ValidateManifest())
{
Manifest = new PackageManifest();
Manifest.PackageName = tbName.Text;
Manifest.Author = tbAuthor.Text;
Manifest.Version = tbVersion.Text;
Manifest.DllPath = cbbMainDll.SelectedValue.ToString();
Manifest.Description = tbDescription.Text;
PackageDefinition definition = Definitions.Find(def => def.Extension == cbbPackageType.SelectedValue.ToString());
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = $"{definition.Name} (*.{definition.Extension})";
bool?result = saveFileDialog.ShowDialog();
if (result.HasValue)
{
if (result.Value == true)
{
if (Packages.Pack(contents.ToList(), saveFileDialog.FileName, Manifest))
{
DoneAlert.Show($"package created.\nLocation:\n{saveFileDialog.FileName}");
}
}
}
}
}
public void CanParseManifest_TrackingAllowed()
{
const string json = @"{""allowPackageTelemetry"": false }";
PackageManifest manifest = _parser.ParseManifest(json);
Assert.IsFalse(manifest.AllowPackageTelemetry);
}
public void DelimitedValueValidator()
{
const string json = @"{'propertyEditors': [
{
alias: 'Test.Test2',
name: 'Test 2',
isParameterEditor: true,
defaultConfig: { key1: 'some default val' },
editor: {
view: '~/App_Plugins/MyPackage/PropertyEditors/MyEditor.html',
valueType: 'int',
validation: {
delimited: {
delimiter: ',',
pattern: '^[a-zA-Z]*$'
}
}
}
}
]}";
PackageManifest manifest = _parser.ParseManifest(json);
Assert.AreEqual(1, manifest.ParameterEditors.Length);
Assert.AreEqual(1, manifest.ParameterEditors[0].GetValueEditor().Validators.Count);
Assert.IsTrue(manifest.ParameterEditors[0].GetValueEditor().Validators[0] is DelimitedValueValidator);
var validator = manifest.ParameterEditors[0].GetValueEditor().Validators[0] as DelimitedValueValidator;
Assert.IsNotNull(validator.Configuration);
Assert.AreEqual(",", validator.Configuration.Delimiter);
Assert.AreEqual("^[a-zA-Z]*$", validator.Configuration.Pattern);
}
public void read_a_package_manifest()
{
var manifest = new PackageManifest {
Role = "application",
Name = "something"
};
new FileSystem().WriteObjectToFile(PackageManifest.FILE, manifest);
if (File.Exists("zip1.zip"))
{
File.Delete("zip1.zip");
}
using (var zip1 = new ZipFile("zip1.zip"))
{
zip1.AddFile(PackageManifest.FILE, "");
zip1.Save();
}
var service = new ZipFileService(new FileSystem());
var manifest2 = service.GetPackageManifest("zip1.zip");
manifest2.Name.ShouldEqual(manifest.Name);
manifest2.Role.ShouldEqual(manifest.Role);
}
public void read_a_package_manifest()
{
theOriginal = new ApplicationManifest
{
Name = "Han Solo",
ContentFileSet = new FileSet()
{
DeepSearch = true,
Exclude = "*.xml",
Include = "*.config"
},
DataFileSet = new FileSet()
{
DeepSearch = true,
Exclude = "*.txt",
Include = "*.xml"
}
};
theOriginal.AddAssembly("Fubu.Assem1");
theOriginal.AddAssembly("Fubu.Assem2");
theOriginal.AddAssembly("Fubu.Assem3");
new FileSystem().WriteObjectToFile("manifest.xml", theOriginal);
var reader = new PackageManifestXmlReader();
theResultingManifest = reader.ReadFrom("manifest.xml");
}
public HttpResponseMessage Generate(PackageManifest manifest)
{
try
{
var filePath = Services.PackageBuilder.GeneratePackage(manifest);
var result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new ByteArrayContent(File.ReadAllBytes(filePath))
};
result.Content.Headers.ContentDisposition =
new ContentDispositionHeaderValue("attachment")
{
FileName = $"{manifest.PackageName}.zip"
};
result.Content.Headers.ContentType =
new MediaTypeHeaderValue("application/octet-stream");
return(result);
}
catch (Exception exception)
{
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.InternalServerError);
httpResponseMessage.Content = new StringContent(
JsonConvert.SerializeObject(exception.Message),
System.Text.Encoding.UTF8, "application/json");
return(httpResponseMessage);
}
}
public void set_role_to_binaries()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Binaries);
manifest.ContentFileSet.ShouldBeNull();
}
public void set_role_to_data()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Data);
manifest.ContentFileSet.ShouldBeNull();
}
private void UpdatePackageManifest(Package package, PackagePart updatedPart)
{
if (package == null)
throw new ArgumentNullException(nameof(package));
if (updatedPart == null)
throw new ArgumentNullException(nameof(updatedPart));
if (package.FileOpenAccess != FileAccess.ReadWrite)
throw new InvalidOperationException("Package must be open for reading and writing");
var manifestRelation = package.GetRelationship("MANIFEST");
var manifestPart = package.GetPart(manifestRelation.TargetUri);
// parse manifest
var manifest = new PackageManifest(manifestPart, null);
// rehash updated part
var csDefPart = manifest.Items.FirstOrDefault(i => i.PartUri == updatedPart.Uri);
if (csDefPart == null)
throw new InvalidOperationException(string.Format("Unable to find part '{0}' in package manifest", updatedPart.Uri));
csDefPart.Hash = manifest.HashAlgorithm.ComputeHash(updatedPart.GetStream(FileMode.Open, FileAccess.Read)); ;
csDefPart.ModifiedDate = DateTime.UtcNow;
var manifestStream = manifestPart.GetStream(FileMode.Open, FileAccess.Write);
manifest.WriteToStream(manifestStream);
}
public void read_a_package_manifest()
{
theOriginal = new ApplicationManifest
{
Name = "Han Solo",
ContentFileSet = new FileSet()
{
DeepSearch = true,
Exclude = "*.xml",
Include = "*.config"
},
DataFileSet = new FileSet()
{
DeepSearch = true,
Exclude = "*.txt",
Include = "*.xml"
}
};
theOriginal.AddAssembly("Fubu.Assem1");
theOriginal.AddAssembly("Fubu.Assem2");
theOriginal.AddAssembly("Fubu.Assem3");
new FileSystem().WriteObjectToFile("manifest.xml", theOriginal);
var reader = new PackageManifestXmlReader();
theResultingManifest = reader.ReadFrom("manifest.xml");
}
private void writeZipFile(CreatePackageInput input, PackageManifest manifest, AssemblyFiles assemblies)
{
var zipFileName = input.GetZipFileName(manifest);
if (_fileSystem.FileExists(zipFileName))
{
LogWriter.Current.Highlight(" Deleting existing file at " + zipFileName);
_fileSystem.DeleteFile(zipFileName);
}
_zipFileService.CreateZipFile(zipFileName, zipFile =>
{
assemblies.Files.Each(file =>
{
zipFile.AddFile(file, "bin");
});
if (input.PdbFlag)
{
assemblies.PdbFiles.Each(file =>
{
zipFile.AddFile(file, "bin");
});
}
WriteVersion(zipFile);
zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), "");
// TODO -- there's an opportunity to generalize this
AddDataFiles(input, zipFile, manifest);
AddContentFiles(input, zipFile, manifest);
AddConfigFiles(input, zipFile, manifest);
});
}
private void writeZipFile(CreatePackageInput input, PackageManifest manifest, AssemblyFiles assemblies)
{
_zipFileService.CreateZipFile(input.GetZipFileName(manifest), zipFile =>
{
assemblies.Files.Each(file =>
{
zipFile.AddFile(file, "bin");
});
if (input.PdbFlag)
{
assemblies.PdbFiles.Each(file =>
{
zipFile.AddFile(file, "bin");
});
}
WriteVersion(zipFile);
zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), "");
// TODO -- there's an opportunity to generalize this
AddDataFiles(input, zipFile, manifest);
AddContentFiles(input, zipFile, manifest);
AddConfigFiles(input, zipFile, manifest);
});
}
private void writeZipFile(CreateBottleInput input, PackageManifest manifest, AssemblyFiles assemblies)
{
var zipFileName = input.GetZipFileName(manifest);
if (_fileSystem.FileExists(zipFileName))
{
LogWriter.Current.Highlight(" Deleting existing file at " + zipFileName);
_fileSystem.DeleteFile(zipFileName);
}
_zipFileService.CreateZipFile(zipFileName, zipFile =>
{
assemblies.Files.Each(file =>
{
zipFile.AddFile(file, "bin");
});
if (input.PdbFlag)
{
assemblies.PdbFiles.Each(file =>
{
zipFile.AddFile(file, "bin");
});
}
WriteVersion(zipFile);
zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), "");
// TODO -- there's an opportunity to generalize this
AddDataFiles(input, zipFile, manifest);
AddContentFiles(input, zipFile, manifest);
AddConfigFiles(input, zipFile, manifest);
});
}
public void SetManifest(PackageManifest thisManifest)
{
if (thisManifest == null)
{
throw new ArgumentNullException(nameof(thisManifest));
}
_children.Clear();
foreach (PackageDependency pd in thisManifest.Dependencies)
{
_children.Add(new DependencyNode(this, pd.PackageId, pd.Framework,
new VersionRangeExtended(pd.AllowedVersions)
{
ReleaseLabel = AllowedVersions.ReleaseLabel
}));
}
HasManifest = true;
// TODO: Hack to populate the Framework to Pundit packages which come from a dependency of a NuGet as NuGet does not have a FW defined in the Manifest
if (Framework == null && thisManifest.LegacyFramework != null)
{
Framework = thisManifest.LegacyFramework;
}
}
protected override void beforeEach()
{
theBaseFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "folder1");
theBinFolder = Path.Combine(theBaseFolder, "bin");
theManifest = new PackageManifest {
Assemblies = "A;B;C",
DataFileSet = new FileSet(),
ContentFileSet = new FileSet()
};
theInput = new CreatePackageInput()
{
PackageFolder = theBaseFolder
};
theAssemblyFiles = new AssemblyFiles()
{
Files = new string[] { "a.dll", "b.dll" },
MissingAssemblies = new string[] { "c" },
PdbFiles = new string[] { "a.dll", "b.dll", "c.dll" },
Success = false
};
MockFor <IAssemblyFileFinder>()
.Stub(x => x.FindAssemblies(theBinFolder, theManifest.AssemblyNames))
.Return(theAssemblyFiles);
ClassUnderTest.CreatePackage(theInput, theManifest);
}
public void print_sample_manifest()
{
var manifest = new PackageManifest
{
Id = "linqpad",
Version = "4.51.03",
Home = "http://www.linqpad.net/",
InstallMethod = InstallMethodTypes.Zip,
Installers = new List <Installer>
{
new Installer
{
Location = "http://www.linqpad.net/GetFile.aspx?LINQPad4-AnyCPU.zip",
Architecture = ArchitectureTypes.x86
},
new Installer
{
Location = "http://www.linqpad.net/GetFile.aspx?LINQPad4-AnyCPU.zip",
Architecture = ArchitectureTypes.x86,
MinWindowsVersion = WindowsVersion.KnownVersions.First(),
}
}
};
Console.WriteLine(manifest.ToYaml());
}
public IEnumerable<BottleExplosionRequest> DetermineExplosionRequests(PackageManifest manifest)
{
switch (manifest.Role)
{
case BottleRoles.Module:
yield return new BottleExplosionRequest
{
BottleDirectory = SchedTaskPackageFacility.PackagesFolder,
BottleName = manifest.Name,
DestinationDirectory = _physicalPath.AppendPath(BottleFiles.PackagesFolder) //is this correct
};
break;
case BottleRoles.Config:
yield return new BottleExplosionRequest
{
BottleDirectory = BottleFiles.ConfigFolder,
BottleName = manifest.Name,
DestinationDirectory = _physicalPath.AppendPath(BottleFiles.ConfigFolder)
};
break;
case BottleRoles.Binaries:
case BottleRoles.Application:
yield return new BottleExplosionRequest
{
BottleDirectory = BottleFiles.BinaryFolder,
BottleName = manifest.Name,
DestinationDirectory = _physicalPath
};
break;
default:
yield break;
}
}
void InstallManifest(PackageManifest packageManifest)
{
if (Directory.Exists(packageManifestPath) == false)
{
Directory.CreateDirectory(packageManifestPath);
}
string manifestFilePath = Path.Combine(packageManifestPath, packageManifest.title) + ".manifest";
if (Provider.isActive)
{
Asset manifestAsset = new Asset(manifestFilePath);
Task statusTask = Provider.Status(manifestAsset);
statusTask.Wait();
AssetList manifestAssetList = statusTask.assetList;
manifestAsset = manifestAssetList[0];
if (File.Exists(manifestFilePath) == true)
{
if (Provider.IsOpenForEdit(manifestAssetList[0]) == false)
{
Task checkoutTask = Provider.Checkout(manifestAssetList, CheckoutMode.Asset);
checkoutTask.Wait();
if (checkoutTask.success == false)
{
throw new Exception(string.Format("Failed to check out manifest file {0}", manifestFilePath));
}
}
}
}
//If there's an existing manifest at this point, merge in the installed files from previous runs.
//Since you can install a package multiple times with different subsets of the files, we need to aggregate the results of the separate
//installations
if (File.Exists(manifestFilePath) == true)
{
PackageManifest oldManifest = (PackageManifest)JsonUtility.FromJson(File.ReadAllText(manifestFilePath), typeof(PackageManifest));
packageManifest.filelistInstalled.AddRange(oldManifest.filelistInstalled.Except(packageManifest.filelistInstalled, new PackageManifestEntryComparer()));
}
File.WriteAllText(manifestFilePath, JsonUtility.ToJson(packageManifest));
if (Provider.isActive)
{
Asset manifestAsset = new Asset(manifestFilePath);
Task statusTask = Provider.Status(manifestAsset);
statusTask.Wait();
AssetList manifestAssetList = statusTask.assetList;
manifestAsset = manifestAssetList[0];
if (manifestAsset.isInCurrentProject == false)
{
Task addTask = Provider.Add(manifestAssetList, false);
addTask.Wait();
if (addTask.success == false)
{
throw new Exception(string.Format("Failed to add manifest file {0} to version control", manifestFilePath));
}
}
}
}
public void CanParseManifest_GridEditors()
{
const string json = @"{
'javascript': [ ],
'css': [ ],
'gridEditors': [
{
'name': 'Small Hero',
'alias': 'small-hero',
'view': '~/App_Plugins/MyPlugin/small-hero/editortemplate.html',
'render': '~/Views/Partials/Grid/Editors/SmallHero.cshtml',
'icon': 'icon-presentation',
'config': {
'image': {
'size': {
'width': 1200,
'height': 185
}
},
'link': {
'maxNumberOfItems': 1,
'minNumberOfItems': 0
}
}
},
{
'name': 'Document Links By Category',
'alias': 'document-links-by-category',
'view': '~/App_Plugins/MyPlugin/document-links-by-category/editortemplate.html',
'render': '~/Views/Partials/Grid/Editors/DocumentLinksByCategory.cshtml',
'icon': 'icon-umb-members'
}
]
}";
PackageManifest manifest = _parser.ParseManifest(json);
Assert.AreEqual(2, manifest.GridEditors.Length);
GridEditor editor = manifest.GridEditors[0];
Assert.AreEqual("small-hero", editor.Alias);
Assert.AreEqual("Small Hero", editor.Name);
Assert.AreEqual(_ioHelper.ResolveUrl("/App_Plugins/MyPlugin/small-hero/editortemplate.html"), editor.View);
Assert.AreEqual(_ioHelper.ResolveUrl("/Views/Partials/Grid/Editors/SmallHero.cshtml"), editor.Render);
Assert.AreEqual("icon-presentation", editor.Icon);
IDictionary <string, object> config = editor.Config;
Assert.AreEqual(2, config.Count);
Assert.IsTrue(config.ContainsKey("image"));
object c = config["image"];
Assert.IsInstanceOf <JObject>(c); // FIXME: is this what we want?
Assert.IsTrue(config.ContainsKey("link"));
c = config["link"];
Assert.IsInstanceOf <JObject>(c); // FIXME: is this what we want?
// FIXME: should we resolveUrl in configs?
}
public InstallerException(int exitCode, PackageManifest packageManifest, ExistReason exitReason, string logPath)
: base(GetMessage(exitCode, packageManifest, exitReason, logPath))
{
PackageManifest = packageManifest;
LogPath = logPath;
ExitReason = exitReason;
ExitCode = exitCode;
}
private void persist(IFileSystem fileSystem, ManifestInput input, PackageManifest manifest)
{
Console.WriteLine("");
Console.WriteLine("Persisted changes to " + FileSystem.Combine(input.AppFolder, PackageManifest.FILE));
Console.WriteLine("");
fileSystem.PersistToFile(manifest, input.AppFolder, PackageManifest.FILE);
}
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreatePackageInput input)
{
Console.WriteLine("Did not locate all designated assemblies at {0}", input.PackageFolder);
Console.WriteLine("Looking for these assemblies in the package manifest file:");
manifest.AssemblyNames.Each(name => Console.WriteLine(" " + name));
Console.WriteLine("But only found");
theAssemblyFiles.Files.Each(file => Console.WriteLine(" " + file));
}
public void set_role_to_data()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Data);
manifest.ContentFileSet.ShouldBeNull();
}
private static PackageManifest createDefaultManifest(string packageDirectory)
{
var manifest = PackageManifest.DefaultModuleManifest();
manifest.AddAssembly(LinkCommand.GuessAssemblyNameForFolder(packageDirectory, new FileSystem()));
manifest.Name = Path.GetFileName(packageDirectory);
return(manifest);
}
public void set_role_to_binaries()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Binaries);
manifest.ContentFileSet.ShouldBeNull();
}
public InstallerContext Build(PackageManifest manifest, InstallInteractivityLevel interactivityLevel, PackageOperation operation)
{
return(new InstallerContext(manifest.Id, interactivityLevel, _windowsInstallerClient, _nexClient)
{
InstallerRecords = _windowsInstallerClient.GetRecords(),
Operation = operation
});
}
public CreatePackageManifestTask(string targetFile, PackageManifest manifest)
{
TaskName = "Creating manifest file...";
ActionName = "Create manifest file";
TargetFile = targetFile;
TargetFile = targetFile;
Manifest = manifest;
}
public static PackageSpec ToPackageSpec(this PackageManifest manifest) //, NuGet.Frameworks.NuGetFramework framework)
{
var spec = manifest.Adapt <PackageSpec>();
//spec.Framework = framework;
return(spec);
}
public void ExtractManifest()
{
PackageManifest manifest = Extractor.ExtractManifest(Path.Combine(DataDirectory, "Package", "package.zip"));
Assert.NotNull(manifest);
Assert.Equal("DefaultPlugin", manifest.Title);
Assert.Equal(3, manifest.Files.Count);
}
public void fileset_for_searching()
{
var fileSet = PackageManifest.FileSetForSearching();
fileSet.DeepSearch.ShouldBeTrue();
fileSet.Include.ShouldEqual(PackageManifest.FILE);
fileSet.Exclude.ShouldBeNull();
}
public void should_not_serialize_is_latest()
{
var manifest = new PackageManifest();
var yaml = manifest.ToYaml();
yaml.Should().NotContain("isLatest");
}
public void PrintManifest(PackageManifest manifest)
{
Console.WriteLine("===============================================");
Console.WriteLine();
Console.WriteLine(manifest.ToYaml());
Console.WriteLine();
Console.WriteLine("===============================================");
}
public void AddConfigFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest(){
FileSet = manifest.ConfigFileSet,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void AddDataFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.DataFileSet,
ZipDirectory = BottleFiles.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder)
});
}
public void ExtractManifestToFile()
{
string inputFile = Path.Combine(DataDirectory, "Package", "package.zip");
string outputFile = Path.Combine(TempDirectory, "manifest.json");
PackageManifest manifest = Extractor.ExtractManifest(inputFile, outputFile);
Assert.True(File.Exists(outputFile));
}
public void Initialize(PackageManifest packageManifest, string installerPath)
{
if (InstallerPath != null && BuildInfo.IsDebug)
{
throw new InvalidOperationException(@"Can't reuse installer.");
}
InstallerPath = installerPath;
}
public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
ConsoleWriter.Write(" Adding Config folder for " + BottleFiles.ConfigFiles);
zipFile.AddFiles(new ZipFolderRequest(){
FileSet = BottleFiles.ConfigFiles,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreatePackageInput input)
{
Console.WriteLine("Did not locate all designated assemblies at {0}", input.PackageFolder);
Console.WriteLine("Looking for these assemblies in the package manifest file:");
manifest.Assemblies.Each(name => Console.WriteLine(" " + name));
Console.WriteLine("But only found:");
if(!theAssemblyFiles.Files.Any()) Console.WriteLine(" Found no files");
theAssemblyFiles.Files.Each(file => Console.WriteLine(" " + file));
}
public void AddDataFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.DataFileSet,
ZipDirectory = BottleFiles.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder)
});
}
public void set_role_to_module()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Module);
manifest.Role.ShouldEqual(BottleRoles.Module);
manifest.ContentFileSet.ShouldNotBeNull();
manifest.ContentFileSet.Include.ShouldContain("*.as*x");
}
public void set_role_to_config()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Config);
manifest.Role.ShouldEqual(BottleRoles.Config);
manifest.ContentFileSet.ShouldBeNull();
manifest.Assemblies.Any().ShouldBeFalse();
}
public void read_config_manifest_from_file()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Config);
var system = new FileSystem();
system.WriteObjectToFile("manifest.xml", manifest);
var manifest2 = system.LoadFromFile<PackageManifest>("manifest.xml");
manifest2.ContentFileSet.ShouldBeNull();
}
public void set_role_to_data()
{
var manifest = new PackageManifest();
manifest.SetRole(BottleRoles.Data);
manifest.ContentFileSet.ShouldBeNull();
manifest.ConfigFileSet.ShouldBeNull();
manifest.DataFileSet.DeepSearch.ShouldBeTrue();
manifest.DataFileSet.Include.ShouldEqual("*.*");
}
public void AddContentFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest)
{
manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin","*.*"));
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ContentFileSet,
ZipDirectory = BottleFiles.WebContentFolder,
RootDirectory = input.PackageFolder
});
}
//REVIEW: why is this reading?
public void ReadFrom(string fileName, Action<PackageManifest> onCreation)
{
if (_fileSystem.FileExists(fileName))
{
_manifest = _fileSystem.LoadFromFile<PackageManifest>(fileName);
}
else
{
_manifest = new PackageManifest();
onCreation(_manifest);
}
}
public virtual IEnumerable<BottleExplosionRequest> DetermineExplosionRequests(PackageManifest manifest)
{
switch (manifest.Role)
{
case BottleRoles.Binaries:
yield return new BottleExplosionRequest
{
BottleDirectory = BottleFiles.BinaryFolder,
BottleName = manifest.Name,
DestinationDirectory = FileSystem.Combine(_physicalPath, BottleFiles.BinaryFolder)
};
break;
case BottleRoles.Config:
yield return new BottleExplosionRequest()
{
BottleDirectory = BottleFiles.ConfigFolder,
BottleName = manifest.Name,
DestinationDirectory = FileSystem.Combine(_physicalPath, BottleFiles.ConfigFolder)
};
break;
case BottleRoles.Module:
yield return new BottleExplosionRequest
{
BottleDirectory = BottleFiles.BinaryFolder,
BottleName = manifest.Name,
DestinationDirectory = _physicalPath.AppendPath(BottleFiles.BinaryFolder)
};
break;
case BottleRoles.Application:
yield return new BottleExplosionRequest
{
BottleName = manifest.Name,
BottleDirectory = BottleFiles.BinaryFolder,
DestinationDirectory = FileSystem.Combine(_physicalPath, BottleFiles.BinaryFolder)
};
yield return new BottleExplosionRequest
{
BottleName = manifest.Name,
BottleDirectory = BottleFiles.WebContentFolder,
DestinationDirectory = _physicalPath
};
break;
default:
yield break;
}
}
public void BeforeEach()
{
var fs = new FileSystem();
fs.DeleteDirectory(thePathToScan);
fs.CreateDirectory(thePathToScan);
fs.CreateDirectory(thePathToScan, "bin");
theLoader = new SolutionDirectoryPackageLoader(thePathToScan.ToFullPath());
var manifest = new PackageManifest();
manifest.Name = "test-mani";
fs.PersistToFile(manifest, thePathToScan, PackageManifest.FILE);
}
public bool CreatePackage(CreateBottleInput input, PackageManifest manifest)
{
var binFolder = _fileSystem.FindBinaryDirectory(input.PackageFolder, input.TargetFlag);
var assemblies = _assemblyFinder.FindAssemblies(binFolder, manifest.Assemblies);
if (assemblies.Success)
{
writeZipFile(input, manifest, assemblies);
return true;
}
_logger.WriteAssembliesNotFound(assemblies, manifest, input, binFolder);
return false;
}
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreateBottleInput input, string binFolder)
{
ConsoleWriter.Write("Did not locate all designated assemblies at '{0}'", binFolder);
ConsoleWriter.Write("Looking for these assemblies in the package manifest file:");
manifest.Assemblies.Each(name => ConsoleWriter.Write(" " + name));
ConsoleWriter.Write("But only found:");
if(!theAssemblyFiles.Files.Any()) ConsoleWriter.Write(" Found no files");
theAssemblyFiles.Files.Each(file => ConsoleWriter.Write(" " + file));
ConsoleWriter.Write("Missing");
theAssemblyFiles.MissingAssemblies.Each(file => ConsoleWriter.Write(" " + file));
throw new ApplicationException("Invalid package manifest or missing files");
}
public void CreatePackage(CreatePackageInput input, PackageManifest manifest)
{
var binFolder = _fileSystem.FindBinaryDirectory(input.PackageFolder, input.TargetFlag);
var assemblies = _assemblyFinder.FindAssemblies(binFolder, manifest.Assemblies);
if (assemblies.Success)
{
writeZipFile(input, manifest, assemblies);
}
else
{
_logger.WriteAssembliesNotFound(assemblies, manifest, input);
}
}
public void load_all_packages_by_reading_the_include_folder()
{
var includes = new PackageManifest();
includes.AddLink("../TestPackage1");
new FileSystem().PersistToFile(includes, "../../".ToFullPath(), PackageManifest.FILE);
var assemblyLoader = new AssemblyLoader(new PackagingDiagnostics());
assemblyLoader.AssemblyFileLoader = file => Assembly.Load(File.ReadAllBytes(file));
var package = reader.Load(new PackageLog()).Single();
assemblyLoader.LoadAssembliesFromPackage(package);
assemblyLoader.Assemblies.Single().GetName().Name.ShouldEqual("TestPackage1");
}
public AssemblyPackageInfo(Assembly assembly)
{
_manifest = new AssemblyPackageManifestFactory().Extract(assembly);
_inner = new Lazy<PackageInfo>(() =>
{
var inner = new PackageInfo(_manifest);
var exploder = BottleExploder.GetPackageExploder(new FileSystem());
exploder.ExplodeAssembly(PackageRegistry.GetApplicationDirectory(), assembly, inner);
return inner;
});
_assembly = assembly;
}
public void SetUp()
{
theFileSystem = MockRepository.GenerateMock<IFileSystem>();
theInput = new AssembliesInput{
Directory = "directory1",
FileNameFlag = null
};
thePackageManifest = new PackageManifest(){
Name = "the package"
};
theApplicationManifest = new PackageManifest(){
Name = "the application"
};
}
public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.ConfigFileSet == null)
{
ConsoleWriter.Write(" No config files");
return;
}
ConsoleWriter.Write(" Adding Config folder for " + manifest.ConfigFileSet);
zipFile.AddFiles(new ZipFolderRequest(){
FileSet = manifest.ConfigFileSet,
RootDirectory = input.PackageFolder,
ZipDirectory = BottleFiles.ConfigFolder
});
}
public void creates_a_single_explosion_request_for_a_module()
{
var manifest = new PackageManifest(){
Name = "the manifest",
Role = BottleRoles.Module
};
var destination = new CopyAllModulesDestination("something");
var request = destination.DetermineExplosionRequests(manifest).Single();
// copies the bottle as is
request.BottleDirectory.ShouldBeNull();
request.BottleName.ShouldEqual(manifest.Name);
request.DestinationDirectory.ShouldEqual("something");
}
public void AddDataFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.DataFileSet == null)
{
ConsoleWriter.Write(" No data files");
return;
}
ConsoleWriter.Write(" Adding Data folder for " + manifest.DataFileSet);
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.DataFileSet,
ZipDirectory = BottleFiles.DataFolder,
RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder)
});
}
public void ModulePackage()
{
var dest = new TopshelfBottleDestination("bob");
var mani = new PackageManifest()
{
Name = "hi",
Role = BottleRoles.Module
};
var requests = dest.DetermineExplosionRequests(mani);
requests.Count().ShouldEqual(1);
var req = requests.Single();
req.BottleDirectory.ShouldEqual(BottleFiles.BinaryFolder);
req.BottleName = mani.Name;
req.DestinationDirectory = "bob".AppendPath(TopshelfPackageLoader.TopshelfPackagesFolder);
}
public void use_the_file_name_if_it_is_given_and_the_manifest_exists_at_that_file()
{
var manifest = new PackageManifest(){
Name = "special"
};
theInput.FileNameFlag = "special.xml";
theFileSystem.Stub(x => x.FileExists(theInput.Directory, theInput.FileNameFlag))
.Return(true);
theFileSystem.Stub(x => x.LoadFromFile<PackageManifest>(theInput.Directory, theInput.FileNameFlag))
.Return(manifest);
theInput.FindManifestAndBinaryFolders(theFileSystem);
theInput.Manifest.ShouldBeTheSameAs(manifest);
}
public void AddContentFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
{
if (manifest.ContentFileSet == null)
{
ConsoleWriter.Write(" No WebContent files");
return;
}
ConsoleWriter.Write(" Adding WebContent folder for " + manifest.ContentFileSet);
manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin","*.*"));
zipFile.AddFiles(new ZipFolderRequest()
{
FileSet = manifest.ContentFileSet,
ZipDirectory = BottleFiles.WebContentFolder,
RootDirectory = input.PackageFolder
});
}
