public async Task Handle_HappyFlow()
{
// Arrange
var note1 = await _wolkDbContext.CreateAndSaveNote();
var note2 = await _wolkDbContext.CreateAndSaveNote();
var file1 = await _wolkDbContext.CreateAndSaveAttachment(note1);
var file2 = await _wolkDbContext.CreateAndSaveAttachment(note2);
var file3 = await _wolkDbContext.CreateAndSaveAttachment(note1);
var request = new GetAttachmentsQuery {
NoteId = note1.Id
};
// Act
var result = (await _handler.Handle(request, CancellationToken.None)).ToArray();
// Assert
Assert.AreEqual(2, result.Length);
ShouldBeEqual(file1, result[0]);
ShouldBeEqual(file3, result[1]);
}
public async Task Handle_NoteNotFound_ShouldThrowNotFoundException()
{
// Arrange
var note = await _wolkDbContext.CreateAndSaveNote();
var request = new DeleteNotebookCommand(note.Id + 1);
// Act / Assert
await Assert.ThrowsExceptionAsync <NotFoundException>(() => _handler.Handle(request, CancellationToken.None));
}
public async Task Handle_NoteNotFound_ShouldThrowNotFoundException()
{
// Arrange
var notebook = await _wolkDbContext.CreateAndSaveNotebook();
var note = await _wolkDbContext.CreateAndSaveNote(notebook);
var request = new UpdateNoteCommand
{
Id = note.Id + 1, Content = "bladibla", Title = "Note title", NotebookId = notebook.Id
};
// Act / Assert
await Assert.ThrowsExceptionAsync <NotFoundException>(() =>
_handler.Handle(request, CancellationToken.None));
}
public async Task Update_HappyFlow()
{
// Arrange
var notebook1 = await WolkDbContext.CreateAndSaveNotebook();
var notebook2 = await WolkDbContext.CreateAndSaveNotebook();
var note = await WolkDbContext.CreateAndSaveNote(notebook1);
var url = $"/api/note/{note.Id}";
var model = new MutateNoteModel
{
Title = Guid.NewGuid().ToString(),
Content = Guid.NewGuid().ToString(),
NotebookId = notebook2.Id,
NoteType = NoteType.Markdown
};
var request = new HttpRequestMessage(HttpMethod.Put, url)
{
Content = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, MimeTypes.Json)
};
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
ShouldBeEqual(note, model);
}
public async Task CreateAttachment_ValidationError_ShouldReturn400()
{
// Arrange
var note = await WolkDbContext.CreateAndSaveNote();
var contents = new byte[] { 1, 2, 3, 4 };
var model = new MutateAttachmentModel
{
Filename = new string('a', 301), Base64Contents = Convert.ToBase64String(contents)
};
var url = $"/api/note/{note.Id}/attachments";
var request = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, MimeTypes.Json)
};
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task GetAllIncludingContent_HappyFlow()
{
// Arrange
var note1 = await WolkDbContext.CreateAndSaveNote();
var note2 = await WolkDbContext.CreateAndSaveNote();
var url = "/api/note/all";
var request = new HttpRequestMessage(HttpMethod.Get, url);
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var notes = JsonConvert.DeserializeObject <NoteDto[]>(content);
ShouldBeEqual(note1, notes[0]);
ShouldBeEqual(note2, notes[1]);
}
public async Task GetAll_HappyFlow_NotebookIdSet()
{
// Arrange
var notebook1 = await WolkDbContext.CreateAndSaveNotebook();
var notebook2 = await WolkDbContext.CreateAndSaveNotebook();
var note1 = await WolkDbContext.CreateAndSaveNote(notebook1);
var note2 = await WolkDbContext.CreateAndSaveNote(notebook2);
var note3 = await WolkDbContext.CreateAndSaveNote(notebook1);
var url = $"/api/note?notebookId={notebook1.Id}";
var request = new HttpRequestMessage(HttpMethod.Get, url);
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var notes = JsonConvert.DeserializeObject <NoteOverviewDto[]>(content);
Assert.AreEqual(2, notes.Length);
ShouldBeEqual(note1, notes[0]);
ShouldBeEqual(note3, notes[1]);
}
public async Task GetAllAttachments_HappyFlow()
{
// Arrange
var note1 = await WolkDbContext.CreateAndSaveNote();
var note2 = await WolkDbContext.CreateAndSaveNote();
var file1 = await WolkDbContext.CreateAndSaveAttachment(note1);
var file2 = await WolkDbContext.CreateAndSaveAttachment(note2);
var file3 = await WolkDbContext.CreateAndSaveAttachment(note1);
var url = $"/api/note/{note1.Id}/attachments";
var request = new HttpRequestMessage(HttpMethod.Get, url);
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var attachments = JsonConvert.DeserializeObject <AttachmentDto[]>(content);
Assert.AreEqual(2, attachments.Length);
ShouldBeEqual(file1, attachments[0]);
ShouldBeEqual(file3, attachments[1]);
}
public async Task Validate_ValidationErrors()
{
// Arrange
var note = await _wolkDbContext.CreateAndSaveNote();
var request = new CreateAttachmentCommand
{
Contents = new byte[0], Filename = new string('a', 301), NoteId = note.Id + 1
};
// Act
var result = await _validator.ValidateAsync(request, CancellationToken.None);
// Assert
Assert.AreEqual(3, result.Errors.Count);
Assert.IsTrue(result.Errors.ElementAt(0).ErrorMessage.Contains("Please provide a file."));
Assert.IsTrue(result.Errors.ElementAt(1).ErrorMessage.Contains("300 characters or fewer"));
Assert.IsTrue(result.Errors.ElementAt(2).ErrorMessage.Contains("Note with ID"));
}
public async Task Delete_NoteNotFound_ShouldReturn404()
{
// Arrange
var note = await WolkDbContext.CreateAndSaveNote();
var url = $"/api/note/{note.Id + 1}";
var request = new HttpRequestMessage(HttpMethod.Delete, url);
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task Delete_HappyFlow()
{
// Arrange
var note = await WolkDbContext.CreateAndSaveNote();
var url = $"/api/note/{note.Id}";
var request = new HttpRequestMessage(HttpMethod.Delete, url);
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
Assert.IsFalse(await WolkDbContext.Notes.AnyAsync());
}
public async Task Handle_ShouldAddAttachmentCorrectly()
{
// Arrange
var note = await _wolkDbContext.CreateAndSaveNote();
var request = new CreateAttachmentCommand
{
Contents = new byte[] { 1, 2, 3, 4 },
Filename = "file.txt",
NoteId = note.Id
};
var mime = "text/plain";
_mockMimeService
.Setup(m => m.GetMimeType(request.Filename))
.Returns(mime);
// Act
var result = await _handler.Handle(request, CancellationToken.None);
// Assert
Assert.AreEqual(request.Filename, result.Filename);
Assert.AreEqual(request.NoteId, result.NoteId);
Assert.AreEqual(4, result.FileSize);
Assert.AreEqual(mime, result.MimeType);
var attachment = await _wolkDbContext.Attachments.SingleAsync();
ShouldBeEqual(attachment, result);
Assert.IsFalse(string.IsNullOrWhiteSpace(attachment.InternalFilename));
var expectedFilePath = Path.Combine(_configuration.UploadsPath, attachment.InternalFilename);
_mockFileService
.Verify(m => m.WriteAllBytes(expectedFilePath, request.Contents), Times.Once);
}
public async Task CreateAttachment_HappyFlow()
{
// Arrange
var note = await WolkDbContext.CreateAndSaveNote();
var contents = new byte[] { 1, 2, 3, 4 };
var model = new MutateAttachmentModel
{
Filename = "file.txt", Base64Contents = Convert.ToBase64String(contents)
};
var url = $"/api/note/{note.Id}/attachments";
var request = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, MimeTypes.Json)
};
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var returnedAttachment = JsonConvert.DeserializeObject <AttachmentDto>(content);
var attachment = await WolkDbContext.Attachments.SingleAsync();
ShouldBeEqual(attachment, returnedAttachment);
Assert.AreEqual(1, MockFileService.Files.Count);
}
public async Task UploadBackup_ShouldRestoreEntitiesCorrectly()
{
// Arrange
for (var i = 0; i < 10; i++)
{
await WolkDbContext.CreateAndSaveNote();
}
var url = "/api/backup";
var zipPath = Path.Combine(AssemblyHelper.GetExecutingAssemblyRootPath(), "Files", "wolk-backup.zip");
var zipBytes = File.ReadAllBytes(zipPath);
var model = new UploadBackupModel {
ZipBytes = zipBytes
};
var request = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, MimeTypes.Json)
};
var token = await GetJwt();
request.AddJwtBearer(token);
// Act
using var response = await HttpClient.SendAsync(request);
// Assert
Assert.AreEqual(HttpStatusCode.NoContent, response.StatusCode);
// Assert access tokens
var accessToken = await WolkDbContext.AccessTokens.SingleAsync();
Assert.AreEqual("1b7d6a57-a464-47c3-9ec7-e5a30403d8c7", accessToken.Token);
Assert.AreEqual("1", accessToken.Identifier);
// Assert attachments
var attachment = await WolkDbContext.Attachments.SingleAsync();
Assert.AreEqual("b2e6ba68-4597-4404-a078-bee38e4085c8", attachment.InternalFilename);
Assert.AreEqual(235567, attachment.FileSize);
Assert.AreEqual("id.png", attachment.Filename);
Assert.AreEqual(1, attachment.NoteId);
// Assert notebooks
var notebooks = await WolkDbContext.Notebooks.ToArrayAsync();
Assert.AreEqual(2, notebooks.Length);
Assert.IsTrue(notebooks.All(n => n.Name == "Test notebook 1" || n.Name == "Test notebook 2"));
// Assert notes
var notes = await WolkDbContext.Notes.ToArrayAsync();
Assert.AreEqual(4, notes.Length);
Assert.IsTrue(notes.All(n =>
n.Title == "Markdown test" ||
n.Title == "Plain text test" ||
n.Title == "Sticky notes test" ||
n.Title == "Todo.txt test"));
// Assert users
var user = await WolkDbContext.Users.SingleAsync();
Assert.AreEqual("*****@*****.**", user.Email);
}
