public async Task Can_Create_Article_With_Existing_Author()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
var article = ArticleFactory.Get();
context.Authors.Add(author);
await context.SaveChangesAsync();
//const string authorLocalId = "author-1";
var content = new
{
operations = new object[] {
new {
op = "add",
data = new {
type = "articles",
attributes = new {
name = article.Name
},
relationships = new {
author = new {
data = new {
type = "authors",
id = author.Id
}
}
}
}
}
}
};
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Single(data.Operations);
var lastAuthor = await context.Authors
.Include(a => a.Articles)
.SingleAsync(a => a.Id == author.Id);
var articleOperationResult = data.Operations[0];
// author validation: sanity checks
Assert.NotNull(lastAuthor);
Assert.Equal(author.Name, lastAuthor.Name);
//// article validation
Assert.Single(lastAuthor.Articles);
Assert.Equal(article.Name, lastAuthor.Articles[0].Name);
Assert.Equal(articleOperationResult.DataObject.Id, lastAuthor.Articles[0].StringId);
}
public async Task Can_Create_Author()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
var content = new
{
operations = new[] {
new {
op = "add",
data = new {
type = "authors",
attributes = new {
name = author.Name
}
}
}
}
};
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var id = data.Operations.Single().DataObject.Id;
var lastAuthor = await context.Authors.SingleAsync(a => a.StringId == id);
Assert.Equal(author.Name, lastAuthor.Name);
}
public async Task Can_Get_Article_Author()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
var article = ArticleFactory.Get();
article.Author = author;
context.Articles.Add(article);
context.SaveChanges();
var content = new
{
operations = new[] {
new Dictionary <string, object> {
{ "op", "get" },
{ "ref", new { type = "articles", id = article.StringId, relationship = nameof(article.Author) } }
}
}
};
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.NotNull(data);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Single(data.Operations);
var resourceObject = data.Operations.Single().DataObject;
Assert.Equal(author.Id.ToString(), resourceObject.Id);
Assert.Equal("authors", resourceObject.Type);
}
public async Task Can_Remove_Author()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
context.Authors.Add(author);
context.SaveChanges();
var content = new
{
operations = new[] {
new Dictionary <string, object> {
{ "op", "remove" },
{ "ref", new { type = "authors", id = author.StringId } }
}
}
};
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.NotNull(data);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Empty(data.Operations);
Assert.Null(context.Authors.SingleOrDefault(a => a.Id == author.Id));
}
public async Task Can_Get_Authors()
{
// arrange
var expectedCount = _faker.Random.Int(1, 10);
var context = GetService <AppDbContext>();
context.Articles.RemoveRange(context.Articles);
context.Authors.RemoveRange(context.Authors);
var authors = AuthorFactory.Get(expectedCount);
context.AddRange(authors);
context.SaveChanges();
var content = new
{
operations = new[] {
new Dictionary <string, object> {
{ "op", "get" },
{ "ref", new { type = "authors" } }
}
}
};
// act
var result = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(result.response);
Assert.NotNull(result.data);
Assert.Equal(HttpStatusCode.OK, result.response.StatusCode);
Assert.Equal(1, result.data.Operations.Count);
Assert.Equal(expectedCount, result.data.Operations.Single().DataList.Count);
}
public async Task Can_Get_Author_By_Id()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
context.Authors.Add(author);
context.SaveChanges();
var content = new
{
operations = new[] {
new Dictionary <string, object> {
{ "op", "get" },
{ "ref", new { type = "authors", id = author.StringId } }
}
}
};
// act
var result = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(result.response);
Assert.NotNull(result.data);
Assert.Equal(HttpStatusCode.OK, result.response.StatusCode);
Assert.Equal(1, result.data.Operations.Count);
Assert.Equal(author.Id.ToString(), result.data.Operations.Single().DataObject.Id);
}
public async Task Can_Update_Authors()
{
// arrange
var count = _faker.Random.Int(1, 10);
var context = GetService <AppDbContext>();
var authors = AuthorFactory.Get(count);
var updates = AuthorFactory.Get(count);
context.Authors.AddRange(authors);
context.SaveChanges();
var content = new
{
operations = new List <object>()
};
for (int i = 0; i < count; i++)
{
content.operations.Add(new Dictionary <string, object> {
{ "op", "update" },
{ "ref", new {
type = "authors",
id = authors[i].Id,
} },
{ "data", new {
type = "authors",
id = authors[i].Id,
attributes = new
{
name = updates[i].Name
}
} },
});
}
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(data);
Assert.Equal(count, data.Operations.Count);
for (int i = 0; i < count; i++)
{
var attrs = data.Operations[i].DataObject.Attributes;
Assert.Equal(updates[i].Name, attrs["name"]);
}
}
public async Task Can_Create_Authors()
{
// arrange
var expectedCount = _faker.Random.Int(1, 10);
var context = GetService <AppDbContext>();
var authors = AuthorFactory.Get(expectedCount);
var content = new
{
operations = new List <object>()
};
for (int i = 0; i < expectedCount; i++)
{
content.operations.Add(
new
{
op = "add",
data = new
{
type = "authors",
attributes = new
{
name = authors[i].Name
}
}
}
);
}
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(expectedCount, data.Operations.Count);
for (int i = 0; i < expectedCount; i++)
{
var dataObject = data.Operations[i].DataObject;
var author = context.Authors.Single(a => a.StringId == dataObject.Id);
Assert.Equal(authors[i].Name, author.Name);
}
}
public async Task Can_Update_Author()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
var updates = AuthorFactory.Get();
context.Authors.Add(author);
context.SaveChanges();
var content = new
{
operations = new[] {
new Dictionary <string, object> {
{ "op", "update" },
{ "ref", new {
type = "authors",
id = author.Id,
} },
{ "data", new {
type = "authors",
id = author.Id,
attributes = new
{
name = updates.Name
}
} },
}
}
};
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(data);
Assert.Single(data.Operations);
var attrs = data.Operations.Single().DataObject.Attributes;
Assert.Equal(updates.Name, attrs["name"]);
}
public async Task Can_Remove_Authors()
{
// arrange
var count = _faker.Random.Int(1, 10);
var context = GetService <AppDbContext>();
var authors = AuthorFactory.Get(count);
context.Authors.AddRange(authors);
context.SaveChanges();
var content = new
{
operations = new List <object>()
};
for (int i = 0; i < count; i++)
{
content.operations.Add(
new Dictionary <string, object> {
{ "op", "remove" },
{ "ref", new { type = "authors", id = authors[i].StringId } }
}
);
}
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.NotNull(data);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Empty(data.Operations);
for (int i = 0; i < count; i++)
{
Assert.Null(context.Authors.SingleOrDefault(a => a.Id == authors[i].Id));
}
}
public async Task Can_Create_Articles_With_Existing_Author()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
context.Authors.Add(author);
await context.SaveChangesAsync();
var expectedCount = _faker.Random.Int(1, 10);
var articles = ArticleFactory.Get(expectedCount);
var content = new
{
operations = new List <object>()
};
for (int i = 0; i < expectedCount; i++)
{
content.operations.Add(
new
{
op = "add",
data = new
{
type = "articles",
attributes = new
{
name = articles[i].Name
},
relationships = new
{
author = new
{
data = new
{
type = "authors",
id = author.Id
}
}
}
}
}
);
}
// act
var(response, data) = await PatchAsync <OperationsDocument>("api/bulk", content);
// assert
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(expectedCount, data.Operations.Count);
// author validation: sanity checks
var lastAuthor = context.Authors.Include(a => a.Articles).Single(a => a.Id == author.Id);
Assert.NotNull(lastAuthor);
Assert.Equal(author.Name, lastAuthor.Name);
// articles validation
Assert.True(lastAuthor.Articles.Count == expectedCount);
for (int i = 0; i < expectedCount; i++)
{
var article = articles[i];
Assert.NotNull(lastAuthor.Articles.FirstOrDefault(a => a.Name == article.Name));
}
}
public async Task Cannot_Create_Author_If_Article_Creation_Fails()
{
// arrange
var context = GetService <AppDbContext>();
var author = AuthorFactory.Get();
var article = ArticleFactory.Get();
// do this so that the name is random enough for db validations
author.Name = Guid.NewGuid().ToString("N");
article.Name = Guid.NewGuid().ToString("N");
var content = new
{
operations = new object[] {
new {
op = "add",
data = new {
type = "authors",
attributes = new {
name = author.Name
},
}
},
new {
op = "add",
data = new {
type = "articles",
attributes = new {
name = article.Name
},
// by not including the author, the article creation will fail
// relationships = new {
// author = new {
// data = new {
// type = "authors",
// lid = authorLocalId
// }
// }
// }
}
}
}
};
// act
var(response, data) = await PatchAsync <ErrorCollection>("api/bulk", content);
// assert
Assert.NotNull(response);
// for now, it is up to application implementations to perform validation and
// provide the proper HTTP response code
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
Assert.Single(data.Errors);
Assert.Contains("operation[1] (add)", data.Errors[0].Title);
var dbAuthors = await context.Authors.Where(a => a.Name == author.Name).ToListAsync();
var dbArticles = await context.Articles.Where(a => a.Name == article.Name).ToListAsync();
Assert.Empty(dbAuthors);
Assert.Empty(dbArticles);
}
