Domains and hosts API (#13963)

* API for domains and hostnames incl. unit tests

* Update Open API json

* Update other unit tests to use new domain service methods where applicable

* Fix merge + update models to new naming scheme

* Handle attempts to add the same domain twice + unit tests for duplicate domain handling

* Review fixes

tests/Umbraco.Tests.Integration/Umbraco.Web.BackOffice/Controllers/ContentControllerTests.cs

@@ -496,13 +496,23 @@ public class ContentControllerTests : UmbracoTestServerTestBase
             .Build();
 
         var enLanguage = await languageService.GetAsync(UsIso);
-        var domainService = GetRequiredService<IDomainService>();
-        var enDomain = new UmbracoDomain("/en") {RootContentId = content.Id, LanguageId = enLanguage.Id};
-        domainService.Save(enDomain);
-
         var dkLanguage = await languageService.GetAsync(DkIso);
-        var dkDomain = new UmbracoDomain("/dk") {RootContentId = childContent.Id, LanguageId = dkLanguage.Id};
-        domainService.Save(dkDomain);
+
+        var domainService = GetRequiredService<IDomainService>();
+
+        await domainService.UpdateDomainsAsync(
+            content.Key,
+            new DomainsUpdateModel
+            {
+                Domains = new[] { new DomainModel { DomainName = "/en", IsoCode = enLanguage.IsoCode } }
+            });
+
+        await domainService.UpdateDomainsAsync(
+            childContent.Key,
+            new DomainsUpdateModel
+            {
+                Domains = new[] { new DomainModel { DomainName = "/dk", IsoCode = dkLanguage.IsoCode } }
+            });
 
         var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));
 
@@ -559,8 +569,13 @@ public class ContentControllerTests : UmbracoTestServerTestBase
 
         var dkLanguage = await languageService.GetAsync(DkIso);
         var domainService = GetRequiredService<IDomainService>();
-        var dkDomain = new UmbracoDomain("/") {RootContentId = content.Id, LanguageId = dkLanguage.Id};
-        domainService.Save(dkDomain);
+
+        await domainService.UpdateDomainsAsync(
+            content.Key,
+            new DomainsUpdateModel
+            {
+                Domains = new[] { new DomainModel { DomainName = "/", IsoCode = dkLanguage.IsoCode } }
+            });
 
         var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));
 
@@ -631,12 +646,20 @@ public class ContentControllerTests : UmbracoTestServerTestBase
         var dkLanguage = await languageService.GetAsync(DkIso);
         var usLanguage = await languageService.GetAsync(UsIso);
         var domainService = GetRequiredService<IDomainService>();
-        var dkDomain = new UmbracoDomain("/") {RootContentId = rootNode.Id, LanguageId = dkLanguage.Id};
 
-        var usDomain = new UmbracoDomain("/en") {RootContentId = childNode.Id, LanguageId = usLanguage.Id};
+        await domainService.UpdateDomainsAsync(
+            rootNode.Key,
+            new DomainsUpdateModel
+            {
+                Domains = new[] { new DomainModel { DomainName = "/", IsoCode = dkLanguage.IsoCode } }
+            });
 
-        domainService.Save(dkDomain);
-        domainService.Save(usDomain);
+        await domainService.UpdateDomainsAsync(
+            childNode.Key,
+            new DomainsUpdateModel
+            {
+                Domains = new[] { new DomainModel { DomainName = "/en", IsoCode = usLanguage.IsoCode } }
+            });
 
         var url = PrepareApiControllerUrl<ContentController>(x => x.PostSave(null));
 

tests/Umbraco.Tests.Integration/Umbraco.Web.BackOffice/UrlAndDomains/DomainAndUrlsTests.cs

@@ -1,19 +1,17 @@
-using System.Collections.Generic;
-using System.Linq;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
 using NUnit.Framework;
-using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.ContentEditing;
 using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.Packaging;
 using Umbraco.Cms.Core.Routing;
 using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
 using Umbraco.Cms.Core.Web;
 using Umbraco.Cms.Tests.Common;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;
-using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Tests.Integration.Umbraco.Web.BackOffice.UrlAndDomains;
 
@@ -74,17 +72,147 @@ public class DomainAndUrlsTests : UmbracoIntegrationTest
     private readonly TestVariationContextAccessor _variationContextAccessor = new();
 
     public IContent Root { get; set; }
+
     public string[] Cultures { get; set; }
 
+    [Test]
+    public async Task Can_Update_Domains_For_All_Cultures()
+    {
+        var domainService = GetRequiredService<IDomainService>();
+        var updateModel = new DomainsUpdateModel
+        {
+            Domains = Cultures.Select(culture => new DomainModel
+            {
+                DomainName = GetDomainUrlFromCultureCode(culture), IsoCode = culture
+            })
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+        Assert.AreEqual(DomainOperationStatus.Success, result.Status);
+
+        void VerifyDomains(IDomain[] domains)
+        {
+            Assert.AreEqual(3, domains.Length);
+            for (var i = 0; i < domains.Length; i++)
+            {
+                Assert.AreEqual(Cultures[i], domains[i].LanguageIsoCode);
+                Assert.AreEqual(GetDomainUrlFromCultureCode(Cultures[i]), domains[i].DomainName);
+            }
+        }
+
+        VerifyDomains(result.Result.ToArray());
+
+        // re-get and verify again
+        var domains = await domainService.GetAssignedDomainsAsync(Root.Key, true);
+        VerifyDomains(domains.ToArray());
+    }
 
     [Test]
-    public void Having_three_cultures_and_set_domain_on_all_of_them()
+    public async Task Can_Sort_Domains()
     {
-        foreach (var culture in Cultures)
+        var domainService = GetRequiredService<IDomainService>();
+        var reversedCultures = Cultures.Reverse().ToArray();
+        var updateModel = new DomainsUpdateModel
         {
-            SetDomainOnContent(Root, culture, GetDomainUrlFromCultureCode(culture));
+            Domains = reversedCultures.Select(culture => new DomainModel
+            {
+                DomainName = GetDomainUrlFromCultureCode(culture), IsoCode = culture
+            })
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+        Assert.AreEqual(DomainOperationStatus.Success, result.Status);
+
+        void VerifyDomains(IDomain[] domains)
+        {
+            Assert.AreEqual(3, domains.Length);
+            for (var i = 0; i < domains.Length; i++)
+            {
+                Assert.AreEqual(reversedCultures[i], domains[i].LanguageIsoCode);
+                Assert.AreEqual(GetDomainUrlFromCultureCode(reversedCultures[i]), domains[i].DomainName);
+            }
         }
 
+        VerifyDomains(result.Result.ToArray());
+
+        // re-get and verify again
+        var domains = await domainService.GetAssignedDomainsAsync(Root.Key, true);
+        VerifyDomains(domains.ToArray());
+    }
+
+    [Test]
+    public async Task Can_Remove_All_Domains()
+    {
+        var domainService = GetRequiredService<IDomainService>();
+        var updateModel = new DomainsUpdateModel
+        {
+            Domains = Cultures.Select(culture => new DomainModel
+            {
+                DomainName = GetDomainUrlFromCultureCode(culture), IsoCode = culture
+            })
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+        Assert.AreEqual(DomainOperationStatus.Success, result.Status);
+        Assert.AreEqual(3, result.Result.Count());
+
+        updateModel.Domains = Enumerable.Empty<DomainModel>();
+
+        result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+        Assert.AreEqual(DomainOperationStatus.Success, result.Status);
+        Assert.AreEqual(0, result.Result.Count());
+
+        // re-get and verify again
+        var domains = await domainService.GetAssignedDomainsAsync(Root.Key, true);
+        Assert.AreEqual(0, domains.Count());
+    }
+
+    [Test]
+    public async Task Can_Remove_Single_Domain()
+    {
+        var domainService = GetRequiredService<IDomainService>();
+        var updateModel = new DomainsUpdateModel
+        {
+            Domains = Cultures.Select(culture => new DomainModel
+            {
+                DomainName = GetDomainUrlFromCultureCode(culture), IsoCode = culture
+            })
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+        Assert.AreEqual(DomainOperationStatus.Success, result.Status);
+        Assert.AreEqual(3, result.Result.Count());
+
+        updateModel.Domains = new[] { updateModel.Domains.First(), updateModel.Domains.Last() };
+
+        result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+        Assert.AreEqual(DomainOperationStatus.Success, result.Status);
+        Assert.AreEqual(2, result.Result.Count());
+        Assert.AreEqual(Cultures.First(), result.Result.First().LanguageIsoCode);
+        Assert.AreEqual(Cultures.Last(), result.Result.Last().LanguageIsoCode);
+    }
+
+    [Test]
+    public async Task Can_Resolve_Urls_With_Domains_For_All_Cultures()
+    {
+        var domainService = GetRequiredService<IDomainService>();
+        var updateModel = new DomainsUpdateModel
+        {
+            Domains = Cultures.Select(culture => new DomainModel
+            {
+                DomainName = GetDomainUrlFromCultureCode(culture), IsoCode = culture
+            })
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+
         var rootUrls = GetContentUrlsAsync(Root).ToArray();
 
         Assert.Multiple(() =>
@@ -100,11 +228,21 @@ public class DomainAndUrlsTests : UmbracoIntegrationTest
     }
 
     [Test]
-    public void Having_three_cultures_but_set_domain_on_a_non_default_language()
+    public async Task Can_Resolve_Urls_For_Non_Default_Domain_Culture_Only()
     {
         var culture = Cultures[1];
         var domain = GetDomainUrlFromCultureCode(culture);
-        SetDomainOnContent(Root, culture, domain);
+        var domainService = GetRequiredService<IDomainService>();
+        var updateModel = new DomainsUpdateModel
+        {
+            Domains = new[]
+            {
+                new DomainModel { DomainName = domain, IsoCode = culture }
+            }
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
 
         var rootUrls = GetContentUrlsAsync(Root).ToArray();
 
@@ -124,6 +262,99 @@ public class DomainAndUrlsTests : UmbracoIntegrationTest
         });
     }
 
+    [Test]
+    public async Task Can_Set_Default_Culture()
+    {
+        var domainService = GetRequiredService<IDomainService>();
+        var culture = Cultures[1];
+        var updateModel = new DomainsUpdateModel
+        {
+            DefaultIsoCode = culture,
+            Domains = Enumerable.Empty<DomainModel>()
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+        Assert.AreEqual(1, result.Result.Count());
+
+        // default culture is represented as a wildcard domain
+        var domain = result.Result.First();
+        Assert.IsTrue(domain.IsWildcard);
+        Assert.AreEqual(culture, domain.LanguageIsoCode);
+        Assert.AreEqual("*" + Root.Id, domain.DomainName);
+    }
+
+    [Test]
+    public void Can_Use_Obsolete_Save()
+    {
+        foreach (var culture in Cultures)
+        {
+            SetDomainOnContent(Root, culture, GetDomainUrlFromCultureCode(culture));
+        }
+
+        var domains = GetRequiredService<IDomainService>().GetAssignedDomains(Root.Id, true);
+        Assert.AreEqual(3, domains.Count());
+    }
+
+    [Test]
+    public void Can_Use_Obsolete_Delete()
+    {
+        foreach (var culture in Cultures)
+        {
+            SetDomainOnContent(Root, culture, GetDomainUrlFromCultureCode(culture));
+        }
+
+        var domainService = GetRequiredService<IDomainService>();
+
+        var domains = domainService.GetAssignedDomains(Root.Id, true);
+        Assert.AreEqual(3, domains.Count());
+
+        var result = domainService.Delete(domains.First());
+        Assert.IsTrue(result.Success);
+
+        domains = domainService.GetAssignedDomains(Root.Id, true);
+        Assert.AreEqual(2, domains.Count());
+    }
+
+    [TestCase("/domain")]
+    [TestCase("/")]
+    [TestCase("some.domain.com")]
+    public async Task Cannot_Assign_Duplicate_Domains(string domainName)
+    {
+        var domainService = GetRequiredService<IDomainService>();
+        var updateModel = new DomainsUpdateModel
+        {
+            Domains = Cultures.Select(culture => new DomainModel { DomainName = domainName, IsoCode = culture }).ToArray()
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsFalse(result.Success);
+        Assert.AreEqual(DomainOperationStatus.DuplicateDomainName, result.Status);
+    }
+
+    [Test]
+    public async Task Cannot_Assign_Already_Used_Domains()
+    {
+        var copy = ContentService.Copy(Root, Root.ParentId, false);
+        ContentService.SaveAndPublish(copy!);
+
+        var domainService = GetRequiredService<IDomainService>();
+        var updateModel = new DomainsUpdateModel
+        {
+            Domains = Cultures.Select(culture => new DomainModel
+            {
+                DomainName = GetDomainUrlFromCultureCode(culture), IsoCode = culture
+            })
+        };
+
+        var result = await domainService.UpdateDomainsAsync(Root.Key, updateModel);
+        Assert.IsTrue(result.Success);
+
+        result = await domainService.UpdateDomainsAsync(copy.Key, updateModel);
+        Assert.IsFalse(result.Success);
+        Assert.AreEqual(DomainOperationStatus.DuplicateDomainName, result.Status);
+    }
+
     private static string GetDomainUrlFromCultureCode(string culture) =>
         "/" + culture.Replace("-", string.Empty).ToLower() + "/";