From bb2b564e0c4ce3369b679c31f7765e868e53548b Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Tue, 25 Jun 2024 15:52:56 +0200
Subject: [PATCH 01/16] Add GET endpoint for fetching an options list

---
 .../Designer/Controllers/OptionsController.cs | 64 +++++++++++++++++++
 .../Infrastructure/ServiceRegistration.cs     |  1 +
 .../Services/Implementation/OptionsService.cs | 37 +++++++++++
 .../Services/Implementation/TextsService.cs   |  2 +-
 .../Services/Interfaces/IOptionsService.cs    | 20 ++++++
 .../Controllers/OptionsController/GetTests.cs | 40 ++++++++++++
 6 files changed, 163 insertions(+), 1 deletion(-)
 create mode 100644 backend/src/Designer/Controllers/OptionsController.cs
 create mode 100644 backend/src/Designer/Services/Implementation/OptionsService.cs
 create mode 100644 backend/src/Designer/Services/Interfaces/IOptionsService.cs
 create mode 100644 backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
new file mode 100644
index 00000000000..86714012c2b
--- /dev/null
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -0,0 +1,64 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using System.Threading.Tasks;
+
+using Altinn.Studio.Designer.Helpers;
+using Altinn.Studio.Designer.Services.Interfaces;
+
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Altinn.Studio.Designer.Controllers;
+
+/// <summary>
+/// Controller containing actions related to options (codelists).
+/// </summary>
+[Authorize]
+[AutoValidateAntiforgeryToken]
+[Route("designer/api/{org}/{repo:regex(^(?!datamodels$)[[a-z]][[a-z0-9-]]{{1,28}}[[a-z0-9]]$)}/options")]
+public class OptionsController : ControllerBase
+{
+    private readonly IOptionsService _optionsService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="OptionsController"/> class.
+    /// </summary>
+    /// <param name="optionsService">The options service.</param>
+    public OptionsController(IOptionsService optionsService)
+    {
+        _optionsService = optionsService;
+    }
+
+    /// <summary>
+    /// Endpoint for getting a specific option list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <param name="optionsListId">Options list identifier specifying the file to read.</param>
+    [HttpGet]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+    [Route("{optionsListId}")]
+    public async Task<ActionResult<List<Dictionary<string, string>>>> Get(string org, string repo, [FromRoute] string optionsListId)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        try
+        {
+            List<Dictionary<string, string>> optionList = await _optionsService.GetOptions(org, repo, developer, optionsListId);
+            return Ok(optionList);
+        }
+        catch (IOException)
+        {
+            return NotFound($"The options file {optionsListId}.json does not exist.");
+        }
+        catch (JsonException)
+        {
+            return new ObjectResult(new { errorMessage = $"The format of the file {optionsListId}.json might be invalid." }) { StatusCode = 500 };
+        }
+    }
+}
diff --git a/backend/src/Designer/Infrastructure/ServiceRegistration.cs b/backend/src/Designer/Infrastructure/ServiceRegistration.cs
index 6dff9d1a9e4..03c2cac117e 100644
--- a/backend/src/Designer/Infrastructure/ServiceRegistration.cs
+++ b/backend/src/Designer/Infrastructure/ServiceRegistration.cs
@@ -66,6 +66,7 @@ public static IServiceCollection RegisterServiceImplementations(this IServiceCol
             services.AddTransient<ISigningCredentialsResolver, SigningCredentialsResolver>();
             services.AddTransient<ILanguagesService, LanguagesService>();
             services.AddTransient<ITextsService, TextsService>();
+            services.AddTransient<IOptionsService, OptionsService>();
             services.AddTransient<IEnvironmentsService, EnvironmentsService>();
             services.AddHttpClient<IOrgService, OrgService>();
             services.AddTransient<IAppDevelopmentService, AppDevelopmentService>();
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
new file mode 100644
index 00000000000..c0830b2a573
--- /dev/null
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Services.Interfaces;
+using Newtonsoft.Json;
+
+namespace Altinn.Studio.Designer.Services.Implementation;
+
+/// <summary>
+/// Service for handling options lists.
+/// </summary>
+public class OptionsService : IOptionsService
+{
+    private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
+    private readonly IApplicationMetadataService _applicationMetadataService;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="altinnGitRepositoryFactory">IAltinnGitRepository</param>
+    /// <param name="applicationMetadataService">IApplicationMetadataService</param>
+    public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory, IApplicationMetadataService applicationMetadataService)
+    {
+        _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
+        _applicationMetadataService = applicationMetadataService;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<Dictionary<string, string>>> GetOptions(string org, string repo, string developer, string optionsListId)
+    {
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        string optionsListString = await altinnAppGitRepository.GetOptions(optionsListId);
+        var optionsList = JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(optionsListString);
+
+        return optionsList;
+    }
+}
diff --git a/backend/src/Designer/Services/Implementation/TextsService.cs b/backend/src/Designer/Services/Implementation/TextsService.cs
index 84d2e240f48..680db08331e 100644
--- a/backend/src/Designer/Services/Implementation/TextsService.cs
+++ b/backend/src/Designer/Services/Implementation/TextsService.cs
@@ -14,7 +14,7 @@
 namespace Altinn.Studio.Designer.Services.Implementation
 {
     /// <summary>
-    /// Interface for dealing with texts in new format in an app repository.
+    /// Service for handling texts in new format in an app repository.
     /// </summary>
     public class TextsService : ITextsService
     {
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
new file mode 100644
index 00000000000..095e2ed04de
--- /dev/null
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Altinn.Studio.Designer.Services.Interfaces;
+
+/// <summary>
+/// Interface for handling options lists.
+/// </summary>
+public interface IOptionsService
+{
+    /// <summary>
+    /// Gets options file in app repository according to specified optionsListId.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionsListId">Options list to fetch</param>
+    /// <returns>The options list as a dictionary</returns>
+    public Task<List<Dictionary<string, string>>> GetOptions(string org, string repo, string developer, string optionsListId);
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
new file mode 100644
index 00000000000..fe3994fa2cb
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Designer.Tests.Controllers.ApiTests;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class GetTests : DisagnerEndpointsTestsBase<GetTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public GetTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Theory]
+    [InlineData("ttd", "app-with-layoutsets", "test-options")]
+    public async Task Get_Returns_OptionsList(string org, string repo, string optionsListId)
+    {
+        var expectedOptionsList = new List<Dictionary<string, string>>
+        {
+            new() { { "label", "label1" }, { "value", "value1" } },
+            new() { { "label", "label2" }, { "value", "value2" } }
+        };
+
+        string apiUrl = $"/designer/api/{org}/{repo}/options/{optionsListId}";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        response.EnsureSuccessStatusCode();
+
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Dictionary<string, string>>>(responseBody);
+
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(expectedOptionsList, responseList);
+    }
+}

From 98e5a9ee7f0f3560bcd63ecafb3d0b67d234bf6f Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Wed, 26 Jun 2024 14:18:55 +0200
Subject: [PATCH 02/16] Add PUT endpoint for creating or overwriting an options
 list

---
 .../Designer/Controllers/OptionsController.cs | 40 ++++++++++++++-
 .../GitRepository/AltinnAppGitRepository.cs   | 16 ++++++
 backend/src/Designer/Models/Options.cs        | 49 +++++++++++++++++++
 .../Services/Implementation/OptionsService.cs | 14 +++++-
 .../Services/Interfaces/IOptionsService.cs    | 16 ++++--
 .../Controllers/OptionsController/GetTests.cs |  6 ++-
 .../Controllers/OptionsController/PutTests.cs | 48 ++++++++++++++++++
 7 files changed, 182 insertions(+), 7 deletions(-)
 create mode 100644 backend/src/Designer/Models/Options.cs
 create mode 100644 backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 86714012c2b..6f37163dd10 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -49,7 +49,7 @@ public async Task<ActionResult<List<Dictionary<string, string>>>> Get(string org
 
         try
         {
-            List<Dictionary<string, string>> optionList = await _optionsService.GetOptions(org, repo, developer, optionsListId);
+            List<Dictionary<string, string>> optionList = await _optionsService.GetOptionsList(org, repo, developer, optionsListId);
             return Ok(optionList);
         }
         catch (IOException)
@@ -61,4 +61,42 @@ public async Task<ActionResult<List<Dictionary<string, string>>>> Get(string org
             return new ObjectResult(new { errorMessage = $"The format of the file {optionsListId}.json might be invalid." }) { StatusCode = 500 };
         }
     }
+
+    /// <summary>
+    /// Endpoint for creating a new option list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <param name="optionsListId">Options list identifier specifying the file to create.</param>
+    /// <param name="optionsListPayload">The option list to be created.</param>
+    [HttpPut]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+    [Route("{optionsListId}")]
+    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionsListId, [FromBody] List<Dictionary<string, string>> optionsListPayload)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        if (optionsListPayload == null || optionsListPayload.Count == 0)
+        {
+            return BadRequest("The option list cannot be null or empty.");
+        }
+
+        try
+        {
+            var newOptionsList = await _optionsService.CreateOrOverwriteOptionsList(org, repo, developer, optionsListId, optionsListPayload);
+            return Ok(newOptionsList);
+        }
+        catch (IOException)
+        {
+            return new ObjectResult(new { errorMessage = $"An error occurred while saving the file {optionsListId}.json." }) { StatusCode = 500 };
+        }
+        catch (JsonException)
+        {
+            return new ObjectResult(new { errorMessage = $"The format of the provided option list is invalid." }) { StatusCode = 400 };
+        }
+    }
+
 }
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
index 5f06370e4bd..da7eecb52d1 100644
--- a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
@@ -720,6 +720,22 @@ public async Task<string> GetOptions(string optionsListId, CancellationToken can
             return fileContent;
         }
 
+        /// <summary>
+        /// Creates a new options list with the provided id.
+        /// <param name="optionsListId">The id of the options list to create.</param>
+        /// <param name="optionsListPayload">The contents of the new options list as a string</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+        /// <returns>The new options list as a string.</returns>
+        /// </summary>
+        public async Task<string> CreateOrOverwriteOptions(string optionsListId, string optionsListPayload, CancellationToken cancellationToken = default)
+        {
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
+            await WriteTextByRelativePathAsync(optionsFilePath, optionsListPayload, true, cancellationToken);
+            string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
+
+            return fileContent;
+        }
+
         /// <summary>
         /// Gets a list of file names from the Options folder representing the available options lists.
         /// <returns>A list of option list names.</returns>
diff --git a/backend/src/Designer/Models/Options.cs b/backend/src/Designer/Models/Options.cs
new file mode 100644
index 00000000000..83b50e9d8cc
--- /dev/null
+++ b/backend/src/Designer/Models/Options.cs
@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using Newtonsoft.Json;
+
+namespace Altinn.Studio.Designer.Models;
+
+/// <summary>
+/// Individual options.
+/// </summary>
+[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+public class Options
+{
+    /// <summary>
+    /// The value that connects the option to the data model.
+    /// </summary>
+    [JsonProperty(PropertyName = "value")]
+    public string Value { get; set; }
+
+    /// <summary>
+    /// The label to present to the user.
+    /// </summary>
+    [JsonProperty(PropertyName = "label")]
+    public string Label { get; set; }
+
+    /// <summary>
+    /// Description - typically displayed below the label.
+    /// </summary>
+    [JsonProperty(PropertyName = "description")]
+    public Optional<string> Description { get; set; }
+
+    /// <summary>
+    /// Help text - typically hidden inside a popover.
+    /// </summary>
+    [JsonProperty(PropertyName = "helpText")]
+    public Optional<string> HelpText { get; set; }
+}
+
+/// <summary>
+/// Options list (code list) to be used in radio buttons or checkboxes.
+/// </summary>
+[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
+public class OptionsList
+{
+    /// <summary>
+    /// The options in the list.
+    /// </summary>
+    [JsonProperty(PropertyName = "options")]
+    public List<Options> Options { get; set; }
+}
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index c0830b2a573..712a3742503 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -25,7 +25,7 @@ public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory, IA
     }
 
     /// <inheritdoc />
-    public async Task<List<Dictionary<string, string>>> GetOptions(string org, string repo, string developer, string optionsListId)
+    public async Task<List<Dictionary<string, string>>> GetOptionsList(string org, string repo, string developer, string optionsListId)
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
@@ -34,4 +34,16 @@ public async Task<List<Dictionary<string, string>>> GetOptions(string org, strin
 
         return optionsList;
     }
+
+    /// <inheritdoc />
+    public async Task<List<Dictionary<string, string>>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Dictionary<string, string>> optionsListPayload)
+    {
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        string optionsListPayloadString = JsonConvert.SerializeObject(optionsListPayload);
+        string createdOptionsListString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionsListId, optionsListPayloadString);
+        var createdOptionsList = JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(createdOptionsListString);
+
+        return createdOptionsList;
+    }
 }
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index 095e2ed04de..041287f3da2 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -9,12 +9,22 @@ namespace Altinn.Studio.Designer.Services.Interfaces;
 public interface IOptionsService
 {
     /// <summary>
-    /// Gets options file in app repository according to specified optionsListId.
+    /// Gets a options file from the app repository with the specified optionsListId.
     /// </summary>
     /// <param name="org">Organisation</param>
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
-    /// <param name="optionsListId">Options list to fetch</param>
+    /// <param name="optionsListId">Name of the options list to fetch</param>
     /// <returns>The options list as a dictionary</returns>
-    public Task<List<Dictionary<string, string>>> GetOptions(string org, string repo, string developer, string optionsListId);
+    public Task<List<Dictionary<string, string>>> GetOptionsList(string org, string repo, string developer, string optionsListId);
+
+    /// <summary>
+    /// Creates a new options file in the app repository.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionsListId">Name of the new options list</param>
+    /// <param name="optionsListPayload">The options list contents</param>
+    public Task<List<Dictionary<string, string>>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Dictionary<string, string>> optionsListPayload);
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
index fe3994fa2cb..2ff65b3672c 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Text.Json;
@@ -19,6 +20,7 @@ public GetTests(WebApplicationFactory<Program> factory) : base(factory)
     [InlineData("ttd", "app-with-layoutsets", "test-options")]
     public async Task Get_Returns_OptionsList(string org, string repo, string optionsListId)
     {
+        // Arrange
         var expectedOptionsList = new List<Dictionary<string, string>>
         {
             new() { { "label", "label1" }, { "value", "value1" } },
@@ -28,12 +30,12 @@ public async Task Get_Returns_OptionsList(string org, string repo, string option
         string apiUrl = $"/designer/api/{org}/{repo}/options/{optionsListId}";
         HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
+        // Act
         HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
-        response.EnsureSuccessStatusCode();
-
         string responseBody = await response.Content.ReadAsStringAsync();
         var responseList = JsonSerializer.Deserialize<List<Dictionary<string, string>>>(responseBody);
 
+        // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
         Assert.Equal(expectedOptionsList, responseList);
     }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
new file mode 100644
index 00000000000..03fc545fd05
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class PutTests : DisagnerEndpointsTestsBase<PutTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public PutTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Theory]
+    [InlineData("ttd", "empty-app", "testUser", "new-options")]
+    public async Task Create_Returns_200_With_New_OptionsList(string org, string repo, string developer, string optionsListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+
+        var expectedOptionsList = new List<Dictionary<string, string>>
+        {
+            new() { { "label", "label1" }, { "value", "value1" } },
+            new() { { "label", "label2" }, { "value", "value2" } }
+        };
+
+        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionsListId}";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create(expectedOptionsList);
+
+        // Act
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Dictionary<string, string>>>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(expectedOptionsList, responseList);
+    }
+}

From 68f05f44f774383ab01e7748fc50333a889c1bbd Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Thu, 27 Jun 2024 10:30:39 +0200
Subject: [PATCH 03/16] Implement 'Option' model

---
 .../Designer/Controllers/OptionsController.cs |  9 ++--
 backend/src/Designer/Models/Option.cs         | 34 +++++++++++++
 backend/src/Designer/Models/Options.cs        | 49 -------------------
 .../Services/Implementation/OptionsService.cs | 18 +++----
 .../Services/Interfaces/IOptionsService.cs    |  5 +-
 .../Controllers/OptionsController/GetTests.cs | 33 ++++++++++---
 .../Controllers/OptionsController/PutTests.cs | 30 +++++++++---
 7 files changed, 98 insertions(+), 80 deletions(-)
 create mode 100644 backend/src/Designer/Models/Option.cs
 delete mode 100644 backend/src/Designer/Models/Options.cs

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 6f37163dd10..e0e54424be7 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 
 using Altinn.Studio.Designer.Helpers;
+using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
 
 using Microsoft.AspNetCore.Authorization;
@@ -43,13 +44,13 @@ public OptionsController(IOptionsService optionsService)
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     [ProducesResponseType(StatusCodes.Status500InternalServerError)]
     [Route("{optionsListId}")]
-    public async Task<ActionResult<List<Dictionary<string, string>>>> Get(string org, string repo, [FromRoute] string optionsListId)
+    public async Task<ActionResult<List<Option>>> Get(string org, string repo, [FromRoute] string optionsListId)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         try
         {
-            List<Dictionary<string, string>> optionList = await _optionsService.GetOptionsList(org, repo, developer, optionsListId);
+            List<Option> optionList = await _optionsService.GetOptionsList(org, repo, developer, optionsListId);
             return Ok(optionList);
         }
         catch (IOException)
@@ -75,7 +76,7 @@ public async Task<ActionResult<List<Dictionary<string, string>>>> Get(string org
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
     [ProducesResponseType(StatusCodes.Status500InternalServerError)]
     [Route("{optionsListId}")]
-    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionsListId, [FromBody] List<Dictionary<string, string>> optionsListPayload)
+    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionsListId, [FromBody] List<Option> optionsListPayload)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
@@ -86,7 +87,7 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
 
         try
         {
-            var newOptionsList = await _optionsService.CreateOrOverwriteOptionsList(org, repo, developer, optionsListId, optionsListPayload);
+            var newOptionsList = await _optionsService.UpdateOptionsList(org, repo, developer, optionsListId, optionsListPayload);
             return Ok(newOptionsList);
         }
         catch (IOException)
diff --git a/backend/src/Designer/Models/Option.cs b/backend/src/Designer/Models/Option.cs
new file mode 100644
index 00000000000..b440f854ae6
--- /dev/null
+++ b/backend/src/Designer/Models/Option.cs
@@ -0,0 +1,34 @@
+using System.Text.Json.Serialization;
+using Microsoft.CodeAnalysis;
+
+namespace Altinn.Studio.Designer.Models;
+
+/// <summary>
+/// Options used in checkboxes, radio buttons and dropdowns.
+/// </summary>
+public class Option
+{
+    /// <summary>
+    /// Value that connects the option to the data model.
+    /// </summary>
+    [JsonPropertyName("value")]
+    public string Value { get; set; }
+
+    /// <summary>
+    /// Label to present to the user.
+    /// </summary>
+    [JsonPropertyName("label")]
+    public string Label { get; set; }
+
+    /// <summary>
+    /// Description, typically displayed below the label.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public Optional<string> Description { get; set; }
+
+    /// <summary>
+    /// Help text, typically wrapped inside a popover.
+    /// </summary>
+    [JsonPropertyName("helpText")]
+    public Optional<string> HelpText { get; set; }
+}
diff --git a/backend/src/Designer/Models/Options.cs b/backend/src/Designer/Models/Options.cs
deleted file mode 100644
index 83b50e9d8cc..00000000000
--- a/backend/src/Designer/Models/Options.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using System.Collections.Generic;
-using Microsoft.CodeAnalysis;
-using Newtonsoft.Json;
-
-namespace Altinn.Studio.Designer.Models;
-
-/// <summary>
-/// Individual options.
-/// </summary>
-[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
-public class Options
-{
-    /// <summary>
-    /// The value that connects the option to the data model.
-    /// </summary>
-    [JsonProperty(PropertyName = "value")]
-    public string Value { get; set; }
-
-    /// <summary>
-    /// The label to present to the user.
-    /// </summary>
-    [JsonProperty(PropertyName = "label")]
-    public string Label { get; set; }
-
-    /// <summary>
-    /// Description - typically displayed below the label.
-    /// </summary>
-    [JsonProperty(PropertyName = "description")]
-    public Optional<string> Description { get; set; }
-
-    /// <summary>
-    /// Help text - typically hidden inside a popover.
-    /// </summary>
-    [JsonProperty(PropertyName = "helpText")]
-    public Optional<string> HelpText { get; set; }
-}
-
-/// <summary>
-/// Options list (code list) to be used in radio buttons or checkboxes.
-/// </summary>
-[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
-public class OptionsList
-{
-    /// <summary>
-    /// The options in the list.
-    /// </summary>
-    [JsonProperty(PropertyName = "options")]
-    public List<Options> Options { get; set; }
-}
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index 712a3742503..b174f919b95 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -1,7 +1,8 @@
 using System.Collections.Generic;
+using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
-using Newtonsoft.Json;
 
 namespace Altinn.Studio.Designer.Services.Implementation;
 
@@ -11,38 +12,35 @@ namespace Altinn.Studio.Designer.Services.Implementation;
 public class OptionsService : IOptionsService
 {
     private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
-    private readonly IApplicationMetadataService _applicationMetadataService;
 
     /// <summary>
     /// Constructor
     /// </summary>
     /// <param name="altinnGitRepositoryFactory">IAltinnGitRepository</param>
-    /// <param name="applicationMetadataService">IApplicationMetadataService</param>
-    public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory, IApplicationMetadataService applicationMetadataService)
+    public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory)
     {
         _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
-        _applicationMetadataService = applicationMetadataService;
     }
 
     /// <inheritdoc />
-    public async Task<List<Dictionary<string, string>>> GetOptionsList(string org, string repo, string developer, string optionsListId)
+    public async Task<List<Option>> GetOptionsList(string org, string repo, string developer, string optionsListId)
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
         string optionsListString = await altinnAppGitRepository.GetOptions(optionsListId);
-        var optionsList = JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(optionsListString);
+        var optionsList = JsonSerializer.Deserialize<List<Option>>(optionsListString);
 
         return optionsList;
     }
 
     /// <inheritdoc />
-    public async Task<List<Dictionary<string, string>>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Dictionary<string, string>> optionsListPayload)
+    public async Task<List<Option>> UpdateOptionsList(string org, string repo, string developer, string optionsListId, List<Option> optionsListPayload)
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
-        string optionsListPayloadString = JsonConvert.SerializeObject(optionsListPayload);
+        string optionsListPayloadString = JsonSerializer.Serialize(optionsListPayload);
         string createdOptionsListString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionsListId, optionsListPayloadString);
-        var createdOptionsList = JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(createdOptionsListString);
+        var createdOptionsList = JsonSerializer.Deserialize<List<Option>>(createdOptionsListString);
 
         return createdOptionsList;
     }
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index 041287f3da2..049afce438c 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 
 namespace Altinn.Studio.Designer.Services.Interfaces;
 
@@ -16,7 +17,7 @@ public interface IOptionsService
     /// <param name="developer">Username of developer</param>
     /// <param name="optionsListId">Name of the options list to fetch</param>
     /// <returns>The options list as a dictionary</returns>
-    public Task<List<Dictionary<string, string>>> GetOptionsList(string org, string repo, string developer, string optionsListId);
+    public Task<List<Option>> GetOptionsList(string org, string repo, string developer, string optionsListId);
 
     /// <summary>
     /// Creates a new options file in the app repository.
@@ -26,5 +27,5 @@ public interface IOptionsService
     /// <param name="developer">Username of developer</param>
     /// <param name="optionsListId">Name of the new options list</param>
     /// <param name="optionsListPayload">The options list contents</param>
-    public Task<List<Dictionary<string, string>>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Dictionary<string, string>> optionsListPayload);
+    public Task<List<Option>> UpdateOptionsList(string org, string repo, string developer, string optionsListId, List<Option> optionsListPayload);
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
index 2ff65b3672c..25d0017fdc1 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -1,8 +1,8 @@
-using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 using Designer.Tests.Controllers.ApiTests;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Testing;
@@ -18,25 +18,42 @@ public GetTests(WebApplicationFactory<Program> factory) : base(factory)
 
     [Theory]
     [InlineData("ttd", "app-with-layoutsets", "test-options")]
-    public async Task Get_Returns_OptionsList(string org, string repo, string optionsListId)
+    public async Task Get_Returns_OptionsList(string org, string repo, string optionListId)
     {
         // Arrange
-        var expectedOptionsList = new List<Dictionary<string, string>>
+        // This expected list matches the list in 'app-with-layoutsets'
+        var expectedOptionsList = new List<Option>
         {
-            new() { { "label", "label1" }, { "value", "value1" } },
-            new() { { "label", "label2" }, { "value", "value2" } }
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
         };
 
-        string apiUrl = $"/designer/api/{org}/{repo}/options/{optionsListId}";
+        string apiUrl = $"/designer/api/{org}/{repo}/options/{optionListId}";
         HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
         HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
-        var responseList = JsonSerializer.Deserialize<List<Dictionary<string, string>>>(responseBody);
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(expectedOptionsList, responseList);
+        Assert.Equal(expectedOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < expectedOptionsList.Count; i++)
+        {
+            Assert.Equal(expectedOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(expectedOptionsList[i].Value, responseList[i].Value);
+            Assert.Equal(expectedOptionsList[i].Description, responseList[i].Description);
+            Assert.Equal(expectedOptionsList[i].HelpText, responseList[i].HelpText);
+        }
     }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
index 03fc545fd05..f1d3acf97b6 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
@@ -1,9 +1,9 @@
-using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Json;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 using Designer.Tests.Controllers.ApiTests;
 using Designer.Tests.Utils;
 using Microsoft.AspNetCore.Http;
@@ -26,23 +26,39 @@ public async Task Create_Returns_200_With_New_OptionsList(string org, string rep
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(org, repo, developer, targetRepository);
 
-        var expectedOptionsList = new List<Dictionary<string, string>>
+        var newOptionsList = new List<Option>
         {
-            new() { { "label", "label1" }, { "value", "value1" } },
-            new() { { "label", "label2" }, { "value", "value2" } }
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
         };
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionsListId}";
         HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create(expectedOptionsList);
+        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
         // Act
         HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
-        var responseList = JsonSerializer.Deserialize<List<Dictionary<string, string>>>(responseBody);
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(expectedOptionsList, responseList);
+        Assert.Equal(newOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < newOptionsList.Count; i++)
+        {
+            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
+            Assert.Equal(newOptionsList[i].Description, responseList[i].Description);
+            Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
+        }
     }
 }

From 3c51c4a02475f0270083db78efb929ca72b42c4a Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Thu, 27 Jun 2024 10:30:39 +0200
Subject: [PATCH 04/16] Implement 'Option' model

---
 .../Designer/Controllers/OptionsController.cs | 31 ++++++------
 .../GitRepository/AltinnAppGitRepository.cs   | 19 +++----
 backend/src/Designer/Models/Option.cs         | 34 +++++++++++++
 backend/src/Designer/Models/Options.cs        | 49 -------------------
 .../Services/Implementation/OptionsService.cs | 26 +++++-----
 .../Services/Interfaces/IOptionsService.cs    | 12 +++--
 .../Controllers/OptionsController/GetTests.cs | 33 ++++++++++---
 .../Controllers/OptionsController/PutTests.cs | 34 +++++++++----
 8 files changed, 129 insertions(+), 109 deletions(-)
 create mode 100644 backend/src/Designer/Models/Option.cs
 delete mode 100644 backend/src/Designer/Models/Options.cs

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 6f37163dd10..008947ba98f 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 
 using Altinn.Studio.Designer.Helpers;
+using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
 
 using Microsoft.AspNetCore.Authorization;
@@ -32,66 +33,66 @@ public OptionsController(IOptionsService optionsService)
     }
 
     /// <summary>
-    /// Endpoint for getting a specific option list.
+    /// Endpoint for fetching a specific option list.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
-    /// <param name="optionsListId">Options list identifier specifying the file to read.</param>
+    /// <param name="optionListId">Name of the option list.</param>
     [HttpGet]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-    [Route("{optionsListId}")]
-    public async Task<ActionResult<List<Dictionary<string, string>>>> Get(string org, string repo, [FromRoute] string optionsListId)
+    [Route("{optionListId}")]
+    public async Task<ActionResult<List<Option>>> Get(string org, string repo, [FromRoute] string optionListId)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         try
         {
-            List<Dictionary<string, string>> optionList = await _optionsService.GetOptionsList(org, repo, developer, optionsListId);
+            List<Option> optionList = await _optionsService.GetOptions(org, repo, developer, optionListId);
             return Ok(optionList);
         }
         catch (IOException)
         {
-            return NotFound($"The options file {optionsListId}.json does not exist.");
+            return NotFound($"The options file {optionListId}.json does not exist.");
         }
         catch (JsonException)
         {
-            return new ObjectResult(new { errorMessage = $"The format of the file {optionsListId}.json might be invalid." }) { StatusCode = 500 };
+            return new ObjectResult(new { errorMessage = $"The format of the file {optionListId}.json might be invalid." }) { StatusCode = 500 };
         }
     }
 
     /// <summary>
-    /// Endpoint for creating a new option list.
+    /// Endpoint for creating or overwriting an option list.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
-    /// <param name="optionsListId">Options list identifier specifying the file to create.</param>
-    /// <param name="optionsListPayload">The option list to be created.</param>
+    /// <param name="optionListId">Name of the option list.</param>
+    /// <param name="payload">Contents of the option list.</param>
     [HttpPut]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status201Created)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
     [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-    [Route("{optionsListId}")]
-    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionsListId, [FromBody] List<Dictionary<string, string>> optionsListPayload)
+    [Route("{optionListId}")]
+    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        if (optionsListPayload == null || optionsListPayload.Count == 0)
+        if (payload == null || payload.Count == 0)
         {
             return BadRequest("The option list cannot be null or empty.");
         }
 
         try
         {
-            var newOptionsList = await _optionsService.CreateOrOverwriteOptionsList(org, repo, developer, optionsListId, optionsListPayload);
+            var newOptionsList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
             return Ok(newOptionsList);
         }
         catch (IOException)
         {
-            return new ObjectResult(new { errorMessage = $"An error occurred while saving the file {optionsListId}.json." }) { StatusCode = 500 };
+            return new ObjectResult(new { errorMessage = $"An error occurred while saving the file {optionListId}.json." }) { StatusCode = 500 };
         }
         catch (JsonException)
         {
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
index da7eecb52d1..a0cd16d2e55 100644
--- a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
@@ -704,13 +704,13 @@ public async Task<string> GetAppFrontendCshtml(CancellationToken cancellationTok
 
         /// <summary>
         /// Gets the options list with the provided id.
-        /// <param name="optionsListId">The id of the options list to fetch.</param>
+        /// <param name="optionListId">The name of the options list to fetch.</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The options list as a string.</returns>
         /// </summary>
-        public async Task<string> GetOptions(string optionsListId, CancellationToken cancellationToken = default)
+        public async Task<string> GetOptions(string optionListId, CancellationToken cancellationToken = default)
         {
-            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
             if (!FileExistsByRelativePath(optionsFilePath))
             {
                 throw new NotFoundException("Options file not found.");
@@ -721,16 +721,17 @@ public async Task<string> GetOptions(string optionsListId, CancellationToken can
         }
 
         /// <summary>
-        /// Creates a new options list with the provided id.
-        /// <param name="optionsListId">The id of the options list to create.</param>
-        /// <param name="optionsListPayload">The contents of the new options list as a string</param>
+        /// Creates a new option list with the provided id.
+        /// If the option list already exists, it will be overwritten.
+        /// <param name="optionListId">The name of the option list to create.</param>
+        /// <param name="payload">The contents of the new option list as a string</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The new options list as a string.</returns>
         /// </summary>
-        public async Task<string> CreateOrOverwriteOptions(string optionsListId, string optionsListPayload, CancellationToken cancellationToken = default)
+        public async Task<string> CreateOrOverwriteOptions(string optionListId, string payload, CancellationToken cancellationToken = default)
         {
-            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
-            await WriteTextByRelativePathAsync(optionsFilePath, optionsListPayload, true, cancellationToken);
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
+            await WriteTextByRelativePathAsync(optionsFilePath, payload, true, cancellationToken);
             string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
 
             return fileContent;
diff --git a/backend/src/Designer/Models/Option.cs b/backend/src/Designer/Models/Option.cs
new file mode 100644
index 00000000000..b440f854ae6
--- /dev/null
+++ b/backend/src/Designer/Models/Option.cs
@@ -0,0 +1,34 @@
+using System.Text.Json.Serialization;
+using Microsoft.CodeAnalysis;
+
+namespace Altinn.Studio.Designer.Models;
+
+/// <summary>
+/// Options used in checkboxes, radio buttons and dropdowns.
+/// </summary>
+public class Option
+{
+    /// <summary>
+    /// Value that connects the option to the data model.
+    /// </summary>
+    [JsonPropertyName("value")]
+    public string Value { get; set; }
+
+    /// <summary>
+    /// Label to present to the user.
+    /// </summary>
+    [JsonPropertyName("label")]
+    public string Label { get; set; }
+
+    /// <summary>
+    /// Description, typically displayed below the label.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public Optional<string> Description { get; set; }
+
+    /// <summary>
+    /// Help text, typically wrapped inside a popover.
+    /// </summary>
+    [JsonPropertyName("helpText")]
+    public Optional<string> HelpText { get; set; }
+}
diff --git a/backend/src/Designer/Models/Options.cs b/backend/src/Designer/Models/Options.cs
deleted file mode 100644
index 83b50e9d8cc..00000000000
--- a/backend/src/Designer/Models/Options.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using System.Collections.Generic;
-using Microsoft.CodeAnalysis;
-using Newtonsoft.Json;
-
-namespace Altinn.Studio.Designer.Models;
-
-/// <summary>
-/// Individual options.
-/// </summary>
-[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
-public class Options
-{
-    /// <summary>
-    /// The value that connects the option to the data model.
-    /// </summary>
-    [JsonProperty(PropertyName = "value")]
-    public string Value { get; set; }
-
-    /// <summary>
-    /// The label to present to the user.
-    /// </summary>
-    [JsonProperty(PropertyName = "label")]
-    public string Label { get; set; }
-
-    /// <summary>
-    /// Description - typically displayed below the label.
-    /// </summary>
-    [JsonProperty(PropertyName = "description")]
-    public Optional<string> Description { get; set; }
-
-    /// <summary>
-    /// Help text - typically hidden inside a popover.
-    /// </summary>
-    [JsonProperty(PropertyName = "helpText")]
-    public Optional<string> HelpText { get; set; }
-}
-
-/// <summary>
-/// Options list (code list) to be used in radio buttons or checkboxes.
-/// </summary>
-[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]
-public class OptionsList
-{
-    /// <summary>
-    /// The options in the list.
-    /// </summary>
-    [JsonProperty(PropertyName = "options")]
-    public List<Options> Options { get; set; }
-}
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index 712a3742503..9338315943e 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -1,49 +1,47 @@
 using System.Collections.Generic;
+using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
-using Newtonsoft.Json;
 
 namespace Altinn.Studio.Designer.Services.Implementation;
 
 /// <summary>
-/// Service for handling options lists.
+/// Service for handling option lists.
 /// </summary>
 public class OptionsService : IOptionsService
 {
     private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
-    private readonly IApplicationMetadataService _applicationMetadataService;
 
     /// <summary>
     /// Constructor
     /// </summary>
     /// <param name="altinnGitRepositoryFactory">IAltinnGitRepository</param>
-    /// <param name="applicationMetadataService">IApplicationMetadataService</param>
-    public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory, IApplicationMetadataService applicationMetadataService)
+    public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory)
     {
         _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
-        _applicationMetadataService = applicationMetadataService;
     }
 
     /// <inheritdoc />
-    public async Task<List<Dictionary<string, string>>> GetOptionsList(string org, string repo, string developer, string optionsListId)
+    public async Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId)
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
-        string optionsListString = await altinnAppGitRepository.GetOptions(optionsListId);
-        var optionsList = JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(optionsListString);
+        string optionsListString = await altinnAppGitRepository.GetOptions(optionListId);
+        var optionsList = JsonSerializer.Deserialize<List<Option>>(optionsListString);
 
         return optionsList;
     }
 
     /// <inheritdoc />
-    public async Task<List<Dictionary<string, string>>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Dictionary<string, string>> optionsListPayload)
+    public async Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload)
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
-        string optionsListPayloadString = JsonConvert.SerializeObject(optionsListPayload);
-        string createdOptionsListString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionsListId, optionsListPayloadString);
-        var createdOptionsList = JsonConvert.DeserializeObject<List<Dictionary<string, string>>>(createdOptionsListString);
+        string payloadString = JsonSerializer.Serialize(payload);
+        string updatedOptionsString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionListId, payloadString);
+        var updatedOptions = JsonSerializer.Deserialize<List<Option>>(updatedOptionsString);
 
-        return createdOptionsList;
+        return updatedOptions;
     }
 }
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index 041287f3da2..9475649e0a7 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 
 namespace Altinn.Studio.Designer.Services.Interfaces;
 
@@ -14,17 +15,18 @@ public interface IOptionsService
     /// <param name="org">Organisation</param>
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
-    /// <param name="optionsListId">Name of the options list to fetch</param>
+    /// <param name="optionListId">Name of the options list to fetch</param>
     /// <returns>The options list as a dictionary</returns>
-    public Task<List<Dictionary<string, string>>> GetOptionsList(string org, string repo, string developer, string optionsListId);
+    public Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId);
 
     /// <summary>
     /// Creates a new options file in the app repository.
+    /// If the file already exists, it will be overwritten.
     /// </summary>
     /// <param name="org">Organisation</param>
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
-    /// <param name="optionsListId">Name of the new options list</param>
-    /// <param name="optionsListPayload">The options list contents</param>
-    public Task<List<Dictionary<string, string>>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Dictionary<string, string>> optionsListPayload);
+    /// <param name="optionListId">Name of the new options list</param>
+    /// <param name="payload">The options list contents</param>
+    public Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload);
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
index 2ff65b3672c..7dc37d9045d 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -1,8 +1,8 @@
-using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 using Designer.Tests.Controllers.ApiTests;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Testing;
@@ -18,25 +18,42 @@ public GetTests(WebApplicationFactory<Program> factory) : base(factory)
 
     [Theory]
     [InlineData("ttd", "app-with-layoutsets", "test-options")]
-    public async Task Get_Returns_OptionsList(string org, string repo, string optionsListId)
+    public async Task Get_Returns_OptionList(string org, string repo, string optionListId)
     {
         // Arrange
-        var expectedOptionsList = new List<Dictionary<string, string>>
+        // This expected list matches the list in 'app-with-layoutsets'
+        var expectedOptionsList = new List<Option>
         {
-            new() { { "label", "label1" }, { "value", "value1" } },
-            new() { { "label", "label2" }, { "value", "value2" } }
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
         };
 
-        string apiUrl = $"/designer/api/{org}/{repo}/options/{optionsListId}";
+        string apiUrl = $"/designer/api/{org}/{repo}/options/{optionListId}";
         HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
         HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
-        var responseList = JsonSerializer.Deserialize<List<Dictionary<string, string>>>(responseBody);
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(expectedOptionsList, responseList);
+        Assert.Equal(expectedOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < expectedOptionsList.Count; i++)
+        {
+            Assert.Equal(expectedOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(expectedOptionsList[i].Value, responseList[i].Value);
+            Assert.Equal(expectedOptionsList[i].Description, responseList[i].Description);
+            Assert.Equal(expectedOptionsList[i].HelpText, responseList[i].HelpText);
+        }
     }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
index 03fc545fd05..72573761845 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
@@ -1,9 +1,9 @@
-using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Json;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
 using Designer.Tests.Controllers.ApiTests;
 using Designer.Tests.Utils;
 using Microsoft.AspNetCore.Http;
@@ -20,29 +20,45 @@ public PutTests(WebApplicationFactory<Program> factory) : base(factory)
 
     [Theory]
     [InlineData("ttd", "empty-app", "testUser", "new-options")]
-    public async Task Create_Returns_200_With_New_OptionsList(string org, string repo, string developer, string optionsListId)
+    public async Task Put_Returns_200_When_Creating_New_OptionList(string org, string repo, string developer, string optionListId)
     {
         // Arrange
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(org, repo, developer, targetRepository);
 
-        var expectedOptionsList = new List<Dictionary<string, string>>
+        var newOptionsList = new List<Option>
         {
-            new() { { "label", "label1" }, { "value", "value1" } },
-            new() { { "label", "label2" }, { "value", "value2" } }
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
         };
 
-        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionsListId}";
+        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
         HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create(expectedOptionsList);
+        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
         // Act
         HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
-        var responseList = JsonSerializer.Deserialize<List<Dictionary<string, string>>>(responseBody);
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(expectedOptionsList, responseList);
+        Assert.Equal(newOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < newOptionsList.Count; i++)
+        {
+            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
+            Assert.Equal(newOptionsList[i].Description, responseList[i].Description);
+            Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
+        }
     }
 }

From e5cb3bba92cab8a097e7b06591a162313c7ca006 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Thu, 27 Jun 2024 13:11:55 +0200
Subject: [PATCH 05/16] Add DELETE endpoint

---
 .../Designer/Controllers/OptionsController.cs | 26 +++++++---
 .../GitRepository/AltinnAppGitRepository.cs   | 49 ++++++++++++-------
 .../Services/Implementation/OptionsService.cs |  8 +++
 .../Services/Interfaces/IOptionsService.cs    |  9 ++++
 .../OptionsController/DeleteTests.cs          | 38 ++++++++++++++
 5 files changed, 106 insertions(+), 24 deletions(-)
 create mode 100644 backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 008947ba98f..b5ce266ce41 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -2,11 +2,9 @@
 using System.IO;
 using System.Text.Json;
 using System.Threading.Tasks;
-
 using Altinn.Studio.Designer.Helpers;
 using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
-
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
@@ -82,7 +80,7 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
 
         if (payload == null || payload.Count == 0)
         {
-            return BadRequest("The option list cannot be null or empty.");
+            return BadRequest("The option list has an invalid format.");
         }
 
         try
@@ -94,10 +92,24 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
         {
             return new ObjectResult(new { errorMessage = $"An error occurred while saving the file {optionListId}.json." }) { StatusCode = 500 };
         }
-        catch (JsonException)
-        {
-            return new ObjectResult(new { errorMessage = $"The format of the provided option list is invalid." }) { StatusCode = 400 };
-        }
     }
 
+    /// <summary>
+    /// Endpoint for deleting an option list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <param name="optionListId">Name of the option list.</param>
+    [HttpDelete]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [Route("{optionListId}")]
+    public ActionResult<string> Delete(string org, string repo, [FromRoute] string optionListId)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        _optionsService.DeleteOptions(org, repo, developer, optionListId);
+
+        return Ok($"The options file {optionListId} was successfully deleted.");
+    }
 }
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
index a0cd16d2e55..cffa31de691 100644
--- a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
@@ -703,17 +703,38 @@ public async Task<string> GetAppFrontendCshtml(CancellationToken cancellationTok
         }
 
         /// <summary>
-        /// Gets the options list with the provided id.
+        /// Gets a list of file names from the Options folder representing the available options lists.
+        /// </summary>
+        /// <returns>A list of option list names.</returns>
+        public string[] GetOptionListIds()
+        {
+            string optionsFolder = Path.Combine(OptionsFolderPath);
+            if (!DirectoryExistsByRelativePath(optionsFolder))
+            {
+                throw new NotFoundException("Options folder not found.");
+            }
+            string[] fileNames = GetFilesByRelativeDirectory(optionsFolder);
+            List<string> optionListIds = new();
+            foreach (string fileName in fileNames.Select(Path.GetFileNameWithoutExtension))
+            {
+                optionListIds.Add(fileName);
+            }
+
+            return optionListIds.ToArray();
+        }
+
+        /// <summary>
+        /// Gets a specific options list with the provided id.
+        /// </summary>
         /// <param name="optionListId">The name of the options list to fetch.</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The options list as a string.</returns>
-        /// </summary>
         public async Task<string> GetOptions(string optionListId, CancellationToken cancellationToken = default)
         {
             string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
             if (!FileExistsByRelativePath(optionsFilePath))
             {
-                throw new NotFoundException("Options file not found.");
+                throw new NotFoundException($"Options file {optionListId}.json was not found.");
             }
             string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
 
@@ -723,11 +744,11 @@ public async Task<string> GetOptions(string optionListId, CancellationToken canc
         /// <summary>
         /// Creates a new option list with the provided id.
         /// If the option list already exists, it will be overwritten.
+        /// </summary>
         /// <param name="optionListId">The name of the option list to create.</param>
         /// <param name="payload">The contents of the new option list as a string</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The new options list as a string.</returns>
-        /// </summary>
         public async Task<string> CreateOrOverwriteOptions(string optionListId, string payload, CancellationToken cancellationToken = default)
         {
             string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
@@ -738,24 +759,18 @@ public async Task<string> CreateOrOverwriteOptions(string optionListId, string p
         }
 
         /// <summary>
-        /// Gets a list of file names from the Options folder representing the available options lists.
-        /// <returns>A list of option list names.</returns>
+        /// Deletes the option list with the provided id.
         /// </summary>
-        public string[] GetOptionListIds()
+        /// <param name="optionListId">The name of the option list to create.</param>
+        public void DeleteOptions(string optionListId)
         {
-            string optionsFolder = Path.Combine(OptionsFolderPath);
-            if (!DirectoryExistsByRelativePath(optionsFolder))
-            {
-                throw new NotFoundException("Options folder not found.");
-            }
-            string[] fileNames = GetFilesByRelativeDirectory(optionsFolder);
-            List<string> optionListIds = new();
-            foreach (string fileName in fileNames.Select(Path.GetFileNameWithoutExtension))
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
+            if (!FileExistsByRelativePath(optionsFilePath))
             {
-                optionListIds.Add(fileName);
+                throw new NotFoundException($"Options file {optionListId}.json was not found.");
             }
 
-            return optionListIds.ToArray();
+            DeleteFileByRelativePath(optionsFilePath);
         }
 
         /// <summary>
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index 9338315943e..cb2fae4ef92 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -44,4 +44,12 @@ public async Task<List<Option>> UpdateOptions(string org, string repo, string de
 
         return updatedOptions;
     }
+
+    /// <inheritdoc />
+    public void DeleteOptions(string org, string repo, string developer, string optionListId)
+    {
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        altinnAppGitRepository.DeleteOptions(optionListId);
+    }
 }
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index 9475649e0a7..ddcf815c1f5 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -29,4 +29,13 @@ public interface IOptionsService
     /// <param name="optionListId">Name of the new options list</param>
     /// <param name="payload">The options list contents</param>
     public Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload);
+
+    /// <summary>
+    /// Deletes an options file from the app repository.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionListId">Name of the new options list</param>
+    public void DeleteOptions(string org, string repo, string developer, string optionListId);
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
new file mode 100644
index 00000000000..43162ac7c21
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
@@ -0,0 +1,38 @@
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class DeleteTests : DisagnerEndpointsTestsBase<DeleteTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public DeleteTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Theory]
+    [InlineData("ttd", "app-with-layoutsets", "testUser", "test-options")]
+    public async Task Delete_Returns_200_When_Deleting_OptionList(string org, string repo, string developer, string optionListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
+
+        // Act
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        JsonDocument responseDocument = JsonDocument.Parse(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal($"The options file {optionListId}.json was successfully deleted.", responseDocument.RootElement.ToString());
+    }
+}

From 41dab2e1cf9b1d63312be502e9fa0784d5909657 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Thu, 27 Jun 2024 13:52:56 +0200
Subject: [PATCH 06/16] Add GET endpoint for fetching list of options

---
 .../Designer/Controllers/OptionsController.cs | 30 +++++++++++++++----
 .../Services/Implementation/OptionsService.cs | 17 +++++++++++
 .../Services/Interfaces/IOptionsService.cs    |  9 ++++++
 .../Controllers/OptionsController/GetTests.cs | 20 ++++++++++++-
 4 files changed, 70 insertions(+), 6 deletions(-)

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 083877a6329..cddfc53d57e 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -31,7 +31,27 @@ public OptionsController(IOptionsService optionsService)
     }
 
     /// <summary>
-    /// Endpoint for fetching a specific option list.
+    /// Fetches a list the static option lists belonging to the app.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <returns>Array of option lists. Empty array if none are found</returns>
+    [HttpGet]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+    public string[] GetOptionListIds(string org, string repo)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        string[] optionLists = _optionsService.GetOptionListIds(org, repo, developer);
+
+        return optionLists;
+    }
+
+    /// <summary>
+    /// Fetches a specific option list.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
@@ -42,7 +62,7 @@ public OptionsController(IOptionsService optionsService)
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     [ProducesResponseType(StatusCodes.Status500InternalServerError)]
     [Route("{optionListId}")]
-    public async Task<ActionResult<List<Option>>> Get(string org, string repo, [FromRoute] string optionListId)
+    public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, string repo, [FromRoute] string optionListId)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
@@ -62,7 +82,7 @@ public async Task<ActionResult<List<Option>>> Get(string org, string repo, [From
     }
 
     /// <summary>
-    /// Endpoint for creating or overwriting an option list.
+    /// Creates or overwrites an option list.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
@@ -95,7 +115,7 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
     }
 
     /// <summary>
-    /// Endpoint for deleting an option list.
+    /// Deletes an option list.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
@@ -110,6 +130,6 @@ public ActionResult<string> Delete(string org, string repo, [FromRoute] string o
 
         _optionsService.DeleteOptions(org, repo, developer, optionListId);
 
-        return Ok($"The options file {optionListId} was successfully deleted.");
+        return Ok($"The options file {optionListId}.json was successfully deleted.");
     }
 }
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index c8614da433a..ade36643e33 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
+using LibGit2Sharp;
 
 namespace Altinn.Studio.Designer.Services.Implementation;
 
@@ -22,6 +23,22 @@ public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory)
         _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
     }
 
+    /// <inheritdoc />
+    public string[] GetOptionListIds(string org, string repo, string developer)
+    {
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        try
+        {
+            string[] optionLists = altinnAppGitRepository.GetOptionListIds();
+            return optionLists;
+        }
+        catch (NotFoundException) // Is raised if the Options folder does not exist
+        {
+            return [];
+        }
+    }
+
     /// <inheritdoc />
     public async Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId)
     {
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index 7ec885dc038..451912fba6f 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -9,6 +9,15 @@ namespace Altinn.Studio.Designer.Services.Interfaces;
 /// </summary>
 public interface IOptionsService
 {
+    /// <summary>
+    /// Gets a list of file names from the Options folder representing the available options lists.
+    /// </summary>
+    /// <param name="org"></param>
+    /// <param name="repo"></param>
+    /// <param name="developer"></param>
+    /// <returns></returns>
+    public string[] GetOptionListIds(string org, string repo, string developer);
+
     /// <summary>
     /// Gets a options file from the app repository with the specified optionListId.
     /// </summary>
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
index 5d8b2ce282e..d1fe2dee598 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -16,9 +16,27 @@ public GetTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
+    [Theory]
+    [InlineData("ttd", "app-with-options")]
+    public async Task GetOptionListIds_Returns_OptionListIds(string org, string repo)
+    {
+        // Arrange
+        string apiUrl = $"/designer/api/{org}/{repo}/options";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<string[]>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(2, responseList.Length);
+    }
+
     [Theory]
     [InlineData("ttd", "app-with-layoutsets", "test-options")]
-    public async Task Get_Returns_OptionList(string org, string repo, string optionListId)
+    public async Task GetSingleOptionList_Returns_OptionList(string org, string repo, string optionListId)
     {
         // Arrange
         // This expected list matches the list in 'app-with-layoutsets'

From d2418eafcdeea3bb02a09f80420f3333fdd94750 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Fri, 28 Jun 2024 10:46:34 +0200
Subject: [PATCH 07/16] Add POST endpoint

---
 .../Designer/Controllers/OptionsController.cs |  61 ++++++--
 backend/src/Designer/Models/Option.cs         |   3 +
 .../Services/Implementation/OptionsService.cs |  16 +-
 .../Services/Interfaces/IOptionsService.cs    |   9 ++
 .../OptionsController/PostTests.cs            | 147 ++++++++++++++++++
 5 files changed, 222 insertions(+), 14 deletions(-)
 create mode 100644 backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index cddfc53d57e..2b75c6f21ae 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -12,8 +12,9 @@
 namespace Altinn.Studio.Designer.Controllers;
 
 /// <summary>
-/// Controller containing actions related to options (codelists).
+/// Controller containing actions related to options (code lists).
 /// </summary>
+[ApiController]
 [Authorize]
 [AutoValidateAntiforgeryToken]
 [Route("designer/api/{org}/{repo:regex(^(?!datamodels$)[[a-z]][[a-z0-9-]]{{1,28}}[[a-z0-9]]$)}/options")]
@@ -31,7 +32,7 @@ public OptionsController(IOptionsService optionsService)
     }
 
     /// <summary>
-    /// Fetches a list the static option lists belonging to the app.
+    /// Fetches a list of the static option lists belonging to the app.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
@@ -40,14 +41,13 @@ public OptionsController(IOptionsService optionsService)
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
-    public string[] GetOptionListIds(string org, string repo)
+    public ActionResult<string[]> GetOptionListIds(string org, string repo)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         string[] optionLists = _optionsService.GetOptionListIds(org, repo, developer);
 
-        return optionLists;
+        return Ok(optionLists);
     }
 
     /// <summary>
@@ -81,6 +81,40 @@ public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, st
         }
     }
 
+    /// <summary>
+    /// Create an option list
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <param name="optionListId">Name of the new option list</param>
+    /// <param name="payload">The option list contents</param>
+    /// <returns>The created option list</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+    [Route("{optionListId}")]
+    public async Task<ActionResult> Post(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        bool optionListAlreadyExists = await _optionsService.OptionListExists(org, repo, developer, optionListId);
+        if (optionListAlreadyExists)
+        {
+            return Conflict("The option list already exists.");
+        }
+
+        try
+        {
+            var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
+            return CreatedAtAction("GetSingleOptionList", new { org, repo, optionListId }, newOptionList);
+        }
+        catch (IOException)
+        {
+            return new ObjectResult(new { errorMessage = $"An error occurred while saving the file {optionListId}.json." }) { StatusCode = 500 };
+        }
+    }
+
     /// <summary>
     /// Creates or overwrites an option list.
     /// </summary>
@@ -90,7 +124,7 @@ public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, st
     /// <param name="payload">Contents of the option list.</param>
     [HttpPut]
     [Produces("application/json")]
-    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
     [ProducesResponseType(StatusCodes.Status500InternalServerError)]
     [Route("{optionListId}")]
@@ -98,11 +132,6 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        if (payload == null || payload.Count == 0)
-        {
-            return BadRequest("The option list has an invalid format.");
-        }
-
         try
         {
             var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
@@ -123,13 +152,19 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
     [HttpDelete]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
     [Route("{optionListId}")]
-    public ActionResult<string> Delete(string org, string repo, [FromRoute] string optionListId)
+    public async Task<ActionResult> Delete(string org, string repo, [FromRoute] string optionListId)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        _optionsService.DeleteOptions(org, repo, developer, optionListId);
+        bool optionListExists = await _optionsService.OptionListExists(org, repo, developer, optionListId);
+        if (!optionListExists)
+        {
+            return NotFound($"The options file {optionListId}.json does not exist.");
+        }
 
+        _optionsService.DeleteOptions(org, repo, developer, optionListId);
         return Ok($"The options file {optionListId}.json was successfully deleted.");
     }
 }
diff --git a/backend/src/Designer/Models/Option.cs b/backend/src/Designer/Models/Option.cs
index b440f854ae6..57be499f414 100644
--- a/backend/src/Designer/Models/Option.cs
+++ b/backend/src/Designer/Models/Option.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel.DataAnnotations;
 using System.Text.Json.Serialization;
 using Microsoft.CodeAnalysis;
 
@@ -11,12 +12,14 @@ public class Option
     /// <summary>
     /// Value that connects the option to the data model.
     /// </summary>
+    [Required]
     [JsonPropertyName("value")]
     public string Value { get; set; }
 
     /// <summary>
     /// Label to present to the user.
     /// </summary>
+    [Required]
     [JsonPropertyName("label")]
     public string Label { get; set; }
 
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index ade36643e33..cd33b1f0d0f 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -8,7 +8,7 @@
 namespace Altinn.Studio.Designer.Services.Implementation;
 
 /// <summary>
-/// Service for handling option lists.
+/// Service for handling options (code lists).
 /// </summary>
 public class OptionsService : IOptionsService
 {
@@ -69,4 +69,18 @@ public void DeleteOptions(string org, string repo, string developer, string opti
 
         altinnAppGitRepository.DeleteOptions(optionListId);
     }
+
+    /// <inheritdoc />
+    public async Task<bool> OptionListExists(string org, string repo, string developer, string optionListId)
+    {
+        try
+        {
+            await GetOptions(org, repo, developer, optionListId);
+            return true;
+        }
+        catch (NotFoundException)
+        {
+            return false;
+        }
+    }
 }
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index 451912fba6f..da8c204c56f 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -47,4 +47,13 @@ public interface IOptionsService
     /// <param name="developer">Username of developer</param>
     /// <param name="optionListId">Name of the new options list</param>
     public void DeleteOptions(string org, string repo, string developer, string optionListId);
+
+    /// <summary>
+    /// Checks if an options list exists in the app repository.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionListId">Name of the options list</param>
+    public Task<bool> OptionListExists(string org, string repo, string developer, string optionListId);
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
new file mode 100644
index 00000000000..c505c5efc3a
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
@@ -0,0 +1,147 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class PostTests : DisagnerEndpointsTestsBase<PostTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public PostTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Theory]
+    [InlineData("ttd", "empty-app", "testUser", "new-option-list")]
+    public async Task Post_Returns_201Created_When_OptionList_Is_Created(string org, string repo, string developer, string optionListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+
+        var newOptionsList = new List<Option>
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
+
+        // Act
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status201Created, (int)response.StatusCode);
+        Assert.Equal(newOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < newOptionsList.Count; i++)
+        {
+            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
+        }
+    }
+
+    [Theory]
+    [InlineData("ttd", "app-with-options", "testUser", "test-options")]
+    public async Task Post_Returns_409Conflict_When_OptionList_Already_Exists(string org, string repo, string developer, string optionListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+
+        var newOptionsList = new List<Option>
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
+
+        // Act
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status409Conflict, (int)response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("ttd", "empty-app", "testUser", "null-option-list")]
+    public async Task Post_Returns_400BadRequest_When_OptionList_Is_Null(string org, string repo, string developer, string optionListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
+
+        // Act
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+    }
+
+    [Theory]
+    [InlineData("ttd", "empty-app", "testUser", "invalid-option-list")]
+    public async Task Post_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(string org, string repo, string developer, string optionListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+
+        var invalidOptionsList = new List<Option>
+        {
+            new Option
+            {
+                // Label field is missing
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
+
+        // Act
+        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+    }
+}

From 29468bfc8c11c6cd5f18b5f8516b38c67caed319 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Fri, 28 Jun 2024 12:15:59 +0200
Subject: [PATCH 08/16] Add 'using' statements to HTTP message to ensure safe
 disposal

---
 .../Controllers/OptionsController/DeleteTests.cs |  4 ++--
 .../Controllers/OptionsController/GetTests.cs    | 10 +++++-----
 .../Controllers/OptionsController/PostTests.cs   | 16 ++++++++--------
 .../Controllers/OptionsController/PutTests.cs    |  4 ++--
 4 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
index 43162ac7c21..e645d3c6004 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
@@ -24,10 +24,10 @@ public async Task Delete_Returns_200_When_Deleting_OptionList(string org, string
         await CopyRepositoryForTest(org, repo, developer, targetRepository);
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
         JsonDocument responseDocument = JsonDocument.Parse(responseBody);
 
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
index d1fe2dee598..06be2760de0 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -22,12 +22,12 @@ public async Task GetOptionListIds_Returns_OptionListIds(string org, string repo
     {
         // Arrange
         string apiUrl = $"/designer/api/{org}/{repo}/options";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
-        var responseList = JsonSerializer.Deserialize<string[]>(responseBody);
+        string[] responseList = JsonSerializer.Deserialize<string[]>(responseBody);
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
@@ -55,10 +55,10 @@ public async Task GetSingleOptionList_Returns_OptionList(string org, string repo
         };
 
         string apiUrl = $"/designer/api/{org}/{repo}/options/{optionListId}";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
         var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
 
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
index c505c5efc3a..252f6332ea0 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
@@ -41,11 +41,11 @@ public async Task Post_Returns_201Created_When_OptionList_Is_Created(string org,
         };
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
         var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
 
@@ -83,11 +83,11 @@ public async Task Post_Returns_409Conflict_When_OptionList_Already_Exists(string
         };
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
 
         // Assert
         Assert.Equal(StatusCodes.Status409Conflict, (int)response.StatusCode);
@@ -102,11 +102,11 @@ public async Task Post_Returns_400BadRequest_When_OptionList_Is_Null(string org,
         await CopyRepositoryForTest(org, repo, developer, targetRepository);
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
         httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
 
         // Assert
         Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
@@ -135,11 +135,11 @@ public async Task Post_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(s
         };
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
 
         // Assert
         Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
index 72573761845..368b174554d 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
@@ -41,11 +41,11 @@ public async Task Put_Returns_200_When_Creating_New_OptionList(string org, strin
         };
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
         // Act
-        HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
         string responseBody = await response.Content.ReadAsStringAsync();
         var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
 

From d6d6b0e9841f8432b53a15e7d1370a45ac9cb5d7 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Fri, 28 Jun 2024 14:01:56 +0200
Subject: [PATCH 09/16] Add tests for all return codes

---
 .../Designer/Controllers/OptionsController.cs |  36 ++-----
 .../OptionsController/DeleteTests.cs          |  38 ++++++-
 .../Controllers/OptionsController/GetTests.cs |  55 ++++++++--
 .../OptionsController/PostTests.cs            |  82 +++++++-------
 .../Controllers/OptionsController/PutTests.cs | 102 +++++++++++++++++-
 5 files changed, 223 insertions(+), 90 deletions(-)

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 2b75c6f21ae..4e71317d73d 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -1,10 +1,9 @@
 using System.Collections.Generic;
-using System.IO;
-using System.Text.Json;
 using System.Threading.Tasks;
 using Altinn.Studio.Designer.Helpers;
 using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
+using LibGit2Sharp;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
@@ -60,7 +59,6 @@ public ActionResult<string[]> GetOptionListIds(string org, string repo)
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
     [Route("{optionListId}")]
     public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, string repo, [FromRoute] string optionListId)
     {
@@ -71,14 +69,10 @@ public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, st
             List<Option> optionList = await _optionsService.GetOptions(org, repo, developer, optionListId);
             return Ok(optionList);
         }
-        catch (IOException)
+        catch (NotFoundException)
         {
             return NotFound($"The options file {optionListId}.json does not exist.");
         }
-        catch (JsonException)
-        {
-            return new ObjectResult(new { errorMessage = $"The format of the file {optionListId}.json might be invalid." }) { StatusCode = 500 };
-        }
     }
 
     /// <summary>
@@ -92,7 +86,7 @@ public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, st
     [HttpPost]
     [ProducesResponseType(StatusCodes.Status201Created)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
     [Route("{optionListId}")]
     public async Task<ActionResult> Post(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload)
     {
@@ -104,15 +98,8 @@ public async Task<ActionResult> Post(string org, string repo, [FromRoute] string
             return Conflict("The option list already exists.");
         }
 
-        try
-        {
-            var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
-            return CreatedAtAction("GetSingleOptionList", new { org, repo, optionListId }, newOptionList);
-        }
-        catch (IOException)
-        {
-            return new ObjectResult(new { errorMessage = $"An error occurred while saving the file {optionListId}.json." }) { StatusCode = 500 };
-        }
+        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
+        return CreatedAtAction("GetSingleOptionList", new { org, repo, optionListId }, newOptionList);
     }
 
     /// <summary>
@@ -126,21 +113,14 @@ public async Task<ActionResult> Post(string org, string repo, [FromRoute] string
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status500InternalServerError)]
     [Route("{optionListId}")]
     public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        try
-        {
-            var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
-            return Ok(newOptionList);
-        }
-        catch (IOException)
-        {
-            return new ObjectResult(new { errorMessage = $"An error occurred while saving the file {optionListId}.json." }) { StatusCode = 500 };
-        }
+        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
+
+        return Ok(newOptionList);
     }
 
     /// <summary>
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
index e645d3c6004..a9d2ee64dac 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
@@ -15,15 +15,20 @@ public DeleteTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
-    [Theory]
-    [InlineData("ttd", "app-with-layoutsets", "testUser", "test-options")]
-    public async Task Delete_Returns_200_When_Deleting_OptionList(string org, string repo, string developer, string optionListId)
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task Delete_Returns_200OK_When_Deleting_OptionList()
     {
         // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+
         string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
-        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
 
         // Act
@@ -35,4 +40,27 @@ public async Task Delete_Returns_200_When_Deleting_OptionList(string org, string
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
         Assert.Equal($"The options file {optionListId}.json was successfully deleted.", responseDocument.RootElement.ToString());
     }
+
+    [Fact]
+    public async Task Delete_Returns_404NotFound_When_OptionList_Does_Not_Exist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionListId = "non-existing-options";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        JsonDocument responseDocument = JsonDocument.Parse(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status404NotFound, (int)response.StatusCode);
+        Assert.Equal($"The options file {optionListId}.json does not exist.", responseDocument.RootElement.ToString());
+    }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
index 06be2760de0..b966574a83b 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -16,12 +16,12 @@ public GetTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
-    [Theory]
-    [InlineData("ttd", "app-with-options")]
-    public async Task GetOptionListIds_Returns_OptionListIds(string org, string repo)
+    [Fact]
+    public async Task GetOptionListIds_Returns_200OK_With_OptionListIds()
     {
         // Arrange
-        string apiUrl = $"/designer/api/{org}/{repo}/options";
+        const string repo = "app-with-options";
+        string apiUrl = $"/designer/api/ttd/{repo}/options";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
@@ -34,12 +34,32 @@ public async Task GetOptionListIds_Returns_OptionListIds(string org, string repo
         Assert.Equal(2, responseList.Length);
     }
 
-    [Theory]
-    [InlineData("ttd", "app-with-layoutsets", "test-options")]
-    public async Task GetSingleOptionList_Returns_OptionList(string org, string repo, string optionListId)
+    [Fact]
+    public async Task GetOptionListIds_Returns_200OK_With_Empty_OptionListId_Array()
     {
         // Arrange
-        // This expected list matches the list in 'app-with-layoutsets'
+        const string repo = "empty-app";
+        string apiUrl = $"/designer/api/ttd/{repo}/options";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        string[] responseList = JsonSerializer.Deserialize<string[]>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Empty(responseList);
+    }
+
+    [Fact]
+    public async Task GetSingleOptionList_Returns_200Ok_With_OptionList()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+
+        // This  option list matches the list in 'app-with-options'
         var expectedOptionList = new List<Option>
         {
             new Option
@@ -54,7 +74,7 @@ public async Task GetSingleOptionList_Returns_OptionList(string org, string repo
             }
         };
 
-        string apiUrl = $"/designer/api/{org}/{repo}/options/{optionListId}";
+        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
@@ -74,4 +94,21 @@ public async Task GetSingleOptionList_Returns_OptionList(string org, string repo
             Assert.Equal(expectedOptionList[i].HelpText, responseList[i].HelpText);
         }
     }
+
+    [Fact]
+    public async Task GetSingleOptionList_Returns_404NotFound_When_OptionList_Does_Not_Exist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionListId = "non-existing-options";
+
+        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status404NotFound, (int)response.StatusCode);
+    }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
index 252f6332ea0..878e9e3909e 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
@@ -18,13 +18,18 @@ public PostTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
-    [Theory]
-    [InlineData("ttd", "empty-app", "testUser", "new-option-list")]
-    public async Task Post_Returns_201Created_When_OptionList_Is_Created(string org, string repo, string developer, string optionListId)
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task Post_Returns_201Created_When_OptionList_Is_Created()
     {
+        const string repo = "empty-app";
+        const string optionListId = "new-option-list";
+
         // Arrange
         string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         var newOptionsList = new List<Option>
         {
@@ -40,7 +45,7 @@ public async Task Post_Returns_201Created_When_OptionList_Is_Created(string org,
             }
         };
 
-        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
@@ -60,13 +65,15 @@ public async Task Post_Returns_201Created_When_OptionList_Is_Created(string org,
         }
     }
 
-    [Theory]
-    [InlineData("ttd", "app-with-options", "testUser", "test-options")]
-    public async Task Post_Returns_409Conflict_When_OptionList_Already_Exists(string org, string repo, string developer, string optionListId)
+    [Fact]
+    public async Task Post_Returns_409Conflict_When_OptionList_Already_Exists()
     {
         // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+
         string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         var newOptionsList = new List<Option>
         {
@@ -82,7 +89,7 @@ public async Task Post_Returns_409Conflict_When_OptionList_Already_Exists(string
             }
         };
 
-        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
@@ -94,8 +101,9 @@ public async Task Post_Returns_409Conflict_When_OptionList_Already_Exists(string
     }
 
     [Theory]
-    [InlineData("ttd", "empty-app", "testUser", "null-option-list")]
-    public async Task Post_Returns_400BadRequest_When_OptionList_Is_Null(string org, string repo, string developer, string optionListId)
+    [InlineData("ttd", "empty-app", "testUser", "options-missing-label")]
+    [InlineData("ttd", "empty-app", "testUser", "options-empty-json")]
+    public async Task Post_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(string org, string repo, string developer, string optionListId)
     {
         // Arrange
         string targetRepository = TestDataHelper.GenerateTestRepoName();
@@ -103,40 +111,28 @@ public async Task Post_Returns_400BadRequest_When_OptionList_Is_Null(string org,
 
         string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
 
-        // Act
-        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
-
-        // Assert
-        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
-    }
-
-    [Theory]
-    [InlineData("ttd", "empty-app", "testUser", "invalid-option-list")]
-    public async Task Post_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(string org, string repo, string developer, string optionListId)
-    {
-        // Arrange
-        string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(org, repo, developer, targetRepository);
-
-        var invalidOptionsList = new List<Option>
+        if (optionListId == "options-missing-label")
         {
-            new Option
+            var invalidOptionsList = new List<Option>
             {
-                // Label field is missing
-                Value = "value1",
-            },
-            new Option
-            {
-                Label = "label2",
-                Value = "value2",
-            }
-        };
-
-        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
+                new Option
+                {
+                    // Missing Label
+                    Value = "value1",
+                },
+                new Option
+                {
+                    Label = "label2",
+                    Value = "value2",
+                }
+            };
+            httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
+        }
+        else if (optionListId == "options-empty-json")
+        {
+            httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
+        }
 
         // Act
         using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
index 368b174554d..8e513eb6f0c 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
@@ -18,13 +18,18 @@ public PutTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
-    [Theory]
-    [InlineData("ttd", "empty-app", "testUser", "new-options")]
-    public async Task Put_Returns_200_When_Creating_New_OptionList(string org, string repo, string developer, string optionListId)
+    const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task Put_Returns_200OK_When_Creating_New_OptionList()
     {
         // Arrange
+        const string repo = "empty-app";
+        const string optionListId = "new-options";
+
         string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(org, repo, developer, targetRepository);
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         var newOptionsList = new List<Option>
         {
@@ -40,7 +45,53 @@ public async Task Put_Returns_200_When_Creating_New_OptionList(string org, strin
             }
         };
 
-        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(newOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < newOptionsList.Count; i++)
+        {
+            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
+            Assert.Equal(newOptionsList[i].Description, responseList[i].Description);
+            Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionList()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var newOptionsList = new List<Option>
+        {
+            new Option
+            {
+                Label = "aNewLabelThatDidNotExistBefore",
+                Value = "aNewValueThatDidNotExistBefore",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
@@ -61,4 +112,45 @@ public async Task Put_Returns_200_When_Creating_New_OptionList(string org, strin
             Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
         }
     }
+
+    [Theory]
+    [InlineData("options-missing-label")]
+    [InlineData("options-empty-json")]
+    public async Task Put_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(string optionListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, "empty-app", Developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+
+        if (optionListId == "options-missing-label")
+        {
+            var invalidOptionsList = new List<Option>
+            {
+                new Option
+                {
+                    // Missing Label
+                    Value = "value1",
+                },
+                new Option
+                {
+                    Label = "label2",
+                    Value = "value2",
+                }
+            };
+            httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
+        }
+        else if (optionListId == "options-empty-json")
+        {
+            httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
+        }
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+    }
 }

From 8c4acffffc02ea121e98711aa22b43f47d4abd76 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Tue, 2 Jul 2024 08:30:12 +0200
Subject: [PATCH 10/16] Add tests for new methods in AltinnAppGitRepository

---
 .../Services/Implementation/OptionsService.cs |   4 +-
 .../Controllers/OptionsController/GetTests.cs |   2 +-
 .../OptionsController/PostTests.cs            |   2 +-
 .../AltinnAppGitRepositoryTests.cs            |  77 ++++-
 .../Services/OptionsServiceTests.cs           | 264 ++++++++++++++++++
 5 files changed, 345 insertions(+), 4 deletions(-)
 create mode 100644 backend/tests/Designer.Tests/Services/OptionsServiceTests.cs

diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index cd33b1f0d0f..417d989fda6 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -55,7 +55,9 @@ public async Task<List<Option>> UpdateOptions(string org, string repo, string de
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
-        string payloadString = JsonSerializer.Serialize(payload);
+        var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+        string payloadString = JsonSerializer.Serialize(payload, jsonOptions);
+
         string updatedOptionsString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionListId, payloadString);
         var updatedOptions = JsonSerializer.Deserialize<List<Option>>(updatedOptionsString);
 
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
index b966574a83b..93ab4d6ff4c 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
@@ -59,7 +59,7 @@ public async Task GetSingleOptionList_Returns_200Ok_With_OptionList()
         const string repo = "app-with-options";
         const string optionListId = "test-options";
 
-        // This  option list matches the list in 'app-with-options'
+        // This  option list matches the options in 'app-with-options'
         var expectedOptionList = new List<Option>
         {
             new Option
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
index 878e9e3909e..5b04f9f2821 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
@@ -24,10 +24,10 @@ public PostTests(WebApplicationFactory<Program> factory) : base(factory)
     [Fact]
     public async Task Post_Returns_201Created_When_OptionList_Is_Created()
     {
+        // Arrange
         const string repo = "empty-app";
         const string optionListId = "new-option-list";
 
-        // Arrange
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
diff --git a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
index aa4895e86e6..bf2896f053c 100644
--- a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
+++ b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
@@ -1,9 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Threading.Tasks;
 using Altinn.Platform.Storage.Interface.Models;
 using Altinn.Studio.Designer.Infrastructure.GitRepository;
+using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Models.App;
 using Designer.Tests.Utils;
 using FluentAssertions;
@@ -249,7 +252,7 @@ public async Task SaveLayout_ShouldUpdateLayoutInApp()
         }
 
         [Fact]
-        public async Task GetOptions_WithAppThatHasOptions_ShouldReturnSpecifiecOptionsList()
+        public async Task GetOptions_WithAppThatHasOptions_ShouldReturnSpecificOptionsList()
         {
             string org = "ttd";
             string repository = "app-with-options";
@@ -303,6 +306,78 @@ public Task GetOptionListIds_WithAppThatHasNoOptionLists_ShouldThrowNotFoundExce
             return Task.CompletedTask;
         }
 
+        [Fact]
+        public async Task CreateOrOverwriteOptions_WithAppThatHasNoOptionLists_ShouldCreateOptions()
+        {
+            // Arrange
+            string org = "ttd";
+            string repository = "empty-app";
+            string developer = "testUser";
+            string newOptionName = "new-options";
+            string targetRepository = TestDataHelper.GenerateTestRepoName();
+
+            await TestDataHelper.CopyRepositoryForTest(org, repository, developer, targetRepository);
+            AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, targetRepository, developer);
+
+            var newOptionsList = new List<Option>
+            {
+                new Option
+                {
+                    Label = "label1",
+                    Value = "value1",
+                },
+                new Option
+                {
+                    Label = "label2",
+                    Value = "value2",
+                }
+            };
+            var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+            string newOptionsListString = JsonSerializer.Serialize(newOptionsList, jsonOptions);
+
+            // Act
+            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptions(newOptionName, newOptionsListString);
+
+            // Assert
+            Assert.Equal(newOptionsListString, savedOptionsList);
+        }
+
+        [Fact]
+        public async Task CreateOrOverwriteOptions_WithAppThatHasOptionLists_ShouldOverwriteOptions()
+        {
+            // Arrange
+            string org = "ttd";
+            string repository = "app-with-options";
+            string developer = "testUser";
+            string newOptionName = "test-options"; // these options already exist in this repo
+            string targetRepository = TestDataHelper.GenerateTestRepoName();
+
+            await TestDataHelper.CopyRepositoryForTest(org, repository, developer, targetRepository);
+            AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, targetRepository, developer);
+
+            var newOptionsList = new List<Option>
+            {
+                new Option
+                {
+                    Label = "label1",
+                    Value = "newValue1",
+                },
+                new Option
+                {
+                    Label = "label2",
+                    Value = "newValue2",
+                }
+            };
+            var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+            string newOptionsListString = JsonSerializer.Serialize(newOptionsList, jsonOptions);
+
+            // Act
+            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptions(newOptionName, newOptionsListString);
+
+            // Assert
+            Assert.Equal(newOptionsListString, savedOptionsList);
+        }
+
         private static AltinnAppGitRepository PrepareRepositoryForTest(string org, string repository, string developer)
         {
 
diff --git a/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
new file mode 100644
index 00000000000..b44cdcc29c3
--- /dev/null
+++ b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
@@ -0,0 +1,264 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Factories;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Implementation;
+using Designer.Tests.Utils;
+using LibGit2Sharp;
+using Xunit;
+
+namespace Designer.Tests.Services;
+
+public class OptionsServiceTests
+{
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task GetOptionListIds_ShouldReturnOptionListIds_WhenOptionListsExist()
+    {
+        // Arrange
+        const string repo = "app-with-options"; // Has 2 option lists
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        string[] optionListIds = optionsService.GetOptionListIds(Org, targetRepository, Developer);
+
+        // Assert
+        Assert.Equal(2, optionListIds.Length);
+    }
+
+    [Fact]
+    public async Task GetOptionListIds_ShouldReturnEmptyArray_WhenOptionListsDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app"; // Has no option lists
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        string[] optionListIds = optionsService.GetOptionListIds(Org, targetRepository, Developer);
+
+        // Assert
+        Assert.Empty(optionListIds);
+    }
+
+    [Fact]
+    public async Task GetOptions_ShouldReturnOptions_WhenOptionsExists()
+    {
+        // Arrange
+        // This  option list matches the options in 'app-with-options'
+        var expectedOptions = new List<Option>
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        var fetchedOptions = await optionsService.GetOptions(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.Equal(expectedOptions.Count, fetchedOptions.Count);
+
+        for (int i = 0; i < expectedOptions.Count; i++)
+        {
+            Assert.Equal(expectedOptions[i].Label, fetchedOptions[i].Label);
+            Assert.Equal(expectedOptions[i].Value, fetchedOptions[i].Value);
+            Assert.Equal(expectedOptions[i].Description, fetchedOptions[i].Description);
+            Assert.Equal(expectedOptions[i].HelpText, fetchedOptions[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task GetOptions_ShouldThrowNotFoundException_WhenOptionsDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app"; // Has no option lists
+        const string optionListId = "test-options";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act and assert
+        await Assert.ThrowsAsync<NotFoundException>(async () =>
+        {
+            await optionsService.GetOptions(Org, targetRepository, Developer, optionListId);
+        });
+    }
+
+    [Fact]
+    public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsDoesNotExist()
+    {
+        // Arrange
+        var newOptions = new List<Option>
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        const string repo = "empty-app"; // Has no option lists
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        var updatedOptions = await optionsService.UpdateOptions(Org, targetRepository, Developer, optionListId, newOptions);
+
+        // Assert
+        Assert.Equal(newOptions.Count, updatedOptions.Count);
+
+        for (int i = 0; i < updatedOptions.Count; i++)
+        {
+            Assert.Equal(newOptions[i].Label, updatedOptions[i].Label);
+            Assert.Equal(newOptions[i].Value, updatedOptions[i].Value);
+            Assert.Equal(newOptions[i].Description, updatedOptions[i].Description);
+            Assert.Equal(newOptions[i].HelpText, updatedOptions[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsAlreadyExist()
+    {
+        // Arrange
+        var newOptions = new List<Option>
+        {
+            new Option
+            {
+                Label = "someNewOption",
+                Value = "someNewValue",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        const string repo = "app-with-options";
+        const string optionListId = "test-options"; // Name of an existing option list
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        var updatedOptions = await optionsService.UpdateOptions(Org, targetRepository, Developer, optionListId, newOptions);
+
+        // Assert
+        Assert.Equal(updatedOptions.Count, updatedOptions.Count);
+
+        for (int i = 0; i < updatedOptions.Count; i++)
+        {
+            Assert.Equal(updatedOptions[i].Label, updatedOptions[i].Label);
+            Assert.Equal(updatedOptions[i].Value, updatedOptions[i].Value);
+            Assert.Equal(updatedOptions[i].Description, updatedOptions[i].Description);
+            Assert.Equal(updatedOptions[i].HelpText, updatedOptions[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task DeleteOptions_ShouldDeleteOptions_WhenOptionsExist()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        optionsService.DeleteOptions(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.True(true); // No exception thrown
+    }
+
+    [Fact]
+    public async Task DeleteOptions_ShouldThrowNotFoundException_WhenOptionsDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act and assert
+        Assert.Throws<NotFoundException>(() =>
+        {
+            optionsService.DeleteOptions(Org, targetRepository, Developer, optionListId);
+        });
+    }
+
+    [Fact]
+    public async Task OptionListExists_ShouldReturnTrue_WhenOptionListExists()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act
+        bool optionListExists = await optionsService.OptionListExists(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.True(optionListExists);
+    }
+
+    [Fact]
+    public async Task OptionListExists_ShouldReturnFalse_WhenOptionListDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act
+        bool optionListExists = await optionsService.OptionListExists(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.False(optionListExists);
+    }
+
+    private static OptionsService GetOptionsServiceForTest()
+    {
+        AltinnGitRepositoryFactory altinnGitRepositoryFactory = new(TestDataHelper.GetTestDataRepositoriesRootDirectory());
+        OptionsService optionsService = new(altinnGitRepositoryFactory);
+
+        return optionsService;
+    }
+}

From 47a8c9149156452d8d19e31816481025da3fde36 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Tue, 2 Jul 2024 13:53:43 +0200
Subject: [PATCH 11/16] Add CancellationToken to async operations

---
 .../Designer/Controllers/OptionsController.cs | 23 +++++++++++--------
 .../GitRepository/AltinnAppGitRepository.cs   |  7 +++++-
 .../Services/Implementation/OptionsService.cs | 17 +++++++++-----
 .../Services/Interfaces/IOptionsService.cs    | 10 +++++---
 4 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 4e71317d73d..97901ba8ac6 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Altinn.Studio.Designer.Helpers;
 using Altinn.Studio.Designer.Models;
@@ -55,18 +56,19 @@ public ActionResult<string[]> GetOptionListIds(string org, string repo)
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
     /// <param name="optionListId">Name of the option list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     [HttpGet]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     [Route("{optionListId}")]
-    public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, string repo, [FromRoute] string optionListId)
+    public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, string repo, [FromRoute] string optionListId, CancellationToken cancellationToken = default)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         try
         {
-            List<Option> optionList = await _optionsService.GetOptions(org, repo, developer, optionListId);
+            List<Option> optionList = await _optionsService.GetOptions(org, repo, developer, optionListId, cancellationToken);
             return Ok(optionList);
         }
         catch (NotFoundException)
@@ -82,23 +84,24 @@ public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, st
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
     /// <param name="optionListId">Name of the new option list</param>
     /// <param name="payload">The option list contents</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     /// <returns>The created option list</returns>
     [HttpPost]
     [ProducesResponseType(StatusCodes.Status201Created)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
     [ProducesResponseType(StatusCodes.Status409Conflict)]
     [Route("{optionListId}")]
-    public async Task<ActionResult> Post(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload)
+    public async Task<ActionResult> Post(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        bool optionListAlreadyExists = await _optionsService.OptionListExists(org, repo, developer, optionListId);
+        bool optionListAlreadyExists = await _optionsService.OptionListExists(org, repo, developer, optionListId, cancellationToken);
         if (optionListAlreadyExists)
         {
             return Conflict("The option list already exists.");
         }
 
-        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
+        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload, cancellationToken);
         return CreatedAtAction("GetSingleOptionList", new { org, repo, optionListId }, newOptionList);
     }
 
@@ -109,16 +112,17 @@ public async Task<ActionResult> Post(string org, string repo, [FromRoute] string
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
     /// <param name="optionListId">Name of the option list.</param>
     /// <param name="payload">Contents of the option list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     [HttpPut]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
     [Route("{optionListId}")]
-    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload)
+    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload);
+        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload, cancellationToken);
 
         return Ok(newOptionList);
     }
@@ -129,16 +133,17 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
     /// <param name="optionListId">Name of the option list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     [HttpDelete]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     [Route("{optionListId}")]
-    public async Task<ActionResult> Delete(string org, string repo, [FromRoute] string optionListId)
+    public async Task<ActionResult> Delete(string org, string repo, [FromRoute] string optionListId, CancellationToken cancellationToken = default)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        bool optionListExists = await _optionsService.OptionListExists(org, repo, developer, optionListId);
+        bool optionListExists = await _optionsService.OptionListExists(org, repo, developer, optionListId, cancellationToken);
         if (!optionListExists)
         {
             return NotFound($"The options file {optionListId}.json does not exist.");
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
index cffa31de691..c1fdeb88071 100644
--- a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
@@ -713,8 +713,9 @@ public string[] GetOptionListIds()
             {
                 throw new NotFoundException("Options folder not found.");
             }
+
             string[] fileNames = GetFilesByRelativeDirectory(optionsFolder);
-            List<string> optionListIds = new();
+            List<string> optionListIds = [];
             foreach (string fileName in fileNames.Select(Path.GetFileNameWithoutExtension))
             {
                 optionListIds.Add(fileName);
@@ -731,6 +732,8 @@ public string[] GetOptionListIds()
         /// <returns>The options list as a string.</returns>
         public async Task<string> GetOptions(string optionListId, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
             if (!FileExistsByRelativePath(optionsFilePath))
             {
@@ -751,6 +754,8 @@ public async Task<string> GetOptions(string optionListId, CancellationToken canc
         /// <returns>The new options list as a string.</returns>
         public async Task<string> CreateOrOverwriteOptions(string optionListId, string payload, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
             await WriteTextByRelativePathAsync(optionsFilePath, payload, true, cancellationToken);
             string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index 417d989fda6..29532fe86a5 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Text.Json;
+using System.Threading;
 using System.Threading.Tasks;
 using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Services.Interfaces;
@@ -40,25 +41,27 @@ public string[] GetOptionListIds(string org, string repo, string developer)
     }
 
     /// <inheritdoc />
-    public async Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId)
+    public async Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
-        string optionListString = await altinnAppGitRepository.GetOptions(optionListId);
+        string optionListString = await altinnAppGitRepository.GetOptions(optionListId, cancellationToken);
         var optionList = JsonSerializer.Deserialize<List<Option>>(optionListString);
 
         return optionList;
     }
 
     /// <inheritdoc />
-    public async Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload)
+    public async Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload, CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
         var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
         string payloadString = JsonSerializer.Serialize(payload, jsonOptions);
 
-        string updatedOptionsString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionListId, payloadString);
+        string updatedOptionsString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionListId, payloadString, cancellationToken);
         var updatedOptions = JsonSerializer.Deserialize<List<Option>>(updatedOptionsString);
 
         return updatedOptions;
@@ -73,11 +76,13 @@ public void DeleteOptions(string org, string repo, string developer, string opti
     }
 
     /// <inheritdoc />
-    public async Task<bool> OptionListExists(string org, string repo, string developer, string optionListId)
+    public async Task<bool> OptionListExists(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
+
         try
         {
-            await GetOptions(org, repo, developer, optionListId);
+            await GetOptions(org, repo, developer, optionListId, cancellationToken);
             return true;
         }
         catch (NotFoundException)
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index da8c204c56f..b8b4b118d3f 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Altinn.Studio.Designer.Models;
 
@@ -25,8 +26,9 @@ public interface IOptionsService
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
     /// <param name="optionListId">Name of the options list to fetch</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     /// <returns>The options list as a dictionary</returns>
-    public Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId);
+    public Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Creates a new options file in the app repository.
@@ -37,7 +39,8 @@ public interface IOptionsService
     /// <param name="developer">Username of developer</param>
     /// <param name="optionListId">Name of the new options list</param>
     /// <param name="payload">The options list contents</param>
-    public Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload);
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload, CancellationToken cancellationToken = default);
 
     /// <summary>
     /// Deletes an options file from the app repository.
@@ -55,5 +58,6 @@ public interface IOptionsService
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
     /// <param name="optionListId">Name of the options list</param>
-    public Task<bool> OptionListExists(string org, string repo, string developer, string optionListId);
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<bool> OptionListExists(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default);
 }

From f6166a7dc60e12f462efdcf0d6c86aef7640d54f Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Tue, 2 Jul 2024 13:57:19 +0200
Subject: [PATCH 12/16] Add missing ThrowIfCancellationRequested

---
 backend/src/Designer/Controllers/OptionsController.cs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 97901ba8ac6..1593b5b0e68 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -64,6 +64,7 @@ public ActionResult<string[]> GetOptionListIds(string org, string repo)
     [Route("{optionListId}")]
     public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, string repo, [FromRoute] string optionListId, CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         try
@@ -93,6 +94,7 @@ public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, st
     [Route("{optionListId}")]
     public async Task<ActionResult> Post(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         bool optionListAlreadyExists = await _optionsService.OptionListExists(org, repo, developer, optionListId, cancellationToken);
@@ -120,6 +122,7 @@ public async Task<ActionResult> Post(string org, string repo, [FromRoute] string
     [Route("{optionListId}")]
     public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload, cancellationToken);
@@ -141,6 +144,7 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
     [Route("{optionListId}")]
     public async Task<ActionResult> Delete(string org, string repo, [FromRoute] string optionListId, CancellationToken cancellationToken = default)
     {
+        cancellationToken.ThrowIfCancellationRequested();
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         bool optionListExists = await _optionsService.OptionListExists(org, repo, developer, optionListId, cancellationToken);

From 2b603e93defdfee8425c0f887a8fc6d3e1b89814 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Mon, 8 Jul 2024 10:52:59 +0200
Subject: [PATCH 13/16] Fix PR comments

---
 .../Controllers/AppDevelopmentController.cs   |   2 +-
 .../Designer/Controllers/OptionsController.cs |  84 ++++------
 .../Designer/Controllers/PreviewController.cs |   4 +-
 .../GitRepository/AltinnAppGitRepository.cs   |  36 ++---
 .../Services/Implementation/OptionsService.cs |  28 ++--
 .../Services/Interfaces/IOptionsService.cs    |  26 ++--
 .../{DeleteTests.cs => DeleteOptionsTests.cs} |  22 +--
 .../{GetTests.cs => GetOptionsTests.cs}       |  57 +++----
 .../OptionsController/PostTests.cs            | 143 ------------------
 .../{PutTests.cs => UpdateOptionsTests.cs}    |  26 ++--
 .../AltinnAppGitRepositoryTests.cs            |  12 +-
 .../Services/OptionsServiceTests.cs           |  53 +++----
 12 files changed, 150 insertions(+), 343 deletions(-)
 rename backend/tests/Designer.Tests/Controllers/OptionsController/{DeleteTests.cs => DeleteOptionsTests.cs} (67%)
 rename backend/tests/Designer.Tests/Controllers/OptionsController/{GetTests.cs => GetOptionsTests.cs} (62%)
 delete mode 100644 backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
 rename backend/tests/Designer.Tests/Controllers/OptionsController/{PutTests.cs => UpdateOptionsTests.cs} (88%)

diff --git a/backend/src/Designer/Controllers/AppDevelopmentController.cs b/backend/src/Designer/Controllers/AppDevelopmentController.cs
index ac404340f86..dabfb6eaf01 100644
--- a/backend/src/Designer/Controllers/AppDevelopmentController.cs
+++ b/backend/src/Designer/Controllers/AppDevelopmentController.cs
@@ -515,7 +515,7 @@ public ActionResult GetOptionListIds(string org, string app)
             {
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, app, developer);
-                string[] optionListIds = altinnAppGitRepository.GetOptionListIds();
+                string[] optionListIds = altinnAppGitRepository.GetOptionsListIds();
                 return Ok(optionListIds);
             }
             catch (LibGit2Sharp.NotFoundException)
diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
index 1593b5b0e68..b11d7cc2c26 100644
--- a/backend/src/Designer/Controllers/OptionsController.cs
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -32,22 +32,21 @@ public OptionsController(IOptionsService optionsService)
     }
 
     /// <summary>
-    /// Fetches a list of the static option lists belonging to the app.
+    /// Fetches the IDs of the options lists belonging to the app.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
-    /// <returns>Array of option lists. Empty array if none are found</returns>
+    /// <returns>Array of options list's IDs. Empty array if none are found</returns>
     [HttpGet]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public ActionResult<string[]> GetOptionListIds(string org, string repo)
+    public ActionResult<string[]> GetOptionsListIds(string org, string repo)
     {
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        string[] optionLists = _optionsService.GetOptionListIds(org, repo, developer);
+        string[] optionsListIds = _optionsService.GetOptionsListIds(org, repo, developer);
 
-        return Ok(optionLists);
+        return Ok(optionsListIds);
     }
 
     /// <summary>
@@ -55,79 +54,50 @@ public ActionResult<string[]> GetOptionListIds(string org, string repo)
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
-    /// <param name="optionListId">Name of the option list.</param>
+    /// <param name="optionsListId">Name of the option list.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     [HttpGet]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [Route("{optionListId}")]
-    public async Task<ActionResult<List<Option>>> GetSingleOptionList(string org, string repo, [FromRoute] string optionListId, CancellationToken cancellationToken = default)
+    [Route("{optionsListId}")]
+    public async Task<ActionResult<List<Option>>> GetOptionsList(string org, string repo, [FromRoute] string optionsListId, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
         try
         {
-            List<Option> optionList = await _optionsService.GetOptions(org, repo, developer, optionListId, cancellationToken);
-            return Ok(optionList);
+            List<Option> optionsList = await _optionsService.GetOptionsList(org, repo, developer, optionsListId, cancellationToken);
+            return Ok(optionsList);
         }
-        catch (NotFoundException)
+        catch (NotFoundException ex)
         {
-            return NotFound($"The options file {optionListId}.json does not exist.");
+            return NotFound(ex.Message);
         }
     }
 
     /// <summary>
-    /// Create an option list
+    /// Creates or overwrites an options list.
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
-    /// <param name="optionListId">Name of the new option list</param>
-    /// <param name="payload">The option list contents</param>
-    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
-    /// <returns>The created option list</returns>
-    [HttpPost]
-    [ProducesResponseType(StatusCodes.Status201Created)]
-    [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [ProducesResponseType(StatusCodes.Status409Conflict)]
-    [Route("{optionListId}")]
-    public async Task<ActionResult> Post(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
-
-        bool optionListAlreadyExists = await _optionsService.OptionListExists(org, repo, developer, optionListId, cancellationToken);
-        if (optionListAlreadyExists)
-        {
-            return Conflict("The option list already exists.");
-        }
-
-        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload, cancellationToken);
-        return CreatedAtAction("GetSingleOptionList", new { org, repo, optionListId }, newOptionList);
-    }
-
-    /// <summary>
-    /// Creates or overwrites an option list.
-    /// </summary>
-    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
-    /// <param name="repo">Application identifier which is unique within an organisation.</param>
-    /// <param name="optionListId">Name of the option list.</param>
-    /// <param name="payload">Contents of the option list.</param>
+    /// <param name="optionsListId">Name of the options list.</param>
+    /// <param name="payload">Contents of the options list.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     [HttpPut]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(StatusCodes.Status400BadRequest)]
-    [Route("{optionListId}")]
-    public async Task<ActionResult> Put(string org, string repo, [FromRoute] string optionListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
+    [Route("{optionsListId}")]
+    public async Task<ActionResult> CreateOrOverwriteOptionsList(string org, string repo, [FromRoute] string optionsListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        var newOptionList = await _optionsService.UpdateOptions(org, repo, developer, optionListId, payload, cancellationToken);
+        var newOptionsList = await _optionsService.CreateOrOverwriteOptionsList(org, repo, developer, optionsListId, payload, cancellationToken);
 
-        return Ok(newOptionList);
+        return Ok(newOptionsList);
     }
 
     /// <summary>
@@ -135,25 +105,23 @@ public async Task<ActionResult> Put(string org, string repo, [FromRoute] string
     /// </summary>
     /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
     /// <param name="repo">Application identifier which is unique within an organisation.</param>
-    /// <param name="optionListId">Name of the option list.</param>
+    /// <param name="optionsListId">Name of the option list.</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
     [HttpDelete]
     [Produces("application/json")]
     [ProducesResponseType(StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    [Route("{optionListId}")]
-    public async Task<ActionResult> Delete(string org, string repo, [FromRoute] string optionListId, CancellationToken cancellationToken = default)
+    [Route("{optionsListId}")]
+    public async Task<ActionResult> DeleteOptionsList(string org, string repo, [FromRoute] string optionsListId, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
 
-        bool optionListExists = await _optionsService.OptionListExists(org, repo, developer, optionListId, cancellationToken);
-        if (!optionListExists)
+        bool optionsListExists = await _optionsService.OptionsListExists(org, repo, developer, optionsListId, cancellationToken);
+        if (optionsListExists)
         {
-            return NotFound($"The options file {optionListId}.json does not exist.");
+            _optionsService.DeleteOptionsList(org, repo, developer, optionsListId);
         }
 
-        _optionsService.DeleteOptions(org, repo, developer, optionListId);
-        return Ok($"The options file {optionListId}.json was successfully deleted.");
+        return Ok($"The options file {optionsListId}.json has been deleted.");
     }
 }
diff --git a/backend/src/Designer/Controllers/PreviewController.cs b/backend/src/Designer/Controllers/PreviewController.cs
index 80e226e0e9f..63978096f8b 100644
--- a/backend/src/Designer/Controllers/PreviewController.cs
+++ b/backend/src/Designer/Controllers/PreviewController.cs
@@ -854,7 +854,7 @@ public async Task<ActionResult<string>> GetOptions(string org, string app, strin
             {
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, app, developer);
-                string options = await altinnAppGitRepository.GetOptions(optionListId, cancellationToken);
+                string options = await altinnAppGitRepository.GetOptionsList(optionListId, cancellationToken);
                 return Ok(options);
             }
             catch (NotFoundException)
@@ -883,7 +883,7 @@ public async Task<ActionResult<string>> GetOptionsForInstance(string org, string
                 // TODO: Need code to get dynamic options list based on language and source?
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, app, developer);
-                string options = await altinnAppGitRepository.GetOptions(optionListId, cancellationToken);
+                string options = await altinnAppGitRepository.GetOptionsList(optionListId, cancellationToken);
                 return Ok(options);
             }
             catch (NotFoundException)
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
index c1fdeb88071..fa95f9c563a 100644
--- a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
@@ -706,7 +706,7 @@ public async Task<string> GetAppFrontendCshtml(CancellationToken cancellationTok
         /// Gets a list of file names from the Options folder representing the available options lists.
         /// </summary>
         /// <returns>A list of option list names.</returns>
-        public string[] GetOptionListIds()
+        public string[] GetOptionsListIds()
         {
             string optionsFolder = Path.Combine(OptionsFolderPath);
             if (!DirectoryExistsByRelativePath(optionsFolder))
@@ -715,29 +715,29 @@ public string[] GetOptionListIds()
             }
 
             string[] fileNames = GetFilesByRelativeDirectory(optionsFolder);
-            List<string> optionListIds = [];
+            List<string> optionsListIds = [];
             foreach (string fileName in fileNames.Select(Path.GetFileNameWithoutExtension))
             {
-                optionListIds.Add(fileName);
+                optionsListIds.Add(fileName);
             }
 
-            return optionListIds.ToArray();
+            return optionsListIds.ToArray();
         }
 
         /// <summary>
         /// Gets a specific options list with the provided id.
         /// </summary>
-        /// <param name="optionListId">The name of the options list to fetch.</param>
+        /// <param name="optionsListId">The name of the options list to fetch.</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The options list as a string.</returns>
-        public async Task<string> GetOptions(string optionListId, CancellationToken cancellationToken = default)
+        public async Task<string> GetOptionsList(string optionsListId, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
             if (!FileExistsByRelativePath(optionsFilePath))
             {
-                throw new NotFoundException($"Options file {optionListId}.json was not found.");
+                throw new NotFoundException($"Options file {optionsListId}.json was not found.");
             }
             string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
 
@@ -745,18 +745,18 @@ public async Task<string> GetOptions(string optionListId, CancellationToken canc
         }
 
         /// <summary>
-        /// Creates a new option list with the provided id.
-        /// If the option list already exists, it will be overwritten.
+        /// Creates or overwrites the options list with the provided id.
+        /// If the options list already exists, it will be overwritten.
         /// </summary>
-        /// <param name="optionListId">The name of the option list to create.</param>
-        /// <param name="payload">The contents of the new option list as a string</param>
+        /// <param name="optionsListId">The name of the options list to create.</param>
+        /// <param name="payload">The contents of the new options list as a string</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The new options list as a string.</returns>
-        public async Task<string> CreateOrOverwriteOptions(string optionListId, string payload, CancellationToken cancellationToken = default)
+        public async Task<string> CreateOrOverwriteOptionsList(string optionsListId, string payload, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
             await WriteTextByRelativePathAsync(optionsFilePath, payload, true, cancellationToken);
             string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
 
@@ -766,13 +766,13 @@ public async Task<string> CreateOrOverwriteOptions(string optionListId, string p
         /// <summary>
         /// Deletes the option list with the provided id.
         /// </summary>
-        /// <param name="optionListId">The name of the option list to create.</param>
-        public void DeleteOptions(string optionListId)
+        /// <param name="optionsListId">The name of the option list to create.</param>
+        public void DeleteOptionsList(string optionsListId)
         {
-            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionListId}.json");
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
             if (!FileExistsByRelativePath(optionsFilePath))
             {
-                throw new NotFoundException($"Options file {optionListId}.json was not found.");
+                throw new NotFoundException($"Options file {optionsListId}.json was not found.");
             }
 
             DeleteFileByRelativePath(optionsFilePath);
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
index 29532fe86a5..2f976f22d4b 100644
--- a/backend/src/Designer/Services/Implementation/OptionsService.cs
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -9,7 +9,7 @@
 namespace Altinn.Studio.Designer.Services.Implementation;
 
 /// <summary>
-/// Service for handling options (code lists).
+/// Service for handling options lists (code lists).
 /// </summary>
 public class OptionsService : IOptionsService
 {
@@ -25,14 +25,14 @@ public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory)
     }
 
     /// <inheritdoc />
-    public string[] GetOptionListIds(string org, string repo, string developer)
+    public string[] GetOptionsListIds(string org, string repo, string developer)
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
         try
         {
-            string[] optionLists = altinnAppGitRepository.GetOptionListIds();
-            return optionLists;
+            string[] optionsLists = altinnAppGitRepository.GetOptionsListIds();
+            return optionsLists;
         }
         catch (NotFoundException) // Is raised if the Options folder does not exist
         {
@@ -41,19 +41,19 @@ public string[] GetOptionListIds(string org, string repo, string developer)
     }
 
     /// <inheritdoc />
-    public async Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default)
+    public async Task<List<Option>> GetOptionsList(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
-        string optionListString = await altinnAppGitRepository.GetOptions(optionListId, cancellationToken);
-        var optionList = JsonSerializer.Deserialize<List<Option>>(optionListString);
+        string optionsListString = await altinnAppGitRepository.GetOptionsList(optionsListId, cancellationToken);
+        var optionsList = JsonSerializer.Deserialize<List<Option>>(optionsListString);
 
-        return optionList;
+        return optionsList;
     }
 
     /// <inheritdoc />
-    public async Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload, CancellationToken cancellationToken = default)
+    public async Task<List<Option>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Option> payload, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
@@ -61,28 +61,28 @@ public async Task<List<Option>> UpdateOptions(string org, string repo, string de
         var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
         string payloadString = JsonSerializer.Serialize(payload, jsonOptions);
 
-        string updatedOptionsString = await altinnAppGitRepository.CreateOrOverwriteOptions(optionListId, payloadString, cancellationToken);
+        string updatedOptionsString = await altinnAppGitRepository.CreateOrOverwriteOptionsList(optionsListId, payloadString, cancellationToken);
         var updatedOptions = JsonSerializer.Deserialize<List<Option>>(updatedOptionsString);
 
         return updatedOptions;
     }
 
     /// <inheritdoc />
-    public void DeleteOptions(string org, string repo, string developer, string optionListId)
+    public void DeleteOptionsList(string org, string repo, string developer, string optionsListId)
     {
         var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
 
-        altinnAppGitRepository.DeleteOptions(optionListId);
+        altinnAppGitRepository.DeleteOptionsList(optionsListId);
     }
 
     /// <inheritdoc />
-    public async Task<bool> OptionListExists(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default)
+    public async Task<bool> OptionsListExists(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
 
         try
         {
-            await GetOptions(org, repo, developer, optionListId, cancellationToken);
+            await GetOptionsList(org, repo, developer, optionsListId, cancellationToken);
             return true;
         }
         catch (NotFoundException)
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
index b8b4b118d3f..36db10f39ba 100644
--- a/backend/src/Designer/Services/Interfaces/IOptionsService.cs
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -17,39 +17,39 @@ public interface IOptionsService
     /// <param name="repo"></param>
     /// <param name="developer"></param>
     /// <returns></returns>
-    public string[] GetOptionListIds(string org, string repo, string developer);
+    public string[] GetOptionsListIds(string org, string repo, string developer);
 
     /// <summary>
-    /// Gets a options file from the app repository with the specified optionListId.
+    /// Gets an options list from the app repository with the specified optionListId.
     /// </summary>
     /// <param name="org">Organisation</param>
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
-    /// <param name="optionListId">Name of the options list to fetch</param>
+    /// <param name="optionsListId">Name of the options list to fetch</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
-    /// <returns>The options list as a dictionary</returns>
-    public Task<List<Option>> GetOptions(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default);
+    /// <returns>The options list</returns>
+    public Task<List<Option>> GetOptionsList(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default);
 
     /// <summary>
-    /// Creates a new options file in the app repository.
+    /// Creates a new options list in the app repository.
     /// If the file already exists, it will be overwritten.
     /// </summary>
     /// <param name="org">Organisation</param>
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
-    /// <param name="optionListId">Name of the new options list</param>
+    /// <param name="optionsListId">Name of the new options list</param>
     /// <param name="payload">The options list contents</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
-    public Task<List<Option>> UpdateOptions(string org, string repo, string developer, string optionListId, List<Option> payload, CancellationToken cancellationToken = default);
+    public Task<List<Option>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Option> payload, CancellationToken cancellationToken = default);
 
     /// <summary>
-    /// Deletes an options file from the app repository.
+    /// Deletes an options list from the app repository.
     /// </summary>
     /// <param name="org">Organisation</param>
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
-    /// <param name="optionListId">Name of the new options list</param>
-    public void DeleteOptions(string org, string repo, string developer, string optionListId);
+    /// <param name="optionsListId">Name of the new options list</param>
+    public void DeleteOptionsList(string org, string repo, string developer, string optionsListId);
 
     /// <summary>
     /// Checks if an options list exists in the app repository.
@@ -57,7 +57,7 @@ public interface IOptionsService
     /// <param name="org">Organisation</param>
     /// <param name="repo">Repository</param>
     /// <param name="developer">Username of developer</param>
-    /// <param name="optionListId">Name of the options list</param>
+    /// <param name="optionsListId">Name of the options list</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
-    public Task<bool> OptionListExists(string org, string repo, string developer, string optionListId, CancellationToken cancellationToken = default);
+    public Task<bool> OptionsListExists(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default);
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
similarity index 67%
rename from backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
rename to backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
index a9d2ee64dac..c36fff4a294 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
@@ -9,9 +9,9 @@
 
 namespace Designer.Tests.Controllers.OptionsController;
 
-public class DeleteTests : DisagnerEndpointsTestsBase<DeleteTests>, IClassFixture<WebApplicationFactory<Program>>
+public class DeleteOptionsTests : DisagnerEndpointsTestsBase<DeleteOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
 {
-    public DeleteTests(WebApplicationFactory<Program> factory) : base(factory)
+    public DeleteOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
@@ -19,16 +19,16 @@ public DeleteTests(WebApplicationFactory<Program> factory) : base(factory)
     private const string Developer = "testUser";
 
     [Fact]
-    public async Task Delete_Returns_200OK_When_Deleting_OptionList()
+    public async Task Delete_Returns_200OK_When_Deleting_OptionsList()
     {
         // Arrange
         const string repo = "app-with-options";
-        const string optionListId = "test-options";
+        const string optionsListId = "test-options";
 
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
 
         // Act
@@ -38,20 +38,20 @@ public async Task Delete_Returns_200OK_When_Deleting_OptionList()
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal($"The options file {optionListId}.json was successfully deleted.", responseDocument.RootElement.ToString());
+        Assert.Equal($"The options file {optionsListId}.json has been deleted.", responseDocument.RootElement.ToString());
     }
 
     [Fact]
-    public async Task Delete_Returns_404NotFound_When_OptionList_Does_Not_Exist()
+    public async Task Delete_Returns_200OK_When_OptionsList_Does_Not_Exist()
     {
         // Arrange
         const string repo = "empty-app";
-        const string optionListId = "non-existing-options";
+        const string optionsListId = "non-existing-options";
 
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
 
         // Act
@@ -60,7 +60,7 @@ public async Task Delete_Returns_404NotFound_When_OptionList_Does_Not_Exist()
         JsonDocument responseDocument = JsonDocument.Parse(responseBody);
 
         // Assert
-        Assert.Equal(StatusCodes.Status404NotFound, (int)response.StatusCode);
-        Assert.Equal($"The options file {optionListId}.json does not exist.", responseDocument.RootElement.ToString());
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal($"The options file {optionsListId}.json has been deleted.", responseDocument.RootElement.ToString());
     }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
similarity index 62%
rename from backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
rename to backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
index 93ab4d6ff4c..5433e75ca6c 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
@@ -10,16 +10,18 @@
 
 namespace Designer.Tests.Controllers.OptionsController;
 
-public class GetTests : DisagnerEndpointsTestsBase<GetTests>, IClassFixture<WebApplicationFactory<Program>>
+public class GetOptionsTests : DisagnerEndpointsTestsBase<GetOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
 {
-    public GetTests(WebApplicationFactory<Program> factory) : base(factory)
+    public GetOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
     [Fact]
-    public async Task GetOptionListIds_Returns_200OK_With_OptionListIds()
+    public async Task GetOptionsListIds_Returns200OK_WithOptionsListIds()
     {
         // Arrange
+        string[] expectedOptionsListIds =  ["other-options", "test-options"];
+
         const string repo = "app-with-options";
         string apiUrl = $"/designer/api/ttd/{repo}/options";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
@@ -31,11 +33,11 @@ public async Task GetOptionListIds_Returns_200OK_With_OptionListIds()
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(2, responseList.Length);
+        Assert.Equal(expectedOptionsListIds, responseList);
     }
 
     [Fact]
-    public async Task GetOptionListIds_Returns_200OK_With_Empty_OptionListId_Array()
+    public async Task GetOptionsListIds_Returns200OK_WithEmptyOptionsListIdArray_WhenAppHasNoOptionsList()
     {
         // Arrange
         const string repo = "empty-app";
@@ -53,28 +55,13 @@ public async Task GetOptionListIds_Returns_200OK_With_Empty_OptionListId_Array()
     }
 
     [Fact]
-    public async Task GetSingleOptionList_Returns_200Ok_With_OptionList()
+    public async Task GetSingleOptionsList_Returns200Ok_WithOptionsList()
     {
         // Arrange
         const string repo = "app-with-options";
-        const string optionListId = "test-options";
-
-        // This  option list matches the options in 'app-with-options'
-        var expectedOptionList = new List<Option>
-        {
-            new Option
-            {
-                Label = "label1",
-                Value = "value1",
-            },
-            new Option
-            {
-                Label = "label2",
-                Value = "value2",
-            }
-        };
-
-        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionListId}";
+        const string optionsListId = "test-options";
+
+        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
@@ -84,25 +71,23 @@ public async Task GetSingleOptionList_Returns_200Ok_With_OptionList()
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(expectedOptionList.Count, responseList.Count);
-
-        for (int i = 0; i < expectedOptionList.Count; i++)
-        {
-            Assert.Equal(expectedOptionList[i].Label, responseList[i].Label);
-            Assert.Equal(expectedOptionList[i].Value, responseList[i].Value);
-            Assert.Equal(expectedOptionList[i].Description, responseList[i].Description);
-            Assert.Equal(expectedOptionList[i].HelpText, responseList[i].HelpText);
-        }
+        Assert.Equal(2, responseList.Count);
+
+        Assert.Equal("label1", responseList[0].Label);
+        Assert.Equal("value1", responseList[0].Value);
+
+        Assert.Equal("label2", responseList[1].Label);
+        Assert.Equal("value2", responseList[1].Value);
     }
 
     [Fact]
-    public async Task GetSingleOptionList_Returns_404NotFound_When_OptionList_Does_Not_Exist()
+    public async Task GetSingleOptionsList_Returns404NotFound_WhenOptionsListDoesNotExist()
     {
         // Arrange
         const string repo = "empty-app";
-        const string optionListId = "non-existing-options";
+        const string optionsListId = "non-existing-options";
 
-        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionListId}";
+        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
 
         // Act
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
deleted file mode 100644
index 5b04f9f2821..00000000000
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PostTests.cs
+++ /dev/null
@@ -1,143 +0,0 @@
-using System.Collections.Generic;
-using System.Net.Http;
-using System.Net.Http.Json;
-using System.Text.Json;
-using System.Threading.Tasks;
-using Altinn.Studio.Designer.Models;
-using Designer.Tests.Controllers.ApiTests;
-using Designer.Tests.Utils;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc.Testing;
-using Xunit;
-
-namespace Designer.Tests.Controllers.OptionsController;
-
-public class PostTests : DisagnerEndpointsTestsBase<PostTests>, IClassFixture<WebApplicationFactory<Program>>
-{
-    public PostTests(WebApplicationFactory<Program> factory) : base(factory)
-    {
-    }
-
-    private const string Org = "ttd";
-    private const string Developer = "testUser";
-
-    [Fact]
-    public async Task Post_Returns_201Created_When_OptionList_Is_Created()
-    {
-        // Arrange
-        const string repo = "empty-app";
-        const string optionListId = "new-option-list";
-
-        string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
-
-        var newOptionsList = new List<Option>
-        {
-            new Option
-            {
-                Label = "label1",
-                Value = "value1",
-            },
-            new Option
-            {
-                Label = "label2",
-                Value = "value2",
-            }
-        };
-
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
-        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
-
-        // Act
-        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
-        string responseBody = await response.Content.ReadAsStringAsync();
-        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
-
-        // Assert
-        Assert.Equal(StatusCodes.Status201Created, (int)response.StatusCode);
-        Assert.Equal(newOptionsList.Count, responseList.Count);
-
-        for (int i = 0; i < newOptionsList.Count; i++)
-        {
-            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
-            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
-        }
-    }
-
-    [Fact]
-    public async Task Post_Returns_409Conflict_When_OptionList_Already_Exists()
-    {
-        // Arrange
-        const string repo = "app-with-options";
-        const string optionListId = "test-options";
-
-        string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
-
-        var newOptionsList = new List<Option>
-        {
-            new Option
-            {
-                Label = "label1",
-                Value = "value1",
-            },
-            new Option
-            {
-                Label = "label2",
-                Value = "value2",
-            }
-        };
-
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
-        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
-        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
-
-        // Act
-        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
-
-        // Assert
-        Assert.Equal(StatusCodes.Status409Conflict, (int)response.StatusCode);
-    }
-
-    [Theory]
-    [InlineData("ttd", "empty-app", "testUser", "options-missing-label")]
-    [InlineData("ttd", "empty-app", "testUser", "options-empty-json")]
-    public async Task Post_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(string org, string repo, string developer, string optionListId)
-    {
-        // Arrange
-        string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await CopyRepositoryForTest(org, repo, developer, targetRepository);
-
-        string apiUrl = $"/designer/api/{org}/{targetRepository}/options/{optionListId}";
-        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
-
-        if (optionListId == "options-missing-label")
-        {
-            var invalidOptionsList = new List<Option>
-            {
-                new Option
-                {
-                    // Missing Label
-                    Value = "value1",
-                },
-                new Option
-                {
-                    Label = "label2",
-                    Value = "value2",
-                }
-            };
-            httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
-        }
-        else if (optionListId == "options-empty-json")
-        {
-            httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
-        }
-
-        // Act
-        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
-
-        // Assert
-        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
-    }
-}
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
similarity index 88%
rename from backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
rename to backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
index 8e513eb6f0c..883aeb074be 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/PutTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
@@ -12,21 +12,21 @@
 
 namespace Designer.Tests.Controllers.OptionsController;
 
-public class PutTests : DisagnerEndpointsTestsBase<PutTests>, IClassFixture<WebApplicationFactory<Program>>
+public class UpdateOptionsTests : DisagnerEndpointsTestsBase<UpdateOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
 {
-    public PutTests(WebApplicationFactory<Program> factory) : base(factory)
+    public UpdateOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     {
     }
 
-    const string Org = "ttd";
+    private const string Org = "ttd";
     private const string Developer = "testUser";
 
     [Fact]
-    public async Task Put_Returns_200OK_When_Creating_New_OptionList()
+    public async Task Put_Returns_200OK_When_Creating_New_OptionsList()
     {
         // Arrange
         const string repo = "empty-app";
-        const string optionListId = "new-options";
+        const string optionsListId = "new-options";
 
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
@@ -45,7 +45,7 @@ public async Task Put_Returns_200OK_When_Creating_New_OptionList()
             }
         };
 
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
@@ -68,11 +68,11 @@ public async Task Put_Returns_200OK_When_Creating_New_OptionList()
     }
 
     [Fact]
-    public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionList()
+    public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionsList()
     {
         // Arrange
         const string repo = "app-with-options";
-        const string optionListId = "test-options";
+        const string optionsListId = "test-options";
 
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
@@ -91,7 +91,7 @@ public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionList()
             }
         };
 
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
         httpRequestMessage.Content = JsonContent.Create(newOptionsList);
 
@@ -116,16 +116,16 @@ public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionList()
     [Theory]
     [InlineData("options-missing-label")]
     [InlineData("options-empty-json")]
-    public async Task Put_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(string optionListId)
+    public async Task Put_Returns_400BadRequest_When_OptionsList_Format_Is_Invalid(string optionsListId)
     {
         // Arrange
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await CopyRepositoryForTest(Org, "empty-app", Developer, targetRepository);
 
-        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionListId}";
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
 
-        if (optionListId == "options-missing-label")
+        if (optionsListId == "options-missing-label")
         {
             var invalidOptionsList = new List<Option>
             {
@@ -142,7 +142,7 @@ public async Task Put_Returns_400BadRequest_When_OptionList_Format_Is_Invalid(st
             };
             httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
         }
-        else if (optionListId == "options-empty-json")
+        else if (optionsListId == "options-empty-json")
         {
             httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
         }
diff --git a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
index bf2896f053c..321efd0fbd7 100644
--- a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
+++ b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
@@ -260,7 +260,7 @@ public async Task GetOptions_WithAppThatHasOptions_ShouldReturnSpecificOptionsLi
             string optionsId = "test-options";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
 
-            string options = await altinnAppGitRepository.GetOptions(optionsId);
+            string options = await altinnAppGitRepository.GetOptionsList(optionsId);
             options.Should().NotBeNull();
             var optionsArray = JsonNode.Parse(options).AsArray();
             optionsArray.Count.Should().Be(2);
@@ -277,7 +277,7 @@ public async Task GetOptions_WhenSpecifiedOptionIdDoesNotExistInApp_ShouldThrowN
             string optionsId = "non-existing-test-options";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
 
-            await Assert.ThrowsAsync<LibGit2Sharp.NotFoundException>(async () => await altinnAppGitRepository.GetOptions(optionsId));
+            await Assert.ThrowsAsync<LibGit2Sharp.NotFoundException>(async () => await altinnAppGitRepository.GetOptionsList(optionsId));
         }
 
         [Fact]
@@ -288,7 +288,7 @@ public Task GetOptionListIds_WithAppThatHasOptionLists_ShouldReturnOptionListPat
             string developer = "testUser";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
 
-            string[] optionListIds = altinnAppGitRepository.GetOptionListIds();
+            string[] optionListIds = altinnAppGitRepository.GetOptionsListIds();
 
             optionListIds.Should().NotBeNull();
             optionListIds.Should().HaveCount(2);
@@ -302,7 +302,7 @@ public Task GetOptionListIds_WithAppThatHasNoOptionLists_ShouldThrowNotFoundExce
             string repository = "empty-app";
             string developer = "testUser";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
-            Assert.Throws<LibGit2Sharp.NotFoundException>(altinnAppGitRepository.GetOptionListIds);
+            Assert.Throws<LibGit2Sharp.NotFoundException>(altinnAppGitRepository.GetOptionsListIds);
             return Task.CompletedTask;
         }
 
@@ -336,7 +336,7 @@ public async Task CreateOrOverwriteOptions_WithAppThatHasNoOptionLists_ShouldCre
             string newOptionsListString = JsonSerializer.Serialize(newOptionsList, jsonOptions);
 
             // Act
-            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptions(newOptionName, newOptionsListString);
+            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptionsList(newOptionName, newOptionsListString);
 
             // Assert
             Assert.Equal(newOptionsListString, savedOptionsList);
@@ -372,7 +372,7 @@ public async Task CreateOrOverwriteOptions_WithAppThatHasOptionLists_ShouldOverw
             string newOptionsListString = JsonSerializer.Serialize(newOptionsList, jsonOptions);
 
             // Act
-            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptions(newOptionName, newOptionsListString);
+            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptionsList(newOptionName, newOptionsListString);
 
             // Assert
             Assert.Equal(newOptionsListString, savedOptionsList);
diff --git a/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
index b44cdcc29c3..2a7322f1488 100644
--- a/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
+++ b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
@@ -15,42 +15,42 @@ public class OptionsServiceTests
     private const string Developer = "testUser";
 
     [Fact]
-    public async Task GetOptionListIds_ShouldReturnOptionListIds_WhenOptionListsExist()
+    public async Task GetOptionsListIds_ShouldReturnOptionsListIds_WhenOptionsListsExist()
     {
         // Arrange
-        const string repo = "app-with-options"; // Has 2 option lists
+        const string repo = "app-with-options"; // Has 2 options lists
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         // Act
         var optionsService = GetOptionsServiceForTest();
-        string[] optionListIds = optionsService.GetOptionListIds(Org, targetRepository, Developer);
+        string[] optionListIds = optionsService.GetOptionsListIds(Org, targetRepository, Developer);
 
         // Assert
         Assert.Equal(2, optionListIds.Length);
     }
 
     [Fact]
-    public async Task GetOptionListIds_ShouldReturnEmptyArray_WhenOptionListsDoesNotExist()
+    public async Task GetOptionsListIds_ShouldReturnEmptyArray_WhenOptionsListsDoesNotExist()
     {
         // Arrange
-        const string repo = "empty-app"; // Has no option lists
+        const string repo = "empty-app"; // Has no options lists
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         // Act
         var optionsService = GetOptionsServiceForTest();
-        string[] optionListIds = optionsService.GetOptionListIds(Org, targetRepository, Developer);
+        string[] optionListIds = optionsService.GetOptionsListIds(Org, targetRepository, Developer);
 
         // Assert
         Assert.Empty(optionListIds);
     }
 
     [Fact]
-    public async Task GetOptions_ShouldReturnOptions_WhenOptionsExists()
+    public async Task GetOptionsList_ShouldReturnOptionsList_WhenOptionsExists()
     {
         // Arrange
-        // This  option list matches the options in 'app-with-options'
+        // This  options list matches the options in 'app-with-options'
         var expectedOptions = new List<Option>
         {
             new Option
@@ -72,7 +72,7 @@ public async Task GetOptions_ShouldReturnOptions_WhenOptionsExists()
 
         // Act
         var optionsService = GetOptionsServiceForTest();
-        var fetchedOptions = await optionsService.GetOptions(Org, targetRepository, Developer, optionListId);
+        var fetchedOptions = await optionsService.GetOptionsList(Org, targetRepository, Developer, optionListId);
 
         // Assert
         Assert.Equal(expectedOptions.Count, fetchedOptions.Count);
@@ -87,26 +87,23 @@ public async Task GetOptions_ShouldReturnOptions_WhenOptionsExists()
     }
 
     [Fact]
-    public async Task GetOptions_ShouldThrowNotFoundException_WhenOptionsDoesNotExist()
+    public async Task GetOptionsList_ShouldThrowNotFoundException_WhenOptionsListDoesNotExist()
     {
         // Arrange
-        const string repo = "empty-app"; // Has no option lists
+        const string repo = "empty-app"; // Has no options lists
         const string optionListId = "test-options";
 
-        string targetRepository = TestDataHelper.GenerateTestRepoName();
-        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
-
         var optionsService = GetOptionsServiceForTest();
 
         // Act and assert
         await Assert.ThrowsAsync<NotFoundException>(async () =>
         {
-            await optionsService.GetOptions(Org, targetRepository, Developer, optionListId);
+            await optionsService.GetOptionsList(Org, repo, Developer, optionListId);
         });
     }
 
     [Fact]
-    public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsDoesNotExist()
+    public async Task CreateOrOverwriteOptionsList_ShouldReturnUpdatedOptionsList_WhenOptionsListDoesNotAlreadyExist()
     {
         // Arrange
         var newOptions = new List<Option>
@@ -123,14 +120,14 @@ public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsDoesNotExi
             }
         };
 
-        const string repo = "empty-app"; // Has no option lists
+        const string repo = "empty-app"; // Has no options lists
         const string optionListId = "test-options";
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         // Act
         var optionsService = GetOptionsServiceForTest();
-        var updatedOptions = await optionsService.UpdateOptions(Org, targetRepository, Developer, optionListId, newOptions);
+        var updatedOptions = await optionsService.CreateOrOverwriteOptionsList(Org, targetRepository, Developer, optionListId, newOptions);
 
         // Assert
         Assert.Equal(newOptions.Count, updatedOptions.Count);
@@ -145,7 +142,7 @@ public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsDoesNotExi
     }
 
     [Fact]
-    public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsAlreadyExist()
+    public async Task CreateOrOverwriteOptionsList_ShouldReturnUpdatedOptionsList_WhenOptionsAlreadyExist()
     {
         // Arrange
         var newOptions = new List<Option>
@@ -163,13 +160,13 @@ public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsAlreadyExi
         };
 
         const string repo = "app-with-options";
-        const string optionListId = "test-options"; // Name of an existing option list
+        const string optionListId = "test-options"; // Name of an existing options list
         string targetRepository = TestDataHelper.GenerateTestRepoName();
         await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
 
         // Act
         var optionsService = GetOptionsServiceForTest();
-        var updatedOptions = await optionsService.UpdateOptions(Org, targetRepository, Developer, optionListId, newOptions);
+        var updatedOptions = await optionsService.CreateOrOverwriteOptionsList(Org, targetRepository, Developer, optionListId, newOptions);
 
         // Assert
         Assert.Equal(updatedOptions.Count, updatedOptions.Count);
@@ -184,7 +181,7 @@ public async Task UpdateOptions_ShouldReturnUpdatedOptions_WhenOptionsAlreadyExi
     }
 
     [Fact]
-    public async Task DeleteOptions_ShouldDeleteOptions_WhenOptionsExist()
+    public async Task DeleteOptionsList_ShouldDeleteOptionsList_WhenOptionsListExist()
     {
         // Arrange
         const string repo = "app-with-options";
@@ -194,7 +191,7 @@ public async Task DeleteOptions_ShouldDeleteOptions_WhenOptionsExist()
 
         // Act
         var optionsService = GetOptionsServiceForTest();
-        optionsService.DeleteOptions(Org, targetRepository, Developer, optionListId);
+        optionsService.DeleteOptionsList(Org, targetRepository, Developer, optionListId);
 
         // Assert
         Assert.True(true); // No exception thrown
@@ -214,12 +211,12 @@ public async Task DeleteOptions_ShouldThrowNotFoundException_WhenOptionsDoesNotE
         // Act and assert
         Assert.Throws<NotFoundException>(() =>
         {
-            optionsService.DeleteOptions(Org, targetRepository, Developer, optionListId);
+            optionsService.DeleteOptionsList(Org, targetRepository, Developer, optionListId);
         });
     }
 
     [Fact]
-    public async Task OptionListExists_ShouldReturnTrue_WhenOptionListExists()
+    public async Task OptionsListExists_ShouldReturnTrue_WhenOptionsListExists()
     {
         // Arrange
         const string repo = "app-with-options";
@@ -230,14 +227,14 @@ public async Task OptionListExists_ShouldReturnTrue_WhenOptionListExists()
         var optionsService = GetOptionsServiceForTest();
 
         // Act
-        bool optionListExists = await optionsService.OptionListExists(Org, targetRepository, Developer, optionListId);
+        bool optionListExists = await optionsService.OptionsListExists(Org, targetRepository, Developer, optionListId);
 
         // Assert
         Assert.True(optionListExists);
     }
 
     [Fact]
-    public async Task OptionListExists_ShouldReturnFalse_WhenOptionListDoesNotExist()
+    public async Task OptionListsExists_ShouldReturnFalse_WhenOptionsListDoesNotExist()
     {
         // Arrange
         const string repo = "empty-app";
@@ -248,7 +245,7 @@ public async Task OptionListExists_ShouldReturnFalse_WhenOptionListDoesNotExist(
         var optionsService = GetOptionsServiceForTest();
 
         // Act
-        bool optionListExists = await optionsService.OptionListExists(Org, targetRepository, Developer, optionListId);
+        bool optionListExists = await optionsService.OptionsListExists(Org, targetRepository, Developer, optionListId);
 
         // Assert
         Assert.False(optionListExists);

From d1ff63ef3a720234e0a172f78bab05192cb3d298 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Mon, 8 Jul 2024 10:58:26 +0200
Subject: [PATCH 14/16] Merge main to branch

---
 .../Controllers/OptionsController/DeleteOptionsTests.cs         | 2 +-
 .../Controllers/OptionsController/GetOptionsTests.cs            | 2 +-
 .../Controllers/OptionsController/UpdateOptionsTests.cs         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
index c36fff4a294..00a73484c29 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
@@ -9,7 +9,7 @@
 
 namespace Designer.Tests.Controllers.OptionsController;
 
-public class DeleteOptionsTests : DisagnerEndpointsTestsBase<DeleteOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
+public class DeleteOptionsTests : DesignerEndpointsTestsBase<DeleteOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
 {
     public DeleteOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     {
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
index 5433e75ca6c..9321944668d 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
@@ -10,7 +10,7 @@
 
 namespace Designer.Tests.Controllers.OptionsController;
 
-public class GetOptionsTests : DisagnerEndpointsTestsBase<GetOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
+public class GetOptionsTests : DesignerEndpointsTestsBase<GetOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
 {
     public GetOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     {
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
index 883aeb074be..d4fe5662c27 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
@@ -12,7 +12,7 @@
 
 namespace Designer.Tests.Controllers.OptionsController;
 
-public class UpdateOptionsTests : DisagnerEndpointsTestsBase<UpdateOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
+public class UpdateOptionsTests : DesignerEndpointsTestsBase<UpdateOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
 {
     public UpdateOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     {

From 8f94d33b0a8aa3878d6913735e22a6c90186ec12 Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Mon, 8 Jul 2024 11:04:13 +0200
Subject: [PATCH 15/16] dotnet format

---
 .../Controllers/OptionsController/GetOptionsTests.cs            | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
index 9321944668d..32a67e0b16c 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
@@ -20,7 +20,7 @@ public GetOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     public async Task GetOptionsListIds_Returns200OK_WithOptionsListIds()
     {
         // Arrange
-        string[] expectedOptionsListIds =  ["other-options", "test-options"];
+        string[] expectedOptionsListIds = ["other-options", "test-options"];
 
         const string repo = "app-with-options";
         string apiUrl = $"/designer/api/ttd/{repo}/options";

From c5896554a24e70208b04026c4762d0f18d41fb1e Mon Sep 17 00:00:00 2001
From: Erling Hauan <erling.hauan@digdir.no>
Date: Mon, 8 Jul 2024 12:14:05 +0200
Subject: [PATCH 16/16] Fix test
 GetOptionsListIds_Returns200OK_WithOptionsListIds

---
 .../Controllers/OptionsController/GetOptionsTests.cs        | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
index 32a67e0b16c..6406ed2f63f 100644
--- a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Linq;
 using System.Net.Http;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -20,8 +21,6 @@ public GetOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
     public async Task GetOptionsListIds_Returns200OK_WithOptionsListIds()
     {
         // Arrange
-        string[] expectedOptionsListIds = ["other-options", "test-options"];
-
         const string repo = "app-with-options";
         string apiUrl = $"/designer/api/ttd/{repo}/options";
         using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
@@ -33,7 +32,8 @@ public async Task GetOptionsListIds_Returns200OK_WithOptionsListIds()
 
         // Assert
         Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
-        Assert.Equal(expectedOptionsListIds, responseList);
+        Assert.Contains("test-options", responseList);
+        Assert.Contains("other-options", responseList);
     }
 
     [Fact]