public void TestInsert() { var context = new DigNDB_SmittestopContext(_options); context.Database.EnsureDeleted(); var genericRepository = new GenericRepository <TemporaryExposureKey>(context); var entity = new TemporaryExposureKey { Id = Guid.NewGuid(), CreatedOn = DateTime.Now, KeyData = new byte[] { 1, 2, 3 }, RollingPeriod = 123, RollingStartNumber = 123, TransmissionRiskLevel = RiskLevel.RISK_LEVEL_LOW }; genericRepository.Insert(entity); context.SaveChanges(); var retrievedEntity = context.TemporaryExposureKey.Find(entity.Id); Assert.AreEqual(retrievedEntity, entity); }
public async Task FilterDuplicateKeys_WhenDuplicateKeys_ReturnsDistinctKeys() { // Arrange var addTemporaryExposureKeyService = CreateTestObject(); var key1 = new TemporaryExposureKey { CreatedOn = DateTime.Now, DaysSinceOnsetOfSymptoms = 2, KeyData = new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } }; var key2 = new TemporaryExposureKey { CreatedOn = DateTime.Now, DaysSinceOnsetOfSymptoms = 2, KeyData = new byte[] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } }; var incomingKeys = new List <TemporaryExposureKey> { key1, key2 }; // Act var ret = await addTemporaryExposureKeyService.FilterDuplicateKeysAsync(incomingKeys); // Assert Assert.That(ret.Count, Is.EqualTo(1)); }
public IEnumerable <TemporaryExposureKeyCountry> Resolve( TemporaryExposureKeyGatewayDto source, TemporaryExposureKey destination, IEnumerable <TemporaryExposureKeyCountry> destMember, ResolutionContext context) { if (source.VisitedCountries == null) { return(new List <TemporaryExposureKeyCountry>()); } var visitedDbCountries = _countryRepository.FindByIsoCodes(source.VisitedCountries).ToList(); // log countries that haven't been found if (source.VisitedCountries != null && visitedDbCountries.Count() != source.VisitedCountries.Count) { var notMappedCountries = source.VisitedCountries .Where(countryCodeFromSource => !visitedDbCountries.Where(country => country.Code.ToLower() == countryCodeFromSource.ToLower()).Any()) .ToList(); var notMappedCountriesStr = string.Join(", ", notMappedCountries); _logger.LogError($"Country codes have not been found in the DataBase: {notMappedCountriesStr}"); } var interectionEnties = visitedDbCountries.Select( country => new TemporaryExposureKeyCountry() { Country = country, CountryId = country.Id, TemporaryExposureKey = destination, TemporaryExposureKeyId = destination.Id }) .ToList(); return(interectionEnties); }
public TemporaryExposureKey Build(byte[] keyData) { var key = new TemporaryExposureKey() { CreatedOn = _prototype.CreatedOn, KeyData = (byte[])keyData.Clone(), KeySource = _prototype.KeySource, Origin = _prototype.Origin, ReportType = _prototype.ReportType, RollingPeriod = _prototype.RollingPeriod, RollingStartNumber = _prototype.RollingStartNumber, TransmissionRiskLevel = _prototype.TransmissionRiskLevel, DaysSinceOnsetOfSymptoms = _prototype.DaysSinceOnsetOfSymptoms, SharingConsentGiven = _prototype.SharingConsentGiven }; var allVisitedCountries = _prototype.VisitedCountries.Select(i => i.Country).ToList(); allVisitedCountries.AddRange(_visitedCountries); key.VisitedCountries = allVisitedCountries.Select(country => { return(new TemporaryExposureKeyCountry() { Country = country, TemporaryExposureKey = key }); }).ToList(); return(key); }
public bool ValidateKeyGateway(TemporaryExposureKey exposureKey, out string errorMessage) { errorMessage = string.Empty; var apiValidationErrorMessage = string.Empty; if (!ValidateKeyAPI(exposureKey, out apiValidationErrorMessage)) { errorMessage += apiValidationErrorMessage; return(!Valid); } if (!ValidateKeyReportType(exposureKey.ReportType)) { errorMessage += $"{ErrorPrefix} ReportType is not valid for this key - {exposureKey.ReportType}"; return(!Valid); } if (!ValidateOrigin(exposureKey.Origin)) { errorMessage += $"{ErrorPrefix} The Origin field is invalid. Code {exposureKey.Origin?.Code}, PullingFromGatewayEnabled= {exposureKey.Origin?.PullingFromGatewayEnabled} "; return(!Valid); } if (!ValidateDaysSinceOnsetOfSymptoms(exposureKey.DaysSinceOnsetOfSymptoms)) { errorMessage += $"{ErrorPrefix} The DaysSinceOnesetOfSymptoms is invalid. It should be in range of {DaysSinceOnsetOfSymptomsInvalidRangeMin} and {DaysSinceOnsetOfSymptomsInvalidRangeMax}."; return(!Valid); } if (!ValidateVisitedCountries(exposureKey.VisitedCountries)) { errorMessage += $"{ErrorPrefix} VisitedCountries array is not empty and it doesn't contain API Origin."; return(!Valid); } return(Valid); }
public void PropertiesTest() { // preparation var model = new TemporaryExposureKey(); // model property access Helper.ModelTestHelper.PropetiesTest(model); }
public void EqualsMethodWithSameReference() { // preparation var instance = new TemporaryExposureKey(); // action assert Assert.IsTrue(instance.Equals(instance)); }
public void CreateMethod() { // preparation var instance = new TemporaryExposureKey(); // assert Assert.IsNotNull(instance); }
public Tek(TemporaryExposureKey tek) { key = Convert.ToBase64String(tek.KeyData); rollingStartNumber = tek.RollingStartIntervalNumber; rollingPeriod = tek.RollingPeriod; reportType = (int)ReportType.ConfirmedClinicalDiagnosis; transmissionRisk = (int)RiskLevel.VeryHigh; }
public void EqualsMethodWithNull() { // preparation var instance = new TemporaryExposureKey(); // action assert Assert.IsFalse(instance.Equals(null)); }
public static DbTemporaryExposureKey FromKey(TemporaryExposureKey key) => new DbTemporaryExposureKey { Base64KeyData = Convert.ToBase64String(key.KeyData), TimestampMsSinceEpoch = DateTimeOffset.UtcNow.ToUnixTimeSeconds(), RollingStartSecondsSinceEpoch = key.RollingStart.ToUnixTimeSeconds(), RollingDuration = (int)key.RollingDuration.TotalMinutes, TransmissionRiskLevel = (int)key.TransmissionRiskLevel };
public Domain.Proto.TemporaryExposureKey FromEntityToProto(TemporaryExposureKey source) { return(new Domain.Proto.TemporaryExposureKey( source.KeyData, (int)source.RollingStartNumber / secTo10min, (int)source.RollingPeriod, (int)source.TransmissionRiskLevel )); }
public TemporaryExposureKey CreateMockedExposureKey() { var mockEntity = new TemporaryExposureKey() { Id = Guid.NewGuid() }; return(mockEntity); }
public void CalculateSizeMethod() { // preparation var instance = new TemporaryExposureKey(); // action var actual = instance.CalculateSize(); // assert Assert.AreEqual(0, actual); }
public static Key FromTemporaryExposureKey(TemporaryExposureKey key) { return(new Key() { KeyData = Convert.ToBase64String(key.Key), RollingStart = (long)(key.RollingStart - DateTime.UnixEpoch).TotalMinutes / 10, RollingDuration = (int)(key.RollingDuration.TotalMinutes / 10), TransmissionRisk = (int)key.TransmissionRiskLevel }); }
public Domain.Proto.TemporaryExposureKey FromEntityToProto(TemporaryExposureKey source) { return(new Domain.Proto.TemporaryExposureKey( source.KeyData, (int)source.RollingStartNumber / secTo10min, (int)source.RollingPeriod, (int)source.TransmissionRiskLevel, (Domain.Proto.TemporaryExposureKey.Types.ReportType)source.ReportType, (int)source.DaysSinceOnsetOfSymptoms )); }
public void EqualsMethod() { // preparation var instance = new TemporaryExposureKey(); // action var actual1 = instance.Clone(); var actual2 = new TemporaryExposureKey(instance); // assert Assert.AreEqual(instance, actual1); Assert.AreEqual(instance, actual2); Assert.AreEqual(instance.GetHashCode(), actual1.GetHashCode()); Assert.AreEqual(instance.GetHashCode(), actual2.GetHashCode()); }
public ExposureKeyMock() { _countryFactory = new CountryMockFactory(); _rndGenerator = new MockRandomGenerator(); _epochConverter = new EpochConverter(); _countries = new List <string>() { "AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE" }; _potentialDuplicate01 = MockValidKey(); _potentialDuplicate02 = MockValidKey(); MockListLength = 5; }
private void SetRiskWhenDaysSinceOnsetOfSymptomsIsUnknown(TemporaryExposureKey key) { // DaysSinceOnsetOfSymptoms are unknown var keyCreationDate = _epochConverter.ConvertFromEpoch(key.RollingStartNumber); var sevenDaysAgo = DateTime.UtcNow.AddDays(-7).Date; if (sevenDaysAgo > keyCreationDate) { key.TransmissionRiskLevel = RiskLevel.RISK_LEVEL_LOWEST; // TODO!!! index! } else { key.TransmissionRiskLevel = RiskLevel.RISK_LEVEL_MEDIUM; // TODO!!! Highest risk level - RiskLevel enum is not a risk level it is a index in the "TransmissionRiskScores" from config. } key.DaysSinceOnsetOfSymptoms = 0; }
public void ResetKeyData(TemporaryExposureKey mockEntity) { var denmark = new Country() { Id = 2, Code = "DK" }; var germany = new Country() { Id = 3, Code = "DE" }; var netherlands = new Country() { Id = 4, Code = "NL" }; var mockedVisitedCountries = new List <TemporaryExposureKeyCountry> { new TemporaryExposureKeyCountry() { Country = denmark, CountryId = denmark.Id }, new TemporaryExposureKeyCountry() { Country = germany, CountryId = germany.Id }, new TemporaryExposureKeyCountry() { Country = netherlands, CountryId = netherlands.Id }, }; mockEntity.RollingPeriod = 144; mockEntity.RollingStartNumber = (int)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalMinutes / 10; mockEntity.CreatedOn = DateTime.UtcNow; mockEntity.TransmissionRiskLevel = RiskLevel.RISK_LEVEL_LOW; mockEntity.Origin = _countryFactory.GenerateCountry(21, "PL"); mockEntity.KeyData = _rndGenerator.GenerateKeyData(16); mockEntity.RollingPeriod = 12; mockEntity.RollingStartNumber = _epochConverter.ConvertToEpoch(DateTime.Today); mockEntity.DaysSinceOnsetOfSymptoms = null; mockEntity.ReportType = ReportType.CONFIRMED_TEST; mockEntity.VisitedCountries = mockedVisitedCountries; }
public bool ValidateKeyAPI(TemporaryExposureKey exposureKey, out string errorMessage) { errorMessage = string.Empty; if (!ValidateKeyData(exposureKey.KeyData)) { errorMessage += $"{ErrorPrefix} The KeyData is not a 16byte field. It has more or less."; return(!Valid); } if (!ValidateRollingPeriod(exposureKey.RollingPeriod)) { errorMessage += $"{ErrorPrefix} The RollingPeriod date should be in range of 10 minutes to 24 hours. RollingPeriod: {exposureKey.RollingPeriod}"; return(!Valid); } if (!ValidateRollingStartNumber(exposureKey.RollingStartNumber)) { errorMessage += $"{ErrorPrefix} The RollingStartNumber date is invalid [in the future or older than 14 days]. RollingStartNumber: {exposureKey.RollingStartNumber}"; return(!Valid); } return(Valid); }
public void EqualsMethodWithSetValue() { // preparation var instance = new TemporaryExposureKey(); instance.KeyData = ByteString.CopyFromUtf8("KeyData"); instance.RollingPeriod = 99; instance.RollingStartIntervalNumber = 99; instance.TransmissionRiskLevel = 4; // action var actual1 = instance.Clone(); var actual2 = new TemporaryExposureKey(instance); var actual3 = new TemporaryExposureKey(); var actual4 = new TemporaryExposureKey(); using var memory = new MemoryStream(); using var codedOut = new CodedOutputStream(memory, true); instance.WriteTo(codedOut); codedOut.Flush(); memory.Position = 0; using var codedIn = new CodedInputStream(memory, true); actual3.MergeFrom(codedIn); actual4.MergeFrom(actual3); // assert Assert.AreEqual(instance, actual1); Assert.AreEqual(instance, actual2); Assert.AreEqual(instance, actual3); Assert.AreEqual(instance, actual4); Assert.AreEqual(instance.GetHashCode(), actual1.GetHashCode()); Assert.AreEqual(instance.GetHashCode(), actual2.GetHashCode()); Assert.AreEqual(instance.GetHashCode(), actual3.GetHashCode()); Assert.AreEqual(instance.GetHashCode(), actual4.GetHashCode()); Assert.AreEqual(instance.CalculateSize(), actual1.CalculateSize()); Assert.AreEqual(instance.CalculateSize(), actual2.CalculateSize()); Assert.AreEqual(instance.CalculateSize(), actual3.CalculateSize()); Assert.AreEqual(instance.CalculateSize(), actual4.CalculateSize()); Assert.AreEqual(instance.ToString(), actual1.ToString()); Assert.AreEqual(instance.ToString(), actual2.ToString()); Assert.AreEqual(instance.ToString(), actual3.ToString()); Assert.AreEqual(instance.ToString(), actual4.ToString()); }
public static TestTemporaryExposureKeyBuilder CreateDefault(Country origin) { var yesterday = DateTime.UtcNow.AddDays(-1); var rollingStartNumber = CurrentUnixTimestampOffsetByDays(-Default.RollingStartNumberDaysAgo); var defaultPrototype = new TemporaryExposureKey() { KeyData = Default.KeyData, CreatedOn = yesterday, DaysSinceOnsetOfSymptoms = Default.DaysSinceOnsetOfSymptoms, Origin = origin, ReportType = Default.ReportType, KeySource = Domain.Enums.KeySource.SmitteStopApiVersion2, RollingPeriod = Default.RollingPeriod, RollingStartNumber = rollingStartNumber, TransmissionRiskLevel = Default.TransmissionRiskLevel, VisitedCountries = new List <TemporaryExposureKeyCountry>(), }; return(new TestTemporaryExposureKeyBuilder(defaultPrototype)); }
public static TemporaryExposureKey ToKey(this TemporaryExposureKeyModel tek) { var key = new TemporaryExposureKey() { KeyData = ByteString.CopyFrom(tek.KeyData), RollingStartIntervalNumber = tek.RollingStartIntervalNumber, RollingPeriod = tek.RollingPeriod, TransmissionRiskLevel = tek.TransmissionRiskLevel, }; if (tek.ReportType != Constants.ReportTypeMissingValue) { key.ReportType = ConvertToReportType(tek.ReportType); } if (tek.DaysSinceOnsetOfSymptoms != Constants.DaysSinceOnsetOfSymptomsMissingValue) { key.DaysSinceOnsetOfSymptoms = tek.DaysSinceOnsetOfSymptoms; } return(key); }
public void FilterDuplicateKeys_GiveKeysInExistingKeys_ShouldReturnKeysThatNotExistBefore(int value) { int listCount = 3; var keys = CreateMockedListExposureKeys(listCount); var existingKeys = new List <TemporaryExposureKey>() { }; for (int i = 0; i <= value; i++) { TemporaryExposureKey existKey = keys[i]; existingKeys.Add(new TemporaryExposureKey() { KeyData = existKey.KeyData, CreatedOn = DateTime.UtcNow.AddDays(-1) }); } var expectedKeysCount = keys.Count - existingKeys.Count; var mapper = new ExposureKeyMapper(); var extractNewKeys = mapper.FilterDuplicateKeys(keys, existingKeys); Assert.AreEqual(extractNewKeys.Count, expectedKeysCount); }
public void AddTemporaryExposureKey_ProvideKey_ShouldAddNewKeyToDB() { TemporaryExposureKey key = new TemporaryExposureKey() { CreatedOn = DateTime.UtcNow.Date, Id = Guid.NewGuid(), KeyData = Encoding.ASCII.GetBytes("keyData"), TransmissionRiskLevel = RiskLevel.RISK_LEVEL_LOW, }; using (var context = new DigNDB_SmittestopContext(_options)) { context.Database.EnsureDeleted(); _repo = new TemporaryExposureKeyRepository(context, _countryRepository.Object); _repo.AddTemporaryExposureKey(key).Wait(); } using (var context = new DigNDB_SmittestopContext(_options)) { var keyInDB = context.TemporaryExposureKey.ToList(); Assert.AreEqual(1, keyInDB.Count); Assert.IsNotNull(keyInDB.FirstOrDefault(k => k.Id == key.Id)); } }
public void EqualsMethodWithClear() { // preparation var instance = new TemporaryExposureKey(); instance.KeyData = ByteString.CopyFromUtf8("KeyData"); instance.RollingPeriod = 99; instance.RollingStartIntervalNumber = 99; instance.TransmissionRiskLevel = 4; var actual = instance.Clone(); // action assert actual.ClearTransmissionRiskLevel(); Assert.AreNotEqual(instance, actual); actual = instance.Clone(); actual.ClearRollingStartIntervalNumber(); Assert.AreNotEqual(instance, actual); actual = instance.Clone(); actual.ClearRollingPeriod(); Assert.AreNotEqual(instance, actual); actual = instance.Clone(); actual.ClearKeyData(); Assert.AreNotEqual(instance, actual); }
private TestTemporaryExposureKeyBuilder(TemporaryExposureKey prototype) { _prototype = prototype; }
public static long GetRollingStartIntervalNumberAsUnixTimeInSec(this TemporaryExposureKey temporaryExposureKey) => temporaryExposureKey.RollingStartIntervalNumber * (60 * 10);
public async Task AddTemporaryExposureKey(TemporaryExposureKey temporaryExposureKey) { _dbContext.TemporaryExposureKey.Add(temporaryExposureKey); await _dbContext.SaveChangesAsync(); }