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