private EuGatewayService CreateGatewayService(
TemporaryExposureKeyRepository keysRepository,
ISignatureService signatureService,
IMapper autoMapper,
IGatewayHttpClient gateWayHttpClient,
IKeyFilter keyFilter,
IGatewayWebContextReader webContextReader,
IEFGSKeyStoreService storeService,
ILogger <EuGatewayService> logger,
EuGatewayConfig config)
{
var encodingService = new EncodingService();
var epochConverter = new EpochConverter();
var gatewaySyncStateSettingsDao = new GatewaySyncStateSettingsDao(new SettingRepository(_dbContext));
var settingsService = new SettingsService(gatewaySyncStateSettingsDao);
return(new EuGatewayService(
keysRepository,
signatureService,
encodingService,
keyFilter,
webContextReader,
autoMapper,
logger,
config,
settingsService,
epochConverter,
gateWayHttpClient,
storeService));
}
private EuGatewayService CreateGatewayServiceAndDependencies(IGatewayHttpClient httpClient)
{
var translationsRepositoryMock = new Mock <IGenericRepository <Translation> >(MockBehavior.Strict);
IOriginSpecificSettings originConfig = new AppSettingsConfig()
{
OriginCountryCode = _originCountry.Code.ToUpper()
};
var countryRepository = new CountryRepository(_dbContext, translationsRepositoryMock.Object, originConfig);
var keysRepository = new TemporaryExposureKeyRepository(_dbContext, countryRepository, _logger.Object);
var signatureServiceMock = new Mock <ISignatureService>(MockBehavior.Strict);
signatureServiceMock.Setup(sigService => sigService.Sign(It.IsAny <TemporaryExposureKeyGatewayBatchProtoDto>(), Domain.SortOrder.ASC))
.Returns(new byte[] { 1, 2, 3, 4, 5, 6, 7 });
var webContextReaderMock = new Mock <IGatewayWebContextReader>(MockBehavior.Strict);
var loggerMock = new Mock <ILogger <EuGatewayService> >(MockBehavior.Loose);
var keyFilterMock = new Mock <IKeyFilter>(MockBehavior.Strict);
var storeService = new Mock <IEFGSKeyStoreService>(MockBehavior.Strict);
var autoMapper = CreateAutoMapperWithDependencies(countryRepository);
return(CreateGatewayService(keysRepository,
signatureServiceMock.Object,
autoMapper,
httpClient,
keyFilterMock.Object,
webContextReaderMock.Object,
storeService.Object,
loggerMock.Object,
_config
));
}
public void RemoveKeyDuplicates_ShouldOnlyWorkOnKeysCreatedUpTo14DaysAgo()
{
var options = new DbContextOptionsBuilder <DigNDB_SmittestopContext>()
.UseInMemoryDatabase(nameof(EuGatewayServiceUploadTest))
.Options;
var dbContext = new DigNDB_SmittestopContext(options);
dbContext.Database.EnsureDeleted();
var translationsRepositoryMock = new Mock <IGenericRepository <Translation> >(MockBehavior.Strict);
var originSpecificSettings = new AppSettingsConfig()
{
OriginCountryCode = "dk"
};
var countryRepository = new CountryRepository(dbContext, translationsRepositoryMock.Object, originSpecificSettings);
var keysRepository = new TemporaryExposureKeyRepository(dbContext, countryRepository);
_keyFilter = new KeyFilter(_keyMapper, _keyValidator.Object, new ExposureKeyMapper(), _logger.Object, keysRepository);
var rollingStartNumberNewerThan14Days = DateTimeOffset.Now.Subtract(new TimeSpan(DaysOffset - 1, 0, 0, 0)).ToUnixTimeSeconds();
var rollingStartNumberOlderThan14Days = DateTimeOffset.Now.Subtract(new TimeSpan(DaysOffset + 3, 0, 0, 0)).ToUnixTimeSeconds();
var origin = new Country {
Id = 1
};
var keysNewerThan14Days = new List <TemporaryExposureKey>
{
new TemporaryExposureKey {
Id = Guid.NewGuid(), RollingStartNumber = rollingStartNumberNewerThan14Days, Origin = origin, KeyData = new byte[] { 1 }
},
};
var keysOlderThan14Days = new List <TemporaryExposureKey>
{
new TemporaryExposureKey {
Id = Guid.NewGuid(), RollingStartNumber = rollingStartNumberOlderThan14Days, Origin = origin, KeyData = new byte[] { 2 }
},
new TemporaryExposureKey {
Id = Guid.NewGuid(), RollingStartNumber = rollingStartNumberOlderThan14Days, Origin = origin, KeyData = new byte[] { 3 }
},
};
var keyList = keysNewerThan14Days.Concat(keysOlderThan14Days).ToList();
dbContext.TemporaryExposureKey.AddRange(keyList);
dbContext.SaveChanges();
var filteredList = _keyFilter.RemoveKeyDuplicatesAsync(keyList).Result;
filteredList.Count.Should().Be(keysOlderThan14Days.Count);
}
public void AddTemporaryExposureKeys_ProvideKeys_ShouldAddNewKeysToDB()
{
var data = CreateMockedListExposureKeys(DateTime.UtcNow, 4, false);
using (var context = new DigNDB_SmittestopContext(_options))
{
context.Database.EnsureDeleted();
_repo = new TemporaryExposureKeyRepository(context, _countryRepository.Object);
_repo.AddTemporaryExposureKeys(data).Wait();
}
using (var context = new DigNDB_SmittestopContext(_options))
{
var keyInDB = context.TemporaryExposureKey.ToList();
Assert.AreEqual(4, keyInDB.Count);
}
}
public void GetAllKeyData_HaveData_ShouldReturnCorrectResult()
{
var data = CreateMockedListExposureKeys(DateTime.UtcNow, 4, true);
var expectKeysData = data.Select(x => x.KeyData).ToList();
using (var context = new DigNDB_SmittestopContext(_options))
{
context.Database.EnsureDeleted();
//add data to context
context.TemporaryExposureKey.AddRange(data);
context.SaveChanges();
_repo = new TemporaryExposureKeyRepository(context, _countryRepository.Object);
var keys = _repo.GetAllKeyData().Result;
CollectionAssert.AreEqual(expectKeysData, keys);
}
}
public void GetAll_HaveData_ShouldReturnCorrectNumberOfRecord()
{
var expectKeys = 4;
var data = CreateMockedListExposureKeys(DateTime.UtcNow, expectKeys, true);
using (var context = new DigNDB_SmittestopContext(_options))
{
context.Database.EnsureDeleted();
//add data to context
context.TemporaryExposureKey.AddRange(data);
context.SaveChanges();
_repo = new TemporaryExposureKeyRepository(context, _countryRepository.Object);
var keys = _repo.GetAll().Result;
Assert.AreEqual(expectKeys, keys.Count);
}
}
public void GetById_HaveRecord_ShouldReturnCorrectRecord()
{
var data = CreateMockedListExposureKeys(DateTime.UtcNow, 4, true);
using (var context = new DigNDB_SmittestopContext(_options))
{
context.Database.EnsureDeleted();
context.TemporaryExposureKey.AddRange(data);
context.SaveChanges();
_repo = new TemporaryExposureKeyRepository(context, _countryRepository.Object);
var expectKey = data[0];
var actualKey = _repo.GetById(expectKey.Id).Result;
Assert.AreEqual(expectKey.Id, actualKey.Id);
Assert.AreEqual(expectKey.TransmissionRiskLevel, actualKey.TransmissionRiskLevel);
Assert.AreEqual(expectKey.CreatedOn, actualKey.CreatedOn);
Assert.AreEqual(expectKey.KeyData, actualKey.KeyData);
}
}
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
));
}
public void GetTemporaryExposureKeys_HaveRecord_ShouldReturnCorrectRecordMatchedRequirement()
{
var expectDate = DateTime.UtcNow;
var dataForCurrentDate = CreateMockedListExposureKeys(expectDate, 2, true);
var dataForOtherDate = CreateMockedListExposureKeys(expectDate.AddDays(-12), 3, true);
var dataForNotDK = CreateMockedListExposureKeys(expectDate.AddDays(-12), 3, false);
using (var context = new DigNDB_SmittestopContext(_options))
{
context.Database.EnsureDeleted();
//add data to context
context.TemporaryExposureKey.AddRange(dataForCurrentDate);
context.TemporaryExposureKey.AddRange(dataForOtherDate);
context.TemporaryExposureKey.AddRange(dataForNotDK);
context.SaveChanges();
_repo = new TemporaryExposureKeyRepository(context, _countryRepository.Object);
var keys = _repo.GetKeysOnlyFromApiOriginCountry(expectDate, 0);
Assert.AreEqual(dataForCurrentDate.Count, keys.Count);
}
}
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));
}
}
