/// <summary> /// Initializes a new instance of the <see cref="MessageService" /> class. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="gitHubRepository">The git hub repository.</param> public MessageService( IConfiguration configuration, IGitHubRepository gitHubRepository) { appCredentials = new MicrosoftAppCredentials(configuration); this.gitHubRepository = gitHubRepository; }
public ReposController( IMemoryCache cache, IGitHubRepository gitHubRepository) { _cache = cache; _gitHubRepository = gitHubRepository; }
public GitHubScopedProcessingService( IGitHubApiService gitHubApiService, IGitHubRepository gitHubRepository) { _gitHubApiService = gitHubApiService; _gitHubRepository = gitHubRepository; }
public CreatePRReviewDecorator(IGitHubRepository gitHubRepository, IGitHubRepositoryContext repositoryContext, ISonarCloudRepository sonarCloudRepository) { this._gitHubRepository = gitHubRepository; this._repositoryContext = repositoryContext; this._sonarCloudRepository = sonarCloudRepository; }
public async Task TestGetLatestRelease() { IGitHubRepository repository = MakeRepository(); IGitHubRelease release = await _releaseFinderService.GetLatestRelease(repository); VerifyGetLatestReleaseCalled(repository); }
private async Task <App> CreateAppForRepository(IGitHubRepository repository) { IGitHubRelease latestRelease = await _releaseFinderService.GetLatestRelease(repository); App repositoryApp = _repositoryToAppGeneratorService.GenerateApp(new GitHubRepositoryDataProvider(repository, latestRelease)); return(repositoryApp); }
public DeployController(IGitHubRepository gitHubRepository) { if (gitHubRepository == null) { throw new ArgumentNullException("gitHubRepository"); } GitHubRepository = gitHubRepository; }
public async Task TestDoesNotHaveReleases() { IGitHubRepository repository = MakeRepository(); SetupDoesNotHaveReleases(repository); bool hasReleases = await _releaseFinderService.HasReleases(repository); Assert.False(hasReleases); }
private void SetupGetAllReleases(IGitHubRepository repository, int length) { Mock <IReadOnlyList <Release> > releaseListMock = new Mock <IReadOnlyList <Release> >(); releaseListMock.SetupGet(releaseList => releaseList.Count) .Returns(length); _releasesClientMock.Setup(releasesClient => releasesClient.GetAll(repository.Id)) .ReturnsAsync(releaseListMock.Object); }
private IGitHubRepository[] SetupRepositories(int quantity) { IGitHubRepository[] repositories = new IGitHubRepository[quantity]; for (int repositoryIndex = 0; repositoryIndex < quantity; repositoryIndex++) { repositories[repositoryIndex] = SetupRepository(); } return(SetupRepositories(repositories)); }
public GitHubCreatePullRequest( ILogger <GitHubCreatePullRequest> logger, IWebhookValidator webhookValidator, IKontentRepository kontentRepository, IBlobDownloader blobDownloader, IGitHubRepository gitHubRepository ) : base(logger) { this.webhookValidator = webhookValidator; this.kontentRepository = kontentRepository; this.blobDownloader = blobDownloader; this.gitHubRepository = gitHubRepository; }
private App[] SetupApps() { App[] apps = Data.Apps; IGitHubRepository[] repositories = new IGitHubRepository[apps.Length]; for (int appIndex = 0; appIndex < apps.Length; appIndex++) { repositories[appIndex] = SetupRepository(); } SetupAppGeneratorWithApps(apps); SetupRepositories(repositories); return(apps); }
private void VerifyHasReleasesCalled(IGitHubRepository repository) { _releaseFinderServiceMock.Verify(releaseFinder => releaseFinder.HasReleases(repository)); }
private void SetupHasReleases(IGitHubRepository repository) { const int releaseCount = 5; SetupGetAllReleases(repository, releaseCount); }
private Task <bool> HasReleases(IGitHubRepository repository) { return(_releaseFinderService.HasReleases(repository)); }
public GitHubService(IGitHubRepository gitHubRepository) { _gitHubRepository = gitHubRepository; }
protected CommandBaseCommand(IGitHubRepository gitHubRepository) { this._gitHubRepository = gitHubRepository; }
public HomeController(IGitHubRepository gitHubRepo, ILinkedinRepository linkedIn, IBlobStorageClient storage) { _gitHub = gitHubRepo; _linkedIn = linkedIn; _storage = storage; }
public CreateWorkItemCommand(IGitHubRepository gitHubRepository, IWorkItemRepository workItemRepository, ISonarCloudRepository sonarCloudRepository) : base(gitHubRepository) { _workItemRepository = workItemRepository; _sonarCloudRepository = sonarCloudRepository; }
private void SetupDoesNotHaveReleases(IGitHubRepository repository) { SetupGetAllReleases(repository, 0); }
private void VerifyGetLatestReleaseCalled(IGitHubRepository repository) { VerifyGetLatestReleaseCalled(repository, Times.Once); }
public GitHubAppService(IGitHubRepository repository, GitHubCommandHandler handler) { Repository = repository; _handler = handler; }
private void VerifyGetLatestReleaseCalled(IGitHubRepository repository, Func <Times> times) { _releaseFinderServiceMock.Verify(releaseFinder => releaseFinder.GetLatestRelease(repository), times); }
public GitHubService(IGitHubRepository repository) { this.repository = repository; }
public CommandBaseCommandActivity(IGitHubRepository gitHubRepository) { this._gitHubRepository = gitHubRepository; }
public async Task <IGitHubRelease> GetLatestRelease(IGitHubRepository repository) { return(new GitHubRelease(await _gitHubClient.Repository.Release.GetLatest(repository.Id))); }
public GitHubService(IGitHubRepository gitHubRepository) { _gitHubRepository = gitHubRepository; }
public GitHubCommandOrchestrator(IGitHubRepository repository) { _repository = repository; }
public GitHubCommandHandler(IGitHubRepository repository, IUnitOfWork uow) : base(uow) { _repository = repository; }
public GitHubRepositoryDataProvider(IGitHubRepository gitHubRepository, IGitHubRelease latestRelease) { _gitHubRepository = gitHubRepository; _latestRelease = latestRelease; }
public async Task <bool> HasReleases(IGitHubRepository repository) { IReadOnlyList <Release> releases = await _gitHubClient.Repository.Release.GetAll(repository.Id); return(releases.Count > 0); }
private void VerifyGetLatestReleaseCalled(IGitHubRepository repository) { _releasesClientMock.Verify(releasesClient => releasesClient.GetLatest(repository.Id)); }