private static async Task CreateNextRelease(this IGitHubClient gitHubClient)
{
const string newReleaseBody = @"
### Changed
### New
* Issue Title (#12345)
### Fixed
### Additional Items
### With special thanks for contributions to this release from:
* Real Name - @githubhandle
";
var newRelease = new NewRelease(NextReleaseName)
{
Draft = true, Name = NextReleaseName, Body = newReleaseBody.Trim()
};
Console.WriteLine($"Creating new GitHub release '{newRelease.Name}'...");
var nextRelease = await gitHubClient.Repository.Release.Create(RepoOwner, RepoName, newRelease);
Console.WriteLine($"Created new GitHub release '{nextRelease.Name}'");
}
public async Task CanEditAnAssetLabel()
{
var releaseWithNoUpdate = new NewRelease("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload
{
ContentType = "text/plain",
FileName = "hello-world.txt",
RawData = stream
};
var result = await _releaseClient.UploadAsset(release, newAsset);
var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id);
var updateAsset = asset.ToUpdate();
updateAsset.Label = "some other thing";
var updatedAsset = await _releaseClient.EditAsset(_repositoryOwner, _repositoryName, result.Id, updateAsset);
Assert.Equal("some other thing", updatedAsset.Label);
}
public async Task CanDownloadAnAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload
{
ContentType = "text/plain",
FileName = "hello-world.txt",
RawData = stream
};
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id);
Assert.Equal(result.Id, asset.Id);
var response = await _github.Connection.Get <object>(new Uri(asset.Url), new Dictionary <string, string>(), "application/octet-stream");
Assert.Equal("This is a plain text file.", response.Body);
}
private NewRelease CreateNewRelease()
{
var name = Release.ItemSpec;
var tag = Release.GetMetadata("TagName");
var newRelease = new NewRelease(tag)
{
Name = name
};
var targetCommitSha = Release.GetMetadata("CommitSha");
if (!string.IsNullOrEmpty(targetCommitSha))
{
newRelease.TargetCommitish = targetCommitSha;
}
var prerelease = Release.GetMetadata("Prerelease");
if (!string.IsNullOrEmpty(prerelease))
{
newRelease.Prerelease = bool.Parse(prerelease);
}
var draft = Release.GetMetadata("Draft");
if (!string.IsNullOrEmpty(draft))
{
newRelease.Draft = bool.Parse(draft);
}
return(newRelease);
}
public async Task CanUploadAndRetrieveAnAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var assets = await _releaseClient.GetAllAssets(_context.RepositoryOwner, _context.RepositoryName, release.Id);
Assert.Equal(1, assets.Count);
var asset = assets[0];
Assert.Equal(result.Id, asset.Id);
Assert.NotNull(asset.Url);
Assert.NotNull(asset.BrowserDownloadUrl);
}
public async Task CreateRelease(string changelog)
{
try
{
await _client.Repository.Release.Get(_settings.RepositoryOwner, _settings.RepositoryName, _tag);
Logger.WriteLine($"WARNING: Release already existing.");
}
catch (NotFoundException)
{
var newRelease = new NewRelease($"v{_stringVersion}{_beta}")
{
Name = $"v{_stringVersion}{_beta}",
Body = changelog,
Prerelease = false,
TargetCommitish = string.IsNullOrEmpty(_beta) ? "master" : "beta"
};
await Task.Run(() => _client.Repository.Release.Create(_settings.RepositoryOwner, _settings.RepositoryName, newRelease));
ExecuteWebhook(changelog);
try
{
UpdateFirestoreVersion();
}
catch (Exception e)
{
Logger.WriteLine($"Errors while updating Firestore version: {e}");
}
Logger.WriteLine($"Release created");
}
}
public static async Task <Release> CreateRelease(ModUpdateInfo info, Repository repo, string version,
string name, string body)
{
//Get list of commits
var latestCommits = Task.Run(async() =>
await info.Client.Repository.Commit.GetAll(repo.Owner.Login, repo.Name));
latestCommits.Wait();
var latestCommit = latestCommits.Result.First().Sha;
//Check if release exists for the version #
var curVersion = version;
for (int newVersionAdditive = 0; newVersionAdditive < 999; newVersionAdditive++)
{
Console.WriteLine("Checking if release tag for version number already exists...");
var versCheck = Task.Run(async() => await info.Client.Repository.Release.GetAll(repo.Id));
versCheck.Wait();
if (versCheck.Result.Any(x => x.TagName == curVersion))
{
curVersion = curVersion + newVersionAdditive;
Console.WriteLine("Release tag exists. Setting new version to " + curVersion);
}
else
{
Console.WriteLine("Final release tag set as " + curVersion);
break;
}
}
//Set a tag for our release
var tag = new NewTag
{
Message = name + " - " + body,
Tag = curVersion,
Object = latestCommit, // short SHA
Type = TaggedType.Commit, // TODO: what are the defaults when nothing specified?
Tagger = new Committer(info.GitHubAuthor, info.GitHubEmail, DateTimeOffset.UtcNow)
};
var newTagProc = Task.Run(async() => await info.Client.Git.Tag.Create(repo.Owner.Login, repo.Name, tag));
newTagProc.Wait();
var newTag = newTagProc.Result;
Console.WriteLine("Created a tag for {0} at {1}", newTag.Tag, newTag.Sha);
var newRelease = new NewRelease(newTag.Tag)
{
Name = repo.Name + " " + name,
Body = body,
Draft = false,
Prerelease = false
};
var result = await info.Client.Repository.Release.Create(repo.Owner.Login, repo.Name, newRelease);
return(result);
}
/// <summary>
/// Creates a new <see cref="Release"/> for the specified repository.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#create-a-release">API documentation</a> for more information.
/// </remarks>
/// <param name="owner">The repository's owner</param>
/// <param name="name">The repository's name</param>
/// <param name="data">A description of the release to create</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
public IObservable <Release> Create(string owner, string name, NewRelease data)
{
Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
Ensure.ArgumentNotNullOrEmptyString(name, "name");
Ensure.ArgumentNotNull(data, "data");
return(_client.Create(owner, name, data).ToObservable());
}
public async Task SendsCreateToCorrectUrlWithRepositoryId()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate);
Assert.NotNull(release);
}
/// <summary>
/// Creates a new <see cref="Release"/> for the specified repository.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#create-a-release">API documentation</a> for more information.
/// </remarks>
/// <param name="owner">The repository's owner</param>
/// <param name="name">The repository's name</param>
/// <param name="data">A description of the release to create</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
/// <returns>The created <see cref="Release"/>.</returns>
public IObservable<Release> Create(string owner, string name, NewRelease data)
{
Ensure.ArgumentNotNullOrEmptyString(owner, "owner");
Ensure.ArgumentNotNullOrEmptyString(name, "name");
Ensure.ArgumentNotNull(data, "data");
return _client.Create(owner, name, data).ToObservable();
}
internal static async Task CreateRelease()
{
try
{
string version = BuildConfig.GetAppVersionString();
var newRelease = new NewRelease(version);
newRelease.Name = $"New Update {version}";
newRelease.Body = $"Update for version {version}";
newRelease.Draft = false;
newRelease.Prerelease = false;
var gitHub = new GitHubClient(new ProductHeaderValue(BuildConfig.GetGitAppName()));
gitHub.Credentials = new Credentials(BuildConfig.GetGitToken());
bool success = false;
int maxTries = 2;
int current = 0;
Release release = null;
while (!success && current++ < maxTries)
{
release = await gitHub.Repository.Release.Create("clauderoy790", BuildConfig.GetGitAppName(), newRelease);
success = release != null && !string.IsNullOrEmpty(release.UploadUrl);
}
if (!success)
{
throw new Exception($"Failed to create new releaes, tried {current} times.");
}
var files = Directory.GetFiles(BuildConfig.GetGitRepoLocalPath());
foreach (var file in files)
{
if (!BuildConfig.ShouldIncludeFileInReleaseAsset(file))
{
continue;
}
using (var fs = File.OpenRead(file))
{
FileInfo info = new FileInfo(file);
var assetUpload = new ReleaseAssetUpload()
{
FileName = info.Name,
ContentType = MimeMapping.GetMimeMapping(info.Name),
RawData = fs
};
var asset = await gitHub.Repository.Release.UploadAsset(release, assetUpload);
Console.WriteLine($"Uploaded asset {info.Name} to release {version} successfully");
};
}
}
catch (Exception ex)
{
Console.WriteLine($"Failed to create release: {ex.Message}");
}
Console.WriteLine("Release creation done");
}
public async Task <ReleaseInfo> MakeRelease(IGraph dataGraph, string releaseTag, string owner, string repositoryId, string datasetId, string repositoryDirectory, string authenticationToken)
{
var releaseInfo = new ReleaseInfo(releaseTag);
var ntriplesDumpFileName = Path.Combine(repositoryDirectory, releaseTag + ".nt.gz");
ProgressLog.Info("Generating gzipped NTriples data dump");
var writer = new GZippedNTriplesWriter();
writer.Save(dataGraph, ntriplesDumpFileName);
// Make a release
try
{
ProgressLog.Info("Generating a new release of dataset {0}", datasetId);
if (authenticationToken == null)
{
throw new WorkerException("No valid GitHub access token found for your account.");
}
var client = _gitHubClientFactory.CreateClient(authenticationToken);
client.SetRequestTimeout(TimeSpan.FromSeconds(300));
var releaseClient = client.Repository.Release;
var newRelease = new NewRelease(releaseTag)
{
TargetCommitish = "gh-pages"
};
var release = await releaseClient.Create(owner, repositoryId, newRelease);
// Attach data dump file(s) to release
try
{
ProgressLog.Info("Uploading data dump files to GitHub release");
using (var zipFileStream = File.OpenRead(ntriplesDumpFileName))
{
var upload = new ReleaseAssetUpload(Path.GetFileName(ntriplesDumpFileName), "application/gzip",
zipFileStream, null);
var releaseAsset = await releaseClient.UploadAsset(release, upload);
releaseInfo.DownloadLinks.Add(releaseAsset.BrowserDownloadUrl);
}
}
catch (Exception ex)
{
Log.Error(ex, "Failed to attach dump files to GitHub release");
throw new WorkerException(ex, "Failed to attach dump files to GitHub release");
}
}
catch (WorkerException)
{
throw;
}
catch (Exception ex)
{
Log.Error(ex, "Failed to create a new GitHub release");
throw new WorkerException(ex, "Failed to create a new GitHub release");
}
return(releaseInfo);
}
/// <summary>
/// Creates a new draft release where we can deploy artifacts to
/// Caller is responsible for finalizing the release and marking it as
/// a release or pre-release once that setup is complete
/// </summary>
/// <returns>Reference to the newly created release</returns>
public Release CreateRelease()
{
var data = new NewRelease("Draft")
{
Draft = true
};
return(new Release(_client, _obj, _client.Repository.Release.Create(_obj.Id, data).Result));
}
public static async Task PublishRelease(Configure <GitHubReleaseSettings> configure)
{
var settings = configure.Invoke(new GitHubReleaseSettings());
settings.Validate();
var releaseTag = settings.Tag;
var client = GetAuthenticatedClient(settings.Token, settings.Url);
var existingReleases = await client.Repository.Release.GetAll(settings.RepositoryOwner, settings.RepositoryName);
if (existingReleases.Any(r => r.TagName == releaseTag))
{
// Release already present
return;
}
var newRelease = new NewRelease(releaseTag)
{
TargetCommitish = settings.CommitSha,
Name = settings.Name ?? releaseTag,
Body = settings.ReleaseNotes,
Draft = true,
Prerelease = settings.Prerelease ?? false
};
Logger.Info("Creating release draft...");
var releaseCreationResult = await client.Repository.Release.Create(settings.RepositoryOwner, settings.RepositoryName, newRelease);
var createdRelease = await client.Repository.Release.Get(settings.RepositoryOwner, settings.RepositoryName, releaseCreationResult.Id);
if (settings.ArtifactPaths != null)
{
foreach (var artifactPath in settings.ArtifactPaths)
{
using (var artifactStream = File.OpenRead(artifactPath))
{
var fileName = Path.GetFileName(artifactPath);
var assetUpload = new ReleaseAssetUpload
{
FileName = fileName,
ContentType = "application/octet-stream",
RawData = artifactStream,
};
Logger.Info($"Uploading artifact {artifactPath}...");
await client.Repository.Release.UploadAsset(createdRelease, assetUpload);
}
}
}
var updatedRelease = createdRelease.ToUpdate();
updatedRelease.Draft = false;
await client.Repository.Release.Edit(settings.RepositoryOwner, settings.RepositoryName, createdRelease.Id, updatedRelease);
Logger.Info($"Release {settings.Name ?? releaseTag} was successfully created");
}
protected override void ProcessRecord()
{
try
{
var gitUri = GitHubClient.GitHubApiUrl;
if (GitSourceOption == "external")
{
gitUri = new Uri(GitSourceUrl);
}
var client = new GitHubClient(new ProductHeaderValue(ApplicationName), gitUri);
var tokenAuth = new Credentials(Token);
client.Credentials = tokenAuth;
var newRelease = new NewRelease(TagName)
{
Name = ReleaseName,
Body = ReleaseBody,
Draft = Draft,
Prerelease = PreRelease,
};
var release = client.Repository.Release.Create(Owner, Repo, newRelease).Result;
WriteVerbose("Created release with id: " + release.Id + " at " + release.Url);
if (Assets != null && Assets.Any())
{
WriteVerbose("Uploading " + Assets.Count() + " assets");
foreach (var asset in Assets)
{
WriteVerbose("Uploading " + asset);
using (var archiveContents = File.OpenRead(asset))
{
var fileName = Path.GetFileName(asset);
var assetUpload = new ReleaseAssetUpload()
{
FileName = fileName,
ContentType = "application/zip",
RawData = archiveContents
};
var uploadedAsset = client.Repository.Release.UploadAsset(release, assetUpload).Result;
WriteVerbose("Uploaded " + uploadedAsset.Name);
}
}
}
else
{
WriteVerbose("No assets specified");
}
}
catch (Exception e)
{
WriteVerbose("Error when publishing release: " + e);
throw;
}
}
public void CallsIntoClient()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new NewRelease("fake-tag");
releasesClient.Create("fake", "repo", data);
gitHubClient.Release.Received(1).Create("fake", "repo", data);
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For <IGitHubClient>());
var data = new NewRelease("fake-tag");
Assert.Throws <ArgumentNullException>(() => new NewRelease(null));
Assert.Throws <ArgumentNullException>(() => releasesClient.Create(null, "name", data));
Assert.Throws <ArgumentNullException>(() => releasesClient.Create("owner", null, data));
Assert.Throws <ArgumentNullException>(() => releasesClient.Create("owner", "name", null));
}
public void CallsIntoClient()
{
var gitHubClient = Substitute.For <IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new NewRelease("fake-tag");
releasesClient.Create("fake", "repo", data);
gitHubClient.Repository.Release.Received(1).Create("fake", "repo", data);
}
public void RequestsTheCorrectUrlWithRepositoryId()
{
var gitHubClient = Substitute.For <IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new NewRelease("fake-tag");
releasesClient.Create(1, data);
gitHubClient.Repository.Release.Received(1).Create(1, data);
}
public async Task EnsuresArgumentsNotNull()
{
var releasesClient = new ReleasesClient(Substitute.For<IApiConnection>());
var data = new NewRelease("fake-tag");
Assert.Throws<ArgumentNullException>(() => new NewRelease(null));
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Create(null, "name", data));
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Create("owner", null, data));
await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Create("owner", "name", null));
}
/// <summary>
/// The AsyncRelease Method is an asyncronous method.
/// It creates a plain GitHubClient that includes a User-Agent header.
/// Authenticated access to the repo is used via personal access token.
/// The repo is tagged and released with the new of the repo, a name for the release, and
/// a markdown can be included. newRelease.Draft and newRelease.Prerelease are booleans and
/// the defaults for both is false.
/// </summary>
public static async void AsyncReleaseMethod()
{
//A plain GitHubClient is created. You can use the default string for ProduceHeaderValue or enter your own.
var client = new GitHubClient(new ProductHeaderValue("DevexGitRelease"));
//Enter a personal access token for the repo you want to release.
var tokenAuth = new Credentials("");
client.Credentials = tokenAuth;
//Enter ("GitHub Account Name", "Repo Name", and "Tag Name or Version Number (v1.0.0)" for the release)
string gitHubAccountName = "Jennyf19";
string repoName = "Calculator";
string tagName = "v1.2.0";
Repository result = await client.Repository.Get(gitHubAccountName, repoName);
Console.WriteLine("The Repo Id is: " + result.Id);
Console.WriteLine("The GitURL for the repo is: " + result.GitUrl);
#region Create Tag
//Enter the name of the repo to be released
var newRelease = new NewRelease(tagName);
//Enter the name of the release
newRelease.Name = "Big Cat Adventure";
//Include any information you would like to share with the user in the markdown
newRelease.Body = "This is the markdown";
//The Draft plag is used to indicate when a release should be published
newRelease.Draft = false;
//Indicates whether a release is unofficial or preview release
newRelease.Prerelease = false;
#endregion
#region The Release
///To create a new release, you must have a corresponding tag for the repo
var newReleaseResult = await client.Repository.Release.Create(result.Id, newRelease);
Console.WriteLine("Created release tag: {0}", tagName);
var tagsResult = await client.Repository.GetAllTags(result.Id);
var tag = tagsResult.FirstOrDefault();
NewRelease data = newRelease;
Console.WriteLine("Release of " + repoName + " complete");
Console.ReadLine();
}
public async Task Create(string name, string description, string assetDir)
{
int createdReleaseId = -1;
var client = new GitHubClient(new ProductHeaderValue("kinv-release-app"));
try
{
var tokenAuth = new Credentials(ghToken); // NOTE: not real token
client.Credentials = tokenAuth;
var newRelease = new NewRelease(name);
newRelease.Name = "v" + name;
newRelease.Body = description;
newRelease.Draft = false;
newRelease.Prerelease = false;
var result = await client.Repository.Release.Create(ghUser, ghRepo, newRelease);
Console.WriteLine("Created release id {0}", result.Id);
createdReleaseId = result.Id;
var release = await client.Repository.Release.Get(ghUser, ghRepo, result.Id);
var files = Directory.GetFiles(assetDir);
foreach (var file in files)
{
using (var contents = File.OpenRead(file))
{
var assetUpload = new ReleaseAssetUpload()
{
FileName = Path.GetFileName(file),
ContentType = file.EndsWith(".exe") ? "application/binary" : "application/zip",
RawData = contents
};
var asset = await client.Repository.Release.UploadAsset(release, assetUpload);
}
}
}
catch (Exception exc)
{
// if created and failed, delete it
Console.Error.Write("Failed to create release: " + exc.Message);
if (createdReleaseId != -1)
{
try
{
await client.Repository.Release.Delete(ghUser, ghRepo, createdReleaseId);
}
catch (Exception exc2)
{
Console.Error.Write("Failed to delete release: " + exc2.Message);
}
}
}
}
public Release CreateRelease(GitHubClient client, string releaseName, string body, bool draft = false, bool prerelease = false)
{
var newRelease = new NewRelease(releaseName);
newRelease.Body = body;
newRelease.Name = releaseName;
newRelease.Draft = draft;
newRelease.Prerelease = prerelease;
return(client.Repository.Release.Create(userName, repositoryName, newRelease).Result);
}
public async Task ReturnsReleasesWithNullPublishDate()
{
// create a release without a publish date
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var releases = await _releaseClient.GetAll(_context.RepositoryOwner, _context.RepositoryName);
Assert.True(releases.Count == 1);
Assert.False(releases.First().PublishedAt.HasValue);
}
public async Task SendsCreateToCorrectUrlWithRepositoryId()
{
var releaseWithNoUpdate = new NewRelease("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate);
Assert.NotNull(release);
}
public void RequestsCorrectUrl()
{
var client = Substitute.For<IApiConnection>();
var releasesClient = new ReleasesClient(client);
var data = new NewRelease("fake-tag");
releasesClient.Create("fake", "repo", data);
client.Received().Post<Release>(Arg.Is<Uri>(u => u.ToString() == "repos/fake/repo/releases"),
data,
"application/vnd.github.v3");
}
public static ReleaseVersion Update(Repository repo, string outputPath)
{
NewRelease = GetNextReleaseNumber(repo);
var nextReleaseTag = String.Format(ReleaseTagFormat, NewRelease.ToString());
repo.TagCurrent(nextReleaseTag);
CreateMetaXml(outputPath);
return(new ReleaseVersion(NewRelease));
}
public async Task RequestsCorrectUrl()
{
var client = Substitute.For <IApiConnection>();
var releasesClient = new ReleasesClient(client);
var data = new NewRelease("fake-tag");
await releasesClient.Create("fake", "repo", data);
client.Received().Post <Release>(Arg.Is <Uri>(u => u.ToString() == "repos/fake/repo/releases"),
data,
"application/vnd.github.v3");
}
public async Task EnsuresArgumentsNotNull()
{
var releasesClient = new ReleasesClient(Substitute.For <IApiConnection>());
var data = new NewRelease("fake-tag");
Assert.Throws <ArgumentNullException>(() => new NewRelease(null));
await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.Create(null, "name", data));
await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.Create("owner", null, data));
await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.Create("owner", "name", null));
}
private async Task <Release> CreateRelease(GitHubClient client, string version)
{
var newRelease = new NewRelease(version)
{
Name = $"Version {version}",
Body = "Please see [the official page](https://www.codemade.co.uk/clock) for release notes.",
Draft = true,
Prerelease = false
};
Logger.Normal($"Creating release {version}");
return(await client.Repository.Release.Create(GIT_OWNER, GIT_REPO, newRelease));
}
public async Task ReturnsReleasesWithNullPublishDateWithRepositoryDate()
{
// create a release without a publish date
var releaseWithNoUpdate = new NewRelease("0.1")
{
Draft = true
};
await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var releases = await _releaseClient.GetAll(_context.Repository.Id);
Assert.True(releases.Count == 1);
Assert.False(releases.First().PublishedAt.HasValue);
}
private static async Task ReleaseAsync()
{
var sha = Environment.GetEnvironmentVariable("sha");
var token = Environment.GetEnvironmentVariable("token");
var identity = Environment.GetEnvironmentVariable("repo")?.Split("/");
if (!string.IsNullOrEmpty(token))
{
var owner = identity?[0];
var repoName = identity?[1];
var client = new GitHubClient(new ProductHeaderValue(owner))
{
Credentials = new Credentials(token)
};
var comment = string.Join("\n",
(await client.Repository.Comment.GetAllForCommit(owner, repoName, sha)).Select(c => c.Body));
var tagName = $"汉化资源包-Snapshot-{DateTime.UtcNow:yyyyMMddhhmmss}";
var tag = new NewTag
{
Object = sha,
Message = comment,
Tag = tagName,
Type = TaggedType.Commit,
Tagger = new Committer("CFPABot", "*****@*****.**", DateTimeOffset.UtcNow)
};
var tagResult = await client.Git.Tag.Create(owner, repoName, tag);
Console.WriteLine($"Created a tag for {tagResult.Tag} at {tagResult.Sha}");
var newRelease = new NewRelease(tagName)
{
Name = tagName,
Body = tag.Message,
Draft = false,
Prerelease = false
};
var releaseResult = await client.Repository.Release.Create(owner, repoName, newRelease);
Console.WriteLine($"Created release id {releaseResult.Id}");
await using var rawData = File.OpenRead(@"./Minecraft-Mod-Language-Modpack.zip");
var assetUpload = new ReleaseAssetUpload
{
FileName = "Minecraft-Mod-Language-Modpack.zip",
ContentType = "application/zip",
RawData = rawData
};
var release = await client.Repository.Release.Get(owner, repoName, releaseResult.Id);
await client.Repository.Release.UploadAsset(release, assetUpload);
}
}
public async Task CanChangeBodyOfRelease()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var editRelease = release.ToUpdate();
editRelease.Body = "**This is an updated release";
editRelease.Draft = false;
var updatedRelease = await _releaseClient.Edit(_repositoryOwner, _repositoryName, release.Id, editRelease);
Assert.Equal(release.Id, updatedRelease.Id);
Assert.False(updatedRelease.Draft);
Assert.Equal("**This is an updated release", updatedRelease.Body);
}
private static async Task <Release> CreateRelease(string owner, string repoName, string tagName, string releaseName, string description, bool isPrerelease, bool publish)
{
var newRelease = new NewRelease(tagName)
{
Name = releaseName,
Body = description,
Prerelease = isPrerelease,
Draft = !publish
};
var release = await client.Repository.Release.Create(owner, repoName, newRelease);
Console.WriteLine($"Created {(publish ? "public" : "draft")} release {releaseName}: {release.HtmlUrl}");
return(release);
}
public static async Task PublishRelease(GitHubReleaseSettings settings)
{
var releaseTag = settings.Tag;
var client = GetAuthenticatedClient(settings.Token);
var existingReleases = await client.Repository.Release.GetAll(settings.RepositoryOwner, settings.RepositoryName);
if (existingReleases.Any(r => r.TagName == releaseTag))
{
// Release already present
return;
}
var newRelease = new NewRelease(releaseTag)
{
TargetCommitish = settings.CommitSha,
Name = releaseTag,
Body = settings.ReleaseNotes,
Draft = true,
Prerelease = settings.Prerelease ?? false
};
var releaseCreationResult = await client.Repository.Release.Create(settings.RepositoryOwner, settings.RepositoryName, newRelease);
var createdRelease = await client.Repository.Release.Get(settings.RepositoryOwner, settings.RepositoryName, releaseCreationResult.Id);
if (settings.ArtifactPaths != null)
{
foreach (var artifactPath in settings.ArtifactPaths)
{
using (var artifactStream = File.OpenRead(artifactPath))
{
var fileName = Path.GetFileName(artifactPath);
var assetUpload = new ReleaseAssetUpload
{
FileName = fileName,
ContentType = "application/octet-stream",
RawData = artifactStream,
};
await client.Repository.Release.UploadAsset(createdRelease, assetUpload);
}
}
}
var updatedRelease = createdRelease.ToUpdate();
updatedRelease.Draft = false;
await client.Repository.Release.Edit(settings.RepositoryOwner, settings.RepositoryName, createdRelease.Id, updatedRelease);
}
static async Task Release(string username, string token, string repo, string projectName, string buildNumber, bool promote, string target, string buildDir)
{
GitHubClient client = new GitHubClient(new ProductHeaderValue("GitHubReleaser"));
var basicAuth = new Credentials(token);
client.Credentials = basicAuth;
var releases = client.Repository.Release.GetAll(username, repo);
try
{
var latestRelease = await client.Repository.Release.GetLatest(username, repo);
if (string.IsNullOrWhiteSpace(buildNumber))
{
buildNumber = (int.Parse(latestRelease.TagName.Split('-')[1]) + 1).ToString();
}
}
catch (Exception)
{
buildNumber = "1";
}
Zip(projectName, buildNumber, target, buildDir);
var newRelease = new NewRelease("Build-" + buildNumber);
newRelease.Name = "Build " + buildNumber + " @ " + DateTime.UtcNow.ToString("MM/dd/yyyy HH:mm:ss UTC");
newRelease.Body = promote ? "This was automatically uploaded by [GitHubReleaser](https://github.com/BadCodr/GitHubReleaser) @BadCodr" : "";
newRelease.Draft = false;
newRelease.Prerelease = false;
var result = await client.Repository.Release.Create(username, repo, newRelease);
var archiveContents = File.OpenRead(Path.GetTempPath() + projectName + buildNumber + ".zip"); // TODO: better sample
var assetUpload = new ReleaseAssetUpload()
{
FileName = projectName + buildNumber + ".zip",
ContentType = "application/zip",
RawData = archiveContents
};
var asset = await client.Repository.Release.UploadAsset(result, assetUpload);
Clean(projectName, buildNumber);
Console.WriteLine("Created release id {0}", releases.Id);
}
public async Task CanDeleteWithRepositoryId()
{
var releaseWithNoUpdate = new NewRelease("0.1")
{
Draft = true
};
var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate);
var createdRelease = await _releaseClient.Get(_context.Repository.Id, release.Id);
Assert.NotNull(createdRelease);
await _releaseClient.Delete(_context.Repository.Id, createdRelease.Id);
await Assert.ThrowsAsync <NotFoundException>(async() => await _releaseClient.Get(_context.Repository.Id, createdRelease.Id));
}
public void RequestsTheCorrectUrlWithRepositoryId()
{
var gitHubClient = Substitute.For<IGitHubClient>();
var releasesClient = new ObservableReleasesClient(gitHubClient);
var data = new NewRelease("fake-tag");
releasesClient.Create(1, data);
gitHubClient.Repository.Release.Received(1).Create(1, data);
}
/// <summary>
/// Creates a new <see cref="Release"/> for the specified repository.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#create-a-release">API documentation</a> for more information.
/// </remarks>
/// <param name="repositoryId">The repository's ID</param>
/// <param name="data">A description of the release to create</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
public IObservable<Release> Create(int repositoryId, NewRelease data)
{
Ensure.ArgumentNotNull(data, "data");
return _client.Create(repositoryId, data).ToObservable();
}
public void EnsuresArgumentsNotNull()
{
var releasesClient = new ObservableReleasesClient(Substitute.For<IGitHubClient>());
var data = new NewRelease("fake-tag");
Assert.Throws<ArgumentNullException>(() => new NewRelease(null));
Assert.Throws<ArgumentNullException>(() => releasesClient.Create(null, "name", data));
Assert.Throws<ArgumentNullException>(() => releasesClient.Create("owner", null, data));
Assert.Throws<ArgumentNullException>(() => releasesClient.Create("owner", "name", null));
}
public async Task CanDownloadAnAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload
{
ContentType = "text/plain",
FileName = "hello-world.txt",
RawData = stream
};
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id);
Assert.Equal(result.Id, asset.Id);
var response = await _github.Connection.Get<object>(new Uri(asset.Url), new Dictionary<string, string>(), "application/octet-stream");
Assert.Equal("This is a plain text file.", response.Body);
}
public async Task CanDeleteAssetWithRepositoryId()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
var asset = await _releaseClient.GetAsset(_context.Repository.Id, result.Id);
Assert.NotNull(asset);
Assert.ThrowsAsync<NotFoundException>(async () => await _releaseClient.DeleteAsset(_context.Repository.Id, result.Id));
}
public async Task RequestsCorrectUrlWithRepositoryId()
{
var client = Substitute.For<IApiConnection>();
var releasesClient = new ReleasesClient(client);
var data = new NewRelease("fake-tag");
await releasesClient.Create(1, data);
client.Received().Post<Release>(Arg.Is<Uri>(u => u.ToString() == "repositories/1/releases"),
data,
"application/vnd.github.v3");
}
public async Task CanDeleteWithRepositoryId()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate);
var createdRelease = await _releaseClient.Get(_context.Repository.Id, release.Id);
Assert.NotNull(createdRelease);
await _releaseClient.Delete(_context.Repository.Id, createdRelease.Id);
Assert.ThrowsAsync<NotFoundException>(async () => await _releaseClient.Get(_context.Repository.Id, createdRelease.Id));
}
public async Task CanChangeCommitIshOfRelease()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
Assert.Equal("master", release.TargetCommitish);
var newHead = await _github.CreateTheWorld(_context.Repository);
var editRelease = release.ToUpdate();
editRelease.Draft = false;
editRelease.TargetCommitish = newHead.Object.Sha;
var updatedRelease = await _releaseClient.Edit(_context.RepositoryOwner, _context.RepositoryName, release.Id, editRelease);
Assert.Equal(release.Id, updatedRelease.Id);
Assert.False(updatedRelease.Draft);
Assert.Equal(newHead.Object.Sha, updatedRelease.TargetCommitish);
}
public async Task CanUploadAndRetrieveAnAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var assets = await _releaseClient.GetAllAssets(_context.RepositoryOwner, _context.RepositoryName, release.Id);
Assert.Equal(1, assets.Count);
var asset = assets[0];
Assert.Equal(result.Id, asset.Id);
Assert.NotNull(asset.Url);
Assert.NotNull(asset.BrowserDownloadUrl);
}
public async Task CanEditAnAssetLabel()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
var asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id);
var updateAsset = asset.ToUpdate();
updateAsset.Label = "some other thing";
var updatedAsset = await _releaseClient.EditAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id, updateAsset);
Assert.Equal("some other thing", updatedAsset.Label);
}
public async Task CanDownloadAnAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.txt");
var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id);
Assert.Equal(result.Id, asset.Id);
var response = await _github.Connection.Get<object>(new Uri(asset.Url), new Dictionary<string, string>(), "application/octet-stream");
Assert.Contains("This is a plain text file.", Encoding.ASCII.GetString((byte[])response.Body));
}
public async Task CanDownloadBinaryAsset()
{
var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true };
var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate);
var stream = Helper.LoadFixture("hello-world.zip");
var newAsset = new ReleaseAssetUpload("hello-world.zip"
, "application/octet-stream"
, stream
, null);
var result = await _releaseClient.UploadAsset(release, newAsset);
Assert.True(result.Id > 0);
var asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id);
Assert.Equal(result.Id, asset.Id);
var response = await _github.Connection.Get<object>(new Uri(asset.Url), new Dictionary<string, string>(), "application/octet-stream");
var textContent = string.Empty;
using (var zipstream = new MemoryStream((byte[])response.Body))
using (var archive = new ZipArchive(zipstream))
{
var enttry = archive.Entries[0];
var data = new byte[enttry.Length];
await enttry.Open().ReadAsync(data, 0, data.Length);
textContent = Encoding.ASCII.GetString(data);
}
Assert.Contains("This is a plain text file.", textContent);
}
