public async Task ReturnObjecResultsWithHybridConnectionDtoAndStatusCodeOkAsync() { // Arrange IRelayAzureManagementService relayAzureManagementService = A.Fake <IRelayAzureManagementService>(); ILogger logger = A.Fake <ILogger>(); var sut = new RelayHybridConnectionApi(relayAzureManagementService); var httpContext = new DefaultHttpContext(); var createRelayStorageDto = new CreateRelayDto() { TenantId = TestHelper.TenantId }; var httpRequest = new DefaultHttpRequest(httpContext) { Body = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(createRelayStorageDto))) }; var hybridConnectionDto = new HybridConnectionDto(TestHelper.GetDefaultLocalHostUri, new PolicyDto[2] { TestHelper.GetListenPolicyDto(), TestHelper.GetSendPolicyDto() }); A.CallTo(() => relayAzureManagementService.CreateHybridConnection(createRelayStorageDto)).WithAnyArguments().Returns(hybridConnectionDto); // Act IActionResult actual = await sut.CreateRelayHybridConnectionAsync(httpRequest, logger); // Assert Assert.Equal(HttpStatusCode.OK, (HttpStatusCode)((ObjectResult)actual).StatusCode); Assert.Equal(hybridConnectionDto, (HybridConnectionDto)((ObjectResult)actual).Value); }
async Task <HttpResponseMessage> IProxyRelayCallService.ProxyRelayCallAsync(string tenantId, string body, HttpMethod httpMethod, IHeaderDictionary httpHeaders, string url) { if (string.IsNullOrWhiteSpace(body)) { throw new ArgumentNullException(nameof(body)); } if (string.IsNullOrWhiteSpace(tenantId)) { throw new ArgumentNullException(nameof(tenantId)); } if (string.IsNullOrWhiteSpace(url)) { throw new ArgumentNullException(nameof(url)); } if (httpMethod is null) { throw new ArgumentNullException(nameof(httpMethod)); } HybridConnectionDto hybridConnectionDto = await _storageApiClient.GetRelayFromIdAsync(tenantId); if (hybridConnectionDto is null) { return(new HttpResponseMessage(HttpStatusCode.NotFound)); } var relayCallDto = new RelayCallDto(hybridConnectionDto, body, httpMethod, httpHeaders, url); return(await _relayApiClient.RelayCallAsync(relayCallDto)); }
public async Task <IActionResult> GetRelayListnerInformationAsync([HttpTrigger(AuthorizationLevel.Function, "get", Route = "relay-management/relayinfo/{relayId}/listener")] HttpRequest req, string relayId, ILogger log) { if (string.IsNullOrWhiteSpace(relayId)) { throw new ArgumentNullException(nameof(relayId)); } HybridConnectionDto hybridConnectionDto = await _relayManagementService.GetRelayAsync(relayId); if (hybridConnectionDto != null) { var listenerDto = new ListenerDto() { HybridConnectionUrl = hybridConnectionDto.HybridConnectionUrl, ListenerPolicyName = hybridConnectionDto.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Listen).PolicyName, ListenerPolicyValue = hybridConnectionDto.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Listen).PolicyKey }; return(new OkObjectResult(listenerDto)); } else { return(new NotFoundResult()); } }
public async Task <IActionResult> PostRelayInformationAsync([HttpTrigger(AuthorizationLevel.Function, "post", Route = "relay-management/")] HttpRequest req, ILogger log) { var requestBody = await new StreamReader(req.Body).ReadToEndAsync(); if (string.IsNullOrWhiteSpace(requestBody)) { throw new InvalidOperationException(nameof(requestBody)); } CreateRelayStorageDto createRelayDto = JsonConvert.DeserializeObject <CreateRelayStorageDto>(requestBody); HybridConnectionDto hybridConnectionDto = await _relayManagementService.StoreRelayAsync(createRelayDto); if (hybridConnectionDto != null) { var listenerDto = new ListenerDto() { HybridConnectionUrl = hybridConnectionDto.HybridConnectionUrl, ListenerPolicyName = hybridConnectionDto.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Listen).PolicyName, ListenerPolicyValue = hybridConnectionDto.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Listen).PolicyKey }; return(new OkObjectResult(listenerDto)); } else { return(new BadRequestResult()); } }
public async Task ReturnHybridConnectionDtoWhenCreateHybridConnectionIsCalledAsync() { // Arrange IRelayManagementApiClient relayManagementApiClient = A.Fake <IRelayManagementApiClient>(); IRelayAzureManagementService sut = new RelayAzureManagementService(relayManagementApiClient); var tenantId = TestHelper.TenantId; var createRelayDto = new CreateRelayDto() { TenantId = tenantId }; A.CallTo(() => relayManagementApiClient.CreateHybridConnectionAsync(tenantId)).Returns(TestHelper.GetDefaultLocalHostUri); A.CallTo(() => relayManagementApiClient.CreatePolicykeyAsync(tenantId, PolicyClaim.Listen)).Returns(TestHelper.GetListenPolicyDto()); A.CallTo(() => relayManagementApiClient.CreatePolicykeyAsync(tenantId, PolicyClaim.Send)).Returns(TestHelper.GetSendPolicyDto()); // Act HybridConnectionDto actual = await sut.CreateHybridConnection(createRelayDto); // Assert Assert.Equal(TestHelper.GetDefaultLocalHostUri, actual.HybridConnectionUrl); Assert.Equal(TestHelper.GetListenPolicyDto().PolicyKey, actual.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Listen).PolicyKey); Assert.Equal(TestHelper.GetSendPolicyDto().PolicyKey, actual.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Send).PolicyKey); Assert.Equal(TestHelper.GetListenPolicyDto().PolicyName, actual.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Listen).PolicyName); Assert.Equal(TestHelper.GetSendPolicyDto().PolicyName, actual.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Send).PolicyName); Assert.Equal(TestHelper.GetListenPolicyDto().PolicyType, actual.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Listen).PolicyType); Assert.Equal(TestHelper.GetSendPolicyDto().PolicyType, actual.PolicyDtos.FirstOrDefault(x => x.PolicyType == PolicyClaim.Send).PolicyType); }
async Task <HybridConnectionDto> IRelayManagementService.StoreRelayAsync(CreateRelayStorageDto createRelayStorageDto) { HybridConnectionDto hybridConnectionDto = await _cloudProviderHandlerApiClient.CreateRelayHybridConnection(createRelayStorageDto.TenantId); if (hybridConnectionDto is null) { throw new InvalidOperationException(nameof(hybridConnectionDto)); } return(await _storageApiClient.StoreRelayAsync(createRelayStorageDto.TenantId, hybridConnectionDto)); }
public void ReturnHybridConnectionDtoWhenMapCallIsCalled() { // Arrange var sut = new HybridConnectionDtoMapper(); var hybridConnectionStorageDto = new HybridConnectionStorageDto(TestHelper.TenantId.ToString(), TestHelper.GetHybridConnectionDto()); // Act HybridConnectionDto actual = sut.HybridConnectionDtoMap(hybridConnectionStorageDto); // Assert Assert.Equal(hybridConnectionStorageDto.HybridConnection.HybridConnectionUrl, actual.HybridConnectionUrl); Assert.Equal(hybridConnectionStorageDto.HybridConnection.PolicyDtos.Count(), actual.PolicyDtos.Count()); }
public async Task ReturnHybridConnectionDtoWhenGetRelayIsCalledAsync() { // Arrange IStorageApiClient storageApiClient = A.Fake <IStorageApiClient>(); ICloudProviderHandlerApiClient cloudProviderHandlerApiClient = A.Fake <ICloudProviderHandlerApiClient>(); IRelayManagementService sut = new RelayManagementService(storageApiClient, cloudProviderHandlerApiClient); A.CallTo(() => storageApiClient.GetRelayFromIdAsync(TestHelper.TenantId.ToString())).Returns(TestHelper.GetHybridConnectionDto()); // Act HybridConnectionDto actual = await sut.GetRelayAsync(TestHelper.TenantId.ToString()); // Assert Assert.Equal(TestHelper.GetHybridConnectionDto().HybridConnectionUrl, actual.HybridConnectionUrl); }
public async Task <IActionResult> CreateRelayHybridConnectionAsync( [HttpTrigger(AuthorizationLevel.Function, "post", Route = "relay/hybridconnection")] HttpRequest req, ILogger log) { var requestBody = await new StreamReader(req.Body).ReadToEndAsync(); CreateRelayDto createRelayDto = JsonConvert.DeserializeObject <CreateRelayDto>(requestBody); HybridConnectionDto response = await _relayAzureManagement.CreateHybridConnection(createRelayDto); if (response != null) { return(new OkObjectResult(response)); } else { return(new BadRequestResult()); } }
public async Task <IActionResult> GetRelayInformationAsync([HttpTrigger(AuthorizationLevel.Function, "get", Route = "relay-management/relayinfo/{RelayId}")] HttpRequest req, string relayId, ILogger log) { if (string.IsNullOrWhiteSpace(relayId)) { throw new ArgumentNullException(nameof(relayId)); } HybridConnectionDto response = await _relayManagementService.GetRelayAsync(relayId); if (response != null) { return(new OkObjectResult(response)); } else { return(new NotFoundResult()); } }
public HybridConnectionStorageDto HybridConnectionStorageDtoMap(string id, HybridConnectionDto hybridConnectionStorageDto) { return(new HybridConnectionStorageDto(id, new HybridConnectionDto(hybridConnectionStorageDto.HybridConnectionUrl, hybridConnectionStorageDto.PolicyDtos))); }
async Task <HybridConnectionDto> IStorageApiClient.StoreRelayAsync(string tenantId, HybridConnectionDto hybridConnectionDto) { Database database = await _cosmosClient.CreateDatabaseIfNotExistsAsync("RelayProxyDatabase"); Container container = await database.CreateContainerIfNotExistsAsync("ProxyRelayContainer", "/Connections"); ItemResponse <HybridConnectionStorageDto> cosmosDbResponse = await container.CreateItemAsync(_hybridConnectionDtoMapper.HybridConnectionStorageDtoMap(tenantId, hybridConnectionDto)); return(_hybridConnectionDtoMapper.HybridConnectionDtoMap(cosmosDbResponse.Resource)); }
public HybridConnectionStorageDto(string id, HybridConnectionDto hybridConnection) { Id = id; HybridConnection = hybridConnection; }