public async Task Handler_return_true_if_reading_is_for_portable_sensor()
{
//Arrange
var apiKey = ApiKeyHelper.Generate();
var fakePortableSensor = new PortableSensor()
{
Id = 1, ApiKey = apiKey
};
var fakeReading = new SensorReadingDTO();
_dataContextMock.Setup(x => x.Sensors).ReturnsDbSet(new List <Sensor> {
fakePortableSensor
});
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
//Act
var cancellationToken = new CancellationToken();
var command = new CreateReadingCommand(fakeReading, apiKey);
var handler = new CreateReadingCommandHandler(_mediatorMock.Object, _dataContextFactoryMock.Object,
_mapperMock.Object);
var result = await handler.Handle(command, cancellationToken);
//Assert
Assert.True(result);
}
public async Task Handler_publish_notification_if_reading_is_for_static_sensor()
{
//Arrange
var apiKey = ApiKeyHelper.Generate();
var fakeStaticSensor = new StaticSensor {
Id = 1, ApiKey = apiKey
};
var fakeStaticSensorReading = new StaticSensorReading();
var fakeReadingDTO = new SensorReadingDTO();
var fakeReadingsDbSet = new List <StaticSensorReading>();
_dataContextMock.Setup(x => x.Sensors).ReturnsDbSet(new List <Sensor> {
fakeStaticSensor
});
_dataContextMock.Setup(x => x.StaticSensorReadings).ReturnsDbSet(fakeReadingsDbSet);
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
_mapperMock.Setup(x => x.Map <SensorReadingDTO, StaticSensorReading>(fakeReadingDTO))
.Returns(fakeStaticSensorReading);
//Act
var cancellationToken = new CancellationToken();
var command = new CreateReadingCommand(fakeReadingDTO, apiKey);
var handler = new CreateReadingCommandHandler(_mediatorMock.Object, _dataContextFactoryMock.Object,
_mapperMock.Object);
var result = await handler.Handle(command, cancellationToken);
//Assert
_mediatorMock.Verify(
x => x.Publish(
It.Is <StaticSensorReadingCreatedNotification>(it =>
it.SensorId == fakeStaticSensor.Id && it.Reading == fakeStaticSensorReading),
It.Is <CancellationToken>(it => it == cancellationToken)), Times.Once);
}
public async Task Handler_should_throw_exception_if_sensor_not_found()
{
//Arrange
var apiKey = ApiKeyHelper.Generate();
var notExistingApiKey = apiKey.Reverse().ToString();
var fakeStaticSensor = new StaticSensor {
Id = 1, ApiKey = apiKey
};
var fakeReading = new SensorReadingDTO();
_dataContextMock.Setup(x => x.Sensors).ReturnsDbSet(new List <Sensor> {
fakeStaticSensor
});
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
var cancellationToken = new CancellationToken();
var command = new CreateReadingCommand(fakeReading, notExistingApiKey);
var handler = new CreateReadingCommandHandler(_mediatorMock.Object, _dataContextFactoryMock.Object,
_mapperMock.Object);
//Act
Task Act() => handler.Handle(command, cancellationToken);
//Assert
await Assert.ThrowsAsync <SensorNotFoundException>(Act);
}
public async Task Post_create_static_sensor_and_response_redirect_status_code()
{
//Arrange
using var server = await GetDefaultTestServerBuilder()
.UseDefaultAuth()
.BuildAsync();
var client = server.CreateClient();
var payloadDict = new Dictionary <string, string>
{
{
$"{nameof(CreateStaticSensorViewModel.Model)}.{nameof(CreateStaticSensorModel.Latitude)}",
Defaults.Latitude.ToCommaSeparatedString()
},
{
$"{nameof(CreateStaticSensorViewModel.Model)}.{nameof(CreateStaticSensorModel.Longitude)}",
Defaults.Longitude.ToCommaSeparatedString()
},
{
$"{nameof(CreateStaticSensorViewModel.Model)}.{nameof(CreateStaticSensorModel.ApiKey)}",
(ApiKeyHelper.Generate())
}
};
//Act
var response =
await client.PostAsync("admin/sensors/createStaticSensor", new FormUrlEncodedContent(payloadDict));
//Assert
Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
}
public async Task Handler_should_return_created_sensor_dto_with_provided_params()
{
//Arrange
var apiKey = ApiKeyHelper.Generate();
_dataContextMock.Setup(x => x.StaticSensors).ReturnsDbSet(new List <StaticSensor>());
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
_mapperMock.Setup(x => x.Map <StaticSensor, StaticSensorDTO>(It.IsAny <StaticSensor>())).Returns(
(StaticSensor v) => new StaticSensorDTO
{
ApiKey = v.ApiKey,
Latitude = v.Latitude,
Longitude = v.Longitude
});
var cancellationToken = new CancellationToken();
var command = new CreateStaticSensorCommand(apiKey, 53, 53);
var handler = new CreateStaticSensorCommandHandler(_dataContextFactoryMock.Object, _mapperMock.Object);
//Act
var result = await handler.Handle(command, cancellationToken);
//Assert
Assert.Equal(apiKey, result.ApiKey);
Assert.Equal(command.Latitude, result.Latitude);
Assert.Equal(command.Longitude, result.Longitude);
}
public ActionResult CreatePortableSensor()
{
return(View(new CreatePortableSensorViewModel(new CreatePortableSensorModel
{
ApiKey = ApiKeyHelper.Generate()
})));
}
private async void OnFetchApiKeyButtonClickedAsync(object sender, RoutedEventArgs e)
{
Model.IsValidatingOrFetchingApiKey = true;
if (!string.IsNullOrEmpty(Model.Email) && !string.IsNullOrEmpty(Model.Password))
{
ApiKeyHelper apiKeyHelper = new ApiKeyHelper();
NetworkResult result = await apiKeyHelper.FetchApiKeyAsync(Model.Email, Model.Password);
if (result == NetworkResult.Success)
{
Model.ShowApiKeyErrorMessage = false;
Model.Applications = apiKeyHelper.Applications;
if (apiKeyHelper.Applications?.Count > 1)
{
Model.ShowApiKeySelection = apiKeyHelper.Applications.Count > 1;
}
else
{
// Model.ApiKey = apiKeyHelper.ApiKey;
// Model.IsApiKeyValid = true;
if (apiKeyHelper.Applications?.Count > 0)
{
Model.Application = apiKeyHelper.Applications[0];
}
}
}
else
{
Model.IsApiKeyValid = false;
string message = loader.GetString("unknownFetchApiKeyError");
switch (result)
{
case NetworkResult.NetworkError:
message = loader.GetString("failedToFetchApiKeyDueToNetworkError");
break;
case NetworkResult.AuthenticationFailed:
message = loader.GetString("authenticationFailedForFetchingApiKey");
break;
case NetworkResult.ParsingError:
message = loader.GetString("failedToParseServerResponse");
break;
case NetworkResult.NoWindowsCampains:
message = loader.GetString("noWindowsCampaignsAvailable");
break;
}
Model.ApiKeyErrorMessage = message;
Model.ShowApiKeyErrorMessage = true;
}
}
Model.IsValidatingOrFetchingApiKey = false;
}
public HttpResponseMessage GenerateApiKey(string accessKey = "")
{
var request = Request;
if (string.IsNullOrEmpty(accessKey))
{
accessKey = ApiKeyHelper.GenerateAccessKey();
}
return(Request.CreateResponse(HttpStatusCode.OK, String.Format("AWS {0}:{1}", accessKey, GetSignature(request, accessKey))));
}
private (SensorEmulator emulator, PortableSensor sensor) GetPortableFakeSensor(string guid)
{
var apiKey = ApiKeyHelper.Generate();
var sensorEmulator = new SensorEmulator(guid, _appSettings.ServerUrl, apiKey, typeof(PortableSensor));
var sensor = new PortableSensor
{
ApiKey = apiKey
};
return(sensorEmulator, sensor);
}
private (SensorEmulator emulator, StaticSensor sensor) GetStaticFakeSensor(string guid)
{
var apiKey = ApiKeyHelper.Generate();
var sensorEmulator = new SensorEmulator(guid, _appSettings.ServerUrl, apiKey, typeof(StaticSensor));
var sensor = new StaticSensor
{
ApiKey = apiKey,
Latitude = sensorEmulator.Latitude,
Longitude = sensorEmulator.Longitude
};
return(sensorEmulator, sensor);
}
public async Task Get_Static_Sensors_Success()
{
//Arrange
var fakeApiKey = ApiKeyHelper.Generate();
var fakeStaticSensorReading = new StaticSensorReading {
Id = 1, StaticSensorId = 1
};
var fakeStaticSensor = new StaticSensor
{
Id = 1,
ApiKey = fakeApiKey,
Readings = new List <StaticSensorReading> {
fakeStaticSensorReading
}
};
var fakeStaticSensorCacheItem =
new SensorCacheItemModel(fakeStaticSensor, PollutionLevel.High);
var fakeStaticSensorReadingsDTO = new StaticSensorReadingDTO {
Id = 1
};
var fakeStaticSensorReadingsDTOList = new List <StaticSensorReadingDTO> {
fakeStaticSensorReadingsDTO
};
var fakeStaticSensorsCacheList = new List <SensorCacheItemModel> {
fakeStaticSensorCacheItem
};
_sensorCacheHelperMock.Setup(x => x.GetStaticSensorsAsync())
.Returns(Task.FromResult(fakeStaticSensorsCacheList));
_mapperMock.Setup((x =>
x.Map <List <StaticSensorReading>, List <StaticSensorReadingDTO> >(fakeStaticSensor.Readings)))
.Returns(fakeStaticSensorReadingsDTOList);
var readingQueries = new ReadingsQueries(_sensorCacheHelperMock.Object, _mapperMock.Object);
//Act
var result = await readingQueries.GetStaticSensorsAsync();
//Assert
Assert.NotNull(result.First(x => x.Id == fakeStaticSensor.Id && x.Readings == fakeStaticSensorReadingsDTOList));
}
public async Task Create_portable_sensor_and_response_ok_status_code()
{
//Arrange
using var server = await GetDefaultTestServerBuilder()
.UseDefaultAuth()
.BuildAsync();
var client = server.CreateClient();
var portableSensor = new CreatePortableSensorModel {
ApiKey = ApiKeyHelper.Generate()
};
var portableSensorJsonStr = JsonConvert.SerializeObject(portableSensor);
//Act
var response = await client.PostAsync("api/admin/sensors/portable",
new StringContent(portableSensorJsonStr, Encoding.UTF8, "application/json"));
//Assert
response.EnsureSuccessStatusCode();
}
public async Task Handler_update_cache()
{
//Arrange
var fakeReading = new StaticSensorReading
{
Id = 1,
StaticSensorId = 1
};
var fakeSensor = new StaticSensor
{
Id = 1,
ApiKey = ApiKeyHelper.Generate(),
IsActive = true,
IsVisible = true,
Readings = new List <StaticSensorReading> {
fakeReading
}
};
var fakeSensorDbSet = new List <StaticSensor> {
fakeSensor
};
_dataContextMock.Setup(x => x.Set <StaticSensor>()).ReturnsDbSet(fakeSensorDbSet);
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
var cancellationToken = new CancellationToken();
var notification = new StaticSensorReadingCreatedNotification(fakeSensor.Id, fakeReading);
var handler =
new StaticSensorReadingCreatedNotificationHandler(_dataContextFactoryMock.Object,
_sensorCacheHelperMock.Object);
//Act
await handler.Handle(notification, cancellationToken);
//Assert
_sensorCacheHelperMock.Verify(
x => x.UpdateSensorCacheWithReadingAsync(It.Is <StaticSensorReading>(it => it == fakeReading)), Times.Once);
}
public async Task Send_reading_and_response_ok_status_code(int dataSetIndex)
{
//Arrange
var latitude = 53.333333;
var longitude = 53.333333;
var dataSet = new List <Sensor>
{
new StaticSensor
{
ApiKey = ApiKeyHelper.Generate(),
Latitude = latitude,
Longitude = longitude,
IsActive = true,
IsVisible = true,
Readings = new List <StaticSensorReading>()
},
new PortableSensor
{
ApiKey = ApiKeyHelper.Generate(),
IsActive = true
}
};
var currentSensor = dataSet[dataSetIndex];
using var server = await GetDefaultTestServerBuilder()
.UseSensors(currentSensor)
.BuildAsync();
var client = server.CreateClient();
//Act
var response =
await client.GetAsync(
$"api/integration/getaspost?data={WebUtility.UrlEncode(GenerateData(currentSensor.ApiKey, latitude, longitude))}");
//Assert
response.EnsureSuccessStatusCode();
}
public async Task Handler_should_update_database_with_sensor_with_provided_api_key()
{
//Arrange
var apiKey = ApiKeyHelper.Generate();
_dataContextMock.Setup(x => x.PortableSensors).ReturnsDbSet(new List <PortableSensor>());
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
var cancellationToken = new CancellationToken();
var command = new CreatePortableSensorCommand(apiKey);
var handler = new CreatePortableSensorCommandHandler(_dataContextFactoryMock.Object, _mapperMock.Object);
//Act
await handler.Handle(command, cancellationToken);
//Assert
//Multiple assert because test is the same for both verified methods and they are very closely related
_dataContextMock.Verify(x => x.PortableSensors.AddAsync(It.Is <PortableSensor>(it => it.ApiKey == apiKey),
It.Is <CancellationToken>(it => it == cancellationToken)), Times.Once);
_dataContextMock.Verify(x => x.SaveChangesAsync(
It.Is <CancellationToken>(it => it == cancellationToken)), Times.Once);
}
public async Task Handler_should_return_created_sensor_dto_with_provided_api_key()
{
//Arrange
var apiKey = ApiKeyHelper.Generate();
_dataContextMock.Setup(x => x.PortableSensors).ReturnsDbSet(new List <PortableSensor>());
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
_mapperMock.Setup(x => x.Map <PortableSensor, PortableSensorDTO>(It.IsAny <PortableSensor>())).Returns(
(PortableSensor v) => new PortableSensorDTO
{
ApiKey = v.ApiKey
});
var cancellationToken = new CancellationToken();
var command = new CreatePortableSensorCommand(apiKey);
var handler = new CreatePortableSensorCommandHandler(_dataContextFactoryMock.Object, _mapperMock.Object);
//Act
var result = await handler.Handle(command, cancellationToken);
//Assert
Assert.Equal(apiKey, result.ApiKey);
}
public async Task Handler_should_throw_exception_if_sensor_not_found()
{
//Arrange
var fakeReading = new StaticSensorReading
{
Id = 1,
StaticSensorId = 1
};
var fakeSensor = new StaticSensor
{
Id = 1,
ApiKey = ApiKeyHelper.Generate(),
IsActive = true,
IsVisible = true,
Readings = new List <StaticSensorReading> {
fakeReading
}
};
var fakeSensorDbSet = new List <StaticSensor> ();
_dataContextMock.Setup(x => x.Set <StaticSensor>()).ReturnsDbSet(fakeSensorDbSet);
_dataContextFactoryMock.Setup(x => x.Create()).Returns(_dataContextMock.Object);
var cancellationToken = new CancellationToken();
var notification = new StaticSensorReadingCreatedNotification(fakeSensor.Id, fakeReading);
var handler =
new StaticSensorReadingCreatedNotificationHandler(_dataContextFactoryMock.Object,
_sensorCacheHelperMock.Object);
//Act
Task Act() => handler.Handle(notification, cancellationToken);
//Assert
await Assert.ThrowsAsync <SensorNotFoundException>(Act);
}
/// <summary>
/// Performs a POST request and returns the model asynchronously.
/// </summary>
/// <typeparam name="TModel">The type of model to return.</typeparam>
/// <param name="resource">The resource where the model is located.</param>
/// <param name="input">The input required to cancel a delivery.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The details of the cancelled delivery.</returns>
protected Task <TModel> PostRequestAsync <TModel>(string resource, object input, CancellationToken cancellationToken = default)
{
ApiKeyHelper.AllocateApiKey(input, ApiKey);
return(Service.PostRequestAsync <TModel>(resource, input, cancellationToken));
}
/// <summary>
/// Performs a POST request and returns the model.
/// </summary>
/// <typeparam name="TModel">The type of model to return.</typeparam>
/// <param name="resource">The resource where the model is located.</param>
/// <param name="input">The input required to cancel a delivery.</param>
/// <returns>The model.</returns>
protected TModel PostRequest <TModel>(string resource, object input)
{
ApiKeyHelper.AllocateApiKey(input, ApiKey);
return(Service.PostRequest <TModel>(resource, input));
}
