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