public async Task DeleteNotification_WhenPassedValidId()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "DeleteNotification_WhenPassedValidId")
.Options;
var existingId = Guid.NewGuid().ToString();
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
await assertContext.Notifications.AddRangeAsync(new Notification
{
Id = existingId,
Message = "Some message",
Title = "Some title",
IsDeleted = false,
});
await assertContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new NotificationService(assertContext);
await sut.Delete(existingId);
Assert.IsTrue(assertContext.Notifications.Any(n => n.Id == existingId && n.IsDeleted == true));
}
}
public async Task Successfully_Register_Sensor_When_Parameters_Are_Valid()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Successfully_Register_Sensor_When_Parameters_Are_Valid")
.Options;
string icbSensorId = Guid.NewGuid().ToString();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.IcbSensors.AddAsync(new IcbSensor()
{
Id = icbSensorId
});
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var result = await sut.RegisterNewSensor("userId", icbSensorId, "name", "desc", 50,
true, true, 40, 50, 20.5, 40.5, true);
var sensorsCount = await assertContext.Sensors.CountAsync();
var sensor = await assertContext.Sensors.FirstOrDefaultAsync(x => x.Id == result);
Assert.AreEqual(result, sensor.Id);
Assert.AreEqual(1, sensorsCount);
}
}
public async Task ReturnCorrectSensorsList_WhenCalled()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "ReturnCorrectSensorsCount_WhenCalled")
.Options;
var existingId = Guid.NewGuid().ToString();
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
await assertContext.IcbSensors.AddRangeAsync(new IcbSensor
{
Id = existingId,
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinRangeValue = 10,
MaxRangeValue = 20,
IsDeleted = false
});
await assertContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var measureTypeServiceMock = new Mock <IMeasureTypeService>();
var sut = new IcbSensorsService(assertContext, measureTypeServiceMock.Object);
IEnumerable <IcbSensor> result = await sut.GetAll();
Assert.IsTrue(result.Count() == 1);
}
}
public async Task Successfully_Update_Sensor_When_Parameters_Are_Valid()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Successfully_Update_Sensor_When_Parameters_Are_Valid")
.Options;
var sensor = SetupFakeSensor();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var resultId = await sut.Update(sensor.Id, sensor.UserId, sensor.IcbSensorId,
sensor.Name, sensor.Description, sensor.PollingInterval, sensor.IsPublic,
sensor.AlarmOn, sensor.MinRangeValue, sensor.MaxRangeValue,
sensor.Coordinates.Longitude, sensor.Coordinates.Latitude, sensor.SwitchOn);
var resultSensor = await assertContext.Sensors.FirstOrDefaultAsync(s => s.Id == sensor.Id);
Assert.AreEqual(resultSensor.ModifiedOn.Value.Day, DateTime.Now.Day);
Assert.AreEqual(resultSensor.Id, sensor.Id);
}
}
public async Task Return_Valid_Sensor_Enumerable()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "GetAllUserCoordinates_Private_Return_Valid_Sensor_Enumerable")
.Options;
var userId = Guid.NewGuid().ToString();
var sensor = SetupFakeSensor();
var sensor2 = SetupFakeSensor();
sensor2.IsPublic = true;
sensor.UserId = userId;
sensor2.UserId = userId;
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddRangeAsync(new List <Sensor>() { sensor, sensor2 });
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var sensors = await sut.GetAllUserCoordinates(userId);
Assert.AreEqual(2, sensors.Count());
}
}
public async Task Restore_Sensor_When_Exists_And_Is_Deleted()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Restore_Sensor_When_Exists_And_Is_Deleted")
.Options;
var sensor = SetupFakeSensor();
sensor.IsDeleted = true;
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext,
measureTypeServiceMock.Object);
await sut.DeleteSensor(sensor.Id);
var result = await assertContext.Sensors.FirstOrDefaultAsync(s => s.Id == sensor.Id);
Assert.IsFalse(result.IsDeleted);
}
}
public async Task ReturnTrue_WhenMeasureTypeExists()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "ReturnTrue_WhenMeasureTypeExists")
.Options;
var existingId = Guid.NewGuid().ToString();
var existingMeasureUnit = "ExistingMeasureUnit";
var existingSensorType = "ExistingSensorType";
var existingMeasureType = new MeasureType
{
Id = existingId,
MeasureUnit = existingMeasureUnit,
SuitableSensorType = existingSensorType,
IsDeleted = false
};
using (var arrangeContext = new SmartDormitoryContext(contextOptions))
{
await arrangeContext.MeasureTypes.AddAsync(existingMeasureType);
await arrangeContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new MeasureTypeService(assertContext);
var result = await sut.Exists(existingId);
Assert.IsTrue(result);
}
}
public async Task Return_Sensor_When_Id_Is_Found()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Gauge_Return_Sensor_When_Id_Is_Found")
.Options;
var sensor = SetupFakeSensor();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext,
measureTypeServiceMock.Object);
var result = await sut.GetGaugeData(sensor.Id);
Assert.AreEqual(result.CurrentValue, sensor.CurrentValue);
}
}
public async Task Return_Valid_Sensors_List()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Return_Valid_Sensors_List")
.Options;
var sensor = SetupFakeSensor();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var result = await sut.GetAllForUpdate();
Assert.AreEqual(1, result.Count());
}
}
public async Task Return_Valid_Sensor_Enumerable_When_MeasureType_Is_Not_Default()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase
(databaseName: "GetUserSensorsReturn_Return_Valid_Sensor_Enumerable_When_MeasureType_Is_Not_Default")
.Options;
var sensor = SetupFakeSensor();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
measureTypeServiceMock
.Setup(x => x.Exists(It.IsAny <string>()))
.ReturnsAsync(true);
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var sensors = await sut.GetUserSensors(sensor.UserId, "", "temperature", -1, -1);
Assert.AreEqual(1, sensors.Count());
}
}
public async Task ReturnCorrectCount_WhenPassedValidId()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "ReturnCorrectCount_WhenPassedValidId")
.Options;
var existingId = Guid.NewGuid().ToString();
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
await assertContext.Notifications.AddRangeAsync(new Notification
{
Id = Guid.NewGuid().ToString(),
Message = "Some message",
Title = "Some title",
IsDeleted = false,
ReceiverId = existingId
});
await assertContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new NotificationService(assertContext);
var result = await sut.GetUnseenCount(existingId);
Assert.IsTrue(result == 1);
}
}
public async Task Return_Null_When_Id_Is_Not_Found()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Sensor_Return_Null_When_Id_Is_Not_Found")
.Options;
var sensor = SetupFakeSensor();
sensor.IsDeleted = true;
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext,
measureTypeServiceMock.Object);
var result = await sut.GetSensorById(sensor.Id);
Assert.AreEqual(null, result);
}
}
public async Task Successfully_Call_AddRole_Method_When_Parameters_Are_Valid()
{
// BAD TEST - NOT ISOLATED
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "RemoveRole_Successfully_Call_AddRole_Method_When_Parameters_Are_Valid")
.Options;
string userId = Guid.NewGuid().ToString();
user = new User()
{
Id = userId,
UserName = "******"
};
userManagerMock = MockUserManager <User>();
roleManagerMock = MockRoleManager();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var userService = new UserService(assertContext, userManagerMock.Object, roleManagerMock.Object);
await userService.RemoveRole(userId, It.IsAny <string>());
userManagerMock.Verify(x => x.RemoveFromRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Once);
}
}
public async Task NotAddSensor_WhenPassedInvalidMeasureType()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: " NotAddSensor_WhenPassedInvalidMeasureType")
.Options;
var newSensor = new ApiSensorDetailsDTO
{
ApiSensorId = Guid.NewGuid().ToString(),
MinPollingIntervalInSeconds = 10,
Description = "Some description",
Tag = "Some tag",
MeasureType = "Inexisting measure type"
};
var sensorsToAdd = new List <ApiSensorDetailsDTO>()
{
newSensor
};
// Act and assert
using (var actContext = new SmartDormitoryContext(contextOptions))
{
var measureTypeServiceMock = new Mock <IMeasureTypeService>();
var sut = new IcbSensorsService(actContext, measureTypeServiceMock.Object);
await sut.AddSensors(sensorsToAdd);
var actualCount = await actContext.IcbSensors.CountAsync();
Assert.AreEqual(0, actualCount);
}
}
public async Task Return_Valid_Sensor_Enumerable()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Private_Return_Valid_Sensor_Enumerable")
.Options;
var sensor = SetupFakeSensor();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var sensors = await sut.GetAllUserPrivateCoordinates(sensor.UserId);
Assert.AreEqual(1, sensors.Count());
}
}
public async Task Return_Valid_Sensor_Enumerable_When_SearchTerm_Is_Not_Default()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase
(databaseName: "GetUserSensorsReturn_Return_Valid_Sensor_Enumerable_When_SearchTerm_Is_Not_Default")
.Options;
var sensor = SetupFakeSensor();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var sensors = await sut.GetUserSensors(sensor.UserId, "description", "all", -1, -1);
Assert.AreEqual(1, sensors.Count());
}
}
public async Task Return_Valid_Sensor_Enumerable_When_Passed_Parameters_Are_Default()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Return_Valid_Sensor_Enumerable_When_Passed_Parameters_Are_Default")
.Options;
var sensor = SetupFakeSensor();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var sensors = await sut.AllAdmin();
Assert.AreEqual(1, sensors.Count());
}
}
public async Task Return_Valid_Sensor_Enumerable_When_MeasureType_Is_Boolean_False()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase
(databaseName: "GetUserSensorsReturn_Return_Valid_Sensor_Enumerable_When_MeasureType_Is_Boolean_False")
.Options;
var sensor = SetupFakeSensor();
sensor.IcbSensor.MeasureType.SuitableSensorType = "Boolean switch (door/occupancy/etc)";
sensor.CurrentValue = 0;
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Sensors.AddAsync(sensor);
await actContext.SaveChangesAsync();
}
measureTypeServiceMock
.Setup(x => x.Exists(It.IsAny <string>()))
.ReturnsAsync(true);
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new SensorsService(assertContext, measureTypeServiceMock.Object);
var sensors = await sut.GetUserSensors(sensor.UserId, "",
"all", -1, -1);
Assert.AreEqual(1, sensors.Count());
}
}
public async Task RestoreMeasureType_IfItIsSoftDeleted()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "RestoreMeasureType_IfItIsSoftDeleted")
.Options;
var deletedId = Guid.NewGuid().ToString();
var deletedMeasureUnit = "Some soft deleted measure unit";
var deletedSuitableSensorType = "Some soft deleted sensor type";
using (var arrangeContext = new SmartDormitoryContext(contextOptions))
{
await arrangeContext.MeasureTypes.AddAsync(
new MeasureType
{
Id = deletedId,
MeasureUnit = deletedMeasureUnit,
SuitableSensorType = deletedSuitableSensorType,
IsDeleted = true
});
await arrangeContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new MeasureTypeService(assertContext);
await sut.Create(deletedMeasureUnit, deletedSuitableSensorType);
Assert.IsTrue(assertContext.MeasureTypes.Any(mt => mt.Id == deletedId && mt.IsDeleted == false));
}
}
public async Task Return_Valid_Users_Count()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Return_Valid_Users_Count")
.Options;
string userId = "myId";
user = new User()
{
Id = userId,
UserName = "******"
};
userManagerMock = MockUserManager <User>();
roleManagerMock = MockRoleManager();
using (var actContext = new SmartDormitoryContext(contextOptions))
{
await actContext.Users.AddAsync(user);
await actContext.SaveChangesAsync();
}
// Act && Assert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var userService = new UserService(assertContext, userManagerMock.Object, roleManagerMock.Object);
var usersCount = await userService.TotalUsers();
Assert.AreEqual(1, usersCount);
}
}
public async Task SoftDelete_WhenMeasureTypeExists()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "SoftDelete_WhenMeasureTypeExists")
.Options;
var existingId = Guid.NewGuid().ToString();
var existingMeasureUnit = "Some existing measure unit";
var existingSuitableSensorType = "Some existing sensor type";
using (var arrangeContext = new SmartDormitoryContext(contextOptions))
{
await arrangeContext.MeasureTypes.AddAsync(
new MeasureType
{
Id = existingId,
MeasureUnit = existingMeasureUnit,
SuitableSensorType = existingSuitableSensorType,
IsDeleted = false
});
await arrangeContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new MeasureTypeService(assertContext);
await sut.DeleteType(existingId);
Assert.IsTrue(assertContext.MeasureTypes.Any(mt => mt.Id == existingId && mt.IsDeleted == true));
}
}
public async Task ThrowsEntityAlreadyExistsException_IfMeasureTypeExists()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "ThrowsEntityAlreadyExistsException_IfMeasureTypeExists")
.Options;
var existingId = Guid.NewGuid().ToString();
var existingMeasureUnit = "Some existing measure unit";
var existingSuitableSensorType = "Some existing sensor type";
var softDeletedMeasureType = new MeasureType
{
Id = existingId,
MeasureUnit = existingMeasureUnit,
SuitableSensorType = existingSuitableSensorType,
IsDeleted = false
};
using (var arrangeContext = new SmartDormitoryContext(contextOptions))
{
await arrangeContext.MeasureTypes.AddAsync(softDeletedMeasureType);
await arrangeContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new MeasureTypeService(assertContext);
await Assert.ThrowsExceptionAsync <EntityAlreadyExistsException>(
() => sut.Create(existingMeasureUnit, existingSuitableSensorType), "\nMeasure type is already present in the database.");
}
}
public async Task Return_CorrectIcbSensor_WhenFoundId()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Return_CorrectUser_WhenFoundId")
.Options;
string id = Guid.NewGuid().ToString();
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
await assertContext.IcbSensors.AddAsync(new IcbSensor
{
Id = id,
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinRangeValue = 10,
MaxRangeValue = 20
});
await assertContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var measureTypeServiceMock = new Mock <IMeasureTypeService>();
var sut = new IcbSensorsService(assertContext, measureTypeServiceMock.Object);
var result = await sut.GetById(id);
Assert.IsNotNull(result);
Assert.IsTrue(id.Equals(result.Id));
}
}
public UserService(SmartDormitoryContext context,
UserManager <User> userManager, RoleManager <IdentityRole> roleManager)
: base(context)
{
this.userManager = userManager;
this.roleManager = roleManager;
}
public async Task AddCorrectSensor_WhenPassedValidMeasureType()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "AddCorrectSensor_WhenPassedValidMeasureType")
.Options;
var existingmeasureTypeId = Guid.NewGuid().ToString();
var existingMeasureType = new MeasureType
{
Id = existingmeasureTypeId,
MeasureUnit = "Existing unit",
SuitableSensorType = "Some string"
};
string newApiSensorId = Guid.NewGuid().ToString();
int newApiSensorPollingInterval = 10;
string newApiSensorDescription = "Some description";
string newApiSensorTag = "Some tag";
var newApiSensor = new ApiSensorDetailsDTO
{
ApiSensorId = newApiSensorId,
MinPollingIntervalInSeconds = newApiSensorPollingInterval,
Description = newApiSensorDescription,
Tag = newApiSensorTag,
MeasureType = "Existing unit"
};
var sensorsToAdd = new List <ApiSensorDetailsDTO>()
{
newApiSensor
};
using (var arrangeContext = new SmartDormitoryContext(contextOptions))
{
await arrangeContext.MeasureTypes.AddAsync(existingMeasureType);
await arrangeContext.SaveChangesAsync();
}
// Act and assert
using (var actContext = new SmartDormitoryContext(contextOptions))
{
var measureTypeServiceMock = new Mock <IMeasureTypeService>();
var sut = new IcbSensorsService(actContext, measureTypeServiceMock.Object);
await sut.AddSensors(sensorsToAdd);
var createdSensorId = actContext
.IcbSensors
.FirstOrDefaultAsync(s => s.Id == newApiSensorId &&
s.Description == newApiSensorDescription &&
s.Tag == newApiSensorTag &&
s.PollingInterval == newApiSensorPollingInterval &&
s.MeasureTypeId == existingmeasureTypeId);
Assert.IsNotNull(createdSensorId);
}
}
public async Task ReturnCorrectList_WhenPassedValidParams()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "ReturnCorrectList_WhenPassedValidParams")
.Options;
var existingmeasureTypeId = Guid.NewGuid().ToString();
var existingMeasureType = new MeasureType
{
Id = existingmeasureTypeId,
MeasureUnit = "Existing unit",
SuitableSensorType = "Some string"
};
var existingId = Guid.NewGuid().ToString();
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
await assertContext.MeasureTypes.AddAsync(existingMeasureType);
await assertContext.IcbSensors.AddRangeAsync(new IcbSensor
{
Id = existingId,
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinRangeValue = 10,
MaxRangeValue = 20,
IsDeleted = false,
MeasureTypeId = existingmeasureTypeId
},
new IcbSensor
{
Id = Guid.NewGuid().ToString(),
PollingInterval = 10,
Description = "Some description",
Tag = "Some tag",
MinRangeValue = 10,
MaxRangeValue = 20,
IsDeleted = true,
MeasureTypeId = existingmeasureTypeId
});
await assertContext.SaveChangesAsync();
}
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var measureTypeServiceMock = new Mock <IMeasureTypeService>();
var sut = new IcbSensorsService(assertContext, measureTypeServiceMock.Object);
var result = await sut.GetAllByMeasureTypeId(measureTypeId : existingmeasureTypeId);
Assert.IsTrue(result.Count() == 1);
Assert.IsTrue(result.Any(s => s.Id.Equals(existingId)));
}
}
public async Task AddSensor_WhenPassedValidMeasureType()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "AddSensor_WhenPassedValidMeasureType")
.Options;
var existingmeasureTypeId = Guid.NewGuid().ToString();
var existingMeasureType = new MeasureType
{
Id = existingmeasureTypeId,
MeasureUnit = "Existing unit",
SuitableSensorType = "Some string"
};
string newApiSensorId = Guid.NewGuid().ToString();
var newApiSensor = new ApiSensorDetailsDTO
{
ApiSensorId = newApiSensorId,
MinPollingIntervalInSeconds = 10,
Description = "Some description",
Tag = "Some tag",
MeasureType = "Existing unit"
};
var sensorsToAdd = new List <ApiSensorDetailsDTO>()
{
newApiSensor
};
using (var arrangeContext = new SmartDormitoryContext(contextOptions))
{
await arrangeContext.MeasureTypes.AddAsync(existingMeasureType);
await arrangeContext.SaveChangesAsync();
}
// Act and assert
using (var actContext = new SmartDormitoryContext(contextOptions))
{
var measureTypeServiceMock = new Mock <IMeasureTypeService>();
var sut = new IcbSensorsService(actContext, measureTypeServiceMock.Object);
await sut.AddSensors(sensorsToAdd);
var actualCount = await actContext.IcbSensors.CountAsync();
Assert.AreEqual(1, actualCount);
}
}
public async Task Throw_EntityDoesntExistException_When_UserDoesntExists()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "Throw_EntityDoesntExistException_When_UserDoesntExists")
.Options;
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new NotificationService(assertContext);
await Assert.ThrowsExceptionAsync <EntityDoesntExistException>(
() => sut.ReadAll(Guid.NewGuid().ToString()));
}
}
public async Task ReturnZero_IfNoMeasureTypes()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "ReturnZero_IfNoMeasureTypes")
.Options;
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new MeasureTypeService(assertContext);
var result = await sut.TotalCount();
Assert.AreEqual(0, result);
}
}
public async Task ReturnNull_IfNosuchMeasureType()
{
// Arrange
contextOptions = new DbContextOptionsBuilder <SmartDormitoryContext>()
.UseInMemoryDatabase(databaseName: "ReturnNull_IfNosuchMeasureType")
.Options;
// Act && Asert
using (var assertContext = new SmartDormitoryContext(contextOptions))
{
var sut = new MeasureTypeService(assertContext);
var result = await sut.GetMeasureType("Some inexisting measure unit", "Some inexisting senstor type");
Assert.IsNull(result);
}
}
