public async Task <HttpFragileOperationResult <GetPublicUrlResult> > GetPublicUrlAsync(string identifier, int timeToLive = 60)
{
var generateJwtResult = await _jwtUtility.GenerateJwtAsync(timeToLive, new[] { new KeyValuePair <string, string>("fileId", identifier), }).ConfigureAwait(false);
if (generateJwtResult.Status != Status.Success)
{
return(generateJwtResult.ToHttpFragileOperationResult <GetPublicUrlResult>($"{generateJwtResult.Status} while getting public url with identifier {identifier}."));
}
var publicUrl = _configurationService.ConfigurationSettings.FncFileVaultUrl + $"file/public?jwt={generateJwtResult.Result.Jwt}";
return(HttpFragileOperationResult <GetPublicUrlResult> .CreateSuccessfulResult(new GetPublicUrlResult(publicUrl), generateJwtResult.StatusCode, generateJwtResult.ResponseStringContent));
}
public async Task <HttpFragileOperationResult <ValidateJwtResult> > ValidateJwtAsync(string jwt)
{
var result = await _httpUtility
.HttpPostJsonAsync <FncConnectValidateJwtResponse>(
_configurationService.ConfigurationSettings.FncConnectUrl + "externalapi/jwt/validate/true", jwt)
.ConfigureAwait(false);
if (result.Status != Status.Success)
{
return(result.ToHttpFragileOperationResult <ValidateJwtResult>($"{result.Status} while validating Jwt."));
}
return(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(new ValidateJwtResult(result.Result.Success, result.Result.JwtData.AppInfo.ImmutableAppID.ToString()), result.StatusCode, result.ResponseStringContent));
}
public async Task FileVaultGetFileBehavior_ReturnsErrorResult_WhenJwtUtilityErrorsToGenerateJwt()
{
//Arrange
var jwtUtility = new Mock <IJwtUtility>();
jwtUtility.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >()))
.Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateErrorResult(HttpStatusCode.InternalServerError, "", "ErrorMessage")));
var httpUtility = new Mock <IHttpUtility>();
var getFileBehavior = new FileVaultGetFileBehavior(jwtUtility.Object, httpUtility.Object, TestHelper.GetConfigurationSettings());
//Act
var result = await getFileBehavior.GetFileAsync(Guid.NewGuid().ToString()).ConfigureAwait(false);
//Assert
Assert.AreEqual(Status.Error, result.Status);
}
public async Task FileVaultGetFileBehavior_ReturnsErrorResult_WhenHttpUtilityErrorsGet()
{
//Arrange
var jwtUtility = TestHelper.GetFakeJwtUtility();
var httpUtility = new Mock <IHttpUtility>();
httpUtility.Setup(x => x.HttpGetAsync <FileVaultFile>(It.IsAny <string>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >(), It.IsAny <JsonSerializerSettings>()))
.Returns(Task.FromResult(HttpFragileOperationResult <FileVaultFile> .CreateErrorResult(HttpStatusCode.BadRequest, "", "ErrorMessage")));
var getFileBehavior = new FileVaultGetFileBehavior(jwtUtility, httpUtility.Object, TestHelper.GetConfigurationSettings());
//Act
var result = await getFileBehavior.GetFileAsync(Guid.NewGuid().ToString()).ConfigureAwait(false);
//Assert
Assert.AreEqual(Status.Error, result.Status);
}
public async Task JwtUtlity_GenerateJwt_ReturnsGenerateJwtBehaviorResult()
{
//Arrange
var generateJwtBehaviorResult = new GenerateJwtResult("jwt");
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >()))
.Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(generateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(null, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GenerateJwtAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(generateJwtBehaviorResult.Jwt, result.Result.Jwt);
}
public async Task <HttpFragileOperationResult <GetFileResult> > GetFileAsync(string identifier)
{
var fileVaultUrl = _configurationService.ConfigurationSettings.FncFileVaultUrl + $"api/file/{identifier}/false";
var generateJwtResult = await _jwtUtility.GenerateJwtAsync().ConfigureAwait(false);
if (generateJwtResult.Status != Status.Success)
{
return(generateJwtResult.ToHttpFragileOperationResult <GetFileResult>($"{generateJwtResult.StatusCode} while getting file with identifier {identifier}."));
}
var result = await _httpUtility.HttpGetAsync <FileVaultFile>(fileVaultUrl, new[] { new KeyValuePair <string, string>("Authorization", $"Bearer {generateJwtResult.Result.Jwt}"), }).ConfigureAwait(false);
if (result.Status != Status.Success)
{
return(result.ToHttpFragileOperationResult <GetFileResult>($"{result.StatusCode} while getting file with identifier {identifier}."));
}
return(HttpFragileOperationResult <GetFileResult> .CreateSuccessfulResult(new GetFileResult(result.Result.FileAsByteArray, result.Result.Filename), result.StatusCode, result.ResponseStringContent));
}
public async Task <HttpFragileOperationResult <GenerateJwtResult> > GenerateJwtAsync(int expireTimeInMinutes = 60, IEnumerable <KeyValuePair <string, string> > additionalData = null)
{
var generateJwtRequest = new GenerateJwtRequest()
{
AppKey = _configurationService.ConfigurationSettings.FncConnectKey,
AppSecret = _configurationService.ConfigurationSettings.FncConnectSecret,
ExpireTimeInMinutes = expireTimeInMinutes,
AdditionalData = additionalData
};
var result = await _httpUtility
.HttpPostJsonAsync <string>(_configurationService.ConfigurationSettings.FncConnectUrl + "externalapi/jwt",
generateJwtRequest).ConfigureAwait(false);
if (result.Status != Status.Success)
{
return(result.ToHttpFragileOperationResult <GenerateJwtResult>($"{result.Status} while generating Jwt."));
}
return(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(new GenerateJwtResult(result.Result), result.StatusCode, result.ResponseStringContent));
}
public async Task <HttpFragileOperationResult <StoreFileResult> > StoreFileAsync(byte[] bytes, string fileName)
{
var fileVaultUrl = _configurationService.ConfigurationSettings.FncFileVaultUrl + "/api/file/upload";
var uploadParameters = new UploadFileParametersDto()
{
ExpirationInDays = 10,
Filename = fileName,
Mode = FileVaultFile.FileVaultFileMode.ReadOnly,
Attributes = new FileAttributeSet()
};
var form = new MultipartFormDataContent
{
{ new ByteArrayContent(bytes), "file", fileName },
{ new StringContent(JsonConvert.SerializeObject(uploadParameters)), "uploadParametersJson" }
};
var jwtResult = await _jwtUtility.GenerateJwtAsync().ConfigureAwait(false);
if (jwtResult.Status != Status.Success)
{
return(jwtResult.ToHttpFragileOperationResult <StoreFileResult>($"{jwtResult.Status} while storing file with filename {fileName}."));
}
var result = await _httpUtility.HttpPostContentAsync <string>(fileVaultUrl, form, new[] { new KeyValuePair <string, string>("Authorization", $"Bearer {jwtResult.Result.Jwt}"), }).ConfigureAwait(false);
if (result.Status != Status.Success)
{
return(result.ToHttpFragileOperationResult <StoreFileResult>($"{result.Status} while storing file with filename {fileName}."));
}
var identifier = result.Result.Replace("\"", "");
return(HttpFragileOperationResult <StoreFileResult> .CreateSuccessfulResult(new StoreFileResult(identifier), result.StatusCode, result.ResponseStringContent));
}
public async Task FileUtility_GetHealth_ReturnsActiveHeathCheckResult_WhenAllGood()
{
//Arrange
const string fileContents = "<helloworld/>";
var fileBytes = Encoding.ASCII.GetBytes(fileContents);
const string fileName = "helloworld.txt";
var getFileResult = new GetFileResult(fileBytes, fileName);
var getFileResultBehaviorMock = new Mock <IGetFileBehavior>();
getFileResultBehaviorMock.Setup(x => x.GetFileAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <GetFileResult> .CreateSuccessfulResult(getFileResult, HttpStatusCode.OK, "")));
const string resultIdentifier = "123456";
var storeFileResult = new StoreFileResult(resultIdentifier);
var storeFileResultBehaviorMock = new Mock <IStoreFileBehavior>();
storeFileResultBehaviorMock.Setup(x => x.StoreFileAsync(It.IsAny <byte[]>(), It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <StoreFileResult> .CreateSuccessfulResult(storeFileResult, HttpStatusCode.OK, "")));
var getPublicUrlResult = new GetPublicUrlResult("SomeUrl");
var getPublicUrlBehaviorMock = new Mock <IGetPublicUrlBehavior>();
getPublicUrlBehaviorMock.Setup(x => x.GetPublicUrlAsync(It.IsAny <string>(), It.IsAny <int>())).Returns(Task.FromResult(HttpFragileOperationResult <GetPublicUrlResult> .CreateSuccessfulResult(getPublicUrlResult, HttpStatusCode.OK, "")));
var fileUtility = new FileUtility(getFileResultBehaviorMock.Object, storeFileResultBehaviorMock.Object, getPublicUrlBehaviorMock.Object);
var result = await fileUtility.GetHealthAsync().ConfigureAwait(false);
Assert.AreEqual(HealthStatus.Active, result.Status);
Assert.AreEqual("Files", result.Description);
Assert.AreEqual(3, result.Vitals.Count);
}
public async Task FileUtility_GetFile_ReturnsStoreFileBehaviorResult()
{
//Arrange
const string fileContents = "<helloworld/>";
var fileBytes = Encoding.ASCII.GetBytes(fileContents);
const string fileName = "helloworld.txt";
var getFileResult = new GetFileResult(fileBytes, fileName);
var getFileResultBehaviorMock = new Mock <IGetFileBehavior>();
getFileResultBehaviorMock.Setup(x => x.GetFileAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <GetFileResult> .CreateSuccessfulResult(getFileResult, HttpStatusCode.OK, "")));
//Act
var result = await getFileResultBehaviorMock.Object.GetFileAsync("anything").ConfigureAwait(false);
//Assert
Assert.IsTrue(fileBytes.SequenceEqual(result.Result.Bytes));
Assert.AreEqual(fileName, result.Result.FileName);
Assert.AreEqual(Status.Success, result.Status);
Assert.AreEqual(0, result.ErrorMessages.Count());
}
public async Task FileUtility_StoreFile_ReturnsStoreFileBehaviorResult()
{
//Arrange
const string resultIdentifier = "123456";
var storeFileResult = new StoreFileResult(resultIdentifier);
var storeFileResultBehaviorMock = new Mock <IStoreFileBehavior>();
storeFileResultBehaviorMock.Setup(x => x.StoreFileAsync(It.IsAny <byte[]>(), It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <StoreFileResult> .CreateSuccessfulResult(storeFileResult, HttpStatusCode.OK, "")));
//Act
var result = await storeFileResultBehaviorMock.Object.StoreFileAsync(new byte[] { }, "blah.txt").ConfigureAwait(false);
//Assert
Assert.AreEqual(resultIdentifier, result.Result.Identifier);
Assert.AreEqual(Status.Success, result.Status);
Assert.AreEqual(0, result.ErrorMessages.Count());
}
public static IJwtUtility GetFakeJwtUtility(string jwtToGenerate = "testJwt", int clientIdToReturn = 1)
{
var jwtUtilityMock = new Mock <IJwtUtility>();
jwtUtilityMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(new GenerateJwtResult(jwtToGenerate), HttpStatusCode.OK, "")));
jwtUtilityMock.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(new ValidateJwtResult(true, clientIdToReturn.ToString()), HttpStatusCode.OK, "")));
return(jwtUtilityMock.Object);
}
public async Task JwtUtlityHealthCheck_GetHealth_ReturnsWarningHealthCheckResult_WhenGenerateBehaviorResultsInError()
{
//Arrange
var validateJwtBehaviorResult = new ValidateJwtResult(true, "123");
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(validateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateErrorResult(HttpStatusCode.InternalServerError, "", "TestMessage")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GetHealthAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(HealthStatus.Warning, result.Status);
}
public async Task JwtUtlityHealthCheck_GetHealth_ReturnsActiveHealthCheckResult_WhenAllGood()
{
//Arrange
var validateJwtBehaviorResult = new ValidateJwtResult(true, "123");
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(validateJwtBehaviorResult, HttpStatusCode.OK, "")));
var generateJwtBehaviorResult = new GenerateJwtResult("jwt");
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(generateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GetHealthAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(HealthStatus.Active, result.Status);
Assert.AreEqual("JWT Generate/Validate", result.Description);
Assert.AreEqual(2, result.Vitals.Count);
}
public async Task JwtUtlity_GenerateJwt_ReturnsValidateJwtBehaviorResult()
{
//Arrange
var validateJwtBehaviorResult = new ValidateJwtResult(true, "123");
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateSuccessfulResult(validateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, null);
//Act
var result = await jwtUtility.ValidateJwtAsync("AnyJwt").ConfigureAwait(false);
//Assert
Assert.AreEqual(validateJwtBehaviorResult.ClientId, "123");
Assert.IsTrue(validateJwtBehaviorResult.IsValid);
Assert.AreEqual(0, result.ErrorMessages.Count());
}
public async Task FileUtility_FileVaultGetPublicUrlAsync_ReturnsErrorResult_WhenJwtGenerationErrors()
{
//Arrange
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateErrorResult(HttpStatusCode.InternalServerError, "", "ErrorMessage")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
var fileUtility = new FileUtility(new Mock <IGetFileBehavior>().Object, new Mock <IStoreFileBehavior>().Object, new FileVaultGetPublicUrlBehavior(jwtUtility, TestHelper.GetConfigurationSettings()));
//Act
var result = await fileUtility.GetPublicUrlAsync(Guid.NewGuid().ToString()).ConfigureAwait(false);
//Assert
Assert.AreEqual(Status.Error, result.Status);
}
public async Task JwtUtlityHealthCheck_GetHealth_ReturnsCriticalHealthCheckResult_WhenValidateBehaviorResultIsFailed()
{
//Arrange
var jwtValidateBehavior = new Mock <IValidateJwtBehavior>();
jwtValidateBehavior.Setup(x => x.ValidateJwtAsync(It.IsAny <string>())).Returns(Task.FromResult(HttpFragileOperationResult <ValidateJwtResult> .CreateFailedResult(HttpStatusCode.BadRequest, "", "TestMessage")));
var generateJwtBehaviorResult = new GenerateJwtResult("jwt");
var jwtGenerateBehaviorMock = new Mock <IGenerateJwtBehavior>();
jwtGenerateBehaviorMock.Setup(x => x.GenerateJwtAsync(It.IsAny <int>(), It.IsAny <IEnumerable <KeyValuePair <string, string> > >())).Returns(Task.FromResult(HttpFragileOperationResult <GenerateJwtResult> .CreateSuccessfulResult(generateJwtBehaviorResult, HttpStatusCode.OK, "")));
var jwtUtility = new JwtUtility(jwtValidateBehavior.Object, jwtGenerateBehaviorMock.Object);
//Act
var result = await jwtUtility.GetHealthAsync().ConfigureAwait(false);
//Assert
Assert.AreEqual(HealthStatus.Critical, result.Status);
}
