public void Init()
{
CreatePemFile();
_epochConverter = new EpochConverter();
_mapper = new ExposureKeyMapper(_epochConverter);
SetupMockConfiguration();
}
public void MapDtoWithSharingTrue_ToEntity_ShouldHaveSharingTrue()
{
//Arrange
var dto = new TemporaryExposureKeyBatchDto()
{
keys = new List <TemporaryExposureKeyDto>
{
new TemporaryExposureKeyDto()
{
},
new TemporaryExposureKeyDto()
{
}
},
isSharingAllowed = true
};
var mapper = new ExposureKeyMapper(_epochConverter);
//Act
var entities = mapper.FromDtoToEntity(dto);
//Assert
entities.Should().NotBeNull();
entities.Should().NotBeEmpty();
entities.Select(ent => ent.SharingConsentGiven).Should().AllBeEquivalentTo(true);
}
private void SetupTemporaryExposureKeyExport()
{
var data = new List <TemporaryExposureKey> {
new TemporaryExposureKey
{
CreatedOn = DateTime.UtcNow.Date,
Id = Guid.NewGuid(),
KeyData = Encoding.ASCII.GetBytes("keyData1"),
TransmissionRiskLevel = RiskLevel.RISK_LEVEL_LOW,
ReportType = ReportType.CONFIRMED_TEST,
DaysSinceOnsetOfSymptoms = 1
},
new TemporaryExposureKey
{
CreatedOn = DateTime.UtcNow.Date.AddDays(-12),
Id = Guid.NewGuid(),
KeyData = Encoding.ASCII.GetBytes("keyData2"),
TransmissionRiskLevel = RiskLevel.RISK_LEVEL_HIGH,
ReportType = ReportType.CONFIRMED_TEST,
DaysSinceOnsetOfSymptoms = 2
}
};
ExposureKeyMapper mapper = new ExposureKeyMapper(_epochConverter);
_exportBatch = mapper.FromEntityToProtoBatch(data);
}
public void FromEntityToProto_GiveEntity_ShouldReturnCorrectProtoModel()
{
var mockEntity = CreateMockedExposureKey();
var mapper = new ExposureKeyMapper(_epochConverter);
var protoModel = mapper.FromEntityToProto(mockEntity);
Assert.AreEqual(mockEntity.KeyData, protoModel.KeyData);
Assert.AreEqual((int)mockEntity.RollingPeriod, protoModel.RollingPeriod);
Assert.AreEqual((int)mockEntity.RollingStartNumber / (60 * 10), protoModel.RollingStartIntervalNumber);
Assert.AreEqual((int)mockEntity.TransmissionRiskLevel, protoModel.TransmissionRiskLevel);
Assert.IsInstanceOf <Domain.Proto.TemporaryExposureKey>(protoModel);
}
public void Init()
{
_exposureKeyMock = new ExposureKeyMock();
_countryFactory = new CountryMockFactory();
_mockServices = new SetupMockedServices();
_keyValidator = new Mock <IKeyValidator>(MockBehavior.Strict);
_logger = new Mock <ILogger <KeyFilter> >();
_repository = new Mock <ITemporaryExposureKeyRepository>(MockBehavior.Strict);
_countryRepository = new Mock <ICountryRepository>(MockBehavior.Strict);
_mockServices.SetupMapperAndCountryRepositoryMock(_countryRepository);
_keyMapper = _mockServices.CreateAutoMapperWithDependencies(_countryRepository.Object);
_mockServices.SetupKeyValidatorMock(_keyValidator);
_mockServices.SetupTemopraryExposureKeyRepositoryMock(_repository);
var mapper = new ExposureKeyMapper();
_keyFilter = new KeyFilter(_keyMapper, _keyValidator.Object, mapper, _logger.Object, _repository.Object);
}
public void FromEntityToProtoBatch_GiveEntityList_ShouldReturnCorrectProtoBatchModel()
{
int listCount = 3;
var keys = CreateMockedListExposureKeys(listCount);
var keysByTime = keys.OrderBy(k => k.CreatedOn);
var startTimes = new DateTimeOffset(keysByTime.First().CreatedOn);
var endTimes = new DateTimeOffset(keysByTime.Last().CreatedOn);
var mapper = new ExposureKeyMapper(_epochConverter);
var protoBatch = mapper.FromEntityToProtoBatch(keys);
Assert.AreEqual(listCount, protoBatch.Keys.Count);
Assert.AreEqual(protoBatch.BatchNum, 1);
Assert.AreEqual(protoBatch.BatchSize, 1);
Assert.AreEqual(protoBatch.StartTimestamp, startTimes.ToUnixTimeSeconds());
Assert.AreEqual(protoBatch.EndTimestamp, endTimes.ToUnixTimeSeconds());
Assert.AreEqual(protoBatch.Region, "NO");
Assert.IsInstanceOf <Domain.Proto.TemporaryExposureKeyExport>(protoBatch);
}
private EuGatewayService CreateGatewayServiceAndDependencies(IGatewayHttpClient httpClient)
{
_keysRepository = new TemporaryExposureKeyRepository(_dbContext, _countryRepository, _temporaryExposureKeyRepositoryLogger.Object);
var signatureServiceMock = new Mock <ISignatureService>(MockBehavior.Strict);
var webContextReader = new GatewayWebContextReader(_autoMapper, _loggerGatewayWebContextReader.Object);
var epochConverter = new EpochConverter();
var keyValidator = new KeyValidator(epochConverter);
var exposureKeyMapper = new ExposureKeyMapper(_epochConverter);
var keyFilterLoggerMock = new Mock <ILogger <KeyFilter> >(MockBehavior.Loose);
var keyFilter = new KeyFilter(_autoMapper, keyValidator, exposureKeyMapper, keyFilterLoggerMock.Object, _keysRepository);
var storeServiceLoggerMock = new Mock <ILogger <EFGSKeyStoreService> >();
var riskCalculator = new RiskCalculator();
var dsosDecoder = new DaysSinceOnsetOfSymptomsDecoder();
var addTemporaryExposureKeyService = new Mock <IAddTemporaryExposureKeyService>(MockBehavior.Strict);
addTemporaryExposureKeyService
.Setup(x => x.FilterDuplicateKeysAsync(It.IsAny <List <TemporaryExposureKey> >()))
.ReturnsAsync((List <TemporaryExposureKey> argument) =>
{
return(argument);
});
var storeService = new EFGSKeyStoreService(keyFilter, _keysRepository, storeServiceLoggerMock.Object, riskCalculator, epochConverter, dsosDecoder, addTemporaryExposureKeyService.Object);
var gatewayServiceLoggerMock = new Mock <ILogger <EuGatewayService> >(MockBehavior.Loose);
return(CreateGatewayService(
_keysRepository,
signatureServiceMock.Object,
_autoMapper,
httpClient,
keyFilter,
webContextReader,
storeService,
gatewayServiceLoggerMock.Object,
epochConverter,
_config
));
}
private void SetupTemporaryExposureKeyExport()
{
var data = new List <TemporaryExposureKey> {
new TemporaryExposureKey()
{
CreatedOn = DateTime.UtcNow.Date,
Id = Guid.NewGuid(),
KeyData = Encoding.ASCII.GetBytes("keyData1"),
TransmissionRiskLevel = RiskLevel.RISK_LEVEL_LOW,
},
new TemporaryExposureKey()
{
CreatedOn = DateTime.UtcNow.Date.AddDays(-12),
Id = Guid.NewGuid(),
KeyData = Encoding.ASCII.GetBytes("keyData2"),
TransmissionRiskLevel = RiskLevel.RISK_LEVEL_HIGH,
}
};
ExposureKeyMapper mapper = new ExposureKeyMapper();
_exportBatch = mapper.FromEntityToProtoBatch(data);
}
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);
}
