public async Task Bad_FileId_Is_FilteredOut_Filter()
{
var badEvent = TransactionAdaptionEventModel.NewDocumentEvent();
badEvent.Properties["FileId"] = "Rgsjrjgkisjghr";
JsonSerialiser.Setup(s => s.Deserialize <TransactionAdapationEventMetadataFile>(It.IsAny <MemoryStream>(), It.IsAny <Encoding>()))
.ReturnsAsync(_expectedMetadata = new TransactionAdapationEventMetadataFile
{
Events = new[]
{
TransactionAdaptionEventModel.AnalysisCompletedEvent(_fileId),
TransactionAdaptionEventModel.FileTypeDetectedEvent(FileType.Bmp, _fileId),
TransactionAdaptionEventModel.NcfsCompletedEvent(NcfsOutcome.Blocked, _fileId),
TransactionAdaptionEventModel.NcfsStartedEvent(_fileId),
badEvent,
TransactionAdaptionEventModel.RebuildCompletedEvent(GwOutcome.Failed, _fileId),
TransactionAdaptionEventModel.RebuildEventStarting(_fileId),
}
});
_input.Filter.FileIds = new List <Guid> {
{
Guid.NewGuid()
}
};
_output = await ClassInTest.GetTransactionsAsync(_input, CancellationToken.None);
Assert.That(_output.Count, Is.EqualTo(0));
}
public void OnetimeSetup()
{
CommonSetup();
GlasswallVersionServiceMock.Setup(s => s.GetVersion())
.Returns(Version);
FileTypeDetectorMock.Setup(s => s.DetermineFileType(It.IsAny <byte[]>()))
.Returns(_expectedType = new FileTypeDetectionResponse(FileType.Bmp));
FileProtectorMock.Setup(s => s.GetProtectedFile(
It.IsAny <ContentManagementFlags>(),
It.IsAny <string>(),
It.IsAny <byte[]>()))
.Returns(new FileProtectResponse
{
Outcome = EngineOutcome.Success,
ProtectedFile = ExpectedDecoded
});
_result = ClassInTest.RebuildFromBase64(new Base64Request
{
Base64 = "dGVzdA=="
});
}
public void OnetimeSetup()
{
CommonSetup();
_expectedInputUrl = new Uri("https://www.myfileserver.com/myfile.png");
_expectedOutputUrl = new Uri("https://www.s3bucket.com/buckets/rebuilt/myfile.png");
GlasswallVersionServiceMock.Setup(s => s.GetVersion())
.Returns(Version);
FileTypeDetectorMock.Setup(s => s.DetermineFileType(It.IsAny <byte[]>()))
.Returns(_expectedType = new FileTypeDetectionResponse(FileType.Bmp));
HttpTest.ResponseQueue.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new ByteArrayContent(ExpectedDownloadFile)
});
HttpTest.ResponseQueue.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK
});
FileAnalyserMock.Setup(s => s.GetReport(
It.IsAny <ContentManagementFlags>(),
It.IsAny <string>(),
It.IsAny <byte[]>()))
.Returns("");
_result = ClassInTest.AnalyseFromUrl(new UrlRequest
{
InputGetUrl = _expectedInputUrl
});
}
public void OnetimeSetup()
{
CommonSetup();
GlasswallVersionServiceMock.Setup(s => s.GetVersion())
.Returns(Version);
FileTypeDetectorMock.Setup(s => s.DetermineFileType(It.IsAny <byte[]>()))
.Returns(_expectedType = new FileTypeDetectionResponse(FileType.Bmp));
FileProtectorMock.Setup(s => s.GetProtectedFile(
It.IsAny <ContentManagementFlags>(),
It.IsAny <string>(),
It.IsAny <byte[]>()))
.Returns(_expectedProtectResponse = new FileProtectResponse
{
Outcome = EngineOutcome.Error,
ProtectedFile = null,
ErrorMessage = "banana has been removed because monkey content is set to disallowed"
});
_result = ClassInTest.RebuildFromBase64(new Base64Request
{
Base64 = "dGVzdA=="
});
}
public void Exception_Is_Rethrown()
{
Assert.That(() => ClassInTest.DetermineFileTypeFromUrl(new UrlRequest
{
InputGetUrl = new Uri("https://www.input.com"),
}), Throws.Exception.EqualTo(_dummyException));
}
public async Task Setup()
{
SharedSetup();
_expected = new MemoryStream(new byte[] { 1, 2, 3, 4, 5, 6, 7 });
ShareClient.Setup(s => s.GetRootDirectoryClient())
.Returns((_directory = new Mock <ShareDirectoryClient>()).Object);
_directory.Setup(s => s.GetFileClient(It.IsAny <string>()))
.Returns((_fileClient = new Mock <ShareFileClient>()).Object);
_fileClient.Setup(s => s.DownloadAsync(
It.IsAny <HttpRange>(),
It.IsAny <bool>(),
It.IsAny <ShareFileRequestConditions>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync((_response = new Mock <Response <ShareFileDownloadInfo> >()).Object);
_response.Setup(s => s.Value)
.Returns(FilesModelFactory.StorageFileDownloadInfo(content: _expected, contentLength: _expected.Length));
_fileClient.Setup(s => s.ExistsAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync((_existsResponse = new Mock <Response <bool> >()).Object);
_existsResponse.Setup(s => s.Value)
.Returns(true);
_output = await ClassInTest.DownloadAsync(_input = "some-path", CancellationToken.None);
}
public void Exception_Is_Rethrown()
{
Assert.That(() => ClassInTest.AnalyseFromBase64(new Base64Request
{
Base64 = "dGVzdA=="
}), Throws.Exception.EqualTo(_dummyException));
}
public async Task Setup()
{
base.SharedSetup();
_input = new GetTransactionsRequestV1
{
Filter = new FileStoreFilterV1
{
TimestampRangeStart = DateTimeOffset.MinValue,
TimestampRangeEnd = DateTimeOffset.MaxValue
}
};
Share1.Setup(s => s.ListAsync(It.IsAny <IPathFilter>(), It.IsAny <CancellationToken>()))
.Returns(_paths1 = GetSomePaths(1));
Share2.Setup(s => s.ListAsync(It.IsAny <IPathFilter>(), It.IsAny <CancellationToken>()))
.Returns(GetNoPaths());
var fileId = Guid.NewGuid();
JsonSerialiser.Setup(s => s.Deserialize <TransactionAdapationEventMetadataFile>(It.IsAny <MemoryStream>(), It.IsAny <Encoding>()))
.ReturnsAsync(_expectedMetadata = new TransactionAdapationEventMetadataFile
{
Events = new []
{
TransactionAdaptionEventModel.NewDocumentEvent(fileId)
}
});
_output = await ClassInTest.GetTransactionsAsync(_input, CancellationToken.None);
}
public async Task BadRequest_Not_Set_When_Model_Errors_Do_Not_Occur()
{
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(
Mock.Of <HttpContext>(),
Mock.Of <RouteData>(),
Mock.Of <ActionDescriptor>(),
modelState
);
var actionExecutingContext = new ActionExecutingContext(
actionContext,
new List <IFilterMetadata>(),
new Dictionary <string, object>(),
Mock.Of <Controller>()
)
{
Result = new OkResult() // It will return ok unless during code execution you change this when by condition
};
var context = new ActionExecutedContext(actionContext, new List <IFilterMetadata>(), Mock.Of <Controller>());
await ClassInTest.OnActionExecutionAsync(actionExecutingContext, async() => await Task.FromResult(context));
Assert.That(actionExecutingContext.Result, Is.Not.InstanceOf <BadRequestObjectResult>());
}
public void OnetimeSetup()
{
CommonSetup();
_expectedInputUrl = new Uri("https://www.myfileserver.com/myfile.png");
_expectedOutputUrl = new Uri("https://www.s3bucket.com/buckets/rebuilt/myfile.png");
GlasswallVersionServiceMock.Setup(s => s.GetVersion())
.Returns(Version);
FileTypeDetectorMock.Setup(s => s.DetermineFileType(It.IsAny <byte[]>()))
.Returns(new FileTypeDetectionResponse(FileType.Unknown));
HttpTest.ResponseQueue.Enqueue(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new ByteArrayContent(ExpectedDownloadFile)
});
_result = ClassInTest.RebuildUrlToUrl(new UrlToUrlRequest
{
InputGetUrl = _expectedInputUrl,
OutputPutUrl = _expectedOutputUrl
});
}
public async Task BadRequest_Set_When_Model_Errors_Occur()
{
var modelState = new ModelStateDictionary();
modelState.AddModelError("name", "invalid");
var actionContext = new ActionContext(
Mock.Of <HttpContext>(),
Mock.Of <RouteData>(),
Mock.Of <ActionDescriptor>(),
modelState
);
var actionExecutingContext = new ActionExecutingContext(
actionContext,
new List <IFilterMetadata>(),
new Dictionary <string, object>(),
Mock.Of <Controller>()
)
{
Result = new OkResult() // It will return ok unless during code execution you change this when by condition
};
var context = new ActionExecutedContext(actionContext, new List <IFilterMetadata>(), Mock.Of <Controller>());
await ClassInTest.OnActionExecutionAsync(actionExecutingContext, async() => await Task.FromResult(context));
Assert.That(actionExecutingContext.Result, Is.InstanceOf <BadRequestObjectResult>());
Assert.That(((BadRequestObjectResult)actionExecutingContext.Result).Value, Is.InstanceOf <List <string> >());
CollectionAssert.AreEqual((List <string>)((BadRequestObjectResult)actionExecutingContext.Result).Value, modelState.Values.SelectMany(s => s.Errors).Select(e => e.ErrorMessage).ToList());
}
public async Task Deserialise_Stream_Is_Correct()
{
await using var ms = new MemoryStream(Encoding.UTF8.GetBytes("<xml><TestProp>Test</TestProp></xml>"));
var obj = await ClassInTest.Deserialize <xml>(ms, Encoding.UTF8);
Assert.That(obj.TestProp, Is.EqualTo("Test"));
}
public void OnetimeSetup()
{
CommonSetup();
ClassInTest.ModelState.AddModelError("SomeError", "SomeMessage");
_result = ClassInTest.AnalyseFromBase64(null);
}
public void OnetimeSetup()
{
CommonSetup();
ClassInTest.ModelState.AddModelError("SomeError", "SomeMessage");
_result = ClassInTest.RebuildFromFormFile(null, InvalidFormFileMock.Object);
}
public void Exception_Is_Rethrown()
{
Assert.That(() => ClassInTest.RebuildUrlToUrl(new UrlToUrlRequest
{
InputGetUrl = new Uri("https://www.input.com"),
OutputPutUrl = new Uri("https://www.output.com")
}), Throws.Exception.EqualTo(_dummyException));
}
public void No_Engine_Actions_Are_Performed()
{
_result = ClassInTest.RebuildFromFormFile(null, InvalidFormFileMock.Object);
GlasswallVersionServiceMock.VerifyNoOtherCalls();
FileTypeDetectorMock.VerifyNoOtherCalls();
FileProtectorMock.VerifyNoOtherCalls();
}
public void Throws_With_Invalid_Path(string path)
{
Assert.That(() => ClassInTest.GetDetailAsync(path, CancellationToken.None),
Throws.ArgumentException.With.Property(nameof(ArgumentException.ParamName))
.EqualTo("fileDirectory")
.And
.With.Property(nameof(ArgumentException.Message))
.StartWith("Value must not be null or whitespace"));
}
public async Task Serialise_Is_Correct()
{
var str = await ClassInTest.Serialize(new
{
TestProp = "Test"
});
Assert.That(str, Is.EqualTo("{\"TestProp\":\"Test\"}"));
}
public async Task Deserialise_Stream_Is_Correct()
{
await using (var ms = new MemoryStream(Encoding.UTF8.GetBytes("{\"TestProp\":\"Test\"}")))
{
var obj = await ClassInTest.Deserialize <Dictionary <string, string> >(ms, Encoding.UTF8);
Assert.That(obj["TestProp"], Is.EqualTo("Test"));
}
}
public void No_Engine_Actions_Are_Performed(string base64)
{
ClassInTest.DetermineFileTypeFromBase64(new Base64Request
{
Base64 = base64
});
GlasswallVersionServiceMock.VerifyNoOtherCalls();
FileTypeDetectorMock.VerifyNoOtherCalls();
}
public void Bad_Request_Is_Returned(string base64)
{
_result = ClassInTest.RebuildFromBase64(new Base64Request
{
Base64 = base64
});
Assert.That(_result, Is.Not.Null);
Assert.That(_result, Is.TypeOf <BadRequestObjectResult>());
}
public async Task OnetimeSetup()
{
base.OnetimeSetupShared();
_expected = new GetTransactionsResponseV1();
Service.Setup(s => s.GetTransactionsAsync(It.IsAny <GetTransactionsRequestV1>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_expected);
_result = await ClassInTest.GetTransactions(_input = new GetTransactionsRequestV1(), CancellationToken.None);
}
public async Task OnetimeSetup()
{
base.OnetimeSetupShared();
_expected = new GetDetailResponseV1();
Service.Setup(s => s.GetDetailAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(_expected);
_result = await ClassInTest.GetDetail(_input = "banana", CancellationToken.None);
}
public async Task No_Event_Selected_With_Wrong_FileType_Filter()
{
_input.Filter.FileTypes = new List <FileType> {
{
FileType.Coff
}
};
_output = await ClassInTest.GetTransactionsAsync(_input, CancellationToken.None);
Assert.That(_output.Count, Is.EqualTo(0));
}
public void OnetimeSetup()
{
CommonSetup();
GlasswallVersionServiceMock.Setup(s => s.GetVersion())
.Returns(Version);
FileTypeDetectorMock.Setup(s => s.DetermineFileType(It.IsAny <byte[]>()))
.Returns(new FileTypeDetectionResponse(FileType.Unknown));
_result = ClassInTest.RebuildFromFormFile(null, ValidFormFileMock.Object);
}
public async Task No_Event_Selected_With_Wrong_Policy_Filter()
{
_input.Filter.PolicyIds = new List <Guid> {
{
Guid.Empty
}
};
_output = await ClassInTest.GetTransactionsAsync(_input, CancellationToken.None);
Assert.That(_output.Count, Is.EqualTo(0));
}
public void OnetimeSetup()
{
CommonSetup();
_expectedInputUrl = new Uri("https://www.myfileserver.com/myfile.png");
ClassInTest.ModelState.AddModelError("SomeError", "SomeMessage");
_result = ClassInTest.DetermineFileTypeFromUrl(new UrlRequest
{
InputGetUrl = _expectedInputUrl
});
}
public void Bad_Request_Is_Returned()
{
_result = ClassInTest.RebuildFromFormFile(null, InvalidFormFileMock.Object);
Assert.That(_result, Is.Not.Null);
Assert.That(_result, Is.TypeOf <BadRequestObjectResult>());
var result = _result as BadRequestObjectResult;
Assert.That(result, Is.Not.Null);
Assert.That(result.Value, Is.InstanceOf <string>());
Assert.That(result.Value, Is.EqualTo("Input file could not be read."));
}
public async Task No_Event_Selected_With_Wrong_Risk_Filter()
{
_input.Filter.Risks = new List <Risk> {
{
Risk.Unknown
}
};
_output = await ClassInTest.GetTransactionsAsync(_input, CancellationToken.None);
Assert.That(_output.Count, Is.EqualTo(0));
}
public async Task Setup()
{
base.SharedSetup();
Share1.Setup(s => s.ExistsAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
Share1.Setup(s => s.DownloadAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(null as MemoryStream);
_output = await ClassInTest.GetDetailAsync(Input, CancellationToken.None);
}
