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;
}
