Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
121 changes: 121 additions & 0 deletions backend/Savepoint.Api.Tests/ItemRatingFieldsTests.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,121 @@
using System.Net;
using System.Net.Http.Json;
using System.Text.Json;
using Microsoft.Extensions.DependencyInjection;
using Savepoint.Api.Data;
using Savepoint.Api.Library;

namespace Savepoint.Api.Tests;

/// <summary>
/// The rating, ratingChangeId and ratingChangedAt every item answer carries: the
/// newest of its rating changes, or all null until it's rated.
/// </summary>
public sealed class ItemRatingFieldsTests(PostgresFixture postgres) : IAsyncDisposable
{
private readonly ApiFactory factory = new(postgres.ConnectionString);
private readonly CancellationToken cancellationToken = TestContext.Current.CancellationToken;

public ValueTask DisposeAsync() => factory.DisposeAsync();

private async Task<JsonElement> ReadJson(HttpResponseMessage response) =>
await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken);

private async Task<JsonElement> Create(HttpClient client)
{
var response = await client.PostAsJsonAsync(
"/api/items", new { medium = "Book", title = "Piranesi" }, cancellationToken);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
return await ReadJson(response);
}

private async Task<JsonElement> Get(HttpClient client, Guid id)
{
var response = await client.GetAsync($"/api/items/{id}", cancellationToken);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
return await ReadJson(response);
}

// Straight into the database, one save per rating so each gets a later time.
// The endpoint for rating comes with its own tests.
private async Task<Guid> Rate(Guid itemId, int rating)
{
using var scope = factory.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<SavepointDbContext>();
var change = new RatingChange { ItemId = itemId, Rating = rating };
db.RatingChanges.Add(change);
await db.SaveChangesAsync(cancellationToken);
return change.Id;
}

private static void AssertUnrated(JsonElement item)
{
Assert.Equal(JsonValueKind.Null, item.GetProperty("rating").ValueKind);
Assert.Equal(JsonValueKind.Null, item.GetProperty("ratingChangeId").ValueKind);
Assert.Equal(JsonValueKind.Null, item.GetProperty("ratingChangedAt").ValueKind);
}

[Fact]
public async Task A_new_item_answers_with_no_rating()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;

var created = await Create(client);

AssertUnrated(created);
AssertUnrated(await Get(client, created.GetProperty("id").GetGuid()));
}

[Fact]
public async Task Answers_with_the_newest_rating()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;
var id = (await Create(client)).GetProperty("id").GetGuid();
await Rate(id, 2);
var newest = await Rate(id, 4);

var item = await Get(client, id);

Assert.Equal(4, item.GetProperty("rating").GetInt32());
Assert.Equal(newest, item.GetProperty("ratingChangeId").GetGuid());
Assert.True(item.GetProperty("ratingChangedAt").GetDateTimeOffset() > item.GetProperty("createdAt").GetDateTimeOffset());
}

[Fact]
public async Task Lists_each_item_with_its_own_rating()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;
var rated = (await Create(client)).GetProperty("id").GetGuid();
var unrated = (await Create(client)).GetProperty("id").GetGuid();
await Rate(rated, 5);

var response = await client.GetAsync("/api/items", cancellationToken);
var items = (await ReadJson(response)).EnumerateArray().ToDictionary(i => i.GetProperty("id").GetGuid());

Assert.Equal(5, items[rated].GetProperty("rating").GetInt32());
AssertUnrated(items[unrated]);
}

[Fact]
public async Task Keeps_the_rating_when_the_status_or_details_change()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;
var id = (await Create(client)).GetProperty("id").GetGuid();
var change = await Rate(id, 3);

var moved = await ReadJson(await client.PostAsJsonAsync(
$"/api/items/{id}/status", new { status = "Finished" }, cancellationToken));
var edited = await ReadJson(await client.PutAsJsonAsync(
$"/api/items/{id}", new { medium = "Book", title = "Piranesi, again" }, cancellationToken));

foreach (var item in new[] { moved, edited })
{
Assert.Equal(3, item.GetProperty("rating").GetInt32());
Assert.Equal(change, item.GetProperty("ratingChangeId").GetGuid());
}
}
}
77 changes: 77 additions & 0 deletions backend/Savepoint.Api.Tests/LibraryModelTests.cs
Original file line number Diff line number Diff line change
Expand Up @@ -114,6 +114,83 @@ public async Task Refuses_a_medium_or_status_not_in_the_list(string sql, string
Assert.Equal(constraint, error.ConstraintName);
}

[Fact]
public async Task Saves_ratings_as_a_history_with_the_databases_clock()
{
await using var db = NewContext();
var cancellationToken = TestContext.Current.CancellationToken;
var item = NewItem(await CreateUserAsync(db));
db.Items.Add(item);
await db.SaveChangesAsync(cancellationToken);

// Separate saves, as separate changes of heart would be.
item.RatingChanges.Add(new RatingChange { Rating = 3 });
await db.SaveChangesAsync(cancellationToken);
item.RatingChanges.Add(new RatingChange { Rating = 5 });
await db.SaveChangesAsync(cancellationToken);

await using var fresh = NewContext();
var ratings = await fresh.RatingChanges
.Where(r => r.ItemId == item.Id)
.OrderBy(r => r.ChangedAt).ThenBy(r => r.Id)
.ToListAsync(cancellationToken);
Assert.Equal([3, 5], ratings.Select(r => r.Rating));
Assert.All(ratings, r => Assert.NotEqual(default, r.ChangedAt));
Assert.True(ratings[1].ChangedAt > ratings[0].ChangedAt);
}

[Fact]
public async Task A_new_item_has_no_rating()
{
await using var db = NewContext();
var cancellationToken = TestContext.Current.CancellationToken;
var item = NewItem(await CreateUserAsync(db));
db.Items.Add(item);
await db.SaveChangesAsync(cancellationToken);

Assert.False(await db.RatingChanges.AnyAsync(r => r.ItemId == item.Id, cancellationToken));
}

[Theory]
[InlineData(LibraryRules.MinRating)]
[InlineData(LibraryRules.MaxRating)]
public async Task Allows_a_rating_of_1_to_5_stars(int rating)
{
await using var db = NewContext();
var item = NewItem(await CreateUserAsync(db));
item.RatingChanges.Add(new RatingChange { Rating = rating });
db.Items.Add(item);
await db.SaveChangesAsync(TestContext.Current.CancellationToken);
}

[Theory]
[InlineData(LibraryRules.MinRating - 1)]
[InlineData(LibraryRules.MaxRating + 1)]
[InlineData(-3)]
public async Task Refuses_a_rating_outside_1_to_5_stars(int rating)
{
await using var db = NewContext();
var item = NewItem(await CreateUserAsync(db));
item.RatingChanges.Add(new RatingChange { Rating = rating });
db.Items.Add(item);
await AssertRefusedByAsync(db, "CK_RatingChanges_Rating");
}

[Fact]
public async Task Deleting_an_item_deletes_its_ratings()
{
await using var db = NewContext();
var cancellationToken = TestContext.Current.CancellationToken;
var item = NewItem(await CreateUserAsync(db));
item.RatingChanges.Add(new RatingChange { Rating = 4 });
db.Items.Add(item);
await db.SaveChangesAsync(cancellationToken);

await db.Items.Where(i => i.Id == item.Id).ExecuteDeleteAsync(cancellationToken);

Assert.False(await db.RatingChanges.AnyAsync(r => r.ItemId == item.Id, cancellationToken));
}

[Fact]
public async Task Deleting_an_account_deletes_its_library()
{
Expand Down
7 changes: 6 additions & 1 deletion backend/Savepoint.Api.Tests/ListItemsTests.cs
Original file line number Diff line number Diff line change
Expand Up @@ -63,7 +63,12 @@ public async Task Lists_every_item_newest_first_with_the_same_shape_as_creating(
Assert.Equal("Game", hades.GetProperty("medium").GetString());
Assert.Equal("InProgress", hades.GetProperty("status").GetString());
Assert.Equal(
["id", "medium", "title", "creator", "status", "statusChangeId", "statusChangedAt", "createdAt"],
[
"id", "medium", "title", "creator",
"status", "statusChangeId", "statusChangedAt",
"rating", "ratingChangeId", "ratingChangedAt",
"createdAt",
],
hades.EnumerateObject().Select(p => p.Name));
}

Expand Down
136 changes: 136 additions & 0 deletions backend/Savepoint.Api.Tests/ListRatingChangesTests.cs
Original file line number Diff line number Diff line change
@@ -0,0 +1,136 @@
using System.Net;
using System.Net.Http.Json;
using System.Text.Json;

namespace Savepoint.Api.Tests;

/// <summary>GET /api/items/{id}/rating-changes, an item's rating history for its timeline.</summary>
public sealed class ListRatingChangesTests(PostgresFixture postgres) : IAsyncDisposable
{
private readonly ApiFactory factory = new(postgres.ConnectionString);
private readonly CancellationToken cancellationToken = TestContext.Current.CancellationToken;

public ValueTask DisposeAsync() => factory.DisposeAsync();

private async Task<Guid> CreateItem(HttpClient client)
{
var response = await client.PostAsJsonAsync(
"/api/items", new { medium = "Game", title = "Outer Wilds" }, cancellationToken);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
return (await ReadJson(response)).GetProperty("id").GetGuid();
}

private async Task<JsonElement> Rate(HttpClient client, Guid itemId, int rating)
{
var response = await client.PostAsJsonAsync($"/api/items/{itemId}/rating", new { rating }, cancellationToken);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
return await ReadJson(response);
}

private Task<HttpResponseMessage> List(HttpClient client, Guid itemId) =>
client.GetAsync($"/api/items/{itemId}/rating-changes", cancellationToken);

private async Task<JsonElement> ReadJson(HttpResponseMessage response) =>
await response.Content.ReadFromJsonAsync<JsonElement>(cancellationToken);

private async Task<JsonElement[]> ListOk(HttpClient client, Guid itemId)
{
var response = await List(client, itemId);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
return [.. (await ReadJson(response)).EnumerateArray()];
}

[Fact]
public async Task Answers_401_when_not_signed_in()
{
using var client = factory.CreateClient();

var response = await List(client, Guid.NewGuid());

Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}

[Fact]
public async Task Answers_an_empty_list_for_an_item_not_rated_yet()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;

Assert.Empty(await ListOk(client, await CreateItem(client)));
}

[Fact]
public async Task Answers_with_each_rating_as_the_item_shows_it()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;
var itemId = await CreateItem(client);
var item = await Rate(client, itemId, 4);

var change = Assert.Single(await ListOk(client, itemId));

Assert.Equal(item.GetProperty("ratingChangeId").GetGuid(), change.GetProperty("id").GetGuid());
Assert.Equal(4, change.GetProperty("rating").GetInt32());
Assert.Equal(
item.GetProperty("ratingChangedAt").GetDateTimeOffset(),
change.GetProperty("changedAt").GetDateTimeOffset());
}

[Fact]
public async Task Lists_every_change_oldest_first()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;
var itemId = await CreateItem(client);
await Rate(client, itemId, 3);
await Rate(client, itemId, 5);
await Rate(client, itemId, 4);

var changes = await ListOk(client, itemId);

Assert.Equal(new[] { 3, 5, 4 }, changes.Select(c => c.GetProperty("rating").GetInt32()));
var times = changes.Select(c => c.GetProperty("changedAt").GetDateTimeOffset()).ToArray();
Assert.Equal(times.Order(), times);
}

[Fact]
public async Task Lists_only_that_items_ratings()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;
var itemId = await CreateItem(client);
var otherId = await CreateItem(client);
await Rate(client, itemId, 2);
await Rate(client, otherId, 5);

var change = Assert.Single(await ListOk(client, itemId));

Assert.Equal(2, change.GetProperty("rating").GetInt32());
}

[Fact]
public async Task Answers_404_for_someone_elses_item_even_when_it_has_no_ratings()
{
var (owner, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = owner;
var rated = await CreateItem(owner);
var unrated = await CreateItem(owner);
await Rate(owner, rated, 5);
var (stranger, _) = await factory.SignedInClientAsync(cancellationToken);
using var __ = stranger;

Assert.Equal(HttpStatusCode.NotFound, (await List(stranger, rated)).StatusCode);
Assert.Equal(HttpStatusCode.NotFound, (await List(stranger, unrated)).StatusCode);
}

[Fact]
public async Task Answers_404_for_an_item_that_doesnt_exist()
{
var (client, _) = await factory.SignedInClientAsync(cancellationToken);
using var _ = client;

var response = await List(client, Guid.NewGuid());

Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
}
Loading