yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Content type and media type container CRUD controllers and services (#14682)

Browse Source 
* CRUD for content and media type folders + refactor data type folder CRUD controllers and services to match

* Correct response types + update OpenAPI JSON

* Review changes

* Review changes

* Update OpenAPI JSON after merge
This commit is contained in:
Kenn Jacobsen
2023-08-24 09:32:36 +02:00
committed by GitHub
parent 98bcf15373
commit a9d7f3cbbb
39 changed files with 1978 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

204
tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentTypeContainerServiceTests.cs Normal file
View File

@@ -0,0 +1,204 @@
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Services.OperationStatus;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
/// <summary>
/// Tests covering the ContentTypeContainerService
/// </summary>
[TestFixture]
[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
public class ContentTypeContainerServiceTests : UmbracoIntegrationTest
{
private IContentTypeContainerService ContentTypeContainerService => GetRequiredService<IContentTypeContainerService>();
private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
[Test]
public async Task Can_Create_Container_At_Root()
{
var result = await ContentTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var created = await ContentTypeContainerService.GetAsync(result.Result.Key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
}
[Test]
public async Task Can_Create_Child_Container()
{
EntityContainer root = (await ContentTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
var result = await ContentTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var created = await ContentTypeContainerService.GetAsync(result.Result.Key);
Assert.NotNull(created);
Assert.AreEqual("Child Container", created.Name);
Assert.AreEqual(root.Id, created.ParentId);
}
[Test]
public async Task Can_Create_Container_With_Explicit_Key()
{
var key = Guid.NewGuid();
var result = await ContentTypeContainerService.CreateAsync(key, "Root Container", null, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
Assert.AreEqual(key, result.Result.Key);
var created = await ContentTypeContainerService.GetAsync(key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
}
[Test]
public async Task Can_Update_Container_At_Root()
{
var key = (await ContentTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result.Key;
var result = await ContentTypeContainerService.UpdateAsync(key, "Root Container UPDATED", Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var updated = await ContentTypeContainerService.GetAsync(key);
Assert.NotNull(updated);
Assert.AreEqual("Root Container UPDATED", updated.Name);
Assert.AreEqual(Constants.System.Root, updated.ParentId);
}
[Test]
public async Task Can_Update_Child_Container()
{
EntityContainer root = (await ContentTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await ContentTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
var result = await ContentTypeContainerService.UpdateAsync(child.Key, "Child Container UPDATED", Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
EntityContainer updated = await ContentTypeContainerService.GetAsync(child.Key);
Assert.NotNull(updated);
Assert.AreEqual("Child Container UPDATED", updated.Name);
Assert.AreEqual(root.Id, updated.ParentId);
}
[Test]
public async Task Can_Get_Container_At_Root()
{
EntityContainer root = (await ContentTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer created = await ContentTypeContainerService.GetAsync(root.Key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
}
[Test]
public async Task Can_Get_Child_Container()
{
EntityContainer root = (await ContentTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await ContentTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
EntityContainer created = await ContentTypeContainerService.GetAsync(child.Key);
Assert.IsNotNull(created);
Assert.AreEqual("Child Container", created.Name);
Assert.AreEqual(root.Id, child.ParentId);
}
[Test]
public async Task Can_Delete_Container_At_Root()
{
EntityContainer root = (await ContentTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
var result = await ContentTypeContainerService.DeleteAsync(root.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var current = await ContentTypeContainerService.GetAsync(root.Key);
Assert.IsNull(current);
}
[Test]
public async Task Can_Delete_Child_Container()
{
EntityContainer root = (await ContentTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await ContentTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
var result = await ContentTypeContainerService.DeleteAsync(child.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
child = await ContentTypeContainerService.GetAsync(child.Key);
Assert.IsNull(child);
root = await ContentTypeContainerService.GetAsync(root.Key);
Assert.IsNotNull(root);
}
[Test]
public async Task Cannot_Create_Child_Container_Below_Invalid_Parent()
{
var key = Guid.NewGuid();
var result = await ContentTypeContainerService.CreateAsync(key, "Child Container", Guid.NewGuid(), Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.ParentNotFound, result.Status);
var created = await ContentTypeContainerService.GetAsync(key);
Assert.IsNull(created);
}
[Test]
public async Task Cannot_Delete_Container_With_Child_Container()
{
EntityContainer root = (await ContentTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await ContentTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
var result = await ContentTypeContainerService.DeleteAsync(root.Key, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.NotEmpty, result.Status);
var current = await ContentTypeContainerService.GetAsync(root.Key);
Assert.IsNotNull(current);
}
[Test]
public async Task Cannot_Delete_Container_With_Child_ContentType()
{
EntityContainer container = (await ContentTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
IContentType contentType = new ContentType(ShortStringHelper, container.Id)
{
Alias = "test", Name = "Test"
};
ContentTypeService.Save(contentType);
var result = await ContentTypeContainerService.DeleteAsync(container.Key, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.NotEmpty, result.Status);
var currentContainer = await ContentTypeContainerService.GetAsync(container.Key);
Assert.IsNotNull(currentContainer);
var currentContentType = ContentTypeService.Get(contentType.Key);
Assert.IsNotNull(currentContentType);
}
[Test]
public async Task Cannot_Delete_Non_Existing_Container()
{
var result = await ContentTypeContainerService.DeleteAsync(Guid.NewGuid(), Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.NotFound, result.Status);
}
}

180
tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/DataTypeContainerServiceTests.cs
View File

@@ -31,13 +31,11 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Create_Container_At_Root()
{
EntityContainer toCreate = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
var result = await DataTypeContainerService.CreateAsync(toCreate, null, Constants.Security.SuperUserKey);
var result = await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.Success, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var created = await DataTypeContainerService.GetAsync(toCreate.Key);
var created = await DataTypeContainerService.GetAsync(result.Result.Key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
@@ -46,35 +44,43 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Create_Child_Container()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
EntityContainer root = (await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Child Container" };
var result = await DataTypeContainerService.CreateAsync(child, root.Key, Constants.Security.SuperUserKey);
var result = await DataTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.Success, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var created = await DataTypeContainerService.GetAsync(child.Key);
var created = await DataTypeContainerService.GetAsync(result.Result.Key);
Assert.NotNull(created);
Assert.AreEqual("Child Container", created.Name);
Assert.AreEqual(root.Id, child.ParentId);
Assert.AreEqual(root.Id, created.ParentId);
}
[Test]
public async Task Can_Create_Container_With_Explicit_Key()
{
var key = Guid.NewGuid();
var result = await DataTypeContainerService.CreateAsync(key, "Root Container", null, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
Assert.AreEqual(key, result.Result.Key);
var created = await DataTypeContainerService.GetAsync(key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
}
[Test]
public async Task Can_Update_Container_At_Root()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
var key = (await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result.Key;
EntityContainer toUpdate = await DataTypeContainerService.GetAsync(root.Key);
Assert.NotNull(toUpdate);
toUpdate.Name += " UPDATED";
var result = await DataTypeContainerService.UpdateAsync(toUpdate, Constants.Security.SuperUserKey);
var result = await DataTypeContainerService.UpdateAsync(key, "Root Container UPDATED", Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.Success, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var updated = await DataTypeContainerService.GetAsync(toUpdate.Key);
var updated = await DataTypeContainerService.GetAsync(key);
Assert.NotNull(updated);
Assert.AreEqual("Root Container UPDATED", updated.Name);
Assert.AreEqual(Constants.System.Root, updated.ParentId);
@@ -83,21 +89,14 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Update_Child_Container()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
EntityContainer root = (await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await DataTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
EntityContainer child = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Child Container" };
await DataTypeContainerService.CreateAsync(child, root.Key, Constants.Security.SuperUserKey);
EntityContainer toUpdate = await DataTypeContainerService.GetAsync(child.Key);
Assert.NotNull(toUpdate);
toUpdate.Name += " UPDATED";
var result = await DataTypeContainerService.UpdateAsync(toUpdate, Constants.Security.SuperUserKey);
var result = await DataTypeContainerService.UpdateAsync(child.Key, "Child Container UPDATED", Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.Success, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var updated = await DataTypeContainerService.GetAsync(toUpdate.Key);
EntityContainer updated = await DataTypeContainerService.GetAsync(child.Key);
Assert.NotNull(updated);
Assert.AreEqual("Child Container UPDATED", updated.Name);
Assert.AreEqual(root.Id, updated.ParentId);
@@ -106,10 +105,9 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Get_Container_At_Root()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
EntityContainer root = (await DataTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
var created = await DataTypeContainerService.GetAsync(root.Key);
EntityContainer created = await DataTypeContainerService.GetAsync(root.Key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
@@ -118,13 +116,10 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Get_Child_Container()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
EntityContainer root = (await DataTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await DataTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
EntityContainer child = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Child Container" };
await DataTypeContainerService.CreateAsync(child, root.Key, Constants.Security.SuperUserKey);
var created = await DataTypeContainerService.GetAsync(child.Key);
EntityContainer created = await DataTypeContainerService.GetAsync(child.Key);
Assert.IsNotNull(created);
Assert.AreEqual("Child Container", created.Name);
Assert.AreEqual(root.Id, child.ParentId);
@@ -133,12 +128,11 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Delete_Container_At_Root()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
EntityContainer root = (await DataTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
var result = await DataTypeContainerService.DeleteAsync(root.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.Success, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var current = await DataTypeContainerService.GetAsync(root.Key);
Assert.IsNull(current);
@@ -147,100 +141,41 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Delete_Child_Container()
{
Guid userKey = Constants.Security.SuperUserKey;
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, userKey);
EntityContainer root = (await DataTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await DataTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
EntityContainer child = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Child Container" };
await DataTypeContainerService.CreateAsync(child, root.Key, userKey);
var result = await DataTypeContainerService.DeleteAsync(child.Key, userKey);
var result = await DataTypeContainerService.DeleteAsync(child.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.Success, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var current = await DataTypeContainerService.GetAsync(child.Key);
Assert.IsNull(current);
child = await DataTypeContainerService.GetAsync(child.Key);
Assert.IsNull(child);
current = await DataTypeContainerService.GetAsync(root.Key);
Assert.IsNotNull(current);
root = await DataTypeContainerService.GetAsync(root.Key);
Assert.IsNotNull(root);
}
[Test]
public async Task Cannot_Create_Child_Container_Below_Invalid_Parent()
{
EntityContainer child = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Child Container" };
var result = await DataTypeContainerService.CreateAsync(child, Guid.NewGuid(), Constants.Security.SuperUserKey);
var key = Guid.NewGuid();
var result = await DataTypeContainerService.CreateAsync(key, "Child Container", Guid.NewGuid(), Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.ParentNotFound, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.ParentNotFound, result.Status);
var created = await DataTypeContainerService.GetAsync(child.Key);
var created = await DataTypeContainerService.GetAsync(key);
Assert.IsNull(created);
}
[Test]
public async Task Cannot_Create_Child_Container_With_Explicit_Id()
{
EntityContainer toCreate = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container", Id = 1234 };
var result = await DataTypeContainerService.CreateAsync(toCreate, null, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.InvalidId, result.Status);
var created = await DataTypeContainerService.GetAsync(toCreate.Key);
Assert.IsNull(created);
}
[TestCase(Constants.ObjectTypes.Strings.DocumentType)]
[TestCase(Constants.ObjectTypes.Strings.MediaType)]
public async Task Cannot_Create_Container_With_Invalid_Contained_Type(string containedObjectType)
{
EntityContainer toCreate = new EntityContainer(new Guid(containedObjectType)) { Name = "Root Container" };
var result = await DataTypeContainerService.CreateAsync(toCreate, null, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.InvalidObjectType, result.Status);
var created = await DataTypeContainerService.GetAsync(toCreate.Key);
Assert.IsNull(created);
}
[Test]
public async Task Cannot_Update_Container_Parent()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
EntityContainer root2 = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container 2" };
await DataTypeContainerService.CreateAsync(root2, null, Constants.Security.SuperUserKey);
EntityContainer child = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Child Container" };
await DataTypeContainerService.CreateAsync(child, root.Key, Constants.Security.SuperUserKey);
EntityContainer toUpdate = await DataTypeContainerService.GetAsync(child.Key);
Assert.IsNotNull(toUpdate);
toUpdate.ParentId = root2.Id;
var result = await DataTypeContainerService.UpdateAsync(toUpdate, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.ParentNotFound, result.Status);
var current = await DataTypeContainerService.GetAsync(child.Key);
Assert.IsNotNull(current);
Assert.AreEqual(root.Id, child.ParentId);
}
[Test]
public async Task Cannot_Delete_Container_With_Child_Container()
{
EntityContainer root = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(root, null, Constants.Security.SuperUserKey);
EntityContainer child = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Child Container" };
await DataTypeContainerService.CreateAsync(child, root.Key, Constants.Security.SuperUserKey);
EntityContainer root = (await DataTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await DataTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
var result = await DataTypeContainerService.DeleteAsync(root.Key, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.NotEmpty, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.NotEmpty, result.Status);
var current = await DataTypeContainerService.GetAsync(root.Key);
Assert.IsNotNull(current);
@@ -249,8 +184,7 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
[Test]
public async Task Cannot_Delete_Container_With_Child_DataType()
{
EntityContainer container = new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" };
await DataTypeContainerService.CreateAsync(container, null, Constants.Security.SuperUserKey);
EntityContainer container = (await DataTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
IDataType dataType =
new DataType(new TextboxPropertyEditor(DataValueEditorFactory, IOHelper, EditorConfigurationParser), ConfigurationEditorJsonSerializer)
@@ -263,7 +197,7 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
var result = await DataTypeContainerService.DeleteAsync(container.Key, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.NotEmpty, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.NotEmpty, result.Status);
var currentContainer = await DataTypeContainerService.GetAsync(container.Key);
Assert.IsNotNull(currentContainer);
@@ -277,6 +211,6 @@ public class DataTypeContainerServiceTests : UmbracoIntegrationTest
{
var result = await DataTypeContainerService.DeleteAsync(Guid.NewGuid(), Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(DataTypeContainerOperationStatus.NotFound, result.Status);
Assert.AreEqual(EntityContainerOperationStatus.NotFound, result.Status);
}
}

14
tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/DataTypeServiceTests.cs
View File

@@ -174,7 +174,7 @@ public class DataTypeServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Create_DataType_In_Container()
{
var container = (await DataTypeContainerService.CreateAsync(new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" }, null, Constants.Security.SuperUserKey)).Result;
var container = (await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
var result = await DataTypeService.CreateAsync(
new DataType(new LabelPropertyEditor(DataValueEditorFactory, IOHelper), ConfigurationEditorJsonSerializer)
@@ -205,7 +205,7 @@ public class DataTypeServiceTests : UmbracoIntegrationTest
},
Constants.Security.SuperUserKey)).Result;
var container = (await DataTypeContainerService.CreateAsync(new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" }, null, Constants.Security.SuperUserKey)).Result;
var container = (await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
dataType = await DataTypeService.GetAsync(dataType.Key);
Assert.IsNotNull(dataType);
@@ -223,7 +223,7 @@ public class DataTypeServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Move_DataType_To_Root()
{
var container = (await DataTypeContainerService.CreateAsync(new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" }, null, Constants.Security.SuperUserKey)).Result;
var container = (await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
var dataType = (await DataTypeService.CreateAsync(
new DataType(new LabelPropertyEditor(DataValueEditorFactory, IOHelper), ConfigurationEditorJsonSerializer)
{
@@ -272,7 +272,7 @@ public class DataTypeServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Copy_DataType_To_Container()
{
var container = (await DataTypeContainerService.CreateAsync(new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container" }, null, Constants.Security.SuperUserKey)).Result;
var container = (await DataTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
var dataType = (await DataTypeService.CreateAsync(
new DataType(new LabelPropertyEditor(DataValueEditorFactory, IOHelper), ConfigurationEditorJsonSerializer)
{
@@ -296,8 +296,8 @@ public class DataTypeServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Copy_DataType_Between_Containers()
{
var container1 = (await DataTypeContainerService.CreateAsync(new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container 1" }, null, Constants.Security.SuperUserKey)).Result;
var container2 = (await DataTypeContainerService.CreateAsync(new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container 2" }, null, Constants.Security.SuperUserKey)).Result;
var container1 = (await DataTypeContainerService.CreateAsync(null, "Root Container 1", null, Constants.Security.SuperUserKey)).Result;
var container2 = (await DataTypeContainerService.CreateAsync(null, "Root Container 2", null, Constants.Security.SuperUserKey)).Result;
var dataType = (await DataTypeService.CreateAsync(
new DataType(new LabelPropertyEditor(DataValueEditorFactory, IOHelper), ConfigurationEditorJsonSerializer)
{
@@ -326,7 +326,7 @@ public class DataTypeServiceTests : UmbracoIntegrationTest
[Test]
public async Task Can_Copy_DataType_From_Container_To_Root()
{
var container1 = (await DataTypeContainerService.CreateAsync(new EntityContainer(Constants.ObjectTypes.DataType) { Name = "Root Container 1" }, null, Constants.Security.SuperUserKey)).Result;
var container1 = (await DataTypeContainerService.CreateAsync(null, "Root Container 1", null, Constants.Security.SuperUserKey)).Result;
var dataType = (await DataTypeService.CreateAsync(
new DataType(new LabelPropertyEditor(DataValueEditorFactory, IOHelper), ConfigurationEditorJsonSerializer)
{

204
tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MediaTypeContainerServiceTests.cs Normal file
View File

@@ -0,0 +1,204 @@
using NUnit.Framework;
using Umbraco.Cms.Core;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Services;
using Umbraco.Cms.Core.Services.OperationStatus;
using Umbraco.Cms.Tests.Common.Testing;
using Umbraco.Cms.Tests.Integration.Testing;
namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
/// <summary>
/// Tests covering the MediaTypeContainerService
/// </summary>
[TestFixture]
[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
public class MediaTypeContainerServiceTests : UmbracoIntegrationTest
{
private IMediaTypeContainerService MediaTypeContainerService => GetRequiredService<IMediaTypeContainerService>();
private IMediaTypeService MediaTypeService => GetRequiredService<IMediaTypeService>();
[Test]
public async Task Can_Create_Container_At_Root()
{
var result = await MediaTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var created = await MediaTypeContainerService.GetAsync(result.Result.Key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
}
[Test]
public async Task Can_Create_Child_Container()
{
EntityContainer root = (await MediaTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
var result = await MediaTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var created = await MediaTypeContainerService.GetAsync(result.Result.Key);
Assert.NotNull(created);
Assert.AreEqual("Child Container", created.Name);
Assert.AreEqual(root.Id, created.ParentId);
}
[Test]
public async Task Can_Create_Container_With_Explicit_Key()
{
var key = Guid.NewGuid();
var result = await MediaTypeContainerService.CreateAsync(key, "Root Container", null, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
Assert.AreEqual(key, result.Result.Key);
var created = await MediaTypeContainerService.GetAsync(key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
}
[Test]
public async Task Can_Update_Container_At_Root()
{
var key = (await MediaTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result.Key;
var result = await MediaTypeContainerService.UpdateAsync(key, "Root Container UPDATED", Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var updated = await MediaTypeContainerService.GetAsync(key);
Assert.NotNull(updated);
Assert.AreEqual("Root Container UPDATED", updated.Name);
Assert.AreEqual(Constants.System.Root, updated.ParentId);
}
[Test]
public async Task Can_Update_Child_Container()
{
EntityContainer root = (await MediaTypeContainerService.CreateAsync(null, "Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await MediaTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
var result = await MediaTypeContainerService.UpdateAsync(child.Key, "Child Container UPDATED", Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
EntityContainer updated = await MediaTypeContainerService.GetAsync(child.Key);
Assert.NotNull(updated);
Assert.AreEqual("Child Container UPDATED", updated.Name);
Assert.AreEqual(root.Id, updated.ParentId);
}
[Test]
public async Task Can_Get_Container_At_Root()
{
EntityContainer root = (await MediaTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer created = await MediaTypeContainerService.GetAsync(root.Key);
Assert.NotNull(created);
Assert.AreEqual("Root Container", created.Name);
Assert.AreEqual(Constants.System.Root, created.ParentId);
}
[Test]
public async Task Can_Get_Child_Container()
{
EntityContainer root = (await MediaTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await MediaTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
EntityContainer created = await MediaTypeContainerService.GetAsync(child.Key);
Assert.IsNotNull(created);
Assert.AreEqual("Child Container", created.Name);
Assert.AreEqual(root.Id, child.ParentId);
}
[Test]
public async Task Can_Delete_Container_At_Root()
{
EntityContainer root = (await MediaTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
var result = await MediaTypeContainerService.DeleteAsync(root.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
var current = await MediaTypeContainerService.GetAsync(root.Key);
Assert.IsNull(current);
}
[Test]
public async Task Can_Delete_Child_Container()
{
EntityContainer root = (await MediaTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await MediaTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
var result = await MediaTypeContainerService.DeleteAsync(child.Key, Constants.Security.SuperUserKey);
Assert.IsTrue(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.Success, result.Status);
child = await MediaTypeContainerService.GetAsync(child.Key);
Assert.IsNull(child);
root = await MediaTypeContainerService.GetAsync(root.Key);
Assert.IsNotNull(root);
}
[Test]
public async Task Cannot_Create_Child_Container_Below_Invalid_Parent()
{
var key = Guid.NewGuid();
var result = await MediaTypeContainerService.CreateAsync(key, "Child Container", Guid.NewGuid(), Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.ParentNotFound, result.Status);
var created = await MediaTypeContainerService.GetAsync(key);
Assert.IsNull(created);
}
[Test]
public async Task Cannot_Delete_Container_With_Child_Container()
{
EntityContainer root = (await MediaTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
EntityContainer child = (await MediaTypeContainerService.CreateAsync(null, "Child Container", root.Key, Constants.Security.SuperUserKey)).Result;
var result = await MediaTypeContainerService.DeleteAsync(root.Key, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.NotEmpty, result.Status);
var current = await MediaTypeContainerService.GetAsync(root.Key);
Assert.IsNotNull(current);
}
[Test]
public async Task Cannot_Delete_Container_With_Child_MediaType()
{
EntityContainer container = (await MediaTypeContainerService.CreateAsync(null,"Root Container", null, Constants.Security.SuperUserKey)).Result;
IMediaType MediaType = new MediaType(ShortStringHelper, container.Id)
{
Alias = "test", Name = "Test"
};
MediaTypeService.Save(MediaType);
var result = await MediaTypeContainerService.DeleteAsync(container.Key, Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.NotEmpty, result.Status);
var currentContainer = await MediaTypeContainerService.GetAsync(container.Key);
Assert.IsNotNull(currentContainer);
var currentMediaType = MediaTypeService.Get(MediaType.Key);
Assert.IsNotNull(currentMediaType);
}
[Test]
public async Task Cannot_Delete_Non_Existing_Container()
{
var result = await MediaTypeContainerService.DeleteAsync(Guid.NewGuid(), Constants.Security.SuperUserKey);
Assert.IsFalse(result.Success);
Assert.AreEqual(EntityContainerOperationStatus.NotFound, result.Status);
}
}