public void Test_Empty( )
{
IEndpointResolver resolver = GetResolver( );
EndpointAddressResult result = resolver.ResolveEndpoint(new string[] {}, false);
Assert.That(result, Is.Not.Null);
Assert.That(result.ApiId, Is.EqualTo(0));
Assert.That(result.EndpointId, Is.EqualTo(0));
}
public void Test_ApiOnly_Exists( )
{
Api api = MakeApi("address1");
IEndpointResolver resolver = GetResolver( );
EndpointAddressResult result = resolver.ResolveEndpoint("address1", false);
Assert.That(result, Is.Not.Null);
Assert.That(result.ApiId, Is.EqualTo(api.Id));
Assert.That(result.EndpointId, Is.EqualTo(0));
}
public void Test_Endpoint_WithSuffix( )
{
Api api = MakeApi("my-api");
ApiResourceEndpoint endpoint = MakeEndpoint(api, "my-end-point");
IEndpointResolver resolver = GetResolver( );
EndpointAddressResult result = resolver.ResolveEndpoint("my-api/my-end-point/0", false);
Assert.That(result, Is.Not.Null);
Assert.That(result.ApiId, Is.EqualTo(api.Id));
Assert.That(result.EndpointId, Is.EqualTo(endpoint.Id));
}
/// <summary>
/// Determine the API and Endpoint entities that an apiPath is referring to.
/// </summary>
/// <param name="apiPath">The relative API, relative to the API controller address.</param>
/// <param name="apiOnly">If true, only resolve the API portion.</param>
/// <returns>Entity IDs f the API and Endpoint.</returns>
public EndpointAddressResult ResolveEndpoint(string[] apiPath, bool apiOnly)
{
// Handle empty address
if (apiPath == null || apiPath.Length == 0)
{
return(new EndpointAddressResult(0, 0));
}
// Determine API
Api api = GetApi(apiPath [0]);
long apiId = api?.Id ?? 0;
long endpointId = 0;
if (!apiOnly && apiPath.Length > 1 && api != null)
{
endpointId = GetEndpoint(api, apiPath [1]);
}
EndpointAddressResult result = new EndpointAddressResult(apiId, endpointId);
return(result);
}
public void Test_Successful_Impersonation(bool apiKeyCanSeeApi, HttpStatusCode expectCode)
{
string apiKey = "6cb36a1cd60e460bbbfce5af03eb9507"; // or whatever
string tenantName = RunAsDefaultTenant.DefaultTenantName;
Mock <IConnectorService> mockService;
Mock <IEndpointResolver> mockEndpointResolver;
IConnectorService apiKeyService;
ConnectorRequest request;
ConnectorResponse response;
UserAccount userAccount;
ApiKey key;
Api api;
long tenantId;
EndpointAddressResult endpoint;
// Define key and user
using (new TenantAdministratorContext(tenantName))
{
tenantId = RequestContext.TenantId;
userAccount = new UserAccount( );
userAccount.Name = "Test user " + Guid.NewGuid( );
userAccount.AccountStatus_Enum = UserAccountStatusEnum_Enumeration.Active;
userAccount.Password = "******";
userAccount.Save( );
api = new Api();
api.Name = "Test API";
api.Save( );
key = new ApiKey();
key.Name = apiKey;
key.ApiKeyEnabled = true;
key.ApiKeyUserAccount = userAccount;
if (apiKeyCanSeeApi)
{
key.KeyForApis.Add(api);
}
key.Save();
}
// Define service and mock
mockService = new Mock <IConnectorService>(MockBehavior.Strict);
mockEndpointResolver = new Mock <IEndpointResolver>(MockBehavior.Strict);
apiKeyService = new ApiKeySecurity(mockService.Object, mockEndpointResolver.Object, Factory.EntityRepository);
// Define request
request = new ConnectorRequest
{
TenantName = tenantName,
QueryString = new Dictionary <string, string> {
{ "key", apiKey }
},
ApiPath = new[] { "whatever" }
};
// Setup
if (apiKeyCanSeeApi)
{
mockService.Setup(connector => connector.HandleRequest(request)).Returns(() =>
{
Assert.That(RequestContext.TenantId, Is.EqualTo(tenantId));
return(new ConnectorResponse(HttpStatusCode.OK));
}).Verifiable( );
}
endpoint = new EndpointAddressResult(api.Id, 0);
mockEndpointResolver.Setup(resolver => resolver.ResolveEndpoint(request.ApiPath, true)).Returns(endpoint).Verifiable( );
// Place request
response = apiKeyService.HandleRequest(request);
Assert.That(response.StatusCode, Is.EqualTo(expectCode));
mockService.VerifyAll( );
}
