///
/// <param name="property">Module2Property to be written</param>
/// <param name="timestamp">Time when data arrived to module</param>
public void WriteProperty(IModule2Property property)
{
logger.LogNewInfo("Writing new property to database.");
Dataset set = DatasetRepository.GetDataset(property.Code);
string tableName = DatabaseTableNamesRepository.GetTableNameByDataset(set);
string signalCode = property.Code.ToString();
double value = property.Value;
string query = @"INSERT INTO " + tableName + "(signalCode, signalValue) VALUES (@code, @value)";
using (SQLiteCommand command = new SQLiteCommand(query, databaseConnection))
{
command.Parameters.AddWithValue("@code", signalCode);
command.Parameters.AddWithValue("@value", value);
if (command.ExecuteNonQuery() == 0)
{
logger.LogNewWarning("Could not write to database.");
}
else
{
logger.LogNewInfo("Property written successfully.");
}
}
}
public void ReadLastByCode_MultipleEntriesOfTheFirstDatasetSameCode_AssertLastRead(SignalCode code, double firstValue, double secondValue)
{
/*Connect to test database to write*/
using (SQLiteConnection databaseConnection = new SQLiteConnection(string.Format(@"Data Source={0}{1};New=False;", path, testDatabaseName)))
{
databaseConnection.Open();
/*Insert test data*/
string query = "INSERT INTO res_dataset1(signalCode, signalValue) VALUES(@code, @value)";
using (SQLiteCommand command = new SQLiteCommand(query, databaseConnection))
{
command.Parameters.AddWithValue("@code", code.ToString());
command.Parameters.AddWithValue("@value", firstValue);
command.ExecuteNonQuery();
Thread.Sleep(2000);
}
query = "INSERT INTO res_dataset1(signalCode, signalValue) VALUES(@code, @value)";
using (SQLiteCommand command = new SQLiteCommand(query, databaseConnection))
{
command.Parameters.AddWithValue("@code", code.ToString());
command.Parameters.AddWithValue("@value", secondValue);
command.ExecuteNonQuery();
}
}
Module2DatabaseManager module2DatabaseManager = new Module2DatabaseManager(loggingMock.Object, testDatabaseName);
/*Assert*/
IModule2Property recievedProperty = module2DatabaseManager.ReadLastByCode(code);
Assert.AreEqual(code, recievedProperty.Code);
Assert.AreEqual(secondValue, recievedProperty.Value);
}
public void PackToModule2Property_RegularParameters_AssertObjectContent(SignalCode signal, double value)
{
IModule2Property module2Property = adapter.PackToModule2Property(signal, value);
Assert.AreEqual(signal, module2Property.Code);
Assert.AreEqual(value, module2Property.Value);
}
public bool IsDeadbandSatisfied_CODEANALOG_ReturnsTrue(double oldValue, double newValue, double percentageDeadband)
{
IModule2Property oldProperty = MockModule2Property(SignalCode.CODE_DIGITAL, oldValue);
IModule2Property newProperty = MockModule2Property(SignalCode.CODE_DIGITAL, newValue);
return(providerPartialyMocked.IsDeadbandSatisfied(oldProperty, newProperty, percentageDeadband));
}
public bool IsDeadbandSatisfied_NotSatisfiedEgdeCases_ReturnsFalse(double oldValue, double newValue, double percentageDeadband)
{
IModule2Property oldProperty = MockModule2Property(SignalCode.CODE_ANALOG, oldValue);
IModule2Property newProperty = MockModule2Property(SignalCode.CODE_ANALOG, newValue);
return(providerPartialyMocked.IsDeadbandSatisfied(oldProperty, newProperty, percentageDeadband));
}
public void UpdateDatabase_MockedAdapterAndManagerNoPropertiesInDatabase_AssertNumberOfCalls()
{
IModule2Property propertyReturn = null;
List <IModule2Property> module2Properties = new List <IModule2Property>();
List <ICollectionDescription> collections = new List <ICollectionDescription>();
Mock <IListDescription> mockList = new Mock <IListDescription>();
Mock <ICollectionDescription> mockCollection = new Mock <ICollectionDescription>();
Mock <IHistoricalCollection> mockHistorical = new Mock <IHistoricalCollection>();
Mock <IModule2Property> mockModule2Property = new Mock <IModule2Property>();
mockModule2Property.SetupGet(x => x.Code).Returns(SignalCode.CODE_ANALOG);
mockModule2Property.SetupGet(x => x.Value).Returns(100);
module2Properties.Add(mockModule2Property.Object);
mockHistorical.SetupGet(x => x.Properties).Returns(module2Properties);
mockCollection.SetupGet(x => x.Collection).Returns(mockHistorical.Object);
collections.Add(mockCollection.Object);
Mock <IModule2DataAdapting> mockAdapter = new Mock <IModule2DataAdapting>();
mockAdapter.Setup(x => x.RepackToCollectionDescriptionArray(It.IsAny <IListDescription>())).Returns(collections);
Mock <IModule2DatabaseManagement> mockDatabase = new Mock <IModule2DatabaseManagement>();
mockDatabase.Setup(x => x.ReadLastByCode(It.IsAny <SignalCode>())).Returns(propertyReturn);
Module2ServiceProvider provider = new Module2ServiceProvider(mockedLogger, mockDatabase.Object, mockAdapter.Object);
provider.UpdateDatabase(mockList.Object);
mockDatabase.Verify(x => x.ReadLastByCode(SignalCode.CODE_ANALOG), Times.Exactly(1));
mockDatabase.Verify(x => x.WriteProperty(mockModule2Property.Object), Times.Exactly(1));
mockAdapter.Verify(x => x.RepackToCollectionDescriptionArray(mockList.Object), Times.Exactly(1));
}
///
/// <param name="oldValue">Module 2 property of the last saved value for a given signal code</param>
/// <param name="newValue">Module 2 property of the new value for a given signal code</param>
/// <param name="deadbandPercentage">Percentage deadband to be checked</param>
public bool IsDeadbandSatisfied(IModule2Property oldValue, IModule2Property newValue, double deadbandPercentage)
{
logger.LogNewInfo(string.Format("Checking deadband for old value {0}, and new value {1}, with percentage {2}", oldValue.Value, newValue.Value, deadbandPercentage));
double difference = Math.Abs(newValue.Value - oldValue.Value);
double percentageDifference = (difference / oldValue.Value) * 100;
if (percentageDifference > deadbandPercentage || oldValue.Code == SignalCode.CODE_DIGITAL)
{
logger.LogNewInfo("Deadband satisfied");
return true;
}
else
{
logger.LogNewInfo("Deadband not satisfied");
return false;
}
}
///
/// <param name="property">List description form module1</param>
public bool UpdateDatabase(IListDescription property)
{
logger.LogNewInfo("New list description arrived. Performing update on database..");
IModule2Property lastProperty = null;
List<ICollectionDescription> collectionDescriptions = null;
try
{
collectionDescriptions = dataAdapter.RepackToCollectionDescriptionArray(property);
}catch(ArgumentException)
{
logger.LogNewWarning("Argument exception thrown by data adapter, aborting all operations.");
return false;
}catch(Exception)
{
logger.LogNewWarning("Unknown exception thrown by data adapter, aborting all operations.");
return false;
}
List<IModule2Property> allProperties = new List<IModule2Property>();
foreach(ICollectionDescription cd in collectionDescriptions)
{
allProperties.AddRange(cd.Collection.Properties);
}
foreach(IModule2Property module2property in allProperties)
{
lastProperty = databaseManager.ReadLastByCode(module2property.Code);
if(lastProperty == null)
{
logger.LogNewInfo(string.Format("No property found in database for signal code {0}. Writing directly without deadband checking..", module2property.Code));
databaseManager.WriteProperty(module2property);
}
else if(IsDeadbandSatisfied(lastProperty, module2property, deadbandPercentage))
{
databaseManager.WriteProperty(module2property);
}
}
return true;
}
///
/// <param name="code">Signal code</param>
/// <param name="value">Signal value</param>
public void WriteToHistory(SignalCode code, double value)
{
logger.LogNewInfo(string.Format("Writing to history called for code {0} and value {1}", code, value));
IModule2Property property = dataAdapter.PackToModule2Property(code, value);
databaseManager.WriteProperty(property);
}
