public async Task Change_Longitude_When_Invoked()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var longitude = 3;
var latitude = 2;
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensor = new UserSensors
{
Id = 1,
Longitude = 2,
Latitude = 2
};
assertContext.UserSensors.Add(userSensor);
assertContext.SaveChanges();
var userSensorService = new UserSensorService(assertContext);
await userSensorService.ChangeCoordinatesAsync(1, longitude, latitude);
Assert.AreEqual(longitude, userSensor.Longitude);
}
}
public async Task Change_Description_When_Invoked()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var sensorId = 1;
string description = "testchangeddescription";
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensor = new UserSensors
{
Id = 1,
Description = "testinitialdescription"
};
assertContext.UserSensors.Add(userSensor);
assertContext.SaveChanges();
var userSensorService = new UserSensorService(assertContext);
await userSensorService.ChangeDescriptionAsync(sensorId, description);
Assert.AreEqual(description, userSensor.Description);
}
}
public async Task Change_UpdateInterval_When_Invoked()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var sensorId = 1;
int updateInterval = 2;
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensor = new UserSensors
{
Id = 1,
UpdateInterval = 33
};
assertContext.UserSensors.Add(userSensor);
assertContext.SaveChanges();
var userSensorService = new UserSensorService(assertContext);
await userSensorService.ChangeUpdatenIntervalAsync(sensorId, updateInterval);
Assert.AreEqual(updateInterval, userSensor.UpdateInterval);
}
}
public async Task Change_IsPublic_When_Invoked()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var sensorId = 1;
bool isPublic = false;
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensor = new UserSensors
{
Id = 1,
IsPublic = true
};
assertContext.UserSensors.Add(userSensor);
assertContext.SaveChanges();
var userSensorService = new UserSensorService(assertContext);
await userSensorService.ChangeIsPublicAsync(sensorId, isPublic);
Assert.AreEqual(isPublic, userSensor.IsPublic);
}
}
public void ThrowArgumentNullException_WhenNullDataContext()
{
// Arrange
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
// Act
var userSensorService = new UserSensorService(null, sensorServiceMock.Object);
}
public void ThrowArgumentNullException_WhenNullSensorService()
{
// Arrange
Mock <DataContext> dataContextMock = new Mock <DataContext>();
// Act
var userSensorService = new UserSensorService(dataContextMock.Object, null);
}
public void ThrowArgumentNullException_WhenParameterIsNull(string searchText)
{
// Arrange
var dbContextStub = new Mock <smartDormitoryDbContext>();
var userSensorsServiceMock = new UserSensorService(dbContextStub.Object);
// Act and Assert
Assert.ThrowsException <ArgumentNullException>(() => userSensorsServiceMock.TotalContainingText(searchText));
}
public async Task ThrowArgumentException_WhenArgumentsAreIncorrect(int userSensorId, string icbSensorId, string name, string description, double minValue, double maxValue, int pollingInterval, double latitude, double longitude, bool isPublic, bool alarm)
{
// Arrange
var dbContextStub = new Mock <smartDormitoryDbContext>();
var userSensorServiceMock = new UserSensorService(dbContextStub.Object);
// Act and Assert
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await userSensorServiceMock.EditSensor(userSensorId, icbSensorId, name, description, minValue, maxValue, pollingInterval, latitude, longitude, isPublic, alarm));
}
public async Task ThrowArgumentNullException_WhenArgumentsAreNull(string searchByName, string searchByTag, int page, int pageSize)
{
// Arrange
var dbContextStub = new Mock <smartDormitoryDbContext>();
var userSensorsServiceMock = new UserSensorService(dbContextStub.Object);
// Act and Assert
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await userSensorsServiceMock.GetAllUsersSensorsAsync(searchByName, searchByTag, page, pageSize));
}
public async Task ThrowArgumentException_WhenArgumentIsIncorrect(string id)
{
// Arrange
var dbContextStub = new Mock <smartDormitoryDbContext>();
var userSensorServiceMock = new UserSensorService(dbContextStub.Object);
// Act and Assert
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await userSensorServiceMock.UpdateSensorValue(id));
}
public async Task ThrowArgumentNullException_WhenArgumentIsNull(string tag)
{
// Arrange
var dbContextStub = new Mock <smartDormitoryDbContext>();
var userSensorServiceMock = new UserSensorService(dbContextStub.Object);
// Act and Assert
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await userSensorServiceMock.GetSensorsTypeMinMaxValues(tag));
}
public async Task GetSensorsTypeMinMaxValues_WhenArgumentIsCorrect(string tag)
{
// Arrange
contextOptions = new DbContextOptionsBuilder <smartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: "GetSensorsTypeMinMaxValues_WhenArgumentIsCorrect")
.Options;
const double minValue = 5.00;
const double maxValue = 15.00;
using (var assertContext = new smartDormitoryDbContext(contextOptions))
{
await assertContext.Sensors.AddRangeAsync(
new Sensor
{
Id = 1,
PollingInterval = 10,
Description = "Some description",
Tag = tag,
MinValue = minValue,
MaxValue = maxValue,
TimeStamp = DateTime.Now,
Value = 15.00,
Url = "Some URL",
ModifiedOn = DateTime.Now,
},
new Sensor
{
Id = 2,
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinValue = 10.00,
MaxValue = 20.00,
TimeStamp = DateTime.Now,
Value = 15.00,
Url = "Some URL",
ModifiedOn = DateTime.Now,
});
await assertContext.SaveChangesAsync();
}
using (var assertContext = new smartDormitoryDbContext(contextOptions))
{
var userSensorServiceMock = new UserSensorService(assertContext);
// Act
var minMax = new List <double>(await userSensorServiceMock.GetSensorsTypeMinMaxValues(tag));
var min = minMax[0];
var max = minMax[1];
// Assert
Assert.IsTrue(min == minValue);
Assert.IsTrue(max == maxValue);
}
}
public async Task ListSensorByIdAsync_ShouldReturnValidSensor()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "ListSensorByIdAsync_ShouldReturnValidSensor")
.Options;
UserSensor userSensor = new UserSensor
{
AlarmMin = 20,
AlarmMax = 30,
AlarmTriggered = true,
Coordinates = "42.672143,23.292216",
CreatedOn = DateTime.Now,
Description = "Description122",
Id = "82a2e1b1-ea5d-4356-8266-b6b42471653e",
IsPublic = true,
LastValueUser = "******",
Latitude = "42.672143",
Longitude = "23.292216",
Name = "Thermostat temp",
IsDeleted = false,
PollingInterval = 50,
SensorId = "81a2e1b1-ea5d-4356-8266-b6b42471653e",
TimeStamp = DateTime.Now,
Type = "Celsius",
UserId = "81a2e1b1-ea5d-4356-8266-b6b42471665e",
UserInterval = 44
};
var result = new UserSensor();
// Act
using (DataContext actContext = new DataContext(contextOptions))
{
Mock <ISensorService> sensor = new Mock <ISensorService>();
await actContext.UserSensors.AddAsync(userSensor);
await actContext.SaveChangesAsync();
UserSensorService SUT = new UserSensorService(actContext, sensor.Object);
result = await SUT.ListSensorByIdAsync("82a2e1b1-ea5d-4356-8266-b6b42471653e");
}
//Assert
using (DataContext assertContext = new DataContext(contextOptions))
{
Assert.IsTrue(assertContext.UserSensors.Any(s => s.Coordinates.Equals(result.Coordinates)));
Assert.IsTrue(assertContext.UserSensors.Any(s => s.LastValueUser.Equals(result.LastValueUser)));
Assert.IsTrue(assertContext.UserSensors.Any(s => s.SensorId.Equals(result.SensorId)));
}
}
public async Task AddUserSensorAsync_ShouldThrowEntityAlreadyExistsExceptionExceptionsWhenSensorExists()
{
UserSensor validUserSensor = new UserSensor
{
AlarmMin = 20,
AlarmMax = 30,
AlarmTriggered = true,
Coordinates = "42.672143,23.292216",
CreatedOn = DateTime.Now,
Description = "Description122",
Id = "82a2e1b1-ea5d-4356-8266-b6b42471653e",
IsPublic = true,
LastValueUser = "******",
Latitude = "42.672143",
Longitude = "23.292216",
Name = "name example",
IsDeleted = false,
PollingInterval = 50,
SensorId = "81a2e1b1-ea5d-4356-8266-b6b42471653e",
TimeStamp = DateTime.Now,
Type = "Celsius",
UserId = "81a2e1b1-ea5d-4356-8266-b6b42471665e",
UserInterval = 44,
Sensor = new Sensor {
Id = "81a2e1b1-ea5d-4356-8266-b6b42471653e",
SensorId = "81a2e1b1-ea5d-4356-8266-b6b42471653e"
}
};
// Arrange
var contextOptions = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "AddUserSensorAsync_ShouldThrowEntityAlreadyExistsExceptionExceptionsWhenSensorExists")
.Options;
var result = new UserSensor();
// Act
using (DataContext actContext = new DataContext(contextOptions))
{
Mock <ISensorService> sensor = new Mock <ISensorService>();
await actContext.UserSensors.AddAsync(validUserSensor);
await actContext.SaveChangesAsync();
UserSensorService SUT = new UserSensorService(actContext, sensor.Object);
await SUT.AddUserSensorAsync(validUserSensor.Id, validUserSensor.SensorId, validUserSensor.Name, validUserSensor.Description, validUserSensor.Latitude,
validUserSensor.Longitude, validUserSensor.AlarmMin, validUserSensor.AlarmMax, validUserSensor.PollingInterval, validUserSensor.AlarmTriggered,
validUserSensor.IsPublic, validUserSensor.LastValueUser, validUserSensor.Type);
}
}
public async Task ThrowArgumentNullException_WhenICBSensorDoesNotExist(int userSensorId, string icbSensorId, string name, string description, double minValue, double maxValue, int pollingInterval, double latitude, double longitude, bool isPublic, bool alarm)
{
// Arrange
contextOptions = new DbContextOptionsBuilder <smartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: "ThrowArgumentNullException_WhenICBSensorDoesNotExist")
.Options;
using (var assertContext = new smartDormitoryDbContext(contextOptions))
{
await assertContext.Sensors.AddRangeAsync(
new Sensor
{
Id = 1,
IcbSensorId = "Another icbSensorId",
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinValue = 10.00,
MaxValue = 20.00,
TimeStamp = DateTime.Now,
Value = 15.00,
Url = "Some URL",
ModifiedOn = DateTime.Now,
},
new Sensor
{
Id = 2,
IcbSensorId = "Another icbSensorId 1",
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinValue = 10.00,
MaxValue = 20.00,
TimeStamp = DateTime.Now,
Value = 15.00,
Url = "Some URL",
ModifiedOn = DateTime.Now,
});
await assertContext.SaveChangesAsync();
}
// Act and Assert
using (var assertContext = new smartDormitoryDbContext(contextOptions))
{
var userSensorServiceMock = new UserSensorService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await userSensorServiceMock.EditSensor(userSensorId, icbSensorId, name, description, minValue, maxValue, pollingInterval, latitude, longitude, isPublic, alarm));
}
}
public async Task ThrowArgumentException_WhenMaxValueIsOutOfSensorValueRange(string userId, int sensorId, string name, string description, double minValue, double maxValue, int pollingInterval, double latitude, double longitude, bool isPublic, bool alarm, string imageUrl)
{
// Arrange
contextOptions = new DbContextOptionsBuilder <smartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: "ThrowArgumentException_WhenMaxValueIsOutOfSensorValueRange")
.Options;
int existID = sensorId;
using (var assertContext = new smartDormitoryDbContext(contextOptions))
{
await assertContext.Sensors.AddRangeAsync(
new Sensor
{
Id = existID,
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinValue = 10.00,
MaxValue = 20.00,
TimeStamp = DateTime.Now,
Value = 15.00,
Url = "Some URL",
ModifiedOn = DateTime.Now,
},
new Sensor
{
Id = 2,
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinValue = 10.00,
MaxValue = 20.00,
TimeStamp = DateTime.Now,
Value = 15.00,
Url = "Some URL",
ModifiedOn = DateTime.Now,
});
await assertContext.SaveChangesAsync();
}
// Act and Assert
using (var assertContext = new smartDormitoryDbContext(contextOptions))
{
var userSensorServiceMock = new UserSensorService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await userSensorServiceMock.AddSensorAsync(userId, sensorId, name, description, minValue, maxValue, pollingInterval, latitude, longitude, isPublic, alarm, imageUrl));
}
}
public async Task ThrowArgumentNullException_WhenPassedNullId()
{
// Arrange
Mock <DataContext> dataContextMock = new Mock <DataContext>();
Mock <ISensorService> sensorServicetMock = new Mock <ISensorService>();
// Act
UserSensorService SUT = new UserSensorService(
dataContextMock.Object,
sensorServicetMock.Object);
// Assert
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() =>
await SUT.RestoreUserSensor(null));
}
public async Task ThrowException_When_SensorIsNotFound()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var sensorId = 0;
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await userSensorService.FindAsync(sensorId));
}
}
public async Task ThrowArgumentException_WhenPassedInvalidId(string invalidId)
{
// Arrange
Mock <DataContext> dataContextMock = new Mock <DataContext>();
Mock <ISensorService> sensorServicetMock = new Mock <ISensorService>();
// Act
UserSensorService SUT = new UserSensorService(
dataContextMock.Object,
sensorServicetMock.Object);
// Assert
await Assert.ThrowsExceptionAsync <ArgumentException>(async() =>
await SUT.DisableUserSensor(invalidId));
}
public async Task ThrowException_When_DescriptionIsNull()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var sensorId = 1;
string description = null;
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await userSensorService.ChangeDescriptionAsync(sensorId, description));
}
}
public void ReturnNull_When_PassedId_IsInvalid()
{
//Arrange
var contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
// Act && Asert
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
var userSensor = userSensorService.GetUserSensorsById(1);
Assert.IsNull(userSensor);
}
}
public async Task ThrowArgumentOutOfRangeException_WhenPassedInvalidPageSize(int invalidPageSize)
{
// Arrange
Mock <ISensorService> sensorServiceMock = new Mock <ISensorService>();
Mock <DataContext> dataContextMock = new Mock <DataContext>();
string validFilter = string.Empty;
int validPageNumber = 1;
UserSensorService SUT = new UserSensorService(
dataContextMock.Object,
sensorServiceMock.Object);
// Act & Assert
await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(
() => SUT.FilterUserSensorsAsync(validFilter, validPageNumber, invalidPageSize));
}
public void Return_EmptyUserSensorsColletion_WhenUserSensors_IsEmpty()
{
//Arrange
var contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
// Act && Asert
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
var count = userSensorService.UserSensorsCount();
Assert.AreEqual(0, count);
}
}
public void ThrowArgumentNullExc_When_SensorId_IsNull()
{
//Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
// Act && Asert
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => userSensorService.RegisterSensor(0, 0, 10, 99, 40,
"name", "description", false, false,
"0", "userId", null));
}
}
public void ThrowArgumentNullExc_When_NullId_IsPassed()
{
//Arrange
var contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
string UserId = null;
// Act && Asert
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => userSensorService.GetAllUserSensorsByUserDictionary(UserId));
}
}
public async Task ThrowException_When_MinIsGreaterThanMax()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var sensorId = 0;
var min = 3;
var max = 2;
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(async() => await userSensorService.ChangeMinMaxAsync(sensorId, min, max));
}
}
public async Task UpdateUserSensorAsync_ShouldThrowArgumentNullExceptionsWhenUserSensorIsIsNull()
{
// Arrange
var contextOptions = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase(databaseName: "UpdateUserSensorAsync_ShouldThrowArgumentNullExceptionsWhenUserSensorIsIsNull")
.Options;
// Act
using (DataContext actContext = new DataContext(contextOptions))
{
Mock <ISensorService> sensor = new Mock <ISensorService>();
UserSensorService SUT = new UserSensorService(actContext, sensor.Object);
await SUT.UpdateUserSensorAsync(null);
}
}
public void ThrowArgumentOutOfRangeEx_When_UserMinValue_IsBigger_Than_UserMaxValue()
{
//Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
// Act && Asert
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
Assert.ThrowsException <ArgumentOutOfRangeException>(() => userSensorService.RegisterSensor(0, 0, 10, 9, 40,
"name", "description", false, false,
"0", "userId", "1"));
}
}
public void ReturnUserSensor_When_PassedId_IsValid()
{
//Arrange
var contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var UserId = Guid.NewGuid().ToString();
using (var arrangeContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensor = new UserSensors
{
Id = 1,
UserId = UserId,
Value = 10,
Description = "Description",
Name = "Name",
MinValue = 1,
MaxValue = 100,
UpdateInterval = 60,
Type = 1,
LastUpdatedOn = DateTime.Now,
IsPublic = false,
IsRequiredNotification = false,
Latitude = 0,
Longitude = 0,
UserMaxValue = 99,
UserMinValue = 2,
SensorId = 1
};
arrangeContext.UserSensors.Add(userSensor);
arrangeContext.SaveChanges();
}
// Act && Asert
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
var userSensor = userSensorService.GetUserSensorsById(1);
Assert.AreEqual(userSensor.UserId, UserId);
}
}
public async Task ThrowException_When_MinIsLessThanSensorMin()
{
contextOptions = new DbContextOptionsBuilder <SmartDormitoryDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var ApiID = Guid.NewGuid().ToString();
using (var arrangeContext = new SmartDormitoryDbContext(contextOptions))
{
var sensorForDB = new Sensor
{
Id = 1,
ApiId = ApiID,
CurrentValue = 10,
Description = "Description",
Name = "Name",
MinValue = 1,
MaxValue = 100,
MinPollingIntervalInSeconds = 60,
SensorTypeId = 1,
LastUpdate = DateTime.Now,
};
var userSensorForDB = new UserSensors
{
Id = 1,
UserMinValue = 1,
UserMaxValue = 100,
SensorId = 1
};
arrangeContext.UserSensors.Add(userSensorForDB);
arrangeContext.Sensors.Add(sensorForDB);
arrangeContext.SaveChanges();
}
// Act && Asert
using (var assertContext = new SmartDormitoryDbContext(contextOptions))
{
var userSensorService = new UserSensorService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentOutOfRangeException>(async() => await userSensorService.ChangeMinMaxAsync(1, 0, 1));
}
}
