public async Task OnMessage_WithOldApiFields_ConvertsToNewFieldNames()
{
// Arrange
Guid deviceId = new Guid("FC6B39AF-352A-42F3-A848-45AA1FA08183");
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
var device = new User
{
UserId = deviceId,
AccountId = accountId,
FieldDescriptors = new List <FieldDescriptor>
{
new FieldDescriptor
{
Index = 0,
Name = "Temperature",
Visible = true
}
}
};
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
var measurementEvent = new NewMeasurementEvent
{
UserId = deviceId,
AccountId = accountId,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto
{
Name = "Field1",
StringValue = "23.6",
Value = 23.6M,
}
},
RemapOldFields = true
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(1, processedMeasurement.MeasurementFields.Count);
var measurementField = processedMeasurement.MeasurementFields[0];
Assert.AreEqual("Temperature", measurementField.Name);
Assert.AreEqual(23.6M, measurementField.Value);
}
public async Task WithLatAndLongSingleField_SetsMeasurementLocation(string fieldName)
{
// Arrange
Guid deviceId = new Guid("FC6B39AF-352A-42F3-A848-45AA1FA08183");
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
var device = new User {
AccountId = accountId, UserId = deviceId
};
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "temp", Visible = true
});
device.FieldDescriptors.Add(new FieldDescriptor {
Name = fieldName, Visible = false
});
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
var measurementEvent = new NewMeasurementEvent
{
UserId = deviceId,
AccountId = accountId,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto {
Name = "temp", Value = 23.5M
},
new MeasurementFieldDto {
Name = fieldName, StringValue = "1.2345,2.5876"
},
}
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(2, processedMeasurement.MeasurementFields.Count);
Assert.NotNull(processedMeasurement.Location);
Assert.AreEqual(1.2346D, processedMeasurement.Location.Latitude, 0.0001D, "Latitude");
Assert.AreEqual(2.5876D, processedMeasurement.Location.Longitude, 0.0001D, "Longitude");
Assert.AreEqual(0.0D, processedMeasurement.Location.Elevation, 0.0001D, "Elevation");
Assert.AreEqual(Guid.Empty, processedMeasurement.Location.Id, "Id");
Assert.IsNull(processedMeasurement.Location.Name);
}
public async Task ExtractsSampleIdFromField(string fieldName, double value, int expectedLevel)
{
// Arrange
Guid deviceId = new Guid("FC6B39AF-352A-42F3-A848-45AA1FA08183");
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
var device = new User {
AccountId = accountId, UserId = deviceId
};
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "temp", Visible = true
});
device.FieldDescriptors.Add(new FieldDescriptor {
Name = fieldName, Visible = false
});
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
var measurementEvent = new NewMeasurementEvent
{
UserId = deviceId,
AccountId = accountId,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto {
Name = "temp", Value = 23.5M
},
new MeasurementFieldDto {
Name = fieldName, Value = Convert.ToDecimal(value)
},
}
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(2, processedMeasurement.MeasurementFields.Count);
var doubleLevel = Convert.ToDouble(processedMeasurement.BatteryLevel);
Assert.AreEqual(value, doubleLevel, 0.001D, "BatteryLevel");
Assert.AreEqual(expectedLevel, processedMeasurement.BatteryLevelPercentage, "BatteryLevelPercentage");
// Battery level message?
}
public async Task WhereMeasurementHasTags_CombinesTags()
{
// Arrange
Guid deviceId = new Guid("FC6B39AF-352A-42F3-A848-45AA1FA08183");
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
var device = new User {
AccountId = accountId, UserId = deviceId
};
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "temp", Visible = true
});
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "tags", Visible = false
});
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
var measurementEvent = new NewMeasurementEvent
{
Tags = new List <string> {
"Foo", "Bar"
},
UserId = deviceId,
AccountId = accountId,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto {
Name = "temp", Value = 23.5M
},
new MeasurementFieldDto {
Name = "tags", StringValue = "Baz"
},
}
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(2, processedMeasurement.MeasurementFields.Count);
Assert.IsNotNull(processedMeasurement.Tags);
Assert.AreEqual(3, processedMeasurement.Tags.Count);
}
[TestCase("NoOperatorId", null)] // diffierent field.
public async Task ExtractsSampleIdFromField(string fieldName, string operatorId)
{
// Arrange
Guid deviceId = new Guid("FC6B39AF-352A-42F3-A848-45AA1FA08183");
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
var device = new User {
AccountId = accountId, UserId = deviceId
};
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "temp", Visible = true
});
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "operatorid", Visible = false
});
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
var measurementEvent = new NewMeasurementEvent
{
UserId = deviceId,
AccountId = accountId,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto {
Name = "temp", Value = 23.5M
},
new MeasurementFieldDto {
Name = fieldName, StringValue = operatorId
},
}
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(2, processedMeasurement.MeasurementFields.Count);
// Ensure the sample id is as expected.
Assert.AreEqual(operatorId, processedMeasurement.OperatorId);
}
public async Task WhereNoTagsExist_HasNonNullArray()
{
// Arrange
Guid deviceId = new Guid("FC6B39AF-352A-42F3-A848-45AA1FA08183");
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
var device = new User {
AccountId = accountId, UserId = deviceId
};
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "temp", Visible = true
});
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
var measurementEvent = new NewMeasurementEvent
{
UserId = deviceId,
AccountId = accountId,
MeasurementFields = new List <MeasurementFieldDto>
{
// no tags, but same number of fields (to help test :-) )
new MeasurementFieldDto {
Name = "temp", Value = 23.5M
},
new MeasurementFieldDto {
Name = "humidity", Value = 23.5M
},
}
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(2, processedMeasurement.MeasurementFields.Count);
Assert.IsNotNull(processedMeasurement.Tags);
Assert.AreEqual(0, processedMeasurement.Tags.Count);
}
public async Task OnNewMeasurementAsync(NewMeasurementEvent newMeasurementEvent)
{
// We shouldn't get these any more, so any service publishing them needs
// to be modified to use the Kinesis stream rather than EasyNetQ.
_logger.LogWarning("Got new measurement (NewMeasurementEvent) to process. Id: {0}, UserId: {1}, Source:{2} through EasyNetQ! - Change to Kinesis!",
newMeasurementEvent.Id,
newMeasurementEvent.UserId,
newMeasurementEvent.Source);
// Push onto the raw stream
// this should be done by MQTT/API not here
// to reduce dependency/load on RabbitMQ servers.
await _rawStreamWriter.PushStreamAsync(newMeasurementEvent);
}
private Measurement MapFromNewMeasurementEvent(NewMeasurementEvent newMeasurementEvent)
{
var measurement = new Measurement
{
MongoDbId = newMeasurementEvent.Id,
Channel = newMeasurementEvent.Channel,
AccountMongoId = newMeasurementEvent.AccountId,
UserMongoId = newMeasurementEvent.UserId,
MeasurementDate = newMeasurementEvent.MeasurementDate,
PostedOn = newMeasurementEvent.PostedOn,
DateAdded = DateTime.UtcNow,
SampleId = newMeasurementEvent.SampleId,
Tags = newMeasurementEvent.Tags ?? new List <string>(),
Expires = newMeasurementEvent.Expires,
TTL = newMeasurementEvent.TTL,
Source = newMeasurementEvent.Source.ToString(),
};
if (measurement.TTL.HasValue && !measurement.Expires.HasValue)
{
// Expires not set, but measurement has TTL.
measurement.Expires = measurement.MeasurementDate.Add(measurement.TTL.Value);
}
if (newMeasurementEvent.Location != null)
{
measurement.Location = new LocationDetails
{
Elevation = newMeasurementEvent.Location.Elevation,
Latitude = newMeasurementEvent.Location.Latitude,
Longitude = newMeasurementEvent.Location.Longitude,
Id = newMeasurementEvent.Location.Id,
Name = newMeasurementEvent.Location.Name,
};
}
// MeasurementFields is to replace Fields and Field1..12 as
// this is a better match with SenML and
if (newMeasurementEvent.MeasurementFields != null)
{
measurement.MeasurementFields = Map(newMeasurementEvent.MeasurementFields, newMeasurementEvent.MeasurementDate);
}
else
{
_logger.LogWarning("NewMeasurementEvent received with null MeasurementFields");
}
return(measurement);
}
public async Task OnMessage_ProcessesMessage_PublishesOnKinesisStream()
{
// Arrange
Guid deviceId = new Guid("FC6B39AF-352A-42F3-A848-45AA1FA08183");
var bus = new Mock <IBus>();
var streamWriter = new Mock <IRawMeasurementStreamWriter>();
var logger = new Mock <ILogger>();
var device = new User {
UserId = deviceId
};
device.FieldDescriptors.Add(new FieldDescriptor {
Name = "temp", Visible = true
});
var message = new NewMeasurementEvent
{
UserId = deviceId,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto {
Name = "temp", Value = 23.5M
}
}
};
streamWriter
.Setup(x => x.PushStreamAsync(message))
.Returns(Task.CompletedTask);
NewDecimalMeasurementProcessor measurementProcessor = new NewDecimalMeasurementProcessor(bus.Object, streamWriter.Object, logger.Object);
// Act
await measurementProcessor.OnNewMeasurementAsync(message);
// Assert
streamWriter.Verify(x => x.PushStreamAsync(message));
}
public async Task <ProcessedMeasurementEvent> ProcessAsync(NewMeasurementEvent newMeasurementEvent)
{
if (newMeasurementEvent.UserId == Guid.Empty)
{
_logger.LogInformation("Not persisting measurement {0} as invalid user id. {1}",
newMeasurementEvent.Id,
newMeasurementEvent.UserId);
return(null);
}
try
{
Measurement measurement = MapFromNewMeasurementEvent(newMeasurementEvent);
User device = await _membershipService.LoadAsync(newMeasurementEvent.AccountId, newMeasurementEvent.UserId);
if (device == null)
{
return(null);
}
Measurement processedMeasurement = await ProcessMeasurementAsync(measurement, device, newMeasurementEvent.RemapOldFields);
ProcessedMeasurementEvent processedMeasurementEvent = CreateProcessedMeasurementEvent(processedMeasurement, device);
await _membershipService.UpdateFieldsAsync(device, processedMeasurementEvent);
return(processedMeasurementEvent);
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to process new measurement.");
// re-throw so that messaging keeps the message.
throw;
}
}
public async Task PushStreamAsync(NewMeasurementEvent newMeasurementEvent)
{
await Push(newMeasurementEvent, newMeasurementEvent.AccountId);
}
protected virtual void OnNewMeasurementEvent(ParticleMassSensorValues obj)
{
NewMeasurementEvent?.Invoke(obj);
}
public async Task OnMessage_ForFieldWithCalibration_AppliesCalibration()
{
// Arrange
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
Guid deviceId = new Guid("8D37AD07-AB31-43E0-BCFD-B8E9C339F7EA");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
User device = new User
{
AccountId = accountId,
UserId = deviceId,
FieldDescriptors = new List <FieldDescriptor>
{
new FieldDescriptor
{
Channel = 0,
Name = "ToBeCalibrated",
Calibration = new FieldCalibration
{
Enabled = true,
Offset = 10,
Slope = 100
}
}
}
};
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
NewMeasurementEvent measurementEvent = new NewMeasurementEvent
{
Id = new Guid("0D696E5F-F525-43EE-9536-B11F94D8547B"),
AccountId = accountId,
UserId = deviceId,
Channel = 0,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto
{
Value = 2.34M,
Name = "ToBeCalibrated"
}
}
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(1, processedMeasurement.MeasurementFields.Count);
var field = processedMeasurement.MeasurementFields[0];
Assert.IsTrue(field.IsCalibrated);
decimal originalValue = 2.34M;
decimal slope = 100;
decimal offset = 10;
decimal expected = slope * originalValue + offset;
// 100 * 2.34 = 234
// + 10 = 244
// Check the calibration is applied correctly
Assert.AreEqual(244M, field.Value);
// Check original value stored in raw value
Assert.AreEqual(2.34M, field.RawValue);
}
public async Task OnMessage_ForFieldWitoutCalibration_DoesNotApplyCalibration()
{
// Arrange
Guid accountId = new Guid("D1CB14F5-1376-4F82-B4B7-1F2A36639DE4");
Guid deviceId = new Guid("8D37AD07-AB31-43E0-BCFD-B8E9C339F7EA");
var membershipService = new Mock <IMembershipService>();
var logger = new Mock <ILogger>();
User device = new User
{
AccountId = accountId,
UserId = deviceId,
FieldDescriptors = new List <FieldDescriptor>
{
new FieldDescriptor
{
Channel = 0,
Name = "Uncalibrated",
Calibration = null
}
}
};
membershipService
.Setup(x => x.LoadAsync(accountId, deviceId, false))
.Returns(Task.FromResult(device));
var measurementProcessor = new NewMeasurementRecordProcessor(membershipService.Object, logger.Object);
NewMeasurementEvent measurementEvent = new NewMeasurementEvent
{
Id = new Guid("0D696E5F-F525-43EE-9536-B11F94D8547B"),
UserId = deviceId,
AccountId = accountId,
Channel = 0,
MeasurementFields = new List <MeasurementFieldDto>
{
new MeasurementFieldDto
{
Value = 2.34M,
Name = "ToBeCalibrated"
}
}
};
// Act
var processedMeasurement = await measurementProcessor.ProcessAsync(measurementEvent);
// Assert
Assert.NotNull(processedMeasurement);
Assert.NotNull(processedMeasurement.MeasurementFields);
Assert.AreEqual(1, processedMeasurement.MeasurementFields.Count);
var field = processedMeasurement.MeasurementFields[0];
Assert.IsFalse(field.IsCalibrated);
// Value and Raw value should match (no calibration applied)
Assert.AreEqual(2.34M, field.Value);
Assert.AreEqual(2.34M, field.RawValue);
}
