public UnitedValuesConverterTests(EntitiesConverterFixture fixture)
{
_sensorValuesFactory = fixture.SensorValuesFactory;
_sensorValuesTester = fixture.SensorValuesTester;
_timeCollected = DateTime.UtcNow;
}
public void SensorValueToSensorDataEntityConverterTest(SensorType type)
{
var sensorValue = _sensorValuesFactory.BuildSensorValue(type);
var dataEntity = sensorValue.Convert(_timeCollected, SensorStatus.Ok);
SensorValuesTester.TestSensorDataEntity(sensorValue, dataEntity, _timeCollected);
}
public void UnitedValueToBarSensorValueTest(SensorType sensorType)
{
var unitedValue = _sensorValuesFactory.BuildUnitedSensorValue(sensorType);
var barSensorValue = unitedValue.Convert();
SensorValuesTester.TestBarSensorFromUnitedSensor(unitedValue, barSensorValue);
}
public void UnitedValueToSensorDataEntityTest(SensorType sensorType)
{
var unitedValue = _sensorValuesFactory.BuildUnitedSensorValue(sensorType);
var sensorDataEntity = unitedValue.Convert(_timeCollected, SensorStatus.Ok);
SensorValuesTester.TestSensorDataEntity(unitedValue, sensorDataEntity, _timeCollected);
}
public SensorValuesToDataConverterTests(EntitiesConverterFixture converterFixture)
{
_sensorValuesFactory = converterFixture.SensorValuesFactory;
_sensorValuesTester = converterFixture.SensorValuesTester;
_productName = EntitiesConverterFixture.ProductName;
_timeCollected = DateTime.UtcNow;
}
private static void TestBarSensorsHistoryData(List <SensorValueBase> expected, List <SensorHistoryData> actual, int sensorValuesCount)
{
Assert.Equal(expected.Count, actual.Count);
Assert.DoesNotContain(JsonSerializer.Serialize(DateTime.MinValue), actual[sensorValuesCount].TypedData);
for (int i = 0; i < sensorValuesCount; ++i)
{
SensorValuesTester.TestSensorHistoryDataFromDB(expected[i], actual[i]);
}
}
private void TestSeveralSensorHistoryDataFromDB(Dictionary <string, List <SensorValueBase> > sensorValues,
GetAllSensorHistoryData getAllSensorHistoryData)
{
foreach (var sensors in sensorValues)
{
var datas = getAllSensorHistoryData?.Invoke(_testProductName, sensors.Key);
for (int i = 0; i < sensors.Value.Count; ++i)
{
SensorValuesTester.TestSensorHistoryDataFromDB(sensors.Value[i], datas[i]);
}
}
}
public void GetAllSensorsHistoryDataTest(int count)
{
var sensorValues = AddRandomSensorValuesAndGetTheirValues(count);
foreach (var sensorValue in sensorValues)
{
var history = _monitoringCore.GetAllSensorHistory(_testProductName, sensorValue.Key);
for (int i = 0; i < sensorValue.Value.Count; ++i)
{
SensorValuesTester.TestSensorHistoryDataFromDB(sensorValue.Value[i], history[i]);
}
}
}
public void AddBarSensorValueTest(SensorType type)
{
var sensorValue = _sensorValuesFactory.BuildSensorValue(type);
(sensorValue as BarSensorValueBase).EndTime = System.DateTime.MinValue;
_monitoringCore.AddSensorValue(sensorValue);
var lastBarValue = _barStorage.GetLastValue(_testProductName, sensorValue.Path);
Assert.Equal(_testProductName, lastBarValue.ProductName);
Assert.Equal(SensorValuesTester.GetSensorValueType(sensorValue), lastBarValue.ValueType);
Assert.Equal(sensorValue, lastBarValue.Value);
}
private static void FullTestUpdatedSensorInfo(SensorInfo expected, SensorInfo actual, SensorValueBase sensorValue)
{
Assert.NotNull(actual);
Assert.Equal(expected.Description, actual.Description);
Assert.Equal(expected.Path, actual.Path);
Assert.Equal(expected.ProductName, actual.ProductName);
Assert.Equal(expected.ExpectedUpdateInterval, actual.ExpectedUpdateInterval);
Assert.Equal(expected.Unit, actual.Unit);
Assert.Equal(sensorValue.Path, actual.SensorName);
Assert.Equal(SensorValuesTester.GetSensorValueType(sensorValue), actual.SensorType);
Assert.NotEqual(expected.SensorName, actual.SensorName);
Assert.NotEqual(expected.SensorType, actual.SensorType);
Assert.Empty(actual.ValidationParameters);
}
public void AddUnitedBarSensorValueTest(SensorType type)
{
var unitedValue = _sensorValuesFactory.BuildUnitedSensorValue(type, isMinEndTime: true);
_monitoringCore.AddSensorsValues(new List <UnitedSensorValue>()
{
unitedValue
});
var lastBarValue = _barStorage.GetLastValue(_testProductName, unitedValue.Path);
Assert.Equal(_testProductName, lastBarValue.ProductName);
Assert.Equal(SensorValuesTester.GetSensorValueType(unitedValue), lastBarValue.ValueType);
SensorValuesTester.TestBarSensorFromUnitedSensor(unitedValue, lastBarValue.Value);
}
protected MonitoringCoreTestsBase(DatabaseFixture fixture, DatabaseRegisterFixture dbRegisterFixture)
{
_databaseAdapterManager = new DatabaseAdapterManager(fixture.DatabasePath);
_databaseAdapterManager.AddTestProduct();
dbRegisterFixture.RegisterDatabase(_databaseAdapterManager);
_sensorValuesFactory = new SensorValuesFactory(TestProductsManager.TestProduct.Key);
_sensorValuesTester = new SensorValuesTester(TestProductsManager.TestProduct.Name);
_valuesCache = new ValuesCache();
var productManagerLogger = CommonMoqs.CreateNullLogger <ProductManager>();
_productManager = new ProductManager(_databaseAdapterManager.DatabaseAdapter, productManagerLogger);
}
public void GetSensorsHistoryDataFromToTest(int count)
{
DateTime from = DateTime.UtcNow;
var sensorValues = AddRandomSensorValuesAndGetTheirValues(count);
DateTime to = DateTime.UtcNow;
foreach (var sensorValue in sensorValues)
{
var history = _monitoringCore.GetSensorHistory(_testProductName, sensorValue.Key, from, to);
for (int i = 0; i < sensorValue.Value.Count; ++i)
{
SensorValuesTester.TestSensorHistoryDataFromDB(sensorValue.Value[i], history[i]);
}
}
}
private void TestSensorHistoryDataFromDB(SensorValueBase sensorValue, GetSensorHistoryData getSensorHistoryData)
{
var sensorHistoryDataFromDB = getSensorHistoryData?.Invoke(_testProductName, sensorValue.Path);
SensorValuesTester.TestSensorHistoryDataFromDB(sensorValue, sensorHistoryDataFromDB);
}
public SensorValueBaseToSensorInfoConverterTests(EntitiesConverterFixture fixture)
{
_sensorValuesFactory = fixture.SensorValuesFactory;
_sensorValuesTester = fixture.SensorValuesTester;
}
private static void FullTestRemovedSensor(string productName, SensorValueBase sensorValue,
IsSensorRegistered isSensorRegistered, GetSensorInfo getSensorInfo, GetProductSensors getProductSensors,
GetQueueValues getQueueValues, GetAllSensorHistory getAllSensorHistory,
GetSensorInfoFromDB getSensorFromDB, SensorValuesTester tester)
{
string sensorValuePath = sensorValue.Path;
Assert.False(isSensorRegistered(productName, sensorValuePath));
Assert.Null(getSensorInfo(productName, sensorValuePath));
Assert.Null(getProductSensors(productName).FirstOrDefault(s => s.Path == sensorValuePath));
Assert.Empty(getQueueValues(new List <string>()
{
productName
}));
Assert.Empty(getAllSensorHistory(productName, sensorValuePath));
tester.TestSensorInfoFromDB(sensorValue, getSensorFromDB(productName, sensorValuePath));
}
private static void FullTestSensorInfo(string productName, SensorValueBase sensorValue, IsSensorRegistered isSensorRegistered,
GetSensorInfo getSensorInfo, GetProductSensors getProductSensors, GetSensorInfoFromDB getSensorFromDB, SensorValuesTester tester)
{
var sensorValuePath = sensorValue.Path;
Assert.True(isSensorRegistered(productName, sensorValuePath));
tester.TestSensorInfoFromDB(sensorValue, getSensorInfo(productName, sensorValuePath));
tester.TestSensorInfoFromDB(sensorValue, getProductSensors(productName).FirstOrDefault(s => s.Path == sensorValuePath));
tester.TestSensorInfoFromDB(sensorValue, getSensorFromDB(productName, sensorValuePath));
}
public EntitiesConverterFixture()
{
SensorValuesFactory = new SensorValuesFactory(ProductName);
SensorValuesTester = new SensorValuesTester(ProductName);
}
