mirror of https://github.com/Squidex/squidex.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
793 lines
23 KiB
793 lines
23 KiB
// ==========================================================================
|
|
// Squidex Headless CMS
|
|
// ==========================================================================
|
|
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
|
// All rights reserved. Licensed under the MIT license.
|
|
// ==========================================================================
|
|
|
|
using Newtonsoft.Json.Linq;
|
|
using Squidex.ClientLibrary;
|
|
using Squidex.ClientLibrary.EnrichedEvents;
|
|
using TestSuite.Model;
|
|
|
|
#pragma warning disable CS0618 // Type or member is obsolete
|
|
#pragma warning disable SA1300 // Element should begin with upper-case letter
|
|
#pragma warning disable SA1507 // Code should not contain multiple blank lines in a row
|
|
|
|
namespace TestSuite.ApiTests;
|
|
|
|
[UsesVerify]
|
|
public class ContentUpdateTests : IClassFixture<ContentFixture>
|
|
{
|
|
public ContentFixture _ { get; }
|
|
|
|
public ContentUpdateTests(ContentFixture fixture)
|
|
{
|
|
_ = fixture;
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_return_published_content()
|
|
{
|
|
// STEP 1: Create the item unpublished.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
});
|
|
|
|
|
|
// STEP 2: Publish the item.
|
|
await _.Contents.ChangeStatusAsync(content.Id, new ChangeStatus
|
|
{
|
|
Status = "Published"
|
|
});
|
|
|
|
|
|
// STEP 3: Retrieve the item.
|
|
await _.Contents.GetAsync(content.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_not_return_archived_content()
|
|
{
|
|
// STEP 1: Create the item published.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Archive the item.
|
|
await _.Contents.ChangeStatusAsync(content.Id, new ChangeStatus
|
|
{
|
|
Status = "Archived"
|
|
});
|
|
|
|
|
|
// STEP 3. Get a 404 for the item because it is not published anymore.
|
|
await Assert.ThrowsAnyAsync<SquidexException>(() =>
|
|
{
|
|
return _.Contents.GetAsync(content.Id);
|
|
});
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_not_return_unpublished_content()
|
|
{
|
|
// STEP 1: Create the item unpublished.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
});
|
|
|
|
|
|
// STEP 2: Change the status to publiushed and then to draft.
|
|
await _.Contents.ChangeStatusAsync(content.Id, new ChangeStatus
|
|
{
|
|
Status = "Published"
|
|
});
|
|
await _.Contents.ChangeStatusAsync(content.Id, new ChangeStatus
|
|
{
|
|
Status = "Draft"
|
|
});
|
|
|
|
|
|
// STEP 3. Get a 404 for the item because it is not published anymore.
|
|
await Assert.ThrowsAnyAsync<SquidexException>(() =>
|
|
{
|
|
return _.Contents.GetAsync(content.Id);
|
|
});
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_strange_text()
|
|
{
|
|
const string text = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36";
|
|
|
|
// STEP 1: Create a content item with a text that caused a bug before.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
String = text
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Get the item and ensure that the text is the same.
|
|
var queried = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(text, queried.Data.String);
|
|
|
|
await Verify(queried);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_null_localized_text()
|
|
{
|
|
// STEP 1: Create a content item with a text that caused a bug before.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Localized = new Dictionary<string, string>
|
|
{
|
|
["en"] = null
|
|
}
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Get the item and ensure that the text is the same.
|
|
var queried = await _.Contents.GetAsync(content.Id, QueryContext.Default.IgnoreFallback());
|
|
|
|
Assert.Null(queried.Data.Localized["en"]);
|
|
|
|
await Verify(queried);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_json_with_dot()
|
|
{
|
|
// STEP 1: Create a content item with a text that caused a bug before.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Json = new JObject
|
|
{
|
|
["field.with.dot"] = 42
|
|
}
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Get the item and ensure that the text is the same.
|
|
var queried = await _.Contents.GetAsync(content.Id, QueryContext.Default.IgnoreFallback());
|
|
|
|
Assert.Equal(42, (int)queried.Data.Json["field.with.dot"]);
|
|
|
|
await Verify(queried);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_default_text()
|
|
{
|
|
// STEP 1: Create a content item with a text that caused a bug before.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Localized = new Dictionary<string, string>()
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Get the item and ensure that the text is the same.
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal("default", updated.Data.Localized["en"]);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_non_published_content()
|
|
{
|
|
// STEP 1: Create the item unpublished.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
});
|
|
|
|
|
|
// STEP 2. Get a 404 for the item because it is not published.
|
|
await Assert.ThrowsAnyAsync<SquidexException>(() =>
|
|
{
|
|
return _.Contents.GetAsync(content.Id);
|
|
});
|
|
|
|
await Verify(content);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_published_content()
|
|
{
|
|
// STEP 1: Create the item published.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Get the item.
|
|
await _.Contents.GetAsync(content.Id);
|
|
|
|
await Verify(content);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_draft_version()
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Create draft.
|
|
content = await _.Contents.CreateDraftAsync(content.Id);
|
|
|
|
|
|
// STEP 3: Update the item and ensure that the data has not changed.
|
|
await _.Contents.PatchAsync(content.Id, new TestEntityData
|
|
{
|
|
Number = 2
|
|
});
|
|
|
|
var updated_1 = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(1, updated_1.Data.Number);
|
|
|
|
|
|
// STEP 4: Get the unpublished version.
|
|
var unpublished = await _.Contents.GetAsync(content.Id, QueryContext.Default.Unpublished());
|
|
|
|
Assert.Equal(2, unpublished.Data.Number);
|
|
|
|
|
|
// STEP 5: Publish draft and ensure that it has been updated.
|
|
await _.Contents.ChangeStatusAsync(content.Id, new ChangeStatus
|
|
{
|
|
Status = "Published"
|
|
});
|
|
|
|
var updated_2 = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(2, updated_2.Data.Number);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_content_with_custom_id()
|
|
{
|
|
var id = $"custom-{Guid.NewGuid()}";
|
|
|
|
// STEP 1: Create a new item with a custom id.
|
|
var options = new ContentCreateOptions { Id = id, Publish = true };
|
|
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, options);
|
|
|
|
Assert.Equal(id, content.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_not_create_content_with_custom_id_twice()
|
|
{
|
|
var id = $"custom-{Guid.NewGuid()}";
|
|
|
|
// STEP 1: Create a new item with a custom id.
|
|
var options = new ContentCreateOptions { Id = id, Publish = true };
|
|
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, options);
|
|
|
|
Assert.Equal(id, content.Id);
|
|
|
|
|
|
// STEP 2: Create a new item with a custom id.
|
|
var ex = await Assert.ThrowsAnyAsync<SquidexException>(() =>
|
|
{
|
|
return _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, options);
|
|
});
|
|
|
|
Assert.Equal(409, ex.StatusCode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_create_content_with_custom_id_and_upsert()
|
|
{
|
|
var id = $"custom-{Guid.NewGuid()}";
|
|
|
|
// STEP 1: Upsert a new item with a custom id.
|
|
var content = await _.Contents.UpsertAsync(id, new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, ContentUpsertOptions.AsPublish);
|
|
|
|
Assert.Equal(id, content.Id);
|
|
|
|
|
|
// STEP 2: Make an update with the upsert endpoint.
|
|
content = await _.Contents.UpsertAsync(id, new TestEntityData
|
|
{
|
|
Number = 2
|
|
});
|
|
|
|
Assert.Equal(2, content.Data.Number);
|
|
|
|
|
|
// STEP 3: Make an update with the update endpoint.
|
|
content = await _.Contents.UpdateAsync(id, new TestEntityData
|
|
{
|
|
Number = 3
|
|
});
|
|
|
|
Assert.Equal(3, content.Data.Number);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Update.Normal)]
|
|
[InlineData(Strategies.Update.Upsert)]
|
|
[InlineData(Strategies.Update.UpsertBulk)]
|
|
[InlineData(Strategies.Update.Bulk)]
|
|
[InlineData(Strategies.Update.BulkShared)]
|
|
[InlineData(Strategies.Update.BulkWithSchema)]
|
|
public async Task Should_update_content(Strategies.Update strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
String = "2"
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Update with selected strategy.
|
|
await _.Client.UpdateAsync(content, new TestEntityData
|
|
{
|
|
Number = 200
|
|
}, strategy);
|
|
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(200, updated.Data.Number);
|
|
|
|
// Other data fields are overwritten.
|
|
Assert.Null(updated.Data.String);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Update.Normal)]
|
|
[InlineData(Strategies.Update.Upsert)]
|
|
[InlineData(Strategies.Update.UpsertBulk)]
|
|
[InlineData(Strategies.Update.Bulk)]
|
|
[InlineData(Strategies.Update.BulkShared)]
|
|
[InlineData(Strategies.Update.BulkWithSchema)]
|
|
public async Task Should_update_content_to_null(Strategies.Update strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
String = "initial"
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Update with selected strategy.
|
|
await _.Client.UpdateAsync(content, new TestEntityData
|
|
{
|
|
String = null
|
|
}, strategy);
|
|
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Null(updated.Data.String);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Patch.Normal)]
|
|
[InlineData(Strategies.Patch.Upsert)]
|
|
[InlineData(Strategies.Patch.UpsertBulk)]
|
|
[InlineData(Strategies.Patch.Bulk)]
|
|
[InlineData(Strategies.Patch.BulkShared)]
|
|
[InlineData(Strategies.Patch.BulkWithSchema)]
|
|
public async Task Should_patch_content(Strategies.Patch strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
String = "initial"
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Patch with selected strategy.
|
|
await _.Client.PatchAsync(content, new TestEntityData
|
|
{
|
|
Number = 200
|
|
}, strategy);
|
|
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(200, updated.Data.Number);
|
|
|
|
// Other data fields cannot be changed.
|
|
Assert.Equal("initial", updated.Data.String);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Patch.Normal)]
|
|
[InlineData(Strategies.Patch.Upsert)]
|
|
[InlineData(Strategies.Patch.UpsertBulk)]
|
|
[InlineData(Strategies.Patch.Bulk)]
|
|
[InlineData(Strategies.Patch.BulkShared)]
|
|
[InlineData(Strategies.Patch.BulkWithSchema)]
|
|
public async Task Should_patch_id_data_value(Strategies.Patch strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Id = "id1"
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Patch with selected strategy.
|
|
await _.Client.PatchAsync(content, new TestEntityData
|
|
{
|
|
Id = "id2"
|
|
}, strategy);
|
|
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal("id2", updated.Data.Id);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Patch.Normal)]
|
|
[InlineData(Strategies.Patch.Upsert)]
|
|
[InlineData(Strategies.Patch.UpsertBulk)]
|
|
[InlineData(Strategies.Patch.Bulk)]
|
|
[InlineData(Strategies.Patch.BulkShared)]
|
|
[InlineData(Strategies.Patch.BulkWithSchema)]
|
|
public async Task Should_patch_content_to_null(Strategies.Patch strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
String = "initial"
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Patch with selected strategy.
|
|
await _.Client.PatchAsync(content, new
|
|
{
|
|
@string = new { iv = (string)null }
|
|
}, strategy);
|
|
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Null(updated.Data.String);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Deletion.SingleSoft)]
|
|
[InlineData(Strategies.Deletion.SinglePermanent)]
|
|
[InlineData(Strategies.Deletion.BulkSoft)]
|
|
[InlineData(Strategies.Deletion.BulkPermanent)]
|
|
public async Task Should_delete_content(Strategies.Deletion strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Delete with selected strategy.
|
|
await _.Client.DeleteAsync(content, strategy);
|
|
|
|
|
|
// STEP 3: Retrieve all items and ensure that the deleted item does not exist.
|
|
var updated = await _.Contents.GetAsync();
|
|
|
|
Assert.DoesNotContain(updated.Items, x => x.Id == content.Id);
|
|
|
|
|
|
// STEP 4: Retrieve all deleted items and check if found.
|
|
var q = new ContentQuery { Filter = "isDeleted eq true" };
|
|
|
|
var deleted = await _.Contents.GetAsync(q, QueryContext.Default.Unpublished(true));
|
|
|
|
Assert.Equal(strategy is Strategies.Deletion.SingleSoft or Strategies.Deletion.BulkSoft, deleted.Items.Exists(x => x.Id == content.Id));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Deletion.SingleSoft)]
|
|
[InlineData(Strategies.Deletion.SinglePermanent)]
|
|
[InlineData(Strategies.Deletion.BulkSoft)]
|
|
[InlineData(Strategies.Deletion.BulkPermanent)]
|
|
public async Task Should_create_content_with_custom_id_and_delete_it(Strategies.Deletion strategy)
|
|
{
|
|
var id = $"custom-{Guid.NewGuid()}";
|
|
|
|
// STEP 1: Create a new item with a custom id.
|
|
var options = new ContentCreateOptions { Id = id, Publish = true };
|
|
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, options);
|
|
|
|
Assert.Equal(id, content.Id);
|
|
|
|
|
|
// STEP 2: Delete with selected strategy.
|
|
await _.Client.DeleteAsync(content, strategy);
|
|
|
|
|
|
// STEP 3: Retrieve all items and ensure that the deleted item does not exist.
|
|
var updated = await _.Contents.GetAsync();
|
|
|
|
Assert.DoesNotContain(updated.Items, x => x.Id == id);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Deletion.SingleSoft)]
|
|
[InlineData(Strategies.Deletion.SinglePermanent)]
|
|
[InlineData(Strategies.Deletion.BulkSoft)]
|
|
[InlineData(Strategies.Deletion.BulkPermanent)]
|
|
public async Task Should_recreate_deleted_content(Strategies.Deletion strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content_1 = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Delete with selected strategy.
|
|
await _.Client.DeleteAsync(content_1, strategy);
|
|
|
|
|
|
// STEP 3: Recreate the item with the same id.
|
|
var createOptions = new ContentCreateOptions { Id = content_1.Id, Publish = true };
|
|
|
|
var content_2 = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, createOptions);
|
|
|
|
Assert.Equal(Status.Published, content_2.Status);
|
|
|
|
|
|
// STEP 4: Check if we can find it again with a query.
|
|
var q = new ContentQuery { Filter = $"id eq '{content_1.Id}'" };
|
|
|
|
var contents = await _.Contents.GetAsync(q);
|
|
|
|
Assert.Contains(contents.Items, x => x.Id == content_2.Id);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Deletion.SingleSoft)]
|
|
[InlineData(Strategies.Deletion.SinglePermanent)]
|
|
[InlineData(Strategies.Deletion.BulkSoft)]
|
|
[InlineData(Strategies.Deletion.BulkPermanent)]
|
|
public async Task Should_recreate_deleted_content_with_upsert(Strategies.Deletion strategy)
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content_1 = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Delete with selected strategy.
|
|
await _.Client.DeleteAsync(content_1, strategy);
|
|
|
|
|
|
// STEP 3: Recreate the item with the same id.
|
|
var content_2 = await _.Contents.UpsertAsync(content_1.Id, new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, ContentUpsertOptions.AsPublish);
|
|
|
|
Assert.Equal(Status.Published, content_2.Status);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(Strategies.Deletion.SingleSoft)]
|
|
[InlineData(Strategies.Deletion.SinglePermanent)]
|
|
[InlineData(Strategies.Deletion.BulkSoft)]
|
|
[InlineData(Strategies.Deletion.BulkPermanent)]
|
|
public async Task Should_delete_recreated_content(Strategies.Deletion strategy)
|
|
{
|
|
var id = $"custom-{Guid.NewGuid()}";
|
|
|
|
// STEP 1: Create a new item with a custom id.
|
|
var options = new ContentCreateOptions { Id = id, Publish = true };
|
|
|
|
var content_1 = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, options);
|
|
|
|
|
|
// STEP 2: Permanently delete content with custom id.
|
|
await _.Contents.DeleteAsync(content_1.Id, new ContentDeleteOptions { Permanent = true });
|
|
|
|
|
|
// STEP 3: Create a new item with same custom id.
|
|
var content_2 = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, options);
|
|
|
|
Assert.Equal(2, content_2.Data.Number);
|
|
|
|
|
|
// STEP 3: Permanently delete content with custom id again.
|
|
await _.Client.DeleteAsync(content_2, strategy);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_update_singleton_content_with_special_id()
|
|
{
|
|
var schemaName = $"schema-{Guid.NewGuid()}";
|
|
|
|
// STEP 1: Create singleton.
|
|
var createRequest = new CreateSchemaDto
|
|
{
|
|
Name = schemaName,
|
|
IsPublished = true,
|
|
IsSingleton = true,
|
|
Fields = new List<UpsertSchemaFieldDto>
|
|
{
|
|
new UpsertSchemaFieldDto
|
|
{
|
|
Name = "my-field",
|
|
Properties = new StringFieldPropertiesDto()
|
|
}
|
|
}
|
|
};
|
|
|
|
await _.Client.Schemas.PostSchemaAsync(createRequest);
|
|
|
|
|
|
var client = _.Client.DynamicContents(schemaName);
|
|
|
|
// STEP 2: Get content.
|
|
var content_1 = await client.GetAsync("_schemaId_");
|
|
|
|
Assert.NotNull(content_1);
|
|
|
|
|
|
// STEP 3: Update content.
|
|
var content_2 = await client.UpdateAsync("_schemaId_", new DynamicData
|
|
{
|
|
["my-field"] = new JObject
|
|
{
|
|
["iv"] = "singleton"
|
|
}
|
|
});
|
|
|
|
Assert.Equal("singleton", content_2.Data["my-field"]["iv"]);
|
|
|
|
await Verify(content_2);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_get_content_by_version()
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 1
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 2: Update content.
|
|
content = await _.Contents.UpdateAsync(content.Id, new TestEntityData
|
|
{
|
|
Number = 2
|
|
});
|
|
|
|
|
|
// STEP 3: Get current version.
|
|
var content_latest = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(2, content_latest.Data.Number);
|
|
|
|
|
|
// STEP 4: Get current version.
|
|
var content_2 = await _.Contents.GetAsync(content.Id, content.Version);
|
|
|
|
Assert.Equal(2, content_2.Data.Number);
|
|
|
|
|
|
// STEP 4: Get previous version.
|
|
var content_1 = await _.Contents.GetAsync(content.Id, content.Version - 1);
|
|
|
|
Assert.Equal(1, content_1.Data.Number);
|
|
|
|
await Verify(content_1);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_update_content_in_parallel()
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 3: Make parallel updates.
|
|
await Parallel.ForEachAsync(Enumerable.Range(0, 20), async (i, ct) =>
|
|
{
|
|
try
|
|
{
|
|
await _.Contents.UpdateAsync(content.Id, new TestEntityData
|
|
{
|
|
Number = i
|
|
}, ct: ct);
|
|
}
|
|
catch (SquidexException ex) when (ex.StatusCode is 409 or 412)
|
|
{
|
|
return;
|
|
}
|
|
});
|
|
|
|
|
|
// STEP 3: Make an normal update to ensure nothing is corrupt.
|
|
await _.Contents.UpdateAsync(content.Id, new TestEntityData
|
|
{
|
|
Number = 2
|
|
});
|
|
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(2, content.Data.Number);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Should_upsert_content_in_parallel()
|
|
{
|
|
// STEP 1: Create a new item.
|
|
var content = await _.Contents.CreateAsync(new TestEntityData
|
|
{
|
|
Number = 2
|
|
}, ContentCreateOptions.AsPublish);
|
|
|
|
|
|
// STEP 3: Make parallel upserts.
|
|
await Parallel.ForEachAsync(Enumerable.Range(0, 20), async (i, ct) =>
|
|
{
|
|
try
|
|
{
|
|
await _.Contents.UpsertAsync(content.Id, new TestEntityData
|
|
{
|
|
Number = i
|
|
}, ct: ct);
|
|
}
|
|
catch (SquidexException ex) when (ex.StatusCode is 409 or 412)
|
|
{
|
|
return;
|
|
}
|
|
});
|
|
|
|
|
|
// STEP 3: Make an normal update to ensure nothing is corrupt.
|
|
await _.Contents.UpdateAsync(content.Id, new TestEntityData
|
|
{
|
|
Number = 2
|
|
});
|
|
|
|
var updated = await _.Contents.GetAsync(content.Id);
|
|
|
|
Assert.Equal(2, content.Data.Number);
|
|
}
|
|
}
|
|
|