public async Task <ActionResult> RegisterNewSensor()
{
RegisterNewSensorViewModel sensorsFromApi = new RegisterNewSensorViewModel();
//IDictionary<{SensorIdICB}, SensorType>
IDictionary <string, SensorReadInData> availableSensorsFromAPI = await this.sensorApiService.ListSensorsFromAPI();
this.sensorDbService.UpdateSensorTypes(availableSensorsFromAPI);
IEnumerable <SensorReadInData> availableSensors = availableSensorsFromAPI.Values;
sensorsFromApi.AvailableSensors = availableSensors;
//to do later: check if sensors are no longer supported
return(this.View(sensorsFromApi));
}
public void ReturnDefaultViewWithCorrectViewModel()
{
// Arrange
// arrange controller
Mock <ApplicationDbContext> mockApplicationDbContext = new Mock <ApplicationDbContext>();
Mock <SensorDbService> mockSensorDbService = new Mock <SensorDbService>(mockApplicationDbContext.Object);
Mock <HttpClient> mockHttpClient = new Mock <HttpClient>();
Mock <SensorApiService> mockSensorApiService = new Mock <SensorApiService>(mockHttpClient.Object);
// arrange availableSensorsFromAPI
SensorReadInData sensorReadInData1 = new SensorReadInData();
SensorReadInData sensorReadInData2 = new SensorReadInData();
IDictionary <string, SensorReadInData> expected = new Dictionary <string, SensorReadInData>();
expected.Add("key1", sensorReadInData1);
expected.Add("key2", sensorReadInData2);
// arrange sensorApiService
mockSensorApiService.Setup(x => x.ListSensorsFromAPI())
.Returns(Task.Run(() => expected));
// arrange viewModel
RegisterNewSensorViewModel registerNewSensorViewModel = new RegisterNewSensorViewModel
{
AvailableSensors = expected.Values
};
// arrange actual controller
SensorController sensorController = new SensorController(mockSensorDbService.Object, mockSensorApiService.Object);
// act and assert
sensorController.WithCallTo(c => c.RegisterNewSensor())
.ShouldRenderDefaultView()
.WithModel <RegisterNewSensorViewModel> (actual =>
{
Assert.IsNotNull(actual.AvailableSensors);
CollectionAssert.AreEquivalent(registerNewSensorViewModel.AvailableSensors.ToList(),
actual.AvailableSensors.ToList());
});
}
public async Task NotRegisterSensor_WhenSensorIsBooleanAndNonZeroValuesAreSetToMinAndMaxValue()
{
// Arrange
// arrange controller
Mock <ApplicationDbContext> mockApplicationDbContext = new Mock <ApplicationDbContext>();
Mock <SensorDbService> mockSensorDbService = new Mock <SensorDbService>(mockApplicationDbContext.Object);
Mock <HttpClient> mockHttpClient = new Mock <HttpClient>();
Mock <SensorApiService> mockSensorApiService = new Mock <SensorApiService>(mockHttpClient.Object);
//arrange RegisterNewSensorViewModel
DateTime testDateTime1 = DateTime.Now;
Sensor testSensor = new Sensor
{
SensorId = 8,
Name = "dsadas",
DescriptionGivenByTheUser = "******",
MeasurementType = "C",
IsPublic = true,
OperatingRange = "This sensor will return true or false value", //reference
MinValue = 13.4, //invalid testing value
MaxValue = 14.4, //invalid testing value
AddedOn = testDateTime1,
Measurements = new HashSet <Measurement>(),
SharedWith = new HashSet <ApplicationUser>()
};
DateTime testDateTime2 = DateTime.Now;
LastValue testLastValue = new LastValue
{
SensorId = 45,
Sensor = testSensor,
SensorIdICB = "SensorIdICB",
PollingInterval = 10,
Value = "Value",
LastUpdatedOn = testDateTime2
};
testSensor.LastValue = testLastValue;
RegisterNewSensorViewModel expected = new RegisterNewSensorViewModel
{
Sensor = testSensor
};
//koleto. Zaradi validaciite
SensorType sensorType = new SensorType
{
Id = 342,
SensorIdICB = "SensorIdICB",
IsNumericValue = true,
MeasureType = "C",
MinPollingIntervalInSeconds = 2,
Tag = "Tag"
};
mockSensorDbService.Setup(x => x.GetSpecificSensorType("SensorIdICB"))
.Returns(sensorType);
IDictionary <string, SensorReadInData> mockSensorsFromAPI = new Dictionary <string, SensorReadInData>();
mockSensorsFromAPI.Add("SensorIdICB", new SensorReadInData()
{
Tag = "Tag",
MinPollingIntervalInSeconds = 0,
MeasureType = "C",
Description = "This sensor will return values between 6 and 18",
SensorId = "SensorIdICB"
});
mockSensorApiService.Setup(x => x.ListSensorsFromAPI())
.Returns(Task.Run(() => mockSensorsFromAPI));
//arrange username
string loggeduser = "******";
// arrange actual controller
SensorControllerMock controller = new SensorControllerMock(loggeduser, mockSensorDbService.Object, mockSensorApiService.Object);
//act
await controller.RegisterNewSensor(expected);
// assert
mockSensorDbService.Verify(x => x.RegisterNewSensor(loggeduser, testSensor), Times.Never);
}
public async Task <ActionResult> RegisterNewSensor(RegisterNewSensorViewModel wrappedRegisterNewSensorModel)
{
Sensor newSensor = wrappedRegisterNewSensorModel.Sensor;
//validation
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid model state." }));
}
if (newSensor.LastValue.SensorIdICB == null)
{
return(this.RedirectToAction("InvalidInput", new { message = "Sensor ID cannot be empty." }));
}
if (newSensor.Name == null)
{
return(this.RedirectToAction("InvalidInput", new { message = "Name cannot be empty." }));
}
try
{
SensorType serverSensorType = this.sensorDbService
.GetSpecificSensorType(newSensor.LastValue.SensorIdICB);
if (newSensor.LastValue.PollingInterval < serverSensorType.MinPollingIntervalInSeconds)
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid minimal polling interval." }));
}
//emergencyPatch. To Fix later - - - - -
//Fix here: In SensorTypes database model must be added OperationalRange property, from where to cross check the input min/max values
IDictionary <string, SensorReadInData> emergencySensorsFromAPI = await this.sensorApiService.ListSensorsFromAPI();
SensorReadInData serverSensor = emergencySensorsFromAPI[newSensor.LastValue.SensorIdICB];
string operatingRange = serverSensor.Description;
string[] substring = operatingRange.Split();
//"This sensor will return values between 6 and 18" or "This sensor will return true or false value"
if (substring.Contains("between"))
{
//case sensor is integer type
double serverMinVal = double.Parse(substring[substring.Length - 3]);
double serverMaxVal = double.Parse(substring[substring.Length - 1]);
if (newSensor.MinValue >= serverMinVal && newSensor.MinValue <= serverMaxVal)
{
}
else
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor minimal value." }));
}
if (newSensor.MaxValue <= serverMaxVal && newSensor.MaxValue >= serverMinVal)
{
}
else
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor maximum value." }));
}
}
else
{
//case sensor is boolean type
if (newSensor.MinValue != 0 || newSensor.MaxValue != 0)
{
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor min / maximum value when the sensor is boolean type." }));
}
}
newSensor.MeasurementType = serverSensor.MeasureType;
//newSensor.SensorType
}
catch
{
//this is if the user tries even entering invalid sensorIdICB just to brake the application
return(this.RedirectToAction("InvalidInput", new { message = "Invalid sensor ID." }));
}
this.sensorDbService
.RegisterNewSensor(GetLoggedUsername(), newSensor);
return(this.View("Success"));
}
