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

            //Act
            var repository = await environment.Mediator.Send(new EnsurePullDogRepositoryCommand(
                                                                 new PullDogSettings()
            {
                User = new User()
                {
                    StripeCustomerId = "dummy"
                },
                PlanId = "dummy",
                EncryptedApiKey = Array.Empty <byte>()
            },
                                                                 "some-repository-handle"));

            //Assert
            Assert.IsNotNull(repository);

            await environment.WithFreshDataContext(async dataContext =>
            {
                Assert.AreEqual(1, await dataContext.PullDogRepositories.CountAsync());
            });
        }
示例#2
0
        public async Task Handle_NoUserFoundInDatabase_CreatesUserInAmazon()
        {
            //Arrange
            var fakeAmazonIdentityManagementService = Substitute.For <IAmazonIdentityManagementService>();

            fakeAmazonIdentityManagementService
            .CreateAccessKeyAsync(Arg.Any <CreateAccessKeyRequest>())
            .Returns(new CreateAccessKeyResponse()
            {
                AccessKey = new AccessKey()
            });

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services => services.AddSingleton(fakeAmazonIdentityManagementService)
            });

            //Act
            await environment.Mediator.Send(new EnsureAmazonUserWithNameCommand("some-name"));

            //Assert
            await fakeAmazonIdentityManagementService
            .Received(1)
            .CreateUserAsync(Arg.Is <CreateUserRequest>(args =>
                                                        args.UserName == "some-name"));
        }
        public async Task Handle_SubscriptionsUpdateThrowsException_NothingIsCommitted()
        {
            //Arrange
            var fakeMediator = Substitute.For <IMediator>();

            fakeMediator
            .Send(Arg.Is <GetPullDogPlanFromSettingsQuery>(args =>
                                                           args.DoggerPlanId == "some-new-plan-id"))
            .Returns(new PullDogPlan(
                         "some-plan-id",
                         1337,
                         1338));

            fakeMediator
            .Send(Arg.Any <UpdateUserSubscriptionCommand>())
            .Throws(new TestException());

            await using var environment = await IntegrationTestEnvironment.CreateAsync(
                            new EnvironmentSetupOptions ()
            {
                IocConfiguration = services => services.AddSingleton(fakeMediator)
            });

            var databaseUser = new User()
            {
                StripeCustomerId = "dummy",
                PullDogSettings  = new PullDogSettings()
                {
                    PoolSize        = 1337,
                    EncryptedApiKey = Array.Empty <byte>(),
                    PlanId          = "some-plan-id"
                }
            };

            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.Users.AddAsync(databaseUser);
            });

            //Act
            var exception = await Assert.ThrowsExceptionAsync <TestException>(async() =>
                                                                              await environment.Mediator.Send(new ChangePullDogPlanCommand(
                                                                                                                  databaseUser.Id,
                                                                                                                  1338,
                                                                                                                  "some-new-plan-id")));

            //Assert
            Assert.IsNotNull(exception);

            await environment.WithFreshDataContext(async dataContext =>
            {
                var refreshedSettings = await dataContext
                                        .PullDogSettings
                                        .SingleOrDefaultAsync();
                Assert.IsNotNull(refreshedSettings);

                Assert.AreEqual(1337, refreshedSettings.PoolSize);
                Assert.AreEqual("some-plan-id", refreshedSettings.PlanId);
            });
        }
示例#4
0
        public async Task Handle_ExistingUserFoundInDatabase_ReturnsUser()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var userId = Guid.NewGuid();

            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.AmazonUsers.AddAsync(new AmazonUser()
                {
                    Id   = userId,
                    Name = "some-name",
                    EncryptedAccessKeyId     = Array.Empty <byte>(),
                    EncryptedSecretAccessKey = Array.Empty <byte>()
                });
            });

            //Act
            var user = await environment.Mediator.Send(new EnsureAmazonUserWithNameCommand("some-name"));

            //Assert
            Assert.IsNotNull(user);
            Assert.AreEqual(userId, user.Id);
        }
示例#5
0
        public async Task Handle_ErrorOccuredDuringCreationOfAccessKey_DeletesCreatedAmazonUser()
        {
            //Arrange
            var fakeAmazonIdentityManagementService = Substitute.For <IAmazonIdentityManagementService>();

            fakeAmazonIdentityManagementService
            .CreateAccessKeyAsync(Arg.Any <CreateAccessKeyRequest>())
            .Throws(new TestException());

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services => services.AddSingleton(fakeAmazonIdentityManagementService)
            });

            //Act
            var exception = await Assert.ThrowsExceptionAsync <TestException>(async() =>
                                                                              await environment.Mediator.Send(new EnsureAmazonUserWithNameCommand("some-name")));

            //Assert
            Assert.IsNotNull(exception);

            await fakeAmazonIdentityManagementService
            .Received(1)
            .DeleteUserAsync(Arg.Is <DeleteUserRequest>(args => args.UserName == "some-name"));
        }
        public async Task Handle_TwoDifferentEnvironments_CantAccessUncommittedRows()
        {
            //Arrange
            var options = new EnvironmentSetupOptions()
            {
                SkipWebServer = true
            };

            await using var environment1 = await IntegrationTestEnvironment.CreateAsync(options);

            await environment1.DataContext.Database.MigrateAsync();

            await using var environment2 = await IntegrationTestEnvironment.CreateAsync(options);

            //Act & Assert
            await environment1.Mediator.Send(new TestCommand(async() =>
            {
                await environment1.DataContext.Clusters.AddAsync(new Cluster()
                {
                    Name = "outer"
                });
                await environment1.DataContext.SaveChangesAsync();

                var clusterCount1 = await environment1.DataContext.Clusters.CountAsync();
                var clusterCount2 = await environment2.DataContext.Clusters.CountAsync();

                Assert.AreEqual(1, clusterCount1);
                Assert.AreEqual(0, clusterCount2);
            }));
        }
示例#7
0
        public void VerifyThatInvalidIdentifierNamesAreParsed()
        {
            var environment = new IntegrationTestEnvironment();
            var asset       = environment.GetTestAsset("CILProject.dll", "net451");
            var assembly    = Assembly.LoadFrom(asset);
            var types       = assembly.GetTypes();

            foreach (var type in types)
            {
                var methods = type.GetMethods();

                foreach (var method in methods)
                {
                    if (method.DeclaringType != type)
                    {
                        continue;
                    }

                    ManagedNameHelper.GetManagedName(method, out var typeName, out var methodName);
                    var methodInfo = ManagedNameHelper.GetMethod(assembly, typeName, methodName);
                    ManagedNameHelper.GetManagedName(methodInfo, out var typeName2, out var methodName2);

                    Assert.IsTrue(method == methodInfo);
                    Assert.AreEqual(typeName, typeName2, $"Type parse roundtrip test failed: {method} ({typeName} != {typeName2})");
                    Assert.AreEqual(methodName, methodName2, $"Method parse roundtrip test failed: {method} ({methodName} != {methodName2})");
                }
            }
        }
        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());
            });
        }
示例#9
0
        public async Task Authenticate_HasClaims()
        {
            var testServerHandler = IntegrationTestEnvironment.TestIdentityServer.CreateHandler();
            var discoveryClient   = new DiscoveryClient(TestServerFixture.Authority, testServerHandler);

            discoveryClient.Policy.ValidateIssuerName = false;
            var disco = await discoveryClient.GetAsync();

            disco.Error.ShouldBeNull();

            var userTestData  = IntegrationTestEnvironment.TestData <XUserTestData>();
            var admin         = userTestData.Administrator;
            var tokenClient   = new TokenClient(disco.TokenEndpoint, "webclient.ro", "EA59A39A-B03D-4985-A4FA-9297663A1858", testServerHandler);
            var tokenResponse = await tokenClient.RequestResourceOwnerPasswordAsync(admin.LogonName, XUserTestData.AdminPassword, "api");

            tokenResponse.Error.ShouldBeNull();

            var token = new JwtSecurityTokenHandler().ReadToken(tokenResponse.AccessToken) as JwtSecurityToken;

            token.ShouldNotBeNull();
            token.Claims.ShouldContain(clm => clm.Type == Kiss4WebClaims.LogonName);
            token.Claims.ShouldContain(clm => clm.Type == Kiss4WebClaims.ShortName);
            token.Claims.First(clm => clm.Type == Kiss4WebClaims.LogonName).Value.ShouldBe(admin.LogonName);
            token.Claims.First(clm => clm.Type == Kiss4WebClaims.ShortName).Value.ShouldBe(admin.ShortName);
        }
示例#10
0
        public async Task Handle_ProperArgumentsGiven_JobIsQueuedWithProperInstanceName()
        {
            //Arrange
            var fakeProvisioningService = Substitute.For <IProvisioningService>();

            var fakeAmazonLightsail = Substitute.For <IAmazonLightsail>();

            FakeOutBundleFetching(fakeAmazonLightsail);

            var fakeFile = Substitute.For <IFile>();

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services =>
                {
                    services.AddSingleton(fakeProvisioningService);
                    services.AddSingleton(fakeAmazonLightsail);
                    services.AddSingleton(fakeFile);
                }
            });

            //Act
            await environment.Mediator.Send(
                new ProvisionDogfeedInstanceCommand(
                    "some-instance-name"));

            //Assert
            await fakeProvisioningService
            .Received(1)
            .ScheduleJobAsync(
                Arg.Is <AggregateProvisioningStateFlow>(arguments => GetProvisionInstanceStateFlow(arguments)
                                                        .DatabaseInstance.Name == "some-instance-name"));
        }
示例#11
0
 protected static void SetTestEnvironment(IntegrationTestEnvironment testEnvironment,
                                          string runnerFramework, string targetFramework, string targetRuntime)
 {
     testEnvironment.RunnerFramework = runnerFramework;
     testEnvironment.TargetFramework = targetFramework;
     testEnvironment.TargetRuntime   = targetRuntime;
 }
        public async Task Handle_InstanceFound_ProvisionedFlagSetInDatabase()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.Instances.AddAsync(new Instance()
                {
                    Name    = "some-instance-name",
                    PlanId  = "dummy",
                    Cluster = new Cluster()
                });
            });

            //Act
            await environment.Mediator.Send(new RegisterInstanceAsProvisionedCommand("some-instance-name"));

            //Assert
            await environment.WithFreshDataContext(async dataContext =>
            {
                var instances = await dataContext
                                .Instances
                                .ToArrayAsync();

                Assert.AreEqual(1, instances.Length);
                Assert.IsTrue(instances.Single().IsProvisioned);
            });
        }
        public async Task Handle_ProperArgumentsGiven_JobIsQueuedWithProperPlanId()
        {
            //Arrange
            var fakeAmazonLightsail = Substitute.For <IAmazonLightsail>();

            FakeOutBundleFetching(fakeAmazonLightsail);

            var fakeProvisioningService = Substitute.For <IProvisioningService>();

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services =>
                {
                    services.AddSingleton(fakeProvisioningService);
                    services.AddSingleton(fakeAmazonLightsail);
                }
            });

            //Act
            await environment.Mediator.Send(
                new ProvisionDemoInstanceCommand());

            //Assert
            await fakeProvisioningService
            .Received(1)
            .ScheduleJobAsync(
                Arg.Is <ProvisionInstanceStateFlow>(arguments =>
                                                    arguments.PlanId == "some-plan-id"));
        }
        public async Task Handle_LightsailInstanceNotFound_NoExceptionThrown()
        {
            //Arrange
            var fakeAmazonLightsailClient = Substitute.For <IAmazonLightsail>();

            fakeAmazonLightsailClient
            .DeleteInstanceAsync(
                Arg.Any <DeleteInstanceRequest>(),
                default)
            .Throws(new NotFoundException("Not found"));

            var fakeLightsailOperationService = Substitute.For <ILightsailOperationService>();

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services =>
                {
                    services.AddSingleton(fakeAmazonLightsailClient);
                    services.AddSingleton(fakeLightsailOperationService);
                }
            });

            //Act
            await environment.Mediator.Send(
                new DeleteInstanceByNameCommand("some-name"),
                default);

            //Assert
            await fakeLightsailOperationService
            .DidNotReceiveWithAnyArgs()
            .WaitForOperationsAsync(default);
        public async Task Handle_NoClusterIdGivenAndMultipleClustersOnUser_QueryTooBroadExceptionThrown()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var fakeUserId = Guid.NewGuid();

            var user = new User()
            {
                Id = fakeUserId,
                StripeCustomerId = "dummy"
            };

            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.Clusters.AddAsync(new Cluster()
                {
                    User = user
                });
                await dataContext.Clusters.AddAsync(new Cluster()
                {
                    User = user
                });
            });

            //Act
            var exception = await Assert.ThrowsExceptionAsync <ClusterQueryTooBroadException>(async() =>
                                                                                              await environment.Mediator.Send(new GetClusterForUserQuery(fakeUserId)));

            //Assert
            Assert.IsNotNull(exception);
        }
示例#16
0
        public async Task Dogfeed_ExistingUnhealthyInstances_DestroysUnhealthyInstances()
        {
            //Arrange
            var fakeMediator = Substitute.For <IMediator>();

            FakeOutValidSupportedPlans(fakeMediator);
            FakeOutNewlyCreatedInstance(fakeMediator);

            fakeMediator
            .Send(Arg.Any <GetLoadBalancerByNameQuery>())
            .Returns(
                new LoadBalancer()
            {
                InstanceHealthSummary = new List <InstanceHealthSummary>()
                {
                    new InstanceHealthSummary()
                    {
                        InstanceName   = "unhealthy-instance-1",
                        InstanceHealth = InstanceHealthState.Unhealthy
                    },
                    new InstanceHealthSummary()
                    {
                        InstanceName   = "unhealthy-instance-2",
                        InstanceHealth = InstanceHealthState.Unhealthy
                    },
                    new InstanceHealthSummary()
                    {
                        InstanceName   = "new-instance",
                        InstanceHealth = InstanceHealthState.Healthy
                    }
                }
            });

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services =>
                {
                    IocRegistry.ConfigureDogfeeding(services);
                    FakeOutMinimalServices(services);

                    services.AddSingleton(fakeMediator);
                }
            });

            var dogfeedService = environment.ServiceProvider.GetRequiredService <IDogfeedService>();

            //Act
            await dogfeedService.DogfeedAsync();

            //Assert
            await fakeMediator
            .Received()
            .Send(Arg.Is <DeleteInstanceByNameCommand>(
                      arg => arg.Name == "unhealthy-instance-1"));

            await fakeMediator
            .Received()
            .Send(Arg.Is <DeleteInstanceByNameCommand>(
                      arg => arg.Name == "unhealthy-instance-2"));
        }
        public async Task Handle_MultipleUsersExist_MatchingUserIsReturned()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var existingUserIdentityName = "identity-name";

            await environment.Mediator.Send(
                new CreateUserForIdentityCommand(
                    TestClaimsPrincipalFactory.CreateWithIdentityName("some-dummy-user")));

            var existingUser = await environment.Mediator.Send(
                new CreateUserForIdentityCommand(
                    TestClaimsPrincipalFactory.CreateWithIdentityName(existingUserIdentityName)));

            await environment.Mediator.Send(
                new CreateUserForIdentityCommand(
                    TestClaimsPrincipalFactory.CreateWithIdentityName("some-other-dummy-user")));

            //Act
            var returnedUser = await environment.Mediator.Send(
                new GetUserByIdentityNameQuery(existingUserIdentityName));

            //Assert
            Assert.IsNotNull(returnedUser);
            Assert.AreNotEqual(default, existingUser.Id);
示例#18
0
        public async Task PullDogWebhook_AuthenticPayload_ReturnsNoContent()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            environment.Configuration["GitHub:PullDog:WebhookSecret"] = "some-webhook-secret";

            using var httpClient = new HttpClient();

            var stringContent = new StringContent("{\"action\":\"edited\",\"changes\":{\"body\":{\"from\":\"Mangler test af:\\r\\n\\r\\n- [x] `RegisterInstanceAsProvisioned` - der skal ikke laves en betaling hvis instansen har et pull dog pull request attached.\\r\\n- [x] `DeleteInstanceByName` - subscriptions skal ikke slettes hvis det er en pull dog instans.\\r\\n- [ ] `ChangePlan` på controller.\\r\\n- [ ] `CreateStripeSubscriptionCommand`\\r\\n- [ ] `ChangePullDogPlanCommand`\\r\\n- [ ] `UpdateUserSubscriptionCommand`\\r\\n- [ ] `GetSupportedPlansQuery`\\r\\n- [ ] `GetPullDogPlanFromSettings`\\r\\n- [ ] `GetSupportedPullDogPlans`\\r\\n- [ ] `DeleteAllPullDogInstancesForUser`\"}},\"issue\":{\"url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/238\",\"repository_url\":\"https://api.github.com/repos/ffMathy/dogger.io\",\"labels_url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/238/labels{/name}\",\"comments_url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/238/comments\",\"events_url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/238/events\",\"html_url\":\"https://github.com/ffMathy/dogger.io/issues/238\",\"id\":603478783,\"node_id\":\"MDU6SXNzdWU2MDM0Nzg3ODM=\",\"number\":238,\"title\":\"Pull Dog\",\"user\":{\"login\":\"ffMathy\",\"id\":2824010,\"node_id\":\"MDQ6VXNlcjI4MjQwMTA=\",\"avatar_url\":\"https://avatars3.githubusercontent.com/u/2824010?v=4\",\"gravatar_id\":\"\",\"url\":\"https://api.github.com/users/ffMathy\",\"html_url\":\"https://github.com/ffMathy\",\"followers_url\":\"https://api.github.com/users/ffMathy/followers\",\"following_url\":\"https://api.github.com/users/ffMathy/following{/other_user}\",\"gists_url\":\"https://api.github.com/users/ffMathy/gists{/gist_id}\",\"starred_url\":\"https://api.github.com/users/ffMathy/starred{/owner}{/repo}\",\"subscriptions_url\":\"https://api.github.com/users/ffMathy/subscriptions\",\"organizations_url\":\"https://api.github.com/users/ffMathy/orgs\",\"repos_url\":\"https://api.github.com/users/ffMathy/repos\",\"events_url\":\"https://api.github.com/users/ffMathy/events{/privacy}\",\"received_events_url\":\"https://api.github.com/users/ffMathy/received_events\",\"type\":\"User\",\"site_admin\":false},\"labels\":[],\"state\":\"open\",\"locked\":false,\"assignee\":null,\"assignees\":[],\"milestone\":null,\"comments\":10,\"created_at\":\"2020-04-20T19:28:45Z\",\"updated_at\":\"2020-05-30T22:07:12Z\",\"closed_at\":null,\"author_association\":\"OWNER\",\"body\":\"Se indiehackers svar.\"},\"comment\":{\"url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/comments/633209000\",\"html_url\":\"https://github.com/ffMathy/dogger.io/issues/238#issuecomment-633209000\",\"issue_url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/238\",\"id\":633209000,\"node_id\":\"MDEyOklzc3VlQ29tbWVudDYzMzIwOTAwMA==\",\"user\":{\"login\":\"ffMathy\",\"id\":2824010,\"node_id\":\"MDQ6VXNlcjI4MjQwMTA=\",\"avatar_url\":\"https://avatars3.githubusercontent.com/u/2824010?v=4\",\"gravatar_id\":\"\",\"url\":\"https://api.github.com/users/ffMathy\",\"html_url\":\"https://github.com/ffMathy\",\"followers_url\":\"https://api.github.com/users/ffMathy/followers\",\"following_url\":\"https://api.github.com/users/ffMathy/following{/other_user}\",\"gists_url\":\"https://api.github.com/users/ffMathy/gists{/gist_id}\",\"starred_url\":\"https://api.github.com/users/ffMathy/starred{/owner}{/repo}\",\"subscriptions_url\":\"https://api.github.com/users/ffMathy/subscriptions\",\"organizations_url\":\"https://api.github.com/users/ffMathy/orgs\",\"repos_url\":\"https://api.github.com/users/ffMathy/repos\",\"events_url\":\"https://api.github.com/users/ffMathy/events{/privacy}\",\"received_events_url\":\"https://api.github.com/users/ffMathy/received_events\",\"type\":\"User\",\"site_admin\":false},\"created_at\":\"2020-05-24T10:16:58Z\",\"updated_at\":\"2020-05-30T22:07:12Z\",\"author_association\":\"OWNER\",\"body\":\"Mangler test af:\\r\\n\\r\\n- [x] `RegisterInstanceAsProvisioned` - der skal ikke laves en betaling hvis instansen har et pull dog pull request attached.\\r\\n- [x] `DeleteInstanceByName` - subscriptions skal ikke slettes hvis det er en pull dog instans.\\r\\n- [x] `ChangePlan` på controller.\\r\\n- [ ] `CreateStripeSubscriptionCommand`\\r\\n- [ ] `ChangePullDogPlanCommand`\\r\\n- [ ] `UpdateUserSubscriptionCommand`\\r\\n- [ ] `GetSupportedPlansQuery`\\r\\n- [ ] `GetPullDogPlanFromSettings`\\r\\n- [ ] `GetSupportedPullDogPlans`\\r\\n- [ ] `DeleteAllPullDogInstancesForUser`\"},\"repository\":{\"id\":237241523,\"node_id\":\"MDEwOlJlcG9zaXRvcnkyMzcyNDE1MjM=\",\"name\":\"dogger.io\",\"full_name\":\"ffMathy/dogger.io\",\"private\":true,\"owner\":{\"login\":\"ffMathy\",\"id\":2824010,\"node_id\":\"MDQ6VXNlcjI4MjQwMTA=\",\"avatar_url\":\"https://avatars3.githubusercontent.com/u/2824010?v=4\",\"gravatar_id\":\"\",\"url\":\"https://api.github.com/users/ffMathy\",\"html_url\":\"https://github.com/ffMathy\",\"followers_url\":\"https://api.github.com/users/ffMathy/followers\",\"following_url\":\"https://api.github.com/users/ffMathy/following{/other_user}\",\"gists_url\":\"https://api.github.com/users/ffMathy/gists{/gist_id}\",\"starred_url\":\"https://api.github.com/users/ffMathy/starred{/owner}{/repo}\",\"subscriptions_url\":\"https://api.github.com/users/ffMathy/subscriptions\",\"organizations_url\":\"https://api.github.com/users/ffMathy/orgs\",\"repos_url\":\"https://api.github.com/users/ffMathy/repos\",\"events_url\":\"https://api.github.com/users/ffMathy/events{/privacy}\",\"received_events_url\":\"https://api.github.com/users/ffMathy/received_events\",\"type\":\"User\",\"site_admin\":false},\"html_url\":\"https://github.com/ffMathy/dogger.io\",\"description\":null,\"fork\":false,\"url\":\"https://api.github.com/repos/ffMathy/dogger.io\",\"forks_url\":\"https://api.github.com/repos/ffMathy/dogger.io/forks\",\"keys_url\":\"https://api.github.com/repos/ffMathy/dogger.io/keys{/key_id}\",\"collaborators_url\":\"https://api.github.com/repos/ffMathy/dogger.io/collaborators{/collaborator}\",\"teams_url\":\"https://api.github.com/repos/ffMathy/dogger.io/teams\",\"hooks_url\":\"https://api.github.com/repos/ffMathy/dogger.io/hooks\",\"issue_events_url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/events{/number}\",\"events_url\":\"https://api.github.com/repos/ffMathy/dogger.io/events\",\"assignees_url\":\"https://api.github.com/repos/ffMathy/dogger.io/assignees{/user}\",\"branches_url\":\"https://api.github.com/repos/ffMathy/dogger.io/branches{/branch}\",\"tags_url\":\"https://api.github.com/repos/ffMathy/dogger.io/tags\",\"blobs_url\":\"https://api.github.com/repos/ffMathy/dogger.io/git/blobs{/sha}\",\"git_tags_url\":\"https://api.github.com/repos/ffMathy/dogger.io/git/tags{/sha}\",\"git_refs_url\":\"https://api.github.com/repos/ffMathy/dogger.io/git/refs{/sha}\",\"trees_url\":\"https://api.github.com/repos/ffMathy/dogger.io/git/trees{/sha}\",\"statuses_url\":\"https://api.github.com/repos/ffMathy/dogger.io/statuses/{sha}\",\"languages_url\":\"https://api.github.com/repos/ffMathy/dogger.io/languages\",\"stargazers_url\":\"https://api.github.com/repos/ffMathy/dogger.io/stargazers\",\"contributors_url\":\"https://api.github.com/repos/ffMathy/dogger.io/contributors\",\"subscribers_url\":\"https://api.github.com/repos/ffMathy/dogger.io/subscribers\",\"subscription_url\":\"https://api.github.com/repos/ffMathy/dogger.io/subscription\",\"commits_url\":\"https://api.github.com/repos/ffMathy/dogger.io/commits{/sha}\",\"git_commits_url\":\"https://api.github.com/repos/ffMathy/dogger.io/git/commits{/sha}\",\"comments_url\":\"https://api.github.com/repos/ffMathy/dogger.io/comments{/number}\",\"issue_comment_url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues/comments{/number}\",\"contents_url\":\"https://api.github.com/repos/ffMathy/dogger.io/contents/{+path}\",\"compare_url\":\"https://api.github.com/repos/ffMathy/dogger.io/compare/{base}...{head}\",\"merges_url\":\"https://api.github.com/repos/ffMathy/dogger.io/merges\",\"archive_url\":\"https://api.github.com/repos/ffMathy/dogger.io/{archive_format}{/ref}\",\"downloads_url\":\"https://api.github.com/repos/ffMathy/dogger.io/downloads\",\"issues_url\":\"https://api.github.com/repos/ffMathy/dogger.io/issues{/number}\",\"pulls_url\":\"https://api.github.com/repos/ffMathy/dogger.io/pulls{/number}\",\"milestones_url\":\"https://api.github.com/repos/ffMathy/dogger.io/milestones{/number}\",\"notifications_url\":\"https://api.github.com/repos/ffMathy/dogger.io/notifications{?since,all,participating}\",\"labels_url\":\"https://api.github.com/repos/ffMathy/dogger.io/labels{/name}\",\"releases_url\":\"https://api.github.com/repos/ffMathy/dogger.io/releases{/id}\",\"deployments_url\":\"https://api.github.com/repos/ffMathy/dogger.io/deployments\",\"created_at\":\"2020-01-30T15:21:24Z\",\"updated_at\":\"2020-05-30T21:24:42Z\",\"pushed_at\":\"2020-05-30T21:24:40Z\",\"git_url\":\"git://github.com/ffMathy/dogger.io.git\",\"ssh_url\":\"[email protected]:ffMathy/dogger.io.git\",\"clone_url\":\"https://github.com/ffMathy/dogger.io.git\",\"svn_url\":\"https://github.com/ffMathy/dogger.io\",\"homepage\":null,\"size\":2728,\"stargazers_count\":0,\"watchers_count\":0,\"language\":\"C#\",\"has_issues\":true,\"has_projects\":true,\"has_downloads\":true,\"has_wiki\":false,\"has_pages\":false,\"forks_count\":0,\"mirror_url\":null,\"archived\":false,\"disabled\":false,\"open_issues_count\":43,\"license\":null,\"forks\":0,\"open_issues\":43,\"watchers\":0,\"default_branch\":\"master\"},\"sender\":{\"login\":\"ffMathy\",\"id\":2824010,\"node_id\":\"MDQ6VXNlcjI4MjQwMTA=\",\"avatar_url\":\"https://avatars3.githubusercontent.com/u/2824010?v=4\",\"gravatar_id\":\"\",\"url\":\"https://api.github.com/users/ffMathy\",\"html_url\":\"https://github.com/ffMathy\",\"followers_url\":\"https://api.github.com/users/ffMathy/followers\",\"following_url\":\"https://api.github.com/users/ffMathy/following{/other_user}\",\"gists_url\":\"https://api.github.com/users/ffMathy/gists{/gist_id}\",\"starred_url\":\"https://api.github.com/users/ffMathy/starred{/owner}{/repo}\",\"subscriptions_url\":\"https://api.github.com/users/ffMathy/subscriptions\",\"organizations_url\":\"https://api.github.com/users/ffMathy/orgs\",\"repos_url\":\"https://api.github.com/users/ffMathy/repos\",\"events_url\":\"https://api.github.com/users/ffMathy/events{/privacy}\",\"received_events_url\":\"https://api.github.com/users/ffMathy/received_events\",\"type\":\"User\",\"site_admin\":false},\"installation\":{\"id\":9252450,\"node_id\":\"MDIzOkludGVncmF0aW9uSW5zdGFsbGF0aW9uOTI1MjQ1MA==\"}}");

            stringContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            stringContent.Headers.Add("X-Hub-Signature", "sha1=d89914e0f80b9f723ea96b0b9eac5ce245625f10");

            //Act
            var response = await httpClient.PostAsync(
                "http://localhost:14568/api/webhooks/github/pull-dog",
                stringContent);

            //Assert
            Assert.IsNotNull(response);

            var responseString = await response.Content.ReadAsStringAsync();

            Assert.IsNotNull(responseString);

            Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
        }
        public async Task Handle_NestedTransactionsWithNoException_InnerAndOuterTransactionContentsSaved()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            //Act
            await environment.Mediator.Send(new TestCommand(async() =>
            {
                await environment.DataContext.Clusters.AddAsync(new Cluster()
                {
                    Name = "outer"
                });
                await environment.DataContext.SaveChangesAsync();

                await environment.Mediator.Send(new TestCommand(async() =>
                {
                    await environment.DataContext.Clusters.AddAsync(new Cluster()
                    {
                        Name = "inner"
                    });
                    await environment.DataContext.SaveChangesAsync();
                }));
            }));

            //Assert
            await environment.WithFreshDataContext(async (dataContext) =>
            {
                var clusterCount = await dataContext.Clusters.CountAsync();
                Assert.AreEqual(2, clusterCount);
            });
        }
示例#20
0
        public async Task TestUpdate()
        {
            // Arrange
            var person = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;

            // Act
            string newVorname;

            using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
            {
                var context  = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
                var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();

                var personAct = await personen.GetById(person.BaPersonID);

                newVorname        = personAct.Vorname + "-test";
                personAct.Vorname = newVorname;
                //await personen.InsertOrUpdateEntity(personAct);

                await context.SaveChangesAsync();
            }

            // Assert
            using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
            {
                var personen     = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();
                var personAssert = await personen.GetById(person.BaPersonID);

                personAssert.Vorname.ShouldBe(newVorname);
            }
        }
        public async Task Handle_NoPaymentMethodsPresent_DefaultPaymentMethodChangedToAddedMethod()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var user = await environment.Mediator.Send(
                new CreateUserForIdentityCommand(
                    TestClaimsPrincipalFactory.CreateWithIdentityName("some-identity-name")));

            var paymentMethodService = environment
                                       .ServiceProvider
                                       .GetRequiredService <PaymentMethodService>();

            var newPaymentMethod = await CreatePaymentMethodAsync(paymentMethodService);

            //Act
            await environment.Mediator.Send(
                new SetActivePaymentMethodForUserCommand(
                    user,
                    newPaymentMethod.Id));

            //Assert
            var stripeCustomer = await environment
                                 .ServiceProvider
                                 .GetRequiredService <CustomerService>()
                                 .GetAsync(user.StripeCustomerId);

            Assert.AreEqual(stripeCustomer.InvoiceSettings.DefaultPaymentMethodId, newPaymentMethod.Id);
        }
示例#22
0
        public async Task TestUpdateShouldAffectRowversion()
        {
            // Arrange
            var testPerson = IntegrationTestEnvironment.TestData <BaPersonTestData>().Vasquez;

            // Act
            byte[] rowversionBefore;
            using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
            {
                var context  = IntegrationTestEnvironment.Container.GetInstance <IDbContext>();
                var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();

                var person = await personen.GetById(testPerson.BaPersonID);

                rowversionBefore = testPerson.BaPersonTs;
                person.Vorname  += "test";
                await personen.InsertOrUpdateEntity(person);

                await context.SaveChangesAsync();
            }

            // Assert
            using (new EnsureExecutionScope(IntegrationTestEnvironment.Container))
            {
                var personen = IntegrationTestEnvironment.Container.GetInstance <IRepository <BaPerson> >();

                var personAssert = await personen.GetById(testPerson.BaPersonID);

                personAssert.ShouldNotBeNull();
                var rowversionAfter = personAssert.BaPersonTs;
                rowversionAfter.ShouldNotBe(rowversionBefore);
            }
        }
示例#23
0
        public async Task Handle_ErrorOccuredDuringCreationOfAmazonUser_DoesNothing()
        {
            //Arrange
            var fakeAmazonIdentityManagementService = Substitute.For <IAmazonIdentityManagementService>();

            fakeAmazonIdentityManagementService
            .CreateUserAsync(Arg.Any <CreateUserRequest>())
            .Throws(new TestException());

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services => services.AddSingleton(fakeAmazonIdentityManagementService)
            });

            //Act
            var exception = await Assert.ThrowsExceptionAsync <TestException>(async() =>
                                                                              await environment.Mediator.Send(new EnsureAmazonUserWithNameCommand("some-name")));

            //Assert
            Assert.IsNotNull(exception);

            await environment.WithFreshDataContext(async dataContext =>
            {
                var userFromDatabase = await dataContext.AmazonUsers.SingleOrDefaultAsync();
                Assert.IsNull(userFromDatabase);
            });
        }
示例#24
0
        public async Task SavePersonInvalid()
        {
            var client = await IntegrationTestEnvironment.GetClient(TestUser.Administrator);

            var result = await client.GetAsJsonAsync <BaPerson>("api/personen/64810");

            result.IsSuccess.ShouldBeTrue();
            var person = result.Result;

            person.Id.ShouldBe(64810);
            person.Name.ShouldNotBeNull();

            person.Name = null;

            var postResult = await client.PostAsJsonAsync("api/personen/64810", person);

            postResult.HttpResult.ShouldBe(HttpStatusCode.BadRequest);

            var errorResult = postResult as ServiceResult <ErrorDto[]>;

            errorResult.ShouldNotBeNull();
            errorResult.Result.Length.ShouldBe(1);
            var errorDto = errorResult.Result[0];

            errorDto.PropertyName.ShouldBe(nameof(BaPerson.Name));
        }
示例#25
0
        public async Task Handle_NoUserFoundInDatabase_AddsUserToDatabase()
        {
            //Arrange
            var fakeAmazonIdentityManagementService = Substitute.For <IAmazonIdentityManagementService>();

            fakeAmazonIdentityManagementService
            .CreateAccessKeyAsync(Arg.Any <CreateAccessKeyRequest>())
            .Returns(new CreateAccessKeyResponse()
            {
                AccessKey = new AccessKey()
            });

            await using var environment = await IntegrationTestEnvironment.CreateAsync(new EnvironmentSetupOptions ()
            {
                IocConfiguration = services => services.AddSingleton(fakeAmazonIdentityManagementService)
            });

            //Act
            var user = await environment.Mediator.Send(new EnsureAmazonUserWithNameCommand("some-name"));

            //Assert
            Assert.IsNotNull(user);

            await environment.WithFreshDataContext(async dataContext =>
            {
                var userFromDatabase = await dataContext.AmazonUsers.SingleAsync();
                Assert.IsNotNull(userFromDatabase);
            });
        }
示例#26
0
        public async Task Handle_MultipleInstancesPresent_MatchingInstanceIsReturned()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.Instances.AddAsync(new Instance()
                {
                    Name    = "non-matching-name",
                    PlanId  = "dummy",
                    Cluster = new Cluster()
                });
                await dataContext.Instances.AddAsync(new Instance()
                {
                    Name    = "some-instance-name",
                    PlanId  = "dummy",
                    Cluster = new Cluster()
                });
            });

            //Act
            var result = await environment.Mediator.Send(new GetInstanceByNameQuery("some-instance-name"));

            //Assert
            Assert.IsNotNull(result);
            Assert.AreEqual("some-instance-name", result.Name);
        }
        public async Task Handle_PullDogNotInstalled_ThrowsException()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var user = new User()
            {
                PullDogSettings  = null,
                StripeCustomerId = "dummy"
            };
            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.Users.AddAsync(user);
            });

            //Act
            var exception = await Assert.ThrowsExceptionAsync <InvalidOperationException>(async() =>
                                                                                          await environment.Mediator.Send(new ChangePullDogPlanCommand(
                                                                                                                              user.Id,
                                                                                                                              1337,
                                                                                                                              "some-plan-id")));

            //Assert
            Assert.IsNotNull(exception);
        }
        public async Task Handle_NoClusterIdGivenAndSingleClusterOnUser_ClusterReturned()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var fakeUserId = Guid.NewGuid();

            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.Clusters.AddAsync(new Cluster()
                {
                    User = new User()
                    {
                        Id = fakeUserId,
                        StripeCustomerId = "dummy"
                    }
                });
            });

            //Act
            var cluster = await environment.Mediator.Send(new GetClusterForUserQuery(fakeUserId));

            //Assert
            Assert.IsNotNull(cluster);
        }
        public async Task Handle_SeveralUsers_ReturnsFoundUser()
        {
            //Arrange
            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            await environment.WithFreshDataContext(async dataContext =>
            {
                await dataContext.AmazonUsers.AddAsync(new AmazonUser()
                {
                    Name = "user-1",
                    EncryptedSecretAccessKey = Array.Empty <byte>(),
                    EncryptedAccessKeyId     = Array.Empty <byte>()
                });
                await dataContext.AmazonUsers.AddAsync(new AmazonUser()
                {
                    Name = "user-2",
                    EncryptedSecretAccessKey = Array.Empty <byte>(),
                    EncryptedAccessKeyId     = Array.Empty <byte>()
                });
                await dataContext.AmazonUsers.AddAsync(new AmazonUser()
                {
                    Name = "user-3",
                    EncryptedSecretAccessKey = Array.Empty <byte>(),
                    EncryptedAccessKeyId     = Array.Empty <byte>()
                });
            });

            //Act
            var user = await environment.Mediator.Send(new GetAmazonUserByNameQuery("user-2"));

            //Assert
            Assert.IsNotNull(user);
            Assert.AreEqual("user-2", user.Name);
        }
        public async Task Create_AllStatesCanBeCreated()
        {
            //Arrange
            var stateTypes = typeof(Startup)
                             .Assembly
                             .GetTypes()
                             .Where(x => x.IsClass)
                             .Where(x => !x.IsAbstract)
                             .Where(x => !x.IsNestedPrivate)
                             .Where(x => x
                                    .GetInterfaces()
                                    .Contains(typeof(IProvisioningState)));

            await using var environment = await IntegrationTestEnvironment.CreateAsync();

            var stateFactory = new ProvisioningStateFactory(environment.ServiceProvider);

            //Act
            var stateInstances = stateTypes
                                 .Select(stateType => typeof(IProvisioningStateFactory)
                                         .GetMethod(nameof(IProvisioningStateFactory.Create))
                                         ?.MakeGenericMethod(stateType))
                                 .Where(createMethod => createMethod != null)
                                 .Select(createMethod => createMethod
                                         .Invoke(stateFactory, new object[] { null }))
                                 .ToArray();

            //Assert
            Assert.AreNotEqual(0, stateInstances.Length);

            foreach (var stateInstance in stateInstances)
            {
                Assert.IsNotNull(stateInstance);
            }
        }