Example #1
0
        public async Task Update_Returns204NoContentStatusCode_WhenCreatedInDatabase()
        {
            // Arrange
            var gatewayIps = await GenerateGatewayIpsAsync(1);

            var devicesData = DeviceUtilities.GenerateDevicesRequestDataWithUniqueVendors(9, gatewayIps)
                              .OrderBy(x => x.Vendor)
                              .ToArray();

            var createdDevices = (await DeviceUtilities.CreateDevicesAsync(TestHttpClient, devicesData))
                                 .OrderBy(x => x.Vendor)
                                 .ToArray();

            var updatedDevicesData = devicesData
                                     .Select(x => new UpdateDeviceRequest {
                Status    = x.Status,
                Vendor    = x.Vendor?.Replace("device", "changed device"),
                GatewayId = x.GatewayId
            })
                                     .ToArray();

            // Act
            var devicesResponses = await Task.WhenAll(
                createdDevices
                .Zip(updatedDevicesData)
                .Select(x => TestHttpClient.PutAsJsonAsync($"{DeviceApiRoot}/{x.First.UID}", x.Second))
                );

            // Assert
            devicesResponses.Select(x => x.StatusCode)
            .Should().AllBeEquivalentTo(HttpStatusCode.NoContent);
        }
Example #2
0
        Delete_Returns200OkStatusCodeWhenDeletes_Returns404NotFoundStatusCodeAfterDeleted_WhenCreatedInDatabase()
        {
            // Arrange
            var gatewayIps = await GenerateGatewayIpsAsync(5);

            var devicesData = DeviceUtilities.GenerateDevicesRequestDataWithUniqueVendors(9, gatewayIps)
                              .OrderBy(x => x.Vendor)
                              .ToArray();
            var createdDevices = (await Task.WhenAll(
                                      devicesData.Select(async x => {
                var message = await TestHttpClient.PostAsJsonAsync(DeviceApiRoot, x);
                return(await message.Content.ReadAsAsync <DeviceResponse>());
            })
                                      ))
                                 .OrderBy(x => x.Vendor)
                                 .ToArray();

            // Act
            var devicesDeletedResponses = await Task.WhenAll(
                createdDevices.Select(x => TestHttpClient.DeleteAsync($"{DeviceApiRoot}/{x.UID}"))
                );

            var devices = (await Task.WhenAll(
                               devicesDeletedResponses.Select(x => x.Content.ReadAsAsync <DeviceResponse>())
                               ))
                          .OrderBy(x => x.Vendor)
                          .ToArray();
            var devicesAfterDeletedResponses = await Task.WhenAll(
                createdDevices.Select(x => TestHttpClient.DeleteAsync($"{DeviceApiRoot}/{x.UID}"))
                );

            // Assert
            devicesDeletedResponses.Select(x => x.StatusCode)
            .Should().AllBeEquivalentTo(HttpStatusCode.OK);
            devicesAfterDeletedResponses.Select(x => x.StatusCode)
            .Should().AllBeEquivalentTo(HttpStatusCode.NotFound);

            var valueTuples = devices
                              .Zip(devicesData)
                              .Zip(createdDevices, (x, cg) => (x.First, x.Second, cg));

            foreach (var(device, data, createdDevice) in valueTuples)
            {
                device.UID.Should().Be(createdDevice.UID);
                device.Vendor.Should().Be(data.Vendor);
                device.Vendor.Should().Be(createdDevice.Vendor);
            }
        }
Example #3
0
        public async Task GetAll_ReturnsPagedData_WhenCreatedInDatabase()
        {
            // Arrange
            await DeviceUtilities.CreateDevicesAsync(TestHttpClient, 9);

            // Act
            var response = await TestHttpClient.GetAsync(DeviceApiRoot);

            // Assert
            var pagedData = await response.Content.ReadAsAsync <PagedData <DeviceResponse> >();

            response.StatusCode.Should().Be(HttpStatusCode.OK);
            pagedData.Should().NotBeNull();
            pagedData.Items.Should().HaveCount(9);
            pagedData.TotalCount.Should().Be(9);
            pagedData.PageSize.Should().Be(10);
            pagedData.CurrentPage.Should().Be(1);
        }
Example #4
0
        public async Task Get_ReturnsDeviceResponse_WhenCreatedInDatabase()
        {
            // Arrange
            var afterCreatedDateTime = DateTime.UtcNow;
            var gatewayIps           = await GenerateGatewayIpsAsync(5);

            var devicesData = DeviceUtilities.GenerateDevicesRequestDataWithUniqueVendors(9, gatewayIps)
                              .OrderBy(x => x.Vendor)
                              .ToArray();
            var createdDevices = (await DeviceUtilities.CreateDevicesAsync(TestHttpClient, devicesData))
                                 .OrderBy(x => x.Vendor)
                                 .ToArray();

            // Act
            var devicesResponses = await Task.WhenAll(
                createdDevices.Select(x => TestHttpClient.GetAsync($"{DeviceApiRoot}/{x.UID}"))
                );

            var devices = (await Task.WhenAll(
                               devicesResponses.Select(x => x.Content.ReadAsAsync <DeviceResponse>())
                               ))
                          .OrderBy(x => x.Vendor)
                          .ToArray();

            // Assert
            devicesResponses.Select(x => x.StatusCode)
            .Should().AllBeEquivalentTo(HttpStatusCode.OK);

            var valueTuples = devices
                              .Zip(devicesData)
                              .Zip(createdDevices, (x, cg) => (x.First, x.Second, cg));

            foreach (var(device, data, createdDevice) in valueTuples)
            {
                device.UID.Should().Be(createdDevice.UID);
                device.Vendor.Should().Be(data.Vendor).And.Be(createdDevice.Vendor);
                device.Status.Should().Be(data.Status).And.Be(createdDevice.Status);
                device.GatewayId.Should().Be(data.GatewayId).And.Be(createdDevice.GatewayId);
                Math.Abs((device.DateCreated - afterCreatedDateTime).TotalSeconds).Should().BeLessOrEqualTo(20);
            }
        }