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); }