public async Task Handle_RepositoryForHandleFound_ReturnsRepository()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var pullDogRepository = new PullDogRepository()
            {
                Handle          = "some-repository-handle",
                PullDogSettings = new PullDogSettings()
                {
                    User = new User()
                    {
                        StripeCustomerId = "dummy"
                    },
                    PlanId          = "dummy",
                    EncryptedApiKey = Array.Empty <byte>()
                }
            };
            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.PullDogRepositories.AddAsync(pullDogRepository);
            });

            //Act
            var repository = await environment.Mediator.Send(new GetRepositoryByHandleQuery("some-repository-handle"));

            //Assert
            Assert.IsNotNull(repository);

            await environment.WithFreshDataContext(async dataContext =>
            {
                Assert.AreEqual(1, await dataContext.PullDogRepositories.CountAsync());
            });
        }
        public async Task Handle_PullRequestOpenedPayloadWithValidRepository_ProvisionsPullDogInstance()
        {
            //Arrange
            var databaseRepository = new PullDogRepository()
            {
                Handle          = "1337",
                PullDogSettings = new PullDogSettings()
            };

            var fakeMediator = Substitute.For <IMediator>();

            var handler = new PullRequestReadyPayloadHandler(fakeMediator);

            //Act
            await handler.HandleAsync(new WebhookPayloadContext(
                                          new WebhookPayload(),
                                          null !,
                                          databaseRepository,
                                          new PullDogPullRequest()
            {
                Handle = "1338"
            }));

            //Assert
            await fakeMediator
            .Received(1)
            .Send(Arg.Is <ProvisionPullDogEnvironmentCommand>(args =>
                                                              args.PullRequestHandle == "1338" &&
                                                              args.Repository == databaseRepository));
        }
Exemple #3
0
 public ProvisionPullDogEnvironmentCommand(
     string pullRequestHandle,
     PullDogRepository repository)
 {
     this.PullRequestHandle = pullRequestHandle;
     this.Repository        = repository;
 }
 public GetPullRequestHandleFromCommitReferenceQuery(
     PullDogRepository repository,
     string commitReference)
 {
     this.Repository      = repository;
     this.CommitReference = commitReference;
 }
Exemple #5
0
 public EnsurePullDogPullRequestCommand(
     PullDogRepository repository,
     string pullRequestHandle)
 {
     this.Repository        = repository;
     this.PullRequestHandle = pullRequestHandle;
 }
Exemple #6
0
 public WebhookPayloadContext(
     WebhookPayload payload,
     PullDogSettings settings,
     PullDogRepository repository,
     PullDogPullRequest pullRequest)
 {
     this.Payload     = payload;
     this.Settings    = settings;
     this.Repository  = repository;
     this.PullRequest = pullRequest;
 }
        public async Task Handle_ExistingPullRequestFound_ReturnsExistingPullRequest()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var pullDogRepository = new PullDogRepository()
            {
                Handle          = "some-repository-handle",
                PullDogSettings = new PullDogSettings()
                {
                    User = new User()
                    {
                        StripeCustomerId = "dummy"
                    },
                    PlanId          = "dummy",
                    EncryptedApiKey = Array.Empty <byte>()
                }
            };
            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.PullDogPullRequests.AddAsync(new PullDogPullRequest()
                {
                    Handle            = "some-pull-request-handle",
                    PullDogRepository = pullDogRepository
                });
            });

            //Act
            var pullRequest = await environment.Mediator.Send(new EnsurePullDogPullRequestCommand(
                                                                  pullDogRepository,
                                                                  "some-pull-request-handle"));

            //Assert
            Assert.IsNotNull(pullRequest);

            await environment.WithFreshDataContext(async dataContext =>
            {
                Assert.AreEqual(1, await dataContext.PullDogPullRequests.CountAsync());
            });
        }