Esempio n. 1
0
        public static async Task DeleteOrganizationAsync(BackendFixtureFactory factory, OrganizationDto organization)
        {
            // Arrange
            using var client = factory.CreateAdminClient();

            // Act
            var response = await client.DeleteAsync($"api/admin/organization/{organization.Id}");

            // Assert
            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
        }
Esempio n. 2
0
        public static async Task DeleteInquiryAsync(BackendFixtureFactory factory, InquiryDto inquiry)
        {
            // Arrange
            using var client = factory.CreateClient(OrganizationRole.Superuser);

            // Act
            var response = await client.DeleteAsync($"api/inquiry/{inquiry.Id}");

            // Assert
            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
        }
Esempio n. 3
0
        public static async Task DeleteIncidentAsync(BackendFixtureFactory factory, IncidentDto incident)
        {
            // Arrange
            using var client = factory.CreateClient();

            // Act
            var response = await client.DeleteAsync($"api/incident/{incident.Id}");

            // Assert
            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
        }
Esempio n. 4
0
        public static async Task <OrganizationSetupDto> CreateOrganizationAsync(BackendFixtureFactory factory, OrganizationProposalDto organization)
        {
            // Arrange
            using var client = factory.CreateUnauthorizedClient();
            var newObject = new OrganizationSetupDtoFaker().Generate();

            // Act
            var response = await client.PostAsJsonAsync($"api/organization/{organization.Id}/setup", newObject);

            // Assert
            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);

            return(newObject);
        }
Esempio n. 5
0
        public static async Task <OrganizationDto> GetOrganizationAsync(BackendFixtureFactory factory, OrganizationProposalDto organization)
        {
            // Arrange
            using var client = factory.CreateAdminClient();

            // Act
            var response = await client.GetAsync($"api/admin/organization/{organization.Id}");

            var returnObject = await response.Content.ReadFromJsonAsync <OrganizationDto>();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(organization.Id, returnObject.Id);

            return(returnObject);
        }
Esempio n. 6
0
        public static async Task <OrganizationProposalDto> CreateProposalAsync(BackendFixtureFactory factory)
        {
            // Arrange
            using var client = factory.CreateAdminClient();
            var newObject = new OrganizationProposalDtoFaker().Generate();

            // Act
            var response = await client.PostAsJsonAsync("api/organization/proposal", newObject);

            var returnObject = await response.Content.ReadFromJsonAsync <OrganizationProposalDto>();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(newObject.Name, returnObject.Name);

            return(returnObject);
        }
Esempio n. 7
0
        public static async Task <InquirySampleDto> CreateInquirySampleAsync(BackendFixtureFactory factory, InquiryDto inquiry)
        {
            using var client = factory.CreateClient(OrganizationRole.Writer);
            var newObject = new InquirySampleDtoFaker()
                            .RuleFor(f => f.Address, f => "gfm-351cc5645ab7457b92d3629e8c163f0b")
                            .Generate();

            // Act
            var response = await client.PostAsJsonAsync($"api/inquiry/{inquiry.Id}/sample", newObject);

            var returnObject = await response.Content.ReadFromJsonAsync <InquirySampleDto>();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(inquiry.Id, returnObject.Inquiry);
            Assert.Equal(newObject.Address, returnObject.Address);

            return(returnObject);
        }
Esempio n. 8
0
        public static async Task <IncidentDto> CreateIncidentAsync(BackendFixtureFactory factory)
        {
            // Arrange
            var incident = new IncidentDtoFaker()
                           .RuleFor(f => f.Address, f => "gfm-351cc5645ab7457b92d3629e8c163f0b")
                           .Generate();

            using var client = factory.CreateClient();

            // Act
            var response = await client.PostAsJsonAsync("api/incident", incident);

            var returnObject = await response.Content.ReadFromJsonAsync <IncidentDto>();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.StartsWith("FIR", returnObject.Id, StringComparison.InvariantCulture);
            Assert.Equal(AuditStatus.Todo, returnObject.AuditStatus);

            return(returnObject);
        }
Esempio n. 9
0
        public static async Task <RecoveryDto> CreateRecoveryAsync(BackendFixtureFactory factory)
        {
            // Arrange
            using var client = factory.CreateClient(OrganizationRole.Writer);
            var newObject = new RecoveryDtoFaker()
                            .RuleFor(f => f.Reviewer, f => Guid.Parse("21c403fe-45fc-4106-9551-3aada1bbdec3"))
                            .RuleFor(f => f.Contractor, f => Guid.Parse("62af863e-2021-4438-a5ea-730ed3db9eda"))
                            .Generate();

            // Act
            var response = await client.PostAsJsonAsync("api/recovery", newObject);

            var returnObject = await response.Content.ReadFromJsonAsync <RecoveryDto>();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(AuditStatus.Todo, returnObject.AuditStatus);
            Assert.Null(returnObject.UpdateDate);

            return(returnObject);
        }
Esempio n. 10
0
        public static async Task <RecoverySampleDto> CreateRecoverySampleAsync(BackendFixtureFactory factory, RecoveryDto recovery)
        {
            // Arrange
            using var client = factory.CreateClient(OrganizationRole.Writer);
            var newObject = new RecoverySampleDtoFaker()
                            .RuleFor(f => f.Address, f => "gfm-351cc5645ab7457b92d3629e8c163f0b")
                            .RuleFor(f => f.Contractor, f => Guid.Parse("62af863e-2021-4438-a5ea-730ed3db9eda"))
                            .Generate();

            // Act
            var response = await client.PostAsJsonAsync($"api/recovery/{recovery.Id}/sample", newObject);

            var returnObject = await response.Content.ReadFromJsonAsync <RecoverySampleDto>();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(recovery.Id, returnObject.Recovery);
            Assert.Equal(newObject.Address, returnObject.Address);

            return(returnObject);
        }
Esempio n. 11
0
        public static async Task <OrganizationUserPasswordDto> CreateOrganizationUserAsync(BackendFixtureFactory factory, OrganizationDto organization)
        {
            // Arrange
            using var client = factory.CreateAdminClient();
            var newObject = new OrganizationUserPasswordDtoFaker().Generate();

            // Act
            var response = await client.PostAsJsonAsync($"api/admin/organization/{organization.Id}/user", newObject);

            var returnObject = await response.Content.ReadFromJsonAsync <UserDto>();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(newObject.GivenName, returnObject.GivenName);
            Assert.Equal(newObject.LastName, returnObject.LastName);
            Assert.Equal(newObject.Email, returnObject.Email);
            Assert.Equal(newObject.Avatar, returnObject.Avatar);
            Assert.Equal(newObject.JobTitle, returnObject.JobTitle);
            Assert.Equal(newObject.PhoneNumber, returnObject.PhoneNumber);
            Assert.Equal(newObject.Role, returnObject.Role);

            return(newObject with
            {
                Id = returnObject.Id
            });
        }