public async Task SubmitDiagnosisAsyncMethod()
{
// preparation
string SubmissionNumber = "";
DateTimeOffset timestamp = DateTimeOffset.UtcNow;
string UserUuid = "";
TemporaryExposureKeyModel[] keys = new TemporaryExposureKeyModel[] { new TemporaryExposureKeyModel() };
var itemResponse = new Mock <ItemResponse <DiagnosisModel> >();
var cosmos = new Mock <ICosmos>();
cosmos.Setup(_ => _.Diagnosis.UpsertItemAsync
(It.IsAny <DiagnosisModel>(), It.IsAny <PartitionKey?>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()))
.Callback <DiagnosisModel, PartitionKey?, ItemRequestOptions, CancellationToken>((m, p, i, c) =>
{
itemResponse.Setup(_ => _.Resource).Returns(m);
})
.ReturnsAsync(itemResponse.Object)
.Verifiable();
var logger = new Mock.LoggerMock <CosmosDiagnosisRepository>();
var instance = new CosmosDiagnosisRepository(cosmos.Object, logger);
// action
var result = await instance.SubmitDiagnosisAsync(SubmissionNumber, timestamp, UserUuid, keys);
// Assert
Assert.AreEqual(SubmissionNumber, result.SubmissionNumber);
Assert.AreEqual(timestamp.ToUnixTimeSeconds(), result.Timestamp);
Assert.AreEqual(UserUuid, result.UserUuid);
Assert.AreEqual(UserUuid, result.id);
CollectionAssert.AreEqual(keys, result.Keys);
}
public async Task RunApprovedAsyncMethod(string submissionNumber, string userUuid)
{
// preparation
var diagnosisRepo = new Mock <IDiagnosisRepository>();
var keyModel = new TemporaryExposureKeyModel()
{
id = "id123"
};
var model = new DiagnosisModel()
{
SubmissionNumber = submissionNumber,
UserUuid = userUuid,
Keys = new[] { keyModel }
};
diagnosisRepo.Setup(_ => _.GetAsync(It.IsAny <string>(), It.IsAny <string>()))
.ReturnsAsync(model);
var tekRepo = new Mock <ITemporaryExposureKeyRepository>();
var logger = new Mock.LoggerMock <Covid19Radar.Api.External.DiagnosisApi>();
var diagnosisApi = new Covid19Radar.Api.External.DiagnosisApi(diagnosisRepo.Object, tekRepo.Object, logger);
var context = new Mock.HttpContextMock();
tekRepo.Setup(_ => _.UpsertAsync(It.IsAny <TemporaryExposureKeyModel>()))
.Verifiable();
// action
await diagnosisApi.RunApprovedAsync(context.Request, submissionNumber, userUuid);
// assert
}
public void PropertiesTest()
{
// preparation
var model = new TemporaryExposureKeyModel();
// model property access
Helper.ModelTestHelper.PropetiesTest(model);
}
public void CreateMethod()
{
// action
var model = new TemporaryExposureKeyModel();
// assert
Assert.IsNotNull(model);
}
public void GetRollingStartUnixTimeSecondsMethod(int expected, int start)
{
// preparation
var model = new TemporaryExposureKeyModel();
model.RollingStartIntervalNumber = start;
// action
Assert.AreEqual(expected, model.GetRollingStartUnixTimeSeconds());
}
public void GetRollingPeriodSecondsMethod(int expected, int period)
{
// preparation
var model = new TemporaryExposureKeyModel();
model.RollingPeriod = period;
// action
Assert.AreEqual(expected, model.GetRollingPeriodSeconds());
}
public static TemporaryExposureKey ToKey(this TemporaryExposureKeyModel tek)
{
return(new TemporaryExposureKey()
{
KeyData = ByteString.CopyFrom(tek.KeyData),
RollingStartIntervalNumber = tek.RollingStartIntervalNumber,
RollingPeriod = tek.RollingPeriod,
TransmissionRiskLevel = tek.TransmissionRiskLevel
});
}
public async Task <TemporaryExposureKeyModel[]> GetNextAsync()
{
var ins = new TemporaryExposureKeyModel();
ins.KeyData = new byte[64];
ins.RollingPeriod = 24 * 60 / 10;
ins.RollingStartIntervalNumber = (int)(DateTimeOffset.UtcNow.AddDays(-1).ToUnixTimeSeconds() / 60 / 10);
ins.Timestamp = (ulong)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
ins.TransmissionRiskLevel = 0;
return(Enumerable.Repeat(ins, 20000).ToArray());
}
public void ToKeyMethodTest()
{
// preparation
var model = new TemporaryExposureKeyModel();
model.KeyData = new byte[64];
// action
var actual = model.ToKey();
CollectionAssert.AreEqual(model.KeyData, actual.KeyData.ToByteArray());
Assert.AreEqual(model.RollingPeriod, actual.RollingPeriod);
Assert.AreEqual(model.RollingStartIntervalNumber, actual.RollingStartIntervalNumber);
Assert.AreEqual(model.TransmissionRiskLevel, actual.TransmissionRiskLevel);
}
public async Task <TemporaryExposureKeyModel[]> GetNextAsync()
{
_logger.LogInformation($"start {nameof(GetNextAsync)}");
// TODO: implement query
var ins = new TemporaryExposureKeyModel();
ins.KeyData = new byte[64];
ins.RollingPeriod = 24 * 60 / 10;
ins.RollingStartIntervalNumber = (int)(DateTimeOffset.UtcNow.AddDays(-1).ToUnixTimeSeconds() / 60 / 10);
ins.Timestamp = (ulong)DateTimeOffset.UtcNow.ToUnixTimeSeconds();
ins.TransmissionRiskLevel = 0;
ins.Region = "Country";
return(Enumerable.Repeat(ins, 40000).ToArray());
}
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 CreateMethod()
{
// action
var model = new TemporaryExposureKeyModel();
}
public async Task UpsertAsync(TemporaryExposureKeyModel model)
{
_logger.LogInformation($"start {nameof(UpsertAsync)}");
var pk = new PartitionKey(model.PartitionKey);
await _db.TemporaryExposureKey.UpsertItemAsync(model, pk);
}
public async Task DeleteAsync(TemporaryExposureKeyModel model)
{
_logger.LogInformation($"start {nameof(DeleteAsync)}");
var pk = new PartitionKey(model.PartitionKey);
await _db.TemporaryExposureKey.DeleteItemAsync <TemporaryExposureKeyModel>(model.id, pk);
}
