public void Invoke(PackageManifestBuilder manifestBuilder)
{
var suggestion = manifestBuilder.Name.Value?.ToPackageId();
var id = _prompt.Request("Package ID", suggestion);
manifestBuilder.Id.Add(id.ToPackageId(), Confidence.Authoritative, this);
}
public void Copyright()
{
Assert.Null(Builder.Manifest.Copyright);
PackageManifestBuilder builder = Builder.Copyright("Copyright");
Assert.Same(builder, Builder);
Assert.Equal("Copyright", Builder.Manifest.Copyright);
}
public void Version()
{
Assert.Null(Builder.Manifest.Version);
PackageManifestBuilder builder = Builder.Version("Version");
Assert.Same(builder, Builder);
Assert.Equal("Version", Builder.Manifest.Version);
}
public void Publisher()
{
Assert.Null(Builder.Manifest.Publisher);
PackageManifestBuilder builder = Builder.Publisher("Publisher");
Assert.Same(builder, Builder);
Assert.Equal("Publisher", Builder.Manifest.Publisher);
}
public void Namespace()
{
Assert.Null(Builder.Manifest.Namespace);
PackageManifestBuilder builder = Builder.Namespace("Namespace");
Assert.Same(builder, Builder);
Assert.Equal("Namespace", Builder.Manifest.Namespace);
}
public void License()
{
Assert.Null(Builder.Manifest.License);
PackageManifestBuilder builder = Builder.License("License");
Assert.Same(builder, Builder);
Assert.Equal("License", Builder.Manifest.License);
}
public void Description()
{
Assert.Null(Builder.Manifest.Description);
PackageManifestBuilder builder = Builder.Description("Description");
Assert.Same(builder, Builder);
Assert.Equal("Description", Builder.Manifest.Description);
}
public void Url()
{
Assert.Null(Builder.Manifest.Url);
PackageManifestBuilder builder = Builder.Url("Url");
Assert.Same(builder, Builder);
Assert.Equal("Url", Builder.Manifest.Url);
}
public void Signature()
{
Assert.Null(Builder.Manifest.Signature);
PackageManifestSignature signature = new PackageManifestSignature();
PackageManifestBuilder builder = Builder.Signature(signature);
Assert.Same(builder, Builder);
Assert.Same(signature, Builder.Manifest.Signature);
}
public void Files()
{
Assert.Null(Builder.Manifest.Files);
IList <PackageManifestFile> files = new List <PackageManifestFile>();
PackageManifestBuilder builder = Builder.Files(files);
Assert.Same(builder, Builder);
Assert.Same(files, Builder.Manifest.Files);
}
public void Invoke(PackageManifestBuilder manifest)
{
var tag = _prompt.Request("Tag", PackageManifest.LATEST_TAG)?.ToLowerInvariant();
if (TagHelper.IsLatest(tag))
{
tag = null;
}
manifest.Tag = tag;
}
public async Task <SubmissionResponse> Submit(PackageManifestBuilder builder)
{
var req = new HttpRequestMessage(HttpMethod.Post, "https://octobot.appget.net/pr")
{
Content = new StringContent(Json.Serialize(builder), Encoding.UTF8, "application/json")
};
var resp = await _httpClient.SendAsync(req, TimeSpan.FromSeconds(30));
return(await resp.Deserialize <SubmissionResponse>());
}
public string remove_update_download_segments(string url)
{
var manifestBuilder = new PackageManifestBuilder();
manifestBuilder.Installers.Add(new InstallerBuilder {
Location = url
});
Subject.Invoke(manifestBuilder);
return(manifestBuilder.Home.Value);
}
public void Compose(PackageManifestBuilder manifestBuilder, bool interactive)
{
if (!interactive)
{
return;
}
foreach (var prompt in _prompts.Where(c => c.ShouldPrompt(manifestBuilder)))
{
prompt.Invoke(manifestBuilder);
}
}
public void get_non_github_hostname_as_url()
{
var installer = new InstallerBuilder {
Location = "https://microsoft.com/office"
};
var man = new PackageManifestBuilder();
man.Installers.Add(installer);
Subject.Invoke(man);
man.Home.Value.Should().Be("https://microsoft.com");
}
/// <summary>
/// Adds the specified file from the specified directory to the specified builder, using the includeResources and
/// hashFiles parameters to determine whether the file should be added and hashed.
/// </summary>
/// <param name="builder">The manifest builder with which to add the file.</param>
/// <param name="file">The file to add.</param>
/// <param name="directory">The directory containing the file.</param>
/// <param name="hashFiles">A value indicating whether files added to the manifest are to include a SHA512 hash.</param>
private void AddFile(PackageManifestBuilder builder, string file, string directory, bool hashFiles)
{
Verbose($"Adding file '{file}'...");
PackageManifestFile newFile = new PackageManifestFile();
newFile.Source = Common.Utility.GetRelativePath(directory, file);
if (hashFiles)
{
newFile.Checksum = string.Empty;
}
builder.AddFile(newFile);
}
public string WriteManifest(PackageManifestBuilder manifestBuilder)
{
var manifest = manifestBuilder.Build();
var fileName = $"{manifest.GetFileName()}.yaml";
var config = _configStore.Load();
var applicationManifestDir = Path.Combine(config.LocalRepository, manifest.Id);
var manifestPath = Path.Combine(applicationManifestDir, fileName);
_fileSystem.CreateDirectory(applicationManifestDir);
_fileSystem.WriteAllText(manifestPath, manifest.ToYaml());
_logger.Info($"Package manifest was saved to {manifestPath}");
return(manifestPath);
}
public void Constructor()
{
PackageManifestBuilder test = new PackageManifestBuilder();
Assert.NotNull(test.Manifest);
Assert.Null(test.Manifest.Name);
PackageManifest manifest = new PackageManifest();
manifest.Name = "manifest";
test = new PackageManifestBuilder(manifest);
Assert.NotNull(test.Manifest);
Assert.Equal(test.Manifest.Name, "manifest");
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageFactoryTests"/> class.
/// </summary>
public PackageFactoryTests()
{
TempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(TempDirectory);
TempFile = Path.Combine(TempDirectory, "archive.zip");
File.WriteAllText(TempFile, string.Empty);
PackageManifest = new PackageManifestBuilder().BuildDefault().Manifest;
ManifestExtractorMock = new Mock <IManifestExtractor>();
PackageVerifierMock = new Mock <IPackageVerifier>();
PlatformMock = new Mock <IPlatform>();
PlatformManagerMock = new Mock <IPlatformManager>();
PackageMock = new Mock <IPackage>();
PackageArchiveMock = new Mock <IPackageArchive>();
SetupMocks();
}
/// <summary>
/// Generates and populates <see cref="IPackageManifest"/> objects from the specified directory, including resource
/// files and hashing file entries if those options are specified.
/// </summary>
/// <param name="inputDirectory">The directory from which to generate a list of files.</param>
/// <param name="hashFiles">A value indicating whether files added to the manifest are to include a SHA512 hash.</param>
/// <param name="manifestFile">The filename of the file to which the manifest is to be saved.</param>
/// <returns>The generated manifest.</returns>
public IPackageManifest GenerateManifest(string inputDirectory, bool hashFiles = false, string manifestFile = "")
{
ArgumentValidator.ValidateInputDirectoryArgument(inputDirectory);
string[] files = Directory.GetFiles(inputDirectory, "*", SearchOption.AllDirectories);
PackageManifestBuilder builder = new PackageManifestBuilder();
Info($"Generating manifest for directory '{inputDirectory}'...");
builder.BuildDefault();
Verbose($"Adding files from '{inputDirectory}'...");
foreach (string file in files)
{
AddFile(builder, file, inputDirectory, hashFiles);
}
PackageManifest manifest = builder.Manifest;
Success("Manifest generated successfully.");
if (!string.IsNullOrEmpty(manifestFile))
{
try
{
Info($"Saving output to file '{manifestFile}'...");
File.WriteAllText(manifestFile, manifest.ToJson());
Success("File saved successfully.");
}
catch (Exception ex)
{
throw new Exception($"Unable to write to output file '{manifestFile}': {ex.Message}", ex);
}
}
return(manifest);
}
public bool ShouldPrompt(PackageManifestBuilder manifestBuilder)
{
return(!manifestBuilder.InstallMethod.HasConfidence(Confidence.Plausible));
}
public void Invoke(PackageManifestBuilder manifest)
{
var methodPrompt = new EnumPrompt <InstallMethodTypes>();
manifest.InstallMethod.Add(methodPrompt.Request("Installer", InstallMethodTypes.Custom), Confidence.Plausible, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageManifestBuilderTests"/> class.
/// </summary>
public PackageManifestBuilderTests()
{
Builder = new PackageManifestBuilder();
}
public void Invoke(PackageManifestBuilder manifestBuilder)
{
var result = _prompt.Request("Product Homepage", manifestBuilder.Home.Value);
manifestBuilder.Home.Add(result, Confidence.Authoritative, this);
}
public bool ShouldPrompt(PackageManifestBuilder manifestBuilder)
{
return(!manifestBuilder.Id.HasConfidence(Confidence.Authoritative));
}
public void Invoke(PackageManifestBuilder manifest)
{
manifest.Version.Add(_prompt.Request("Application Version", manifest.Version.Value), Confidence.Plausible, this);
}
public void Invoke(PackageManifestBuilder manifest)
{
var name = _prompt.Request("Product Name", manifest.Name.Value);
manifest.Name.Add(name, Confidence.Authoritative, this);
}
public bool ShouldPrompt(PackageManifestBuilder manifestBuilder)
{
return(true);
}
