Release 1.5.0

.github/copilot-instructions.md

@@ -24,5 +24,15 @@ Unit testing:
 - Use Moq for mocking dependencies in unit tests.
 - Use PascalCase for naming test methods, following the pattern: MethodNameStateUnderTestExpectedBehavior.
 
+Architecture:
+- See `docs/architecture.md` for the architecture index. It links to focused sub-files — read only the one relevant to your task:
+  - `docs/architecture.overview.md` — solution structure, config, patterns, file map
+  - `docs/architecture.validation.md` — validation pipeline, interfaces, extensibility
+  - `docs/architecture.models.md` — models, metadata, dimensions, builders
+  - `docs/architecture.readers.md` — metadata/data readers, binary codecs
+  - `docs/architecture.operations.md` — matrix operations
+  - `docs/architecture.serializers.md` — JSON converters
+  - `docs/architecture.testing.md` — unit tests, mocks, benchmarks
+
 Other:
 - When refactoring code, update the documentation comments to reflect the changes made.

Px.Utils.UnitTests/ModelBuilderTests/ValueParserUtilitiesTests/StringToDimensionTypeTests.cs

@@ -1,7 +1,9 @@
-using Px.Utils.ModelBuilders;
+using Px.Utils.ModelBuilders;
 using Px.Utils.Models.Metadata.Enums;
+using Px.Utils.PxFile;
+using System.Globalization;
 
-namespace ModelBuilderTests.ValueParserUtilitiesTests
+namespace Px.Utils.UnitTests.ModelBuilderTests.ValueParserUtilitiesTests
 {
     [TestClass]
     public class StringToDimensionTypeTests
@@ -16,14 +18,27 @@ public void TimeTest()
         }
 
         [TestMethod]
-        public void ContentTest()
+        public void ContentsTest()
         {
-            string input = "Content";
+            string input = "Contents";
             DimensionType expected = DimensionType.Content;
             DimensionType actual = ValueParserUtilities.StringToDimensionType(input);
             Assert.AreEqual(expected, actual);
         }
 
+        [TestMethod]
+        [DataRow("RANKING", DimensionType.Ordinal)]
+        [DataRow("region", DimensionType.Geographical)]
+        public void CustomAliasTest(string alias, DimensionType expected)
+        {
+            string input = alias.ToUpper(CultureInfo.InvariantCulture); // Testing case-insensitivity
+            PxFileConfiguration conf = PxFileConfiguration.Default;
+            conf.Tokens.VariableTypes.Mappings[alias] = expected; 
+
+            DimensionType actual = ValueParserUtilities.StringToDimensionType(input, conf);
+            Assert.AreEqual(expected, actual);
+        }
+
         [TestMethod]
         public void DefaultValueTest()
         {

Px.Utils.UnitTests/Validation/ContentValidationTests/ContentValidationTests.cs

@@ -2,8 +2,11 @@
 using Px.Utils.Validation;
 using Px.Utils.Validation.ContentValidation;
 using Px.Utils.Validation.SyntaxValidation;
+using Px.Utils.PxFile;
+using Px.Utils.Models.Metadata.Enums;
 using System.Text;
 using System.Reflection;
+using System.Globalization;
 
 namespace Px.Utils.UnitTests.Validation.ContentValidationTests
 {
@@ -536,6 +539,60 @@ public void ValidateValueTypesCalledWithStructuredEntryArrayWithWrongValuesRetur
             }
         }
 
+        [TestMethod]
+        [DataRow("ranking", DimensionType.Ordinal)]
+        [DataRow("REGION", DimensionType.Geographical)]
+        public void ValidateValueContentsCalledWithCustomDimensionTypesValueReturnsWithoutFeedback(string alias, DimensionType dimensionType)
+        {
+            // Arrange
+            PxFileConfiguration conf = PxFileConfiguration.Default;
+            conf.Tokens.VariableTypes.Mappings[alias] = dimensionType;
+
+            ValidationStructuredEntry entry = new(
+                filename,
+                new ValidationStructuredEntryKey("VARIABLE-TYPE", "fi", "foo"),
+                alias.ToUpper(CultureInfo.InvariantCulture), // The value is converted to upper case to verify case insensitivity of the dimension type matching
+                0,
+                [],
+                0,
+                Utils.Validation.ValueType.StringValue);
+
+            ContentValidator validator = new(filename, encoding, [entry], conf: conf);
+
+            // Act
+            ValidationFeedback? result = ContentValidator.ValidateValueContents(entry, validator);
+
+            // Assert
+            Assert.IsNull(result);
+        }
+
+        [TestMethod]
+        public void ValidateValueContentsCalledWithUnknownDimensionTypeValueReturnsWithError()
+        {
+            // Arrange
+            PxFileConfiguration conf = PxFileConfiguration.Default;
+
+            ValidationStructuredEntry entry = new(
+                filename,
+                new ValidationStructuredEntryKey("VARIABLE-TYPE", "fi", "foo"),
+                "Ranking",
+                0,
+                [],
+                0,
+                Utils.Validation.ValueType.StringValue);
+
+            ContentValidator validator = new(filename, encoding, [entry], conf: conf);
+
+            // Act
+            ValidationFeedback? result = ContentValidator.ValidateValueContents(entry, validator);
+
+            // Assert
+            Assert.IsNotNull(result);
+            Assert.HasCount(1, result);
+            Assert.AreEqual(ValidationFeedbackRule.InvalidValueFound, result.First().Key.Rule);
+            Assert.AreEqual(ValidationFeedbackLevel.Error, result.First().Key.Level);
+        }
+
         [TestMethod]
         public void ValidateValueAmountsCalledWithUnmatchingAmountOfElementsReturnsWithError()
         {
@@ -559,6 +616,27 @@ public void ValidateValueAmountsCalledWithUnmatchingAmountOfElementsReturnsWithE
             Assert.AreEqual(ValidationFeedbackRule.UnmatchingValueAmount, result.First().Key.Rule);
         }
 
+        [TestMethod]
+        public void ValidateValueAmountsCalledWithMatchingAmountOfElementsWithListDelimetersReturnsNoError()
+        {
+            // Arrange
+            ValidationStructuredEntry[] entries = [ContentValidationFixtures.StructuredEntryWithMatchingAmountOfElementsWithListDelimeters];
+            ContentValidator validator = new(filename, encoding, entries);
+            SetValidatorField(validator, "_defaultLanguage", defaultLanguage);
+            SetValidatorField(validator, "_availableLanguages", availableLanguages);
+            SetValidatorField(validator, "_stubDimensionNames", stubDimensionNames);
+            SetValidatorField(validator, "_dimensionValueNames", dimensionValueNames);
+
+            // Act
+            ValidationFeedback? result = ContentValidator.ValidateValueAmounts(
+                entries[0],
+                validator
+                );
+
+            // Assert
+            Assert.IsNull(result);
+        }
+
         [TestMethod]
         public void ValidateValueUppercaseRecommendationsCalledWithLowerCaseEntryReturnsWithWarning()
         {