public void WriteToHistory_MockedAdapterAndManager_AssertNumberOfCalls(SignalCode code, double value)
{
providerFullyMocked.WriteToHistory(code, value);
mockedManager.Verify(x => x.WriteProperty(It.IsAny <IModule2Property>()), Times.Exactly(1));
mockedAdapter.Verify(x => x.PackToModule2Property(code, value), Times.Exactly(1));
}
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 void ReadPropertiesByTimeframe_TwoPropertiesExist_AssertAllRead(SignalCode code, double firstValue, double secondValue)
{
DateTime periodStart = DateTime.Now;
/*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();
}
}
DateTime periodEnd = DateTime.Now;
Module2DatabaseManager module2DatabaseManager = new Module2DatabaseManager(loggingMock.Object, testDatabaseName);
/*Assert*/
List <IModule2Property> recievedProperty = module2DatabaseManager.ReadPropertiesByTimeframe(periodStart, periodEnd, code);
Assert.AreEqual(recievedProperty.Count, 2);
Assert.AreEqual(recievedProperty[0].Value, secondValue);
Assert.AreEqual(recievedProperty[1].Value, firstValue);
}
/*Helper methods*/
private IModule1Property MockModule1Property(SignalCode signal, double value)
{
Mock <IModule1Property> module1Property = new Mock <IModule1Property>();
module1Property.SetupGet <SignalCode>(x => x.Code).Returns(signal);
module1Property.SetupGet <double>(x => x.Module1Value).Returns(value);
return(module1Property.Object);
}
/*Helper methods*/
public IModule1Property MockModule1Property(SignalCode code, double value)
{
Mock <IModule1Property> mockedProperty = new Mock <IModule1Property>();
mockedProperty.SetupGet(x => x.Code).Returns(code);
mockedProperty.SetupGet(x => x.Module1Value).Returns(value);
return(mockedProperty.Object);
}
public void PackToModule1Property_RegularParameters_AssertObjectContent(SignalCode code, double value)
{
Module1DataAdapter dataAdapter = new Module1DataAdapter(mockedLogger);
IModule1Property module1Property = dataAdapter.PackToModule1Property(code, value);
Assert.AreEqual(module1Property.Code, code);
Assert.AreEqual(module1Property.Module1Value, value);
}
///
/// <param name="signal"></param>
public static Dataset GetDataset(SignalCode signal){
if (signal == SignalCode.CODE_ANALOG || signal == SignalCode.CODE_DIGITAL) return Dataset.SET1;
if (signal == SignalCode.CODE_CUSTOM || signal == SignalCode.CODE_LIMITSET) return Dataset.SET2;
if (signal == SignalCode.CODE_SIGNLENODE|| signal == SignalCode.CODE_MULTIPLENODE) return Dataset.SET3;
return Dataset.SET4;
}
public void WriteProperty_TestDatabase_AssertNoExceptions(SignalCode code, double value)
{
Mock <IModule2Property> property = new Mock <IModule2Property>();
property.SetupGet(x => x.Code).Returns(code);
property.SetupGet(x => x.Value).Returns(value);
Module2DatabaseManager module2DatabaseManager = new Module2DatabaseManager(loggingMock.Object, testDatabaseName);
Assert.DoesNotThrow(() => module2DatabaseManager.WriteProperty(property.Object));
}
public void RepackToCollectionDescription_WrongDatasetForCode_ThrowsException
(int id, Dataset dataset, SignalCode code1, double value1, SignalCode code2, double value2)
{
List <IModule1Property> properties = new List <IModule1Property>
{
MockModule1Property(code1, value1),
MockModule1Property(code2, value2)
};
IDescription description = MockDescription(id, dataset, properties);
Assert.Throws <ArgumentException>(() => adapter.RepackToCollectionDescription(description));
}
public void UpdateDataset_CorrectParameters_VerifyFunctionCalls(SignalCode code, double value)
{
listDescription.Setup(x => x.IsDatasetFull(It.IsAny <Dataset>())).Returns(true);
IModule1 module = new Module1ServiceProvider(logger.Object, module2Proxy.Object, dataAdapter.Object, listDescription.Object, databaseManager.Object);
module.UpdateDataset(value, code);
dataAdapter.Verify(x => x.PackToModule1Property(code, value), Times.Once);
logger.Verify(x => x.LogNewInfo(It.IsAny <string>()), Times.Exactly(3));
listDescription.Verify(x => x.AddOrReplaceProperty(It.IsAny <IModule1Property>()), Times.Once);
module2Proxy.Verify(x => x.UpdateDatabase(It.IsAny <IListDescription>()), Times.Once);
databaseManager.Verify(x => x.WriteProperty(It.IsAny <IModule1Property>()), Times.Once);
}
///
/// <param name="code">Signal code for property</param>
public bool DoesPropertyExist(SignalCode code)
{
logger.LogNewInfo(string.Format("Checking if property exists for signal {0}", code));
foreach (IModule1Property property in propertyList)
{
if (property.Code == code)
{
logger.LogNewInfo("Property found.");
return(true);
}
}
logger.LogNewInfo("Property not found.");
return(false);
}
/*Getters and setters*/
///
/// <param name="code">Signal code for property</param>
public IModule1Property GetPropertyByCode(SignalCode code)
{
logger.LogNewInfo(string.Format("Trying to get property for signal {0}", code));
foreach (IModule1Property property in propertyList)
{
if (property.Code == code)
{
return(property);
}
}
return(null);
}
public void DoesPropertyExist_ExistingProperty_ReturnsTrue(Dataset dataset, SignalCode signal)
{
IModule1Property module1Property = MockModule1Property(signal, 200);
Mock <List <IModule1Property> > mockedList = new Mock <List <IModule1Property> >();
List <IModule1Property> properties = mockedList.Object;
properties.Add(module1Property);
Description description = new Description(dataset, mockedLogger)
{
Properties = properties
};
Assert.IsTrue(description.DoesPropertyExist(signal));
}
///
/// <param name="periodStart">Beginning of the search period</param>
/// <param name="periodEnd">End of the search period</param>
public List<IModule2Property> ReadPropertiesByTimeframe(DateTime periodStart, DateTime periodEnd, SignalCode code)
{
List<IModule2Property> returnList = new List<IModule2Property>();
logger.LogNewInfo(string.Format("Reading properties for code {0} with starting date {1}, end date {2}", code, periodEnd, periodEnd));
Dataset set = DatasetRepository.GetDataset(code);
string tableName = DatabaseTableNamesRepository.GetTableNameByDataset(set);
string signalCode = code.ToString();
string dateStart= periodStart.ToUniversalTime().ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss");
string dateEnd = periodEnd.ToUniversalTime().ToString("yyyy'-'MM'-'dd' 'HH':'mm':'ss");
string query = @"SELECT signalCode, signalValue FROM " + tableName + " WHERE signalCode=@code AND " +
"strftime('%s', timestamp) BETWEEN strftime('%s', @startDate) AND strftime('%s', @endDate) " +
"ORDER BY timestamp DESC ";
using (SQLiteCommand command = new SQLiteCommand(query, databaseConnection))
{
command.Parameters.AddWithValue("@code", signalCode);
command.Parameters.AddWithValue("@startDate", dateStart);
command.Parameters.AddWithValue("@endDate", dateEnd);
try
{
SQLiteDataReader reader = command.ExecuteReader();
while (reader.Read())
{
string retrievedSignal = reader["signalCode"].ToString();
string value = reader["signalValue"].ToString();
SignalCode retrievedCode = (SignalCode)Enum.Parse(typeof(SignalCode), retrievedSignal);
double valueRetrieved = double.Parse(value);
Module2Property property = new Module2Property(retrievedCode, valueRetrieved);
returnList.Add(property);
}
}
catch (Exception ex)
{
logger.LogNewWarning(string.Format("ERROR occured reading database. MESSAGE: {0}", ex.Message));
return returnList;
}
}
logger.LogNewInfo(string.Format("Found {0} properties within the requested timeframe", returnList.Count));
return returnList;
}
public static string SignalCodeToDisplayStr(SignalCode? code)
{
if (code == null || !code.HasValue)
return string.Empty;
switch (code.Value)
{
case SignalCode.Emergency: return "EMERGENCY";
case SignalCode.EmergencyAck: return "EMERGENCY CLEAR";
case SignalCode.PTT: return "PTT";
case SignalCode.RadioCheck: return "RADIO CHECK";
case SignalCode.RadioCheckAck: return "RADIO CHECK ACK";
case SignalCode.RadioRevive: return "RADIO REVIVE";
case SignalCode.RadioReviveAck: return "RADIO REVIVE ACK";
case SignalCode.RadioStun: return "RADIO STUN";
case SignalCode.RadioStunAck: return "RADIO STUN ACK";
case SignalCode.Generic: return string.Empty;
default: return string.Empty;
}
}
///
/// <param name="value">Signal value</param>
/// <param name="signalCode">Code for given signal</param>
public bool UpdateDataset(double value, SignalCode signalCode)
{
logging.LogNewInfo(string.Format("Update dataset called for signal {0} and value {1}", signalCode, value));
Dataset dataset = DatasetRepository.GetDataset(signalCode);
IModule1Property property = dataAdapter.PackToModule1Property(signalCode, value);
listDescription.AddOrReplaceProperty(property);
if (listDescription.IsDatasetFull(dataset))
{
logging.LogNewInfo(string.Format("Dataset {0} is full, sending the whole list to module 2", dataset.ToString()));
module2Proxy.UpdateDatabase(listDescription);
}
logging.LogNewInfo("Calling database manager to write new property..");
databaseManager.WriteProperty(property);
return(true);
}
///
/// <param name="code">Signal code</param>
public IModule2Property ReadLastByCode(SignalCode code)
{
Dataset set = DatasetRepository.GetDataset(code);
string tableName = DatabaseTableNamesRepository.GetTableNameByDataset(set);
string signalCode = code.ToString();
string query = "SELECT ID, signalCode, signalValue FROM " + tableName + " WHERE(signalCode=@code) " +
"ORDER BY timestamp DESC LIMIT 1";
using (SQLiteCommand command = new SQLiteCommand(query, databaseConnection))
{
command.Parameters.AddWithValue("@code", signalCode);
try
{
using (SQLiteDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
string retrievedSignal = reader["signalCode"].ToString();
string value = reader["signalValue"].ToString();
SignalCode retrievedCode = (SignalCode)Enum.Parse(typeof(SignalCode), retrievedSignal);
double valueRetrieved = double.Parse(value);
Module2Property property = new Module2Property(retrievedCode, valueRetrieved);
return property;
}
return null;
}
}catch(Exception ex)
{
logger.LogNewWarning(string.Format("ERROR occured reading database. MESSAGE: {0}", ex.Message));
return null;
}
}
}
public void RepackToCollectionDescription_RegularParameters_AssertObjectContent
(int id, Dataset dataset, SignalCode code1, double value1, SignalCode code2, double value2)
{
List <IModule1Property> properties = new List <IModule1Property>
{
MockModule1Property(code1, value1),
MockModule1Property(code2, value2)
};
IDescription description = MockDescription(id, dataset, properties);
ICollectionDescription collectionDescription = adapter.RepackToCollectionDescription(description);
Assert.AreEqual(dataset, collectionDescription.Dataset);
Assert.AreEqual(id, collectionDescription.ID);
List <IModule2Property> historicalData = collectionDescription.Collection.Properties;
Assert.AreEqual(code1, historicalData[0].Code);
Assert.AreEqual(code2, historicalData[1].Code);
Assert.AreEqual(value1, historicalData[0].Value);
Assert.AreEqual(value2, historicalData[1].Value);
}
public RadioSignalingItem(SignalingSourceType sourceType, string sourceName, string format, SignalCode code, string unitId, string desc, DateTime timestamp, string recordingFileName)
{
this.Latitude = null;
this.Longitude = null;
this.SourceType = sourceType;
this.SourceName = sourceName;
this.SignalingFormat = format;
this.Code = code;
this.UnitId = unitId;
this.Description = desc;
this.Timestamp = timestamp;
this.RecordingFileName = recordingFileName;
this.RadioId = null;
this.AgencyName = string.Empty;
this.UnitName = string.Empty;
this.AssignedPersonnel = string.Empty;
this.AssignedRole = string.Empty;
this.RadioType = RadioTypeCode.Unknown;
this.RadioName = string.Empty;
}
public void AddOrReplaceProperty_ExistingProperty_PropertyReplaced(Dataset dataset, SignalCode signal, double value)
{
IModule1Property existingProperty = MockModule1Property(signal, 100);
IModule1Property newProperty = MockModule1Property(signal, value);
Mock <List <IModule1Property> > mockedList = new Mock <List <IModule1Property> >();
List <IModule1Property> properties = mockedList.Object;
properties.Add(existingProperty);
Description description = new Description(dataset, mockedLogger)
{
Properties = properties
};
IModule1Property propertyInside = description.Properties[0];
Assert.AreEqual(existingProperty.Code, propertyInside.Code);
Assert.AreEqual(existingProperty.Module1Value, propertyInside.Module1Value);
description.AddOrReplaceProperty(newProperty);
propertyInside = description.Properties[0];
Assert.AreEqual(newProperty.Code, propertyInside.Code);
Assert.AreEqual(newProperty.Module1Value, propertyInside.Module1Value);
}
///
/// <param name="code">Signal code for property</param>
/// <param name="value">Value for property</param>
public Module2Property(SignalCode code, double value)
{
this.code = code;
this.codeValue = value;
}
///
/// <param name="signal">Signal code</param>
/// <param name="value">Signal value</param>
public IModule1Property PackToModule1Property(SignalCode signal, double value)
{
logger.LogNewInfo(string.Format("Packing signal {0} and value {1} to module 1 property", signal.ToString(), value));
return(new Module1Property(signal, value));
}
///
/// <param name="startDate">Start date</param>
/// <param name="endDate">End date</param>
public List<IModule2Property> ReadHistory(DateTime startDate, DateTime endDate, SignalCode code)
{
logger.LogNewInfo(string.Format("Request arrived to read from database with start date {0} and end date {1}", startDate, endDate));
return databaseManager.ReadPropertiesByTimeframe(startDate, endDate, code);
}
public void DoesPropertyExist_NonExistingProperty_ReturnsFalse(Dataset dataset, SignalCode signal)
{
Mock <List <IModule1Property> > mockedList = new Mock <List <IModule1Property> >();
List <IModule1Property> properties = mockedList.Object;
Description description = new Description(dataset, mockedLogger)
{
Properties = properties
};
Assert.IsFalse(description.DoesPropertyExist(signal));
}
///
/// <param name="code">Signal code</param>
/// <param name="value">Signal value</param>
public Module1Property(SignalCode code, double value)
{
this.Code = code;
this.Module1Value = value;
}
public SignalCode.eventSet getSignalDataByIDAndType(string EventInstanceID, String DataType)
{
SignalCode sc = new SignalCode();
return(sc.getSignalDataByIDAndType(EventInstanceID, DataType));
}
public SignalCode.eventSet getFaultCurveDataByID(string EventInstanceID)
{
SignalCode sc = new SignalCode();
return(sc.getFaultCurveDataByID(EventInstanceID));
}
public List <SignalCode.FlotSeries> GetFlotData(int eventID, List <int> seriesIndexes)
{
SignalCode sc = new SignalCode();
return(sc.GetFlotData(eventID, seriesIndexes));
}
public void GetPropertyByCode_NonExistingProperty_ReturnsNull(Dataset dataset, SignalCode signal)
{
Mock <List <IModule1Property> > mockedList = new Mock <List <IModule1Property> >();
List <IModule1Property> properties = mockedList.Object;
Description description = new Description(dataset, mockedLogger)
{
Properties = properties
};
Assert.IsNull(description.GetPropertyByCode(signal));
}
public void GetPropertyByCode_ExistingProperty_AssertObjectContent(Dataset dataset, SignalCode signal, double value)
{
IModule1Property module1Property = MockModule1Property(signal, value);
Mock <List <IModule1Property> > mockedList = new Mock <List <IModule1Property> >();
List <IModule1Property> properties = mockedList.Object;
properties.Add(module1Property);
Description description = new Description(dataset, mockedLogger)
{
Properties = properties
};
IModule1Property receivedProperty = description.GetPropertyByCode(signal);
Assert.AreEqual(module1Property.Code, receivedProperty.Code);
Assert.AreEqual(module1Property.Module1Value, receivedProperty.Module1Value);
}
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);
}
///
/// <param name="signal">Signal code</param>
/// <param name="value">Signal value</param>
public IModule2Property PackToModule2Property(SignalCode signal, double value)
{
logger.LogNewInfo(string.Format("Packing module 2 property for signal {0} and value {1}", signal, value));
return(new Module2Property(signal, value));
}
