public async Task ThrowsRepositoryExistsExceptionForExistingRepository()
{
var github = new GitHubClient(new ProductHeaderValue("OctokitTests"))
{
Credentials = Helper.Credentials
};
var repoName = Helper.MakeNameWithTimestamp("existing-repo");
var repository = new NewRepository {
Name = repoName
};
var createdRepository = await github.Repository.Create(repository);
try
{
var thrown = await AssertEx.Throws <RepositoryExistsException>(
async() => await github.Repository.Create(repository));
Assert.NotNull(thrown);
Assert.Equal(repoName, thrown.RepositoryName);
Assert.Equal(Helper.Credentials.Login, thrown.Owner);
Assert.False(thrown.OwnerIsOrganization);
}
finally
{
Helper.DeleteRepo(createdRepository);
}
}
public async Task ThrowsRepositoryExistsExceptionForExistingRepository()
{
var github = Helper.GetAuthenticatedClient();
var repoName = Helper.MakeNameWithTimestamp("existing-repo");
var repository = new NewRepository {
Name = repoName
};
var createdRepository = await github.Repository.Create(repository);
try
{
var message = string.Format(CultureInfo.InvariantCulture, "There is already a repository named '{0}' for the current account.", repoName);
var thrown = await AssertEx.Throws <RepositoryExistsException>(
async() => await github.Repository.Create(repository));
Assert.NotNull(thrown);
Assert.Equal(repoName, thrown.RepositoryName);
Assert.Equal(message, thrown.Message);
Assert.False(thrown.OwnerIsOrganization);
}
finally
{
Helper.DeleteRepo(createdRepository);
}
}
public async Task ThrowsExceptionWhenPrivateRepositoryQuotaExceeded()
{
var newRepository = new NewRepository("aName")
{
Private = true
};
var response = Substitute.For <IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[{""resource"":""Repository"","
+ @"""code"":""custom"",""field"":""name"",""message"":"
+ @"""name can't be private. You are over your quota.""}]}");
var credentials = new Credentials("haacked", "pwd");
var connection = Substitute.For <IApiConnection>();
connection.Connection.BaseAddress.Returns(GitHubClient.GitHubApiUrl);
connection.Connection.Credentials.Returns(credentials);
connection.Post <Repository>(Args.Uri, newRepository)
.Returns <Task <Repository> >(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await Assert.ThrowsAsync <PrivateRepositoryQuotaExceededException>(
() => client.Create(newRepository));
Assert.NotNull(exception);
}
public NewRepository GetNewRepository(string sourceGroupName, string sourceProjectName, string description)
{
sourceGroupName = Regex.Replace(sourceGroupName, @"\s+", string.Empty);
sourceProjectName = Regex.Replace(sourceProjectName, @"\s+", string.Empty);
description = RemoveControlChars(description);
var repositoryName = $"{sourceGroupName}_{sourceProjectName}";
Console.WriteLine($"New GitHub Repository name [{repositoryName}]: ");
var userInput = Console.ReadLine();
repositoryName = string.IsNullOrEmpty(userInput) ? repositoryName : userInput;
var newRepository = new NewRepository(repositoryName);
newRepository.Description = description;
Console.Write($"Should Repository {repositoryName} be Private? [Y/n]");
var allowedKeys = new[] { ConsoleKey.Y, ConsoleKey.N, ConsoleKey.Enter };
ConsoleKeyInfo userInputKeyInfo;
do
{
userInputKeyInfo = Console.ReadKey(false);
} while (!allowedKeys.Contains(userInputKeyInfo.Key));
newRepository.Private = userInputKeyInfo.Key != ConsoleKey.N;
Console.WriteLine(string.Empty);
return(newRepository);
}
internal async static Task <OrganizationRepositoryWithTeamContext> CreateOrganizationRepositoryWithProtectedBranch(this IGitHubClient client)
{
// Create organization owned repo
var orgRepo = new NewRepository(Helper.MakeNameWithTimestamp("protected-org-repo"))
{
AutoInit = true
};
var contextOrgRepo = await client.CreateRepositoryContext(Helper.Organization, orgRepo);
// Create team in org
var contextOrgTeam = await client.CreateTeamContext(Helper.Organization, new NewTeam(Helper.MakeNameWithTimestamp("team")));
// Grant team push access to repo
await client.Organization.Team.AddRepository(
contextOrgTeam.TeamId,
contextOrgRepo.RepositoryOwner,
contextOrgRepo.RepositoryName,
new RepositoryPermissionRequest(Permission.Push));
// Protect master branch
var protection = new BranchProtectionSettingsUpdate(
new BranchProtectionRequiredStatusChecksUpdate(true, true, new[] { "build", "test" }),
new BranchProtectionPushRestrictionsUpdate(new BranchProtectionTeamCollection {
contextOrgTeam.TeamName
}));
await client.Repository.Branch.UpdateBranchProtection(contextOrgRepo.RepositoryOwner, contextOrgRepo.RepositoryName, "master", protection);
return(new OrganizationRepositoryWithTeamContext
{
RepositoryContext = contextOrgRepo,
TeamContext = contextOrgTeam
});
}
public async Task <bool> CreateRepository(string reponame, string description)
{
EwhLogger.Common.Debug("Create github repo : " + JsonHelper.SerializeObject(new { RepoName = reponame, Desc = description }));
var client = InitClient();
var str = string.Empty;
var createRepo = new NewRepository(reponame);
createRepo.Description = description;
createRepo.Private = false;
RepositoryAdded = null;
try
{
RepositoryAdded = client.Repository.Create(createRepo).Result;
}catch (Exception ex)
{
EwhLogger.Common.Debug("Create github repo Failed: " + JsonHelper.SerializeObject(ex));
return(false);
}
if (RepositoryAdded != null)
{
EwhLogger.Common.Debug("Create github repo Success: " + JsonHelper.SerializeObject(RepositoryAdded));
return(true);
}
EwhLogger.Common.Debug("Create github repo Falied ");
return(false);
}
private async Task <Octokit.Repository> CreateRepositoryInternal(NewRepository newRepository, string organization)
{
try
{
logger.Trace("Creating repository");
if (!await LoadKeychainInternal())
{
throw new InvalidOperationException("The keychain did not load");
}
Octokit.Repository repository;
if (!string.IsNullOrEmpty(organization))
{
logger.Trace("Creating repository for organization");
repository = await githubClient.Repository.Create(organization, newRepository);
}
else
{
logger.Trace("Creating repository for user");
repository = await githubClient.Repository.Create(newRepository);
}
logger.Trace("Created Repository");
return(repository);
}
catch (Exception ex)
{
logger.Error(ex, "Error Creating Repository");
throw;
}
}
private async Task<GitHubRepository> CreateRepositoryInternal(NewRepository newRepository, string organization)
{
try
{
logger.Trace("Creating repository");
await ValidateKeychain();
await ValidateCurrentUserInternal();
GitHubRepository repository;
if (!string.IsNullOrEmpty(organization))
{
logger.Trace("Creating repository for organization");
repository = (await githubClient.Repository.Create(organization, newRepository)).ToGitHubRepository();
}
else
{
logger.Trace("Creating repository for user");
repository = (await githubClient.Repository.Create(newRepository)).ToGitHubRepository();
}
logger.Trace("Created Repository");
return repository;
}
catch (Exception ex)
{
logger.Error(ex, "Error Creating Repository");
throw;
}
}
private async Task CreateRepositoryInternal(NewRepository newRepository, Action <Octokit.Repository, Exception> callback, string organization)
{
try
{
logger.Trace("Creating Repository");
Octokit.Repository repository;
if (organization != null)
{
repository = await githubClient.Repository.Create(organization, newRepository);
}
else
{
repository = await githubClient.Repository.Create(newRepository);
}
logger.Trace("Created Repository");
callback(repository, null);
}
catch (Exception ex)
{
logger.Error(ex, "Error Creating Repository");
callback(null, ex);
}
}
internal async static Task<OrganizationRepositoryWithTeamContext> CreateOrganizationRepositoryWithProtectedBranch(this IGitHubClient client)
{
// Create organization owned repo
var orgRepo = new NewRepository(Helper.MakeNameWithTimestamp("protected-org-repo")) { AutoInit = true };
var contextOrgRepo = await client.CreateRepositoryContext(Helper.Organization, orgRepo);
// Create team in org
var contextOrgTeam = await client.CreateTeamContext(Helper.Organization, new NewTeam(Helper.MakeNameWithTimestamp("team")));
// Grant team push access to repo
await client.Organization.Team.AddRepository(
contextOrgTeam.TeamId,
contextOrgRepo.RepositoryOwner,
contextOrgRepo.RepositoryName,
new RepositoryPermissionRequest(Permission.Push));
// Protect master branch
var protection = new BranchProtectionSettingsUpdate(
new BranchProtectionRequiredStatusChecksUpdate(true, true, new[] { "build", "test" }),
new BranchProtectionPushRestrictionsUpdate(new BranchProtectionTeamCollection { contextOrgTeam.TeamName }));
await client.Repository.Branch.UpdateBranchProtection(contextOrgRepo.RepositoryOwner, contextOrgRepo.RepositoryName, "master", protection);
return new OrganizationRepositoryWithTeamContext
{
RepositoryContext = contextOrgRepo,
TeamContext = contextOrgTeam
};
}
public async Task <long> CreateRepository(GitHubRepository repository)
{
var gitHubClient = this.GitHubClientProvider.GetGitHubClient();
var autoInit = repository.InitializeWithReadMe;
string licenseTemplate;
switch (repository.License)
{
case GitHubRepositoryLicense.MIT:
licenseTemplate = LicenseHelper.MitLicenseIdentifier;
break;
default:
throw new Exception(EnumerationHelper.UnexpectedEnumerationValueMessage(repository.License));
}
var @private = repository.Visibility == GitHubRepositoryVisibility.Private ? true : false; // Private if private, otherwise public.
var newRepository = new NewRepository(repository.Name)
{
AutoInit = true, // Create with README for immediate checkout.
Description = repository.Description,
LicenseTemplate = licenseTemplate,
Private = @private, // Default is public (private = false).
};
var createdRepository = await gitHubClient.Repository.Create(newRepository);
return(createdRepository.Id);
}
private void Button_Click(object sender, EventArgs w)
{
if (Omode == "Create")
{
if (RepText.Text != "")
{
NewRepository repository = new NewRepository(RepText.Text);
client.Repository.Create(repository);
GetAllRepositariesForProject();
formPopup.Visible = false;
label9.Visible = true;
label9.Text = "Repo Created Successfully";
label9.ForeColor = Color.Green;
}
else
{
label9.Visible = true;
label9.ForeColor = Color.Red;
label9.Text = "Please Enter Repo Name";
}
}
if (Omode == "RENAME")
{
RenameSelectedRepo();
this.formPopup.Close();
}
}
public async Task ThrowsRepositoryExistsExceptionForExistingRepository()
{
var github = Helper.GetAuthenticatedClient();
var repoName = Helper.MakeNameWithTimestamp("existing-org-repo");
var repository = new NewRepository {
Name = repoName
};
var createdRepository = await github.Repository.Create(Helper.Organization, repository);
try
{
var repositoryUrl = string.Format(CultureInfo.InvariantCulture, "https://github.com/{0}/{1}", Helper.Organization, repository.Name);
var message = string.Format(CultureInfo.InvariantCulture, "There is already a repository named '{0}' in the organization '{1}'.", repository.Name, Helper.Organization);
var thrown = await AssertEx.Throws <RepositoryExistsException>(
async() => await github.Repository.Create(Helper.Organization, repository));
Assert.NotNull(thrown);
Assert.Equal(repoName, thrown.RepositoryName);
Assert.Equal(message, thrown.Message);
Assert.True(thrown.OwnerIsOrganization);
Assert.Equal(Helper.Organization, thrown.Organization);
Assert.Equal(repositoryUrl, thrown.ExistingRepositoryWebUrl.ToString());
}
finally
{
Helper.DeleteRepo(createdRepository);
}
}
public static async Task CommitFileToRepository(string owner, string filePath, string repoName)
{
try
{
Console.WriteLine("Creating the new repository in GitHub.");
var newRepo = new NewRepository(repoName)
{
AutoInit = true,
HasIssues = false,
HasWiki = true,
Private = false
};
string ghtoken = "7f94b2db23f31cd2bbf10bf57fe0771a2ca48cf5";
var ghClient = new GitHubClient(new Octokit.ProductHeaderValue(repoName));
ghClient.Credentials = new Octokit.Credentials(ghtoken);
var repositoryResponse = ghClient.Repository.Create(newRepo).Result;
string cloneUrl = repositoryResponse.CloneUrl.ToString();
CommitAllChanges("Commiting the migrated project", filePath, cloneUrl).Wait();
}
catch (Exception ex)
{
throw;
}
}
public ActionResult _BlogPartial()
{
INewRepository newService = new NewRepository();
var model = newService.News.Where(x => x.DanhMucTinTuc.ThuTuHienThi >= 1000 && x.DanhMucTinTuc.ThuTuHienThi < 2000).OrderByDescending(x => x.NewID).Take(3).ToList();
return(PartialView(model));
}
public async Task ThrowsRepositoryExistsExceptionWhenRepositoryExistsForSpecifiedOrg()
{
var newRepository = new NewRepository("aName");
var response = Substitute.For <IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[{""resource"":""Repository"","
+ @"""code"":""custom"",""field"":""name"",""message"":""name already exists on this account""}]}");
var connection = Substitute.For <IApiConnection>();
connection.Connection.BaseAddress.Returns(GitHubClient.GitHubApiUrl);
connection.Post <Repository>(Args.Uri, newRepository)
.Returns <Task <Repository> >(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await Assert.ThrowsAsync <RepositoryExistsException>(
() => client.Create("illuminati", newRepository));
Assert.True(exception.OwnerIsOrganization);
Assert.Equal("illuminati", exception.Organization);
Assert.Equal("aName", exception.RepositoryName);
Assert.Equal(new Uri("https://github.com/illuminati/aName"), exception.ExistingRepositoryWebUrl);
Assert.Equal("There is already a repository named 'aName' in the organization 'illuminati'.",
exception.Message);
}
public async Task ThrowsRepositoryExistsExceptionWhenRepositoryExistsForCurrentUser()
{
var newRepository = new NewRepository("aName");
var response = Substitute.For <IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[{""resource"":""Repository"","
+ @"""code"":""custom"",""field"":""name"",""message"":""name already exists on this account""}]}");
var credentials = new Credentials("haacked", "pwd");
var connection = Substitute.For <IApiConnection>();
connection.Connection.BaseAddress.Returns(GitHubClient.GitHubApiUrl);
connection.Connection.Credentials.Returns(credentials);
connection.Post <Repository>(Args.Uri, newRepository)
.Returns <Task <Repository> >(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await Assert.ThrowsAsync <RepositoryExistsException>(
() => client.Create(newRepository));
Assert.False(exception.OwnerIsOrganization);
Assert.Null(exception.Organization);
Assert.Equal("aName", exception.RepositoryName);
Assert.Null(exception.ExistingRepositoryWebUrl);
}
public async Task <Repository> CreateRepository(NewRepository newRepositoryDetails, GitHubClient authorizedGitHubClient)
{
if (_repositoriesClient == null)
{
_repositoriesClient = new RepositoriesClient(new ApiConnection(authorizedGitHubClient.Connection));
}
return(await _repositoriesClient.Create(newRepositoryDetails));
}
public IObservable <Repository> CreateRepository(NewRepository repository, string login, bool isUser)
{
Guard.ArgumentNotEmptyString(login, nameof(login));
var client = gitHubClient.Repository;
return(isUser ? client.Create(repository) : client.Create(login, repository));
}
/// <summary>
/// Creates a new repository for the current user.
/// </summary>
/// <param name="newRepository">A <see cref="NewRepository"/> instance describing the new repository to create</param>
/// <returns>An <see cref="IObservable{Repository}"/> instance for the created repository</returns>
public IObservable<Repository> Create(NewRepository newRepository)
{
Ensure.ArgumentNotNull(newRepository, "newRepository");
if (string.IsNullOrEmpty(newRepository.Name))
throw new ArgumentException("The new repository's name must not be null.");
return _client.Create(newRepository).ToObservable();
}
/// <summary>
/// Creates a new repository for the current user.
/// </summary>
/// <param name="newRepository">A <see cref="NewRepository"/> instance describing the new repository to create</param>
/// <returns>An <see cref="IObservable{Repository}"/> instance for the created repository</returns>
public IObservable<Repository> Create(NewRepository newRepository)
{
Ensure.ArgumentNotNull(newRepository, "newRepository");
if (string.IsNullOrEmpty(newRepository.Name))
throw new ArgumentException("The new repository's name must not be null.");
return _client.Create(newRepository).ToObservable();
}
public async Task <string> CreateRepo(string Name)
{
NewRepository newRepo = new NewRepository(Name);
newRepo.AutoInit = true;
await Client.Repository.Create(newRepo);
return($"https://raw.githubusercontent.com/{Username}/{Name}/");
}
public CreateRepositoryRequest(NewRepository newRepository)
: base("/user/repos")
{
this.Method = Method.POST;
this.RequestFormat = DataFormat.Json;
this.AddBody(newRepository);
}
public void TheNewRepositoryDescription()
{
var connection = Substitute.For <IApiConnection>();
var client = new RepositoriesClient(connection);
var newRepository = new NewRepository("aName");
client.Create(newRepository);
connection.Received().Post <Repository>(Args.Uri, newRepository);
}
public async Task TheNewRepositoryDescription()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var newRepository = new NewRepository { Name = "aName" };
await client.Create("aLogin", newRepository);
connection.Received().Post<Repository>(Args.Uri, newRepository);
}
public void TheNewRepositoryDescription()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var newRepository = new NewRepository { Name = "aName" };
client.Create(newRepository);
connection.Received().Post<Repository>(Arg.Any<Uri>(), newRepository);
}
public ManagementForm()
{
repository = new NewRepository();
InitializeComponent();
dgProductions.AutoGenerateColumns = false;
SetTexts();
LoadData();
}
public async Task <string> CreateRepositoryIfNotExists(string projectName, string repositoryOwner, bool isPrivateRepository = true, List <string> members = null)
{
try
{
var client = new GitHubClient(new ProductHeaderValue(projectName))
{
Credentials = _gitHubCredential
};
var repository = await GetGitHubRepository(projectName, repositoryOwner);
if (repository == null)
{
_logger.LogInformation($"Creating repository {repositoryOwner}/{projectName}...");
var newRepository = new NewRepository(projectName)
{
Private = isPrivateRepository
};
var currentUser = await client.User.Current();
if (repositoryOwner.Equals(currentUser.Login, StringComparison.InvariantCultureIgnoreCase))
{
repository = await client.Repository.Create(newRepository);
}
else
{
repository = await client.Repository.Create(repositoryOwner, newRepository);
}
}
else
{
_logger.LogInformation($"Repository {repositoryOwner}/{projectName} is already exists");
}
if (members != null)
{
var currentMembers = await client.Repository.Collaborator.GetAll(repository.Id);
var newMembers = members.Where(m => !currentMembers.Any(u => u.Login.ToLower() == m.ToLower())).ToList();
foreach (var member in newMembers)
{
await client.Repository.Collaborator.Add(repository.Id, member);
}
}
return("");
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
return(ex.Message);
}
}
public async Task CanCreateAndRetrieveEmptyContributorsWithRepositoryId()
{
var newRepository = new NewRepository(Helper.MakeNameWithTimestamp("public-repo")) { AutoInit = false };
using (var context = await _client.CreateRepositoryContext(newRepository))
{
var contributors = await _client.Repository.Statistics.GetContributors(context.Repository.Id);
Assert.NotNull(contributors);
Assert.Empty(contributors);
}
}
/// <summary>
/// Creates a new repository in the specified organization.
/// </summary>
/// <param name="organizationLogin">The login of the organization in which to create the repository</param>
/// <param name="newRepository">A <see cref="NewRepository"/> instance describing the new repository to create</param>
/// <returns>An <see cref="IObservable{Repository}"/> instance for the created repository</returns>
public IObservable <Repository> Create(string organizationLogin, NewRepository newRepository)
{
Ensure.ArgumentNotNull(organizationLogin, nameof(organizationLogin));
Ensure.ArgumentNotNull(newRepository, nameof(newRepository));
if (string.IsNullOrEmpty(newRepository.Name))
{
throw new ArgumentException("The new repository's name must not be null.");
}
return(_client.Create(organizationLogin, newRepository).ToObservable());
}
public override async Task <Command> HandleAsync(Command command, CancellationToken cancellationToken = default(CancellationToken))
{
NewRepository newRepository = new NewRepository(command.RepositoryName)
{
AutoInit = true,
GitignoreTemplate = "VisualStudio",
HasIssues = false
};
var x = await _client.Repository.Create(command.Organization, newRepository);
return(await base.HandleAsync(command, cancellationToken));
}
public IObservable <Unit> CreateRepository(
NewRepository newRepository,
IAccount account,
string directory,
IApiClient apiClient)
{
Guard.ArgumentNotEmptyString(directory, nameof(directory));
return(apiClient.CreateRepository(newRepository, account.Login, account.IsUser)
.Select(repository => cloneService.CloneRepository(repository.CloneUrl, repository.Name, directory))
.SelectUnit());
}
public ViewResult UserInfo(NewUserInput newUserInput)
{
if (ModelState.IsValid)
{
NewRepository.AddResponse(newUserInput);
return(View("Thanks", newUserInput));
}
else
{
// there is a validation error
return(View());
}
}
public async void createRepo(string name)
{
//not functional
var client = new GitHubClient(new ProductHeaderValue("AreaNet"));
var tokenAuth = new Credentials(access_token);
client.Credentials = tokenAuth;
var new_rep = new NewRepository(name)
{
AutoInit = true
};
var repository = await client.Repository.Create(new_rep);
}
public async Task CanQueueAllCodeRepository()
{
var newRepository = new NewRepository(Helper.MakeNameWithTimestamp("public-repo"));
using (var context = await _github.CreateRepositoryContext(newRepository))
{
var observable = _github.Enterprise.SearchIndexing.QueueAllCode(EnterpriseHelper.UserName, context.RepositoryName);
var response = await observable;
Assert.NotNull(response);
Assert.NotNull(response.Message);
Assert.True(response.Message.All(m => m.Contains("was added to the indexing queue")));
}
}
public async Task CreateRepository(NewRepository newRepository, Action<GitHubRepository, Exception> callback, string organization = null)
{
Guard.ArgumentNotNull(callback, "callback");
try
{
var repository = await CreateRepositoryInternal(newRepository, organization);
callback(repository, null);
}
catch (Exception e)
{
callback(null, e);
}
}
internal async static Task<RepositoryContext> CreateRepositoryWithProtectedBranch(this IGitHubClient client)
{
// Create user owned repo
var userRepo = new NewRepository(Helper.MakeNameWithTimestamp("protected-repo")) { AutoInit = true };
var contextUserRepo = await client.CreateRepositoryContext(userRepo);
// Protect master branch
var update = new BranchProtectionSettingsUpdate(
new BranchProtectionRequiredStatusChecksUpdate(true, true, new[] { "build", "test" }));
await client.Repository.Branch.UpdateBranchProtection(contextUserRepo.RepositoryOwner, contextUserRepo.RepositoryName, "master", update);
return contextUserRepo;
}
public async Task CanQueueAllIssuesRepository()
{
var newRepository = new NewRepository(Helper.MakeNameWithTimestamp("public-repo"));
using (var context = await _github.CreateRepositoryContext(newRepository))
{
var response = await
_github.Enterprise.SearchIndexing.QueueAllIssues(EnterpriseHelper.UserName, context.RepositoryName);
Assert.NotNull(response);
Assert.NotNull(response.Message);
Assert.True(response.Message.All(m => m.Contains("were added to the indexing queue")));
}
}
public ProductionDataGridUserControl()
{
InitializeComponent();
SetTexts();
productionStopRegistrationGridView.AutoGenerateColumns = false;
repository = new NewRepository();
cbMachine.DataSource = Settings.Default.Machines;
cbMachine.SelectedItem = null;
cbTeam.DataSource = GetTeams();
cbTeam.DisplayMember = "Name";
cbTeam.SelectedItem = null;
Load();
}
public async Task ThrowsRepositoryExistsExceptionWhenRepositoryExistsForCurrentUser()
{
var newRepository = new NewRepository("aName");
var response = Substitute.For<IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[{""resource"":""Repository"","
+ @"""code"":""custom"",""field"":""name"",""message"":""name already exists on this account""}]}");
var credentials = new Credentials("haacked", "pwd");
var connection = Substitute.For<IApiConnection>();
connection.Connection.BaseAddress.Returns(GitHubClient.GitHubApiUrl);
connection.Connection.Credentials.Returns(credentials);
connection.Post<Repository>(Args.Uri, newRepository)
.Returns<Task<Repository>>(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await Assert.ThrowsAsync<RepositoryExistsException>(
() => client.Create(newRepository));
Assert.False(exception.OwnerIsOrganization);
Assert.Null(exception.Organization);
Assert.Equal("aName", exception.RepositoryName);
Assert.Null(exception.ExistingRepositoryWebUrl);
}
internal static async Task<RepositoryContext> CreateRepositoryContext(this IObservableGitHubClient client, NewRepository newRepository)
{
var repo = await client.Repository.Create(newRepository);
return new RepositoryContext(client.Connection, repo);
}
internal static async Task<RepositoryContext> CreateRepositoryContext(this IGitHubClient client, string organizationLogin, NewRepository newRepository)
{
var repo = await client.Repository.Create(organizationLogin, newRepository);
return new RepositoryContext(client.Connection, repo);
}
public async Task ThrowsRepositoryExistsExceptionForEnterpriseInstance()
{
var newRepository = new NewRepository("aName");
var response = Substitute.For<IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[{""resource"":""Repository"","
+ @"""code"":""custom"",""field"":""name"",""message"":""name already exists on this account""}]}");
var connection = Substitute.For<IApiConnection>();
connection.Connection.BaseAddress.Returns(new Uri("https://example.com"));
connection.Post<Repository>(Args.Uri, newRepository)
.Returns<Task<Repository>>(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await Assert.ThrowsAsync<RepositoryExistsException>(
() => client.Create("illuminati", newRepository));
Assert.Equal("aName", exception.RepositoryName);
Assert.Equal(new Uri("https://example.com/illuminati/aName"), exception.ExistingRepositoryWebUrl);
}
public async Task ThrowsValidationException()
{
var newRepository = new NewRepository("aName");
var response = Substitute.For<IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[]}");
var connection = Substitute.For<IApiConnection>();
connection.Connection.BaseAddress.Returns(GitHubClient.GitHubApiUrl);
connection.Post<Repository>(Args.Uri, newRepository)
.Returns<Task<Repository>>(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await Assert.ThrowsAsync<ApiValidationException>(
() => client.Create("illuminati", newRepository));
Assert.Null(exception as RepositoryExistsException);
}
internal async static Task<RepositoryContext> CreateRepositoryContext(this IObservableGitHubClient client, string organizationLogin, NewRepository newRepository)
{
var repo = await client.Repository.Create(organizationLogin, newRepository);
return new RepositoryContext(repo);
}
public async Task TheNewRepositoryDescription()
{
var connection = Substitute.For<IApiConnection>();
var client = new RepositoriesClient(connection);
var newRepository = new NewRepository("aName");
await client.Create("aLogin", newRepository);
connection.Received().Post<Repository>(Args.Uri, newRepository);
}
internal async static Task<RepositoryContext> CreateRepositoryContext(this IGitHubClient client, NewRepository newRepository)
{
var repo = await client.Repository.Create(newRepository);
return new RepositoryContext(repo);
}
public async Task ThrowsRepositoryExistsExceptionWhenRepositoryExistsForSpecifiedOrg()
{
var newRepository = new NewRepository { Name = "aName" };
var response = Substitute.For<IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[{""resource"":""Repository"","
+ @"""code"":""custom"",""field"":""name"",""message"":""name already exists on this account""}]}");
var connection = Substitute.For<IApiConnection>();
connection.Connection.BaseAddress.Returns(GitHubClient.GitHubApiUrl);
connection.Post<Repository>(Args.Uri, newRepository)
.Returns<Task<Repository>>(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await AssertEx.Throws<RepositoryExistsException>(
async () => await client.Create("illuminati", newRepository));
Assert.True(exception.OwnerIsOrganization);
Assert.Equal("illuminati", exception.Organization);
Assert.Equal("aName", exception.RepositoryName);
Assert.Equal(new Uri("https://github.com/illuminati/aName"), exception.ExistingRepositoryWebUrl);
Assert.Equal("There is already a repository named 'aName' in the organization 'illuminati'.",
exception.Message);
}
public async Task ThrowsExceptionWhenPrivateRepositoryQuotaExceeded()
{
var newRepository = new NewRepository("aName") { Private = true };
var response = Substitute.For<IResponse>();
response.StatusCode.Returns((HttpStatusCode)422);
response.Body.Returns(@"{""message"":""Validation Failed"",""documentation_url"":"
+ @"""http://developer.github.com/v3/repos/#create"",""errors"":[{""resource"":""Repository"","
+ @"""code"":""custom"",""field"":""name"",""message"":"
+ @"""name can't be private. You are over your quota.""}]}");
var credentials = new Credentials("haacked", "pwd");
var connection = Substitute.For<IApiConnection>();
connection.Connection.BaseAddress.Returns(GitHubClient.GitHubApiUrl);
connection.Connection.Credentials.Returns(credentials);
connection.Post<Repository>(Args.Uri, newRepository)
.Returns<Task<Repository>>(_ => { throw new ApiValidationException(response); });
var client = new RepositoriesClient(connection);
var exception = await Assert.ThrowsAsync<PrivateRepositoryQuotaExceededException>(
() => client.Create(newRepository));
Assert.NotNull(exception);
}
