public void ExistsReturnsBool()
{
//Arrange
var moq = new Mock <IDocumentsRepository>();
moq.Setup(m => m.Exists(It.IsAny <int>(), It.IsAny <string>())).Returns(Task.FromResult(true));
DocumentsController controller = new DocumentsController(moq.Object);
//Act
var result = controller.Exists(0, string.Empty).Result;
//Assert
Assert.IsInstanceOfType(result, typeof(bool));
Assert.IsTrue(result);
}
public void DeleteReturnsDocument()
{
//Arrange
var moq = new Mock <IDocumentsRepository>();
moq.Setup(m => m.Delete(It.IsAny <object[]>())).Returns(Task.FromResult(new Document()));
moq.Setup(m => m.Exists(It.IsAny <object[]>())).Returns(Task.FromResult(true));
DocumentsController controller = new DocumentsController(moq.Object);
//Act
var result = (controller.Delete(0).Result as OkObjectResult).Value;
//Assert
Assert.IsInstanceOfType(result, typeof(Document));
}
public async Task return_items_when_getDocumentById_not_null()
{
// Arrange
var query = new GetDocumentById();
var documentDto = new DocumentDto();
_mockDispatcher.Setup(r => r.QueryAsync(query)).ReturnsAsync(documentDto);
// Act
var controller = new DocumentsController(_mockDispatcher.Object);
var result = await controller.GetById(query);
//Assert
Assert.NotNull(result.Result);
Assert.IsType <ActionResult <DocumentDto> >(result);
}
public DocumentsControllerTest()
{
_documentsServiceMock = new Mock <IDocumentsService>();
var responseMock = new Mock <HttpResponse>();
responseMock.SetupGet(x => x.Headers).Returns(new HeaderDictionary());
var httpContextMock = new Mock <HttpContext>();
httpContextMock.SetupGet(x => x.Response).Returns(responseMock.Object);
_documentsController = new DocumentsController(_documentsServiceMock.Object)
{
ControllerContext = new ControllerContext()
{
HttpContext = httpContextMock.Object
}
};
AutoMapperConfiguration.Configure();
_documents = new List <Document>
{
new Document
{
Id = Guid.NewGuid(),
CandidateId = Guid.NewGuid(),
Filename = "MyCV.pdf",
DocumentType = DocumentType.BusinessPlan,
ReviewerId = Guid.NewGuid()
},
new Document
{
Id = Guid.NewGuid(),
CandidateId = Guid.NewGuid(),
Filename = "MyDoc.docx",
DocumentType = DocumentType.License
},
new Document
{
Id = Guid.NewGuid(),
CandidateId = Guid.NewGuid(),
Filename = "TestPdf.pdf",
DocumentType = DocumentType.Other
}
};
}
public static async Task DownloadAsync_DocumentRepositoryException_ReturnsStatusCodeResult()
{
var exception = new DocumentRepositoryException(
new InvalidOperationException(),
StatusCodes.Status502BadGateway);
var mockStorage = new Mock <IDocumentRepository>();
mockStorage.Setup(s => s.DownloadAsync(It.IsAny <string>())).Throws(exception);
var controller = new DocumentsController(mockStorage.Object, Mock.Of <ILogger <DocumentsController> >());
var result = await controller.DownloadAsync("directory") as StatusCodeResult;
Assert.NotNull(result);
result.StatusCode.Should().Be(exception.HttpStatusCode);
}
public async Task TestSendDocumentForApprovalReadEventsErrorBadRequestResult()
{
//Arrange
const string error = "testError";
_documentsController = new DocumentsController(TestHelper.ReadEventsFuncWithError(error), TestHelper.SaveAndPublish,
DocumentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
//Act
var result = await _documentsController.SendDocumentForApproval(Guid.Empty);
//Assert
var badRequestResult = result as BadRequestObjectResult;
Assert.NotNull(badRequestResult);
Assert.NotNull(badRequestResult.Value);
}
public async Task TestCreateDocumentCreatedResult()
{
//Arrange
var command = new CreateDocumentCommand("1234", "test");
_documentsController = new DocumentsController(TestHelper.ValidReadEventsFunc(), TestHelper.SaveAndPublish,
DocumentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
//Act
var result = await _documentsController.CreateDocument(command);
//Assert
var createdResult = result as CreatedResult;
Assert.NotNull(createdResult);
Assert.NotNull(createdResult.Location);
}
public async Task TestingGetDocumentsFromStudentWithNoDocuments()
{
//InitializeDatabaseWithDataTest();
DocumentsController controller = new DocumentsController(_context);
string studentIndex = _context.Students.Where(m => m.UserFullname == "Teste User 2").First().Id;
int appId = _context.Applications.Where(a => a.StudentId.Equals(studentIndex)).FirstOrDefault().ApplicationId;
// Act
var result = await controller.Index(appId);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <Document> >(
viewResult.ViewData.Model);
Assert.Empty(model);
}
public async Task TestCreateDocumentInvalidCommandBadRequestResult()
{
//Arrange
var command = new CreateDocumentCommand(string.Empty, "test");
_documentsController = new DocumentsController(TestHelper.ValidReadEventsFunc(), TestHelper.SaveAndPublish,
DocumentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
//Act
var result = await _documentsController.CreateDocument(command);
//Assert
var badRequestResult = result as BadRequestObjectResult;
Assert.NotNull(badRequestResult);
Assert.NotNull(badRequestResult.Value);
}
public async void DeleteDocumentUpdateIdDeletesDocumentUpdate()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new DocumentsController(context, _mapper))
{
DocumentUpdate dup = context.DocumentUpdates.AsNoTracking().Last();
var result = await controller.DeleteDocumentUpdate(dup.DocumentId, dup.Id);
DocumentUpdateDto a3 = _mapper.Map <DocumentUpdateDto>(dup);
Assert.NotNull(result);
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var resultValue = okObjectResult.Value;
Assert.Equal(a3, resultValue);
}
}
public void SetUp()
{
BlobStore = Substitute.For <IBlobStore>();
IdentityGenerator = Substitute.For <IIdentityGenerator>();
_handleWriter = Substitute.For <IDocumentWriter>();
DocumentReader = Substitute.For <IMongoDbReader <DocumentDescriptorReadModel, DocumentDescriptorId> >();
DocumentDeletedReader = Substitute.For <IMongoDbReader <DocumentDeletedReadModel, String> >();
QueueDispatcher = Substitute.For <IQueueManager>();
CounterService = Substitute.For <ICounterService>();
var bus = Substitute.For <IInProcessCommandBus>();
var configuration = new DocumentStoreTestConfiguration();
Controller = new DocumentsController(
BlobStore,
configuration,
IdentityGenerator,
DocumentReader,
DocumentDeletedReader,
bus,
_handleWriter,
QueueDispatcher,
CounterService,
null)
{
Request = new HttpRequestMessage
{
RequestUri = new Uri("http://localhost/api/products")
},
Logger = new ConsoleLogger(),
Configuration = new HttpConfiguration(),
RequestContext =
{
RouteData = new HttpRouteData(
route: new HttpRoute(),
values: new HttpRouteValueDictionary {
{ "controller", "file" }
})
}
};
// Controller.Configuration.MapHttpAttributeRoutes();
Controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
}
public async Task AddOrUpdate_ValidIdAndDocument_CallsApplicationService()
{
// Arrange
var service = new Mock <IDocumentService>();
var target = new DocumentsController(service.Object);
var fixture = new Fixture();
var model = fixture.Create <AddOrUpdateDocumentModel>();
var documentId = Guid.NewGuid();
// Act
await target.AddOrUpdate(documentId, model);
// Assert
service.Verify(i => i.Save(documentId, It.IsAny <DocumentDto>()));
}
public async Task TestGetNotFoundResult()
{
//Arrange
var documentId = Guid.Empty;
var getDocumentById =
new DocumentRepository.GetDocumentById(_ => Task.FromResult(Option <DocumentDatabaseDto> .None));
_documentsController = new DocumentsController(TestHelper.ValidReadEventsFunc(), TestHelper.SaveAndPublish,
DocumentExistsByNumber, getDocumentById, TestHelper.GetCurrentUserId());
// Act
var actionResult = await _documentsController.Get(documentId);
// Assert
var notFoundResult = actionResult as NotFoundResult;
Assert.NotNull(notFoundResult);
}
public async Task TestCreateDocumentDocumentExistsBadRequestResult()
{
//Arrange
var command = new CreateDocumentCommand("1234", "test");
var documentExistsByNumber = new DocumentRepository.DocumentExistsByNumber(_ => Task.FromResult(true));
_documentsController = new DocumentsController(TestHelper.ValidReadEventsFunc(), TestHelper.SaveAndPublish,
documentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
//Act
var result = await _documentsController.CreateDocument(command);
//Assert
var badRequestResult = result as BadRequestObjectResult;
Assert.NotNull(badRequestResult);
Assert.NotNull(badRequestResult.Value);
}
public void CreateDocumentsAsync_CatchException_BadRequest()
{
var fakeDocument = getFakeDocument();
var documentsInputModel = new AggregatedDocumentInputModel
{
DocumentTypeID = fakeDocument.DocumentTypeID
};
IEnumerable <IResult <Document> > fakeCreateResult = new List <IResult <Document> > {
Result.Ok(fakeDocument)
};
_documentServiceMock.Setup(x => x.CreateDocumentsAsync(It.IsAny <IEnumerable <DocumentWithFileInputModel> >()))
.Throws(new Exception());
var documentController = new DocumentsController(_documentServiceMock.Object);
var actionResult = documentController.CreateDocumentsAsync(documentsInputModel);
Assert.AreEqual((int)System.Net.HttpStatusCode.BadRequest, (actionResult.Result as BadRequestObjectResult).StatusCode);
}
public async Task TestSendDocumentForApprovalInvalidIdBadRequestResult()
{
//Arrange
var documentCreatedDto =
new DocumentCreatedEventDto(Guid.Empty, DateTime.UtcNow, Guid.Empty, "1234", string.Empty);
var readEventsFunc = TestHelper.ValidReadEventsFunc(documentCreatedDto.ToEvent());
_documentsController = new DocumentsController(readEventsFunc, TestHelper.SaveAndPublish,
DocumentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
//Act
var result = await _documentsController.SendDocumentForApproval(Guid.Empty);
//Assert
var badRequestResult = result as BadRequestObjectResult;
Assert.NotNull(badRequestResult);
Assert.NotNull(badRequestResult.Value);
}
public async Task TestGetOkResult()
{
//Arrange
var documentId = Guid.NewGuid();
_documentsController = new DocumentsController(TestHelper.ValidReadEventsFunc(), TestHelper.SaveAndPublish,
DocumentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
// Act
var actionResult = await _documentsController.Get(documentId);
// Assert
var okResult = actionResult as OkObjectResult;
var document = okResult?.Value as Document;
Assert.NotNull(okResult);
Assert.NotNull(document);
Assert.Equal(documentId, document.Id);
}
public async void GetDocumentByIdReturnsSingleDocument()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new DocumentsController(context, _mapper))
{
var result = await controller.GetDocument(3);
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var resultValue = okObjectResult.Value;
DocumentDto a3 = GetTestDocumentDtoFromContext(3);
Assert.NotNull(resultValue);
Assert.IsType <DocumentDto>(resultValue);
DocumentDto a = (DocumentDto)resultValue;
Assert.True(a.Equals(a3));
Assert.True(a.Equals(a3, true));
}
}
public void GetDocumentAsPdf()
{
var textDocument = new TextDocument
{
Id = "1", Text = "Test1", Name = "Test2", Owner = new ApplicationUser {
Id = "1"
}
};
var documentService = new Mock <IDocumentService>();
documentService
.Setup(service => service.GetDocument("1"))
.Returns(textDocument);
var controller = new DocumentsController(documentService.Object);
var result = controller.GetDocumentAsPdf("1");
Assert.IsType <FileStreamResult>(result);
}
static private void SelectProfile()
{
var Profiles = new ProfilesController();
var SelectedProfileId = Profiles.Select();
var Associations = new AssociationsController();
var Documents = new DocumentsController();
var menu = new Menu(true);
menu.Insert("List Associations", Associations.ListAll);
menu.Insert("Add Association", Associations.Add);
menu.Insert("Select Association", SelectAssociation);
menu.Insert("List documents", Documents.ListAll);
menu.Insert("Add document", Documents.Add);
menu.Insert("Select document", SelectDocument);
while (menu.SelectAct())
{
;
}
}
protected bool remove_file(DocFileInfo file, ref string responseText)
{
try
{
if (file != null && file.FolderName.HasValue && file.FolderName.Value == FolderNames.TemporaryFiles)
{
file.delete(paramsContainer.Tenant.Id);
}
}
catch { }
bool result = file != null && file.FileID.HasValue &&
DocumentsController.remove_file(paramsContainer.Tenant.Id, file.FileID.Value);
responseText = result ? "{\"Succeed\":\"" + Messages.OperationCompletedSuccessfully + "\"}" :
"{\"ErrorText\":\"" + Messages.OperationFailed + "\"}";
return(result);
}
static private void SelectAssociation()
{
var Associations = new AssociationsController();
var SelectedAssociationId = Associations.Select();
var Documents = new DocumentsController();
var menu = new Menu(true);
menu.Insert("Edit Association", Associations.Edit);
menu.Insert("Delete Association", Associations.Delete);
menu.Insert("List documents", Documents.ListAll);
menu.Insert("Add document", Documents.Add);
menu.Insert("Edit document", Documents.Edit);
menu.Insert("Delete document", Documents.Delete);
menu.Insert("Select document", SelectDocument);
while (menu.SelectAct())
{
;
}
}
public void GetIdReurnsDocument()
{
//Arrange
var moq = new Mock <IDocumentsRepository>();
moq.Setup(m => m.Get(It.IsAny <object[]>())).Returns <object[]>(id =>
Task.FromResult(new Document {
Id = (long)id[0]
}));
DocumentsController controller = new DocumentsController(moq.Object);
long documentId = 2;
//Act
var result = controller.Get(documentId).Result;
//Assert
Assert.IsInstanceOfType(result, typeof(Document));
Assert.AreEqual(result.Id, documentId);
}
public async Task TestUpdateDocumentNoContentResult()
{
//Arrange
var documentCreatedDto =
new DocumentCreatedEventDto(Guid.Empty, DateTime.UtcNow, Guid.Empty, "1234", string.Empty);
var readEventsFunc = TestHelper.ValidReadEventsFunc(documentCreatedDto.ToEvent());
var command = new UpdateDocumentCommand("1234", "test");
_documentsController = new DocumentsController(readEventsFunc, TestHelper.SaveAndPublish,
DocumentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
//Act
var result = await _documentsController.UpdateDocument(Guid.Empty, command);
//Assert
var noContentResult = result as NoContentResult;
Assert.NotNull(noContentResult);
}
private DocumentsController SetupController(Action <Mock <IDocumentService> > documentMock = null)
{
var documentServiceMock = new Mock <IDocumentService>();
var globalStoreMock = new Mock <IGlobalStoreManager>();
var dataSetSelectorMock = new Mock <IDataSetSelector>();
var dataSetName = "dataset_name";
globalStoreMock.Setup(s => s.DataSets.Get(It.IsAny <string>()))
.Returns(new GlobalStoreDataSet(dataSetName, dataSetName, new DataSet {
Name = dataSetName
}, new List <string> {
}, false, false));
documentMock?.Invoke(documentServiceMock);
var controller = new DocumentsController(documentServiceMock.Object, dataSetSelectorMock.Object);
return(controller);
}
public async Task TestGetDocumentHistoryOkResult()
{
//Arrange
var documentCreatedDto =
new DocumentCreatedEventDto(Guid.Empty, DateTime.UtcNow, Guid.Empty, "1234", string.Empty);
var readEventsFunc = TestHelper.ValidReadEventsFunc(documentCreatedDto.ToEvent());
_documentsController = new DocumentsController(readEventsFunc, TestHelper.SaveAndPublish,
DocumentExistsByNumber, TestHelper.GetDocumentById(), TestHelper.GetCurrentUserId());
//Act
var actionResult = await _documentsController.GetDocumentHistory(Guid.Empty);
//Assert
var okResult = actionResult as OkObjectResult;
var documentHistory = okResult?.Value as IEnumerable <DocumentHistory>;
Assert.NotNull(okResult);
Assert.NotNull(documentHistory);
Assert.Single(documentHistory);
}
public void GetDocumentsReturnsListOfDocuments()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new DocumentsController(context, _mapper))
{
var result = controller.GetDocuments();
DocumentDto d3 = GetTestDocumentDtoFromContext(3);
Assert.NotNull(result);
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var resultValue = okObjectResult.Value;
Assert.IsAssignableFrom <IEnumerable <DocumentDto> >(resultValue);
Assert.NotEmpty((IEnumerable <DocumentDto>)resultValue);
IEnumerable <DocumentDto> resultValueList = (IEnumerable <DocumentDto>)resultValue;
DocumentDto d = (DocumentDto)resultValueList.Single(r => r.Id == 3);
Assert.True(d.Equals(d3));
Assert.True(d.Equals(d3, true));
}
}
public async Task Create_ReturnsViewResult_When_InValidModelIsGiven()
{
// Arrange
Mock <IFormFile> mockResumeFormFile = new Mock <IFormFile>();
mockResumeFormFile.Setup(file => file.Length)
.Returns(0);
DocumentViewModel tempDocumentVM = new DocumentViewModel
{
DocumentName = "new DocumentViewModel",
Resume = mockResumeFormFile.Object
};
ApplicationUser user = new ApplicationUser
{
Id = "ids"
};
Mock <IUserRepository> mockUserRepo = new Mock <IUserRepository>();
HttpContext temp = null;
mockUserRepo.Setup(repo => repo.getUserFromHttpContextAsync(temp))
.ReturnsAsync(user);
Mock <IDocumentRepository> mockDocumentRepo = new Mock <IDocumentRepository>();
mockDocumentRepo.Setup(repo => repo.SaveDocumentToUser(tempDocumentVM, user))
.ReturnsAsync(false);
DocumentsController controller = new DocumentsController(mockUserRepo.Object,
mockDocumentRepo.Object);
// Act
IActionResult result = await controller.Create(tempDocumentVM);
// Assert
ViewResult viewResult = Assert.IsType <ViewResult>(result);
}
public async void ShouldUploadFile()
{
// Get a loose automock
var Mock = AutoMock.GetLoose();
var someOptions = Options.Create(new AppSettings
{
UploadMaxFileSizeInMb = 3
});
// Create the Document Contoller
var documentsController = new DocumentsController(someOptions);
var httpContext = new DefaultHttpContext();
var file = new FormFile(new MemoryStream(Encoding.UTF8.GetBytes("This is a dummy file")), 0, 15, "Data", "dummy.pdf");
file.Headers = new HeaderDictionary();
file.Headers.Add("Content-Type", "application/pdf");
httpContext.Request.Form = new FormCollection(new Dictionary <string, StringValues>(), new FormFileCollection {
file
});
var actx = new ActionContext(httpContext, new RouteData(), new ControllerActionDescriptor());
var context = new ControllerContext(actx);
documentsController.ControllerContext = context;
var mediator = new Mock <IMediator>();
mediator.Setup(m => m.Send(It.IsAny <UploadFileCommand>(), It.IsAny <CancellationToken>())).ReturnsAsync("filelocation.pdf");
var servicesMock = new Mock <IServiceProvider>();
servicesMock.Setup(sp => sp.GetService(typeof(IMediator))).Returns(mediator.Object);
context.HttpContext.RequestServices = servicesMock.Object;
// Invoke the method
await documentsController.UploadDoument();
mediator.Verify(x => x.Send(It.IsAny <UploadFileCommand>(), It.IsAny <CancellationToken>()));
}
public async Task <JsonResult> apiDelete(long id)
{
int userid = GetUserId().Value;
Bookmark bmark = _context.Bookmark.Where(bm => (bm.Id.Equals(id) && bm.UserId == userid)).First();
_context.Bookmark.Remove(bmark);
await _context.SaveChangesAsync();
// now check if deleted document still have bookmarks
Document doc = _context.Document.Find(bmark.DocumentId);
if (doc.DocStatus == Document.DocStatusEnum.Deleted)
{
DocumentsController dc = new DocumentsController(_context, _smngr, null, null, null, null)
{
ControllerContext = ControllerContext,
// User = User
};
await dc.TryDeletePermanent(doc);
}
return(Json(new { status = "Ok" }));
}
