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)); }