public async Task GetReadingsUsingDeviceId_WithReadingsAvailable_ReturnsReadings()
        {
            //Arrange
            var dbContext          = DbContextMocker.GetDbContext(nameof(GetReadingsUsingDeviceId_WithReadingsAvailable_ReturnsReadings));
            var readingsController = new ReadingsController(dbContext);
            var expectedReadings   = new List <Reading> {
            };

            expectedReadings.Add(new Reading()
            {
                Device_id = 1, Timestamp = 1000, Reading_type = "typeTest1", Raw_value = 10
            });
            expectedReadings.Add(new Reading()
            {
                Device_id = 1, Timestamp = 1001, Reading_type = "typeTest2", Raw_value = 20
            });
            expectedReadings.Add(new Reading()
            {
                Device_id = 1, Timestamp = 1002, Reading_type = "typeTest3", Raw_value = 30
            });

            //Act
            var response = await readingsController.GetReadingsUsingDeviceId(1);

            var result           = (ObjectResult)response.Result;
            var readingsReceived = result.Value.As <List <Reading> >();

            dbContext.Dispose();

            //Assert
            result.StatusCode.Should().Be((int)HttpStatusCode.OK);
            Assert.True(ReadingsComparer.CompareReadingsLists(readingsReceived, expectedReadings), "Received readings list did " +
                        "not match with the expected");
        }
Esempio n. 2
0
        public async Task GetReadingsUsingDeviceId_Startingdate_WithReadingsAvailable_ReturnsReadings()
        {
            //Arrange
            CreateDeviceRequest deviceRequest = new CreateDeviceRequest {
                Name = "testGetStartingDateName1", Location = "testGetStartingDateLocation1"
            };

            var insertDeviceSqlString = $"Insert into Devices (Name, Location) values('{deviceRequest.Name}', '{deviceRequest.Location}')";

            ExecuteNonQuery(insertDeviceSqlString);

            var selectSqlStringDevice1 = $"Select * from Devices WHERE Name = '{deviceRequest.Name}'";
            var device = ExecuteDevicesQuery(selectSqlStringDevice1);

            Assert.NotNull(device);

            Reading reading1 = new Reading {
                Device_id = device.Device_id, Timestamp = 1000, Reading_type = "typeTest1", Raw_value = 10
            };
            Reading reading2 = new Reading {
                Device_id = device.Device_id, Timestamp = 1001, Reading_type = "typeTest2", Raw_value = 20
            };

            var insertReadingsSqlString = "Insert into Readings (Device_id, Timestamp, Reading_type, Raw_value)" +
                                          $" values({device.Device_id}, {reading1.Timestamp}, '{reading1.Reading_type}', {reading1.Raw_value})," +
                                          $" ({device.Device_id}, {reading2.Timestamp}, '{reading2.Reading_type}', {reading2.Raw_value})";

            ExecuteNonQuery(insertReadingsSqlString);

            var startingDatetime = 1000;

            string requestUri = $"Readings/{device.Device_id}/{startingDatetime}";

            // Act
            var response = await HttpClient.GetAsync(requestUri);

            var receivedReadingList = await response.Content.ReadAsAsync <List <Reading> >();

            //Assert
            response.StatusCode.Should().Be(HttpStatusCode.OK);

            Assert.True(ReadingsComparer.DoesReadingsListContainSpecificReading(receivedReadingList, reading1), "The reading list received " +
                        "does not contain the expected reading");
            Assert.True(ReadingsComparer.DoesReadingsListContainSpecificReading(receivedReadingList, reading2), "The reading list received " +
                        "does not contain the expected reading");

            //Clean Up
            var cleanUpReadingsSqlString = $"DELETE From Readings WHERE Device_id = {device.Device_id}";
            var cleanedUpReadings        = ExecuteNonQuery(cleanUpReadingsSqlString);

            Assert.True(cleanedUpReadings, "It was not possible to clean up the created readings database.");


            var cleanUpDevicesSqlString = $"DELETE From Devices WHERE Device_id = {device.Device_id}";
            var cleanedUpDevices        = ExecuteNonQuery(cleanUpDevicesSqlString);

            Assert.True(cleanedUpDevices, "It was not possible to clean up the created devices database.");
        }
        public async Task Create_ValidParameters_ReadingIsAdded()
        {
            //Arrange
            var dbContext          = DbContextMocker.GetDbContext(nameof(Create_ValidParameters_ReadingIsAdded));
            var readingsController = new ReadingsController(dbContext);
            var expectedReading    = new Reading {
                Device_id = 2, Timestamp = 1010, Reading_type = "typeTest10", Raw_value = 60
            };

            //Act
            var response = await readingsController.Create(expectedReading);

            var result          = (ObjectResult)response.Result;
            var readingReceived = result.Value.As <Reading>();

            dbContext.Dispose();

            //Assert
            result.StatusCode.Should().Be((int)HttpStatusCode.Created);
            Assert.True(ReadingsComparer.CompareReadings(readingReceived, expectedReading), "Received reading did not " +
                        "match the expected.");
        }