public async Task PostRegisterUserAsyncTestsAsync_Failure()
{
var mockHttpClient = new HttpClient(new MockHttpHandler((r, c) =>
{
var absoluteUri = r.RequestUri.AbsoluteUri;
if (absoluteUri.EndsWith("/api/register"))
{
var response = new HttpResponseMessage(HttpStatusCode.ServiceUnavailable);
return(response);
}
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}));
mockHttpClientService.Setup(x => x.Create()).Returns(mockHttpClient);
mockServerConfigurationRepository.Setup(x => x.UserRegisterApiEndpoint)
.Returns(IServerConfigurationRepository.CombineAsUrl(AppSettings.Instance.ApiUrlBase, "api/register"));
var unitUnderTest = CreateService();
var result = await unitUnderTest.PostRegisterUserAsync();
mockLoggerService.Verify(x => x.StartMethod("PostRegisterUserAsync", It.IsAny <string>(), It.IsAny <int>()), Times.Once());
mockLoggerService.Verify(x => x.EndMethod("PostRegisterUserAsync", It.IsAny <string>(), It.IsAny <int>()), Times.Once());
mockLoggerService.Verify(x => x.Exception(It.IsAny <string>(), It.IsAny <Exception>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()), Times.Never());
Assert.False(result);
}
public EditServerConfigurationPageViewModel(
INavigationService navigationService,
IServerConfigurationRepository serverConfigurationRepository
) : base(navigationService)
{
Title = "Edit ServerConfiguration";
_serverConfigurationRepository = serverConfigurationRepository;
Task.Run(async() =>
{
await _serverConfigurationRepository.LoadAsync();
UserRegisterApiEndpoint = _serverConfigurationRepository.UserRegisterApiEndpoint;
Regions = string.Join(",", _serverConfigurationRepository.Regions);
DiagnosisKeyRegisterApiEndpoint = _serverConfigurationRepository.DiagnosisKeyRegisterApiEndpoint;
DiagnosisKeyListProvideServerEndpoint = _serverConfigurationRepository.DiagnosisKeyListProvideServerEndpoint;
InquiryLogApiUrl = _serverConfigurationRepository.InquiryLogApiUrl;
LogStorageEndpoint = _serverConfigurationRepository.LogStorageEndpoint;
ExposureConfigurationUrl = _serverConfigurationRepository.ExposureConfigurationUrl;
ExposureRiskCalculationConfigurationUrl = _serverConfigurationRepository.ExposureRiskCalculationConfigurationUrl;
ExposureDataCollectServerEndpoint = _serverConfigurationRepository.ExposureDataCollectServerEndpoint;
EventLogApiEndpoint = _serverConfigurationRepository.EventLogApiEndpoint;
UpdateUrls();
});
}
public async Task PostRegisterUserAsyncTestsAsync_Success()
{
var mockHttpClient = new HttpClient(new MockHttpHandler((r, c) =>
{
var absoluteUri = r.RequestUri.AbsoluteUri;
if (absoluteUri.EndsWith("/api/register"))
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent("{}");
response.Content.Headers.Remove("Content-Type");
response.Content.Headers.Add("Content-Type", "application/json");
return(response);
}
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}));
mockHttpClientService.Setup(x => x.Create()).Returns(mockHttpClient);
mockServerConfigurationRepository.Setup(x => x.UserRegisterApiEndpoint)
.Returns(IServerConfigurationRepository.CombineAsUrl(AppSettings.Instance.ApiUrlBase, "api/register"));
var unitUnderTest = CreateService();
var result = await unitUnderTest.PostRegisterUserAsync();
mockLoggerService.Verify(x => x.StartMethod("PostRegisterUserAsync", It.IsAny <string>(), It.IsAny <int>()), Times.Once());
mockLoggerService.Verify(x => x.EndMethod("PostRegisterUserAsync", It.IsAny <string>(), It.IsAny <int>()), Times.Once());
mockLoggerService.Verify(x => x.Exception(It.IsAny <string>(), It.IsAny <Exception>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()), Times.Never());
Assert.Null(mockHttpClient.DefaultRequestHeaders.Authorization);
}
public DebugPageViewModel(
INavigationService navigationService,
ITermsUpdateService termsUpdateService,
IExposureConfigurationRepository exposureConfigurationRepository,
IUserDataRepository userDataRepository,
IExposureDataRepository exposureDataRepository,
AbsExposureNotificationApiService exposureNotificationApiService,
AbsExposureDetectionBackgroundService exposureDetectionBackgroundService,
ICloseApplicationService closeApplicationService,
IServerConfigurationRepository serverConfigurationRepository,
ILocalNotificationService localNotificationService,
ISendEventLogStateRepository sendEventLogStateRepository,
IEventLogRepository eventLogRepository,
IEventLogService eventLogService
) : base(navigationService)
{
Title = "Title:Debug";
_termsUpdateService = termsUpdateService;
_exposureConfigurationRepository = exposureConfigurationRepository;
_userDataRepository = userDataRepository;
_exposureDataRepository = exposureDataRepository;
_exposureNotificationApiService = exposureNotificationApiService;
_exposureDetectionBackgroundService = exposureDetectionBackgroundService;
_closeApplicationService = closeApplicationService;
_serverConfigurationRepository = serverConfigurationRepository;
_localNotificationService = localNotificationService;
_sendEventLogStateRepository = sendEventLogStateRepository;
_eventLogRepository = eventLogRepository;
_eventLogService = eventLogService;
}
public void CombineAsUrlTest_manySlashes()
{
string[] paths = new[] { "/foo", "//bar" };
string result = IServerConfigurationRepository.CombineAsUrl(paths);
Assert.Equal("foo/bar", result);
}
public void CombineAsUrlTest_keepLastOneSlash()
{
string[] paths = new[] { "/foo", "/bar//" };
string result = IServerConfigurationRepository.CombineAsUrl(paths);
Assert.Equal("foo/bar/", result);
}
public DebugExposureDataCollectServer(
ILoggerService loggerService,
IServerConfigurationRepository serverConfigurationRepository,
IHttpClientService httpClientService
)
{
_loggerService = loggerService;
_serverConfigurationRepository = serverConfigurationRepository;
_httpClient = httpClientService.Create();
}
public HttpDataService(
ILoggerService loggerService,
IHttpClientService httpClientService,
IServerConfigurationRepository serverConfigurationRepository
)
{
this.loggerService = loggerService;
this.httpClientService = httpClientService;
this.serverConfigurationRepository = serverConfigurationRepository;
apiClient = CreateApiClient();
httpClient = CreateHttpClient();
}
public ExposureRiskCalculationConfigurationRepository(
IHttpClientService httpClientService,
ILocalPathService localPathService,
IServerConfigurationRepository serverConfigurationRepository,
ILoggerService loggerService
)
{
_localPathService = localPathService;
_serverConfigurationRepository = serverConfigurationRepository;
_loggerService = loggerService;
_httpClient = httpClientService.Create();
_httpClient.Timeout = TimeSpan.FromSeconds(TIMEOUT_SECONDS);
_configDir = PrepareConfigDir();
_currentPath = localPathService.CurrentExposureRiskCalculationConfigurationPath;
}
public EventLogService(
IUserDataRepository userDataRepository,
IServerConfigurationRepository serverConfigurationRepository,
IEssentialsService essentialsService,
IDeviceVerifier deviceVerifier,
IDateTimeUtility dateTimeUtility,
IHttpClientService httpClientService,
ILoggerService loggerService
)
{
_userDataRepository = userDataRepository;
_serverConfigurationRepository = serverConfigurationRepository;
_essentialsService = essentialsService;
_deviceVerifier = deviceVerifier;
_dateTimeUtility = dateTimeUtility;
_loggerService = loggerService;
_httpClient = httpClientService.Create();
}
public AbsExposureDetectionBackgroundService(
IDiagnosisKeyRepository diagnosisKeyRepository,
AbsExposureNotificationApiService exposureNotificationApiService,
IExposureConfigurationRepository exposureConfigurationRepository,
ILoggerService loggerService,
IUserDataRepository userDataRepository,
IServerConfigurationRepository serverConfigurationRepository,
ILocalPathService localPathService,
IDateTimeUtility dateTimeUtility
)
{
_diagnosisKeyRepository = diagnosisKeyRepository;
_exposureNotificationApiService = exposureNotificationApiService;
_exposureConfigurationRepository = exposureConfigurationRepository;
_loggerService = loggerService;
_userDataRepository = userDataRepository;
_serverConfigurationRepository = serverConfigurationRepository;
_localPathService = localPathService;
_dateTimeUtility = dateTimeUtility;
}
public ExposureConfigurationRepository(
IHttpClientService httpClientService,
ILocalPathService localPathService,
IPreferencesService preferencesService,
IServerConfigurationRepository serverConfigurationRepository,
IDateTimeUtility dateTimeUtility,
ILoggerService loggerService
)
{
_localPathService = localPathService;
_preferencesService = preferencesService;
_serverConfigurationRepository = serverConfigurationRepository;
_dateTimeUtility = dateTimeUtility;
_loggerService = loggerService;
_httpClient = httpClientService.Create();
_httpClient.Timeout = TimeSpan.FromSeconds(TIMEOUT_SECONDS);
_configDir = PrepareConfigDir();
_currentExposureConfigurationPath = localPathService.CurrentExposureConfigurationPath;
}
public ExposureDetectionBackgroundServiceMock(
IDiagnosisKeyRepository diagnosisKeyRepository,
AbsExposureNotificationApiService exposureNotificationApiService,
IExposureConfigurationRepository exposureConfigurationRepository,
ILoggerService loggerService,
IUserDataRepository userDataRepository,
IServerConfigurationRepository serverConfigurationRepository,
ILocalPathService localPathService,
IDateTimeUtility dateTimeUtility
) : base(
diagnosisKeyRepository,
exposureNotificationApiService,
exposureConfigurationRepository,
loggerService,
userDataRepository,
serverConfigurationRepository,
localPathService,
dateTimeUtility
)
{
}
public GroupConfigurationController(IServerConfigurationRepository configurationRepository)
{
this.configurationRepository = configurationRepository;
}
public SystemMonitorController(IServerConfigurationRepository configurationRepository)
{
this.configurationRepository = configurationRepository;
}
public SystemMonitorController(IServerConfigurationRepository configurationRepository)
{
this.configurationRepository = configurationRepository;
}
public async Task PutSelfExposureKeysAsync_Success()
{
HttpContent requestContent = null;
var mockHttpClient = new HttpClient(new MockHttpHandler((r, c) =>
{
var absoluteUri = r.RequestUri.AbsoluteUri;
if (absoluteUri.EndsWith("/api/v3/diagnosis"))
{
requestContent = r.Content;
var response = new HttpResponseMessage(HttpStatusCode.NoContent);
response.Content = new StringContent("");
return(response);
}
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}));
mockHttpClientService.Setup(x => x.Create()).Returns(mockHttpClient);
mockServerConfigurationRepository.Setup(x => x.DiagnosisKeyRegisterApiUrls)
.Returns(new List <string>()
{
IServerConfigurationRepository.CombineAsUrl(AppSettings.Instance.ApiUrlBase, "api/v3/diagnosis")
});
var unitUnderTest = CreateService();
var request = new DiagnosisSubmissionParameter()
{
Keys = new DiagnosisSubmissionParameter.Key[] {
new DiagnosisSubmissionParameter.Key()
{
KeyData = "key-data",
RollingStartNumber = 1,
RollingPeriod = 2
}
},
Regions = new string[] { "440" },
Platform = "platform",
DeviceVerificationPayload = "device-verification-payload",
AppPackageName = "app-package-name",
VerificationPayload = "verification-payload",
Padding = "padding"
};
var result = await unitUnderTest.PutSelfExposureKeysAsync(request);
mockLoggerService.Verify(x => x.StartMethod("PutSelfExposureKeysAsync", It.IsAny <string>(), It.IsAny <int>()), Times.Once());
mockLoggerService.Verify(x => x.EndMethod("PutSelfExposureKeysAsync", It.IsAny <string>(), It.IsAny <int>()), Times.Once());
mockLoggerService.Verify(x => x.Exception(It.IsAny <string>(), It.IsAny <Exception>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>()), Times.Never());
Assert.Equal(HttpStatusCode.NoContent, result);
Assert.NotNull(requestContent);
var stringContent = await requestContent.ReadAsStringAsync();
Assert.NotEmpty(stringContent);
var jsonContent = JsonConvert.DeserializeObject(stringContent) as JObject;
Assert.NotNull(jsonContent);
var keys = jsonContent["keys"] as JArray;
Assert.Single(keys);
Assert.Equal("key-data", keys[0]["keyData"].Value <string>());
Assert.Equal(1, keys[0]["rollingStartNumber"].Value <long>());
Assert.Equal(2, keys[0]["rollingPeriod"].Value <long>());
var rgions = jsonContent["regions"] as JArray;
Assert.Equal("440", rgions[0].Value <string>());
Assert.Equal("platform", jsonContent["platform"].Value <string>());
Assert.Equal("device-verification-payload", jsonContent["deviceVerificationPayload"].Value <string>());
Assert.Equal("app-package-name", jsonContent["appPackageName"].Value <string>());
Assert.Equal("verification-payload", jsonContent["verificationPayload"].Value <string>());
Assert.Equal("padding", jsonContent["padding"].Value <string>());
Assert.Null(jsonContent["userUuid"]);
Assert.Null(mockHttpClient.DefaultRequestHeaders.Authorization);
}
public GroupConfigurationController(IServerConfigurationRepository configurationRepository)
{
this.configurationRepository = configurationRepository;
}
