Moved int-string conversion from SortResult to ActionAttributes

ernstaii · ernstaii · commit 47a7122b6917 · 2024-10-11T10:17:51.000+02:00
diff --git a/DsmSuite.DsmViewer.Application.Test/Actions/Base/ActionAttributesTest.cs b/DsmSuite.DsmViewer.Application.Test/Actions/Base/ActionAttributesTest.cs
@@ -89,5 +89,24 @@ public void WhenSetNullableIntIsCalledWitMultipleValuesThenAllValuesAreInDiction
             Assert.IsTrue(data.ContainsKey(key2));
             Assert.AreEqual(memberValue2.ToString(), data[key2]);
         }
+
+        [TestMethod]
+        public void SetListIntTest()
+        {
+            ActionAttributes atts = new ActionAttributes();
+            atts.SetListInt("_empty", new List<int> { } );
+            atts.SetListInt("_single", new List<int> {0});
+            atts.SetListInt("_five", new List<int> {1,2,3,4,5});
+            atts.SetListInt("_dups", new List<int> {5,5,5,5});
+            atts.SetListInt("_many", new List<int> {int.MaxValue,1,0,-1,int.MinValue});
+
+            IReadOnlyDictionary<string, string> data = atts.Data;
+            Assert.AreEqual(5, data.Count);
+            Assert.AreEqual(atts.Data["empty"], "");
+            Assert.AreEqual(atts.Data["single"], "0");
+            Assert.AreEqual(atts.Data["five"], "1,2,3,4,5");
+            Assert.AreEqual(atts.Data["dups"], "5,5,5,5");
+            Assert.AreEqual(atts.Data["many"], "2147483647,1,0,-1,-2147483648");
+        }
     }
 }
diff --git a/DsmSuite.DsmViewer.Application.Test/Actions/Base/ActionReadOnlyAttributesTest.cs b/DsmSuite.DsmViewer.Application.Test/Actions/Base/ActionReadOnlyAttributesTest.cs
@@ -88,5 +88,26 @@ public void GivenMultipleValuesInDictionaryWhenGetValueIsCalledThenAllAreReturne
             Assert.AreEqual(memberValue1, attributes.GetString(memberName1));
             Assert.AreEqual(memberValue2, attributes.GetInt(memberName2));
         }
+
+        [TestMethod]
+        public void GetListIntTest()
+        {
+            Mock<IDsmModel> model = new Mock<IDsmModel>();
+            Dictionary<string, string> data = new Dictionary<string, string>();
+
+            data["empty"] = "";
+            data["single"] = "1";
+            data["five"] = "1,2,3,4,5";
+            data["dups"] = "5,5,5,5";
+            data["many"] = "2147483647,1,0,-1,-2147483648";
+            ActionReadOnlyAttributes atts = new ActionReadOnlyAttributes(model.Object, data);
+            CollectionAssert.AreEqual(new List<int>(), atts.GetListInt("_empty"));
+            CollectionAssert.AreEqual(new List<int>() {1}, atts.GetListInt("_single"));
+            CollectionAssert.AreEqual(new List<int>() {1,2,3,4,5}, atts.GetListInt("_five"));
+            CollectionAssert.AreEqual(new List<int>() {5,5,5,5}, atts.GetListInt("_dups"));
+            CollectionAssert.AreEqual(new List<int>() {int.MaxValue,1,0,-1,int.MinValue}, atts.GetListInt("_many"));
+
+
+        }
     }
 }
diff --git a/DsmSuite.DsmViewer.Application.Test/Actions/Element/ElementSortActionTest.cs b/DsmSuite.DsmViewer.Application.Test/Actions/Element/ElementSortActionTest.cs
@@ -6,6 +6,7 @@
 using DsmSuite.DsmViewer.Application.Sorting;
 using DsmSuite.DsmViewer.Application.Test.Stubs;
 using System;
+using System.Linq;
 
 namespace DsmSuite.DsmViewer.Application.Test.Actions.Element
 {
@@ -20,7 +21,8 @@ public class ElementSortActionTest
         private const int ElementId = 1;
         private const string UsedAlgorithm = "MockedAlgorithm";
         private const string SortResult = "2,0,1";
-        private const string InverseSortResult = "1,2,0";
+        private List<int> SortList = new List<int>() {2, 0, 1};
+        private List<int> InverseSortList = new List<int>() {1, 2, 0};
 
         [TestInitialize()]
         public void Setup()
@@ -48,7 +50,8 @@ public void WhenDoActionThenElementsChildrenAreSorted()
             action.Do();
             Assert.IsTrue(action.IsValid());
 
-            _model.Verify(x => x.ReorderChildren(_element.Object, It.Is<SortResult>(i => i.Data == SortResult)), Times.Once());
+            _model.Verify(x => x.ReorderChildren(_element.Object,
+                    It.Is<SortResult>(i => i.GetOrder().SequenceEqual(SortList))), Times.Once());
         }
 
         [TestMethod]
@@ -59,7 +62,8 @@ public void WhenUndoActionThenElementsChildrenAreSortIsReverted()
             action.Undo();
             Assert.IsTrue(action.IsValid());
 
-            _model.Verify(x => x.ReorderChildren(_element.Object, It.Is<SortResult>(i => i.Data == InverseSortResult)), Times.Once());
+            _model.Verify(x => x.ReorderChildren(_element.Object,
+                    It.Is<SortResult>(i => i.GetOrder().SequenceEqual(InverseSortList))), Times.Once());
         }
 
         [TestMethod]
diff --git a/DsmSuite.DsmViewer.Application.Test/Algorithm/AlphabeticalSortAlgorithmTest.cs b/DsmSuite.DsmViewer.Application.Test/Algorithm/AlphabeticalSortAlgorithmTest.cs
@@ -39,7 +39,7 @@ public void GivenNonSortedElementLIstWhenSortedAlphabeticallyThemElementsAreInAl
             object[] args = { model.Object, parent.Object };
             AlphabeticalSortAlgorithm algorithm = new AlphabeticalSortAlgorithm(args);
             SortResult result = algorithm.Sort();
-            Assert.AreEqual("2,3,0,1", result.Data);
+            CollectionAssert.AreEqual(new List<int>() { 2, 3, 0, 1 }, result.GetOrder());
 
             Assert.AreEqual(a.Object, children[result.GetIndex(0)]);
             Assert.AreEqual(b.Object, children[result.GetIndex(1)]);
diff --git a/DsmSuite.DsmViewer.Application.Test/Algorithm/SortResultTest.cs b/DsmSuite.DsmViewer.Application.Test/Algorithm/SortResultTest.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using DsmSuite.DsmViewer.Application.Sorting;
+using System.Collections.Generic;
 
 namespace DsmSuite.DsmViewer.Application.Test.Algorithm
 {
@@ -26,57 +27,49 @@ public void WhenSortResultConstructedWithNonZeroSizeThenItIsValid()
         }
         
         [TestMethod]
-        public void WhenSortResultConstructedWithEmptyStringThenOrderItIsInvalid()
+        public void WhenSortResultConstructedWithEmptyListThenItIsInvalid()
         {
-            SortResult result = new SortResult("");
-            Assert.IsFalse(result.IsValid);
-        }
-
-        [TestMethod]
-        public void WhenSortResultConstructedWithTextStringThenItIsInvalid()
-        {
-            SortResult result = new SortResult("abc");
+            SortResult result = new SortResult(new List<int>());
             Assert.IsFalse(result.IsValid);
         }
 
         [TestMethod]
         public void WhenSortResultConstructedWithSingleNumberStringThenItIsValid()
         {
-            string input = "0";
-            SortResult result = new SortResult(input);
+            SortResult result = new SortResult( new List<int> {0} );
             Assert.IsTrue(result.IsValid);
             Assert.AreEqual(0, result.GetIndex(0));
         }
 
         [TestMethod]
-        public void WhenSortResultConstructedWithInvalidCommaSeparatedNumberStringThenItIsInvalid()
+        public void WhenSortResultConstructedWithInvalidListThenItIsInvalid()
         {
-            SortResult result = new SortResult("3,1,0");
+            SortResult result = new SortResult( new List<int>() {3, 1, 0} );
             Assert.IsFalse(result.IsValid);
         }
 
         [TestMethod]
-        public void WhenSortResultConstructedWithCommaSeparatedNumberStringThenItIsValid()
+        public void WhenSortResultConstructedWithListThenItIsValid()
         {
-            SortResult result = new SortResult("2,1,0");
+            SortResult result = new SortResult( new List<int>() {2, 1, 0} );
             Assert.IsTrue(result.IsValid);
             Assert.AreEqual(2, result.GetIndex(0));
             Assert.AreEqual(1, result.GetIndex(1));
             Assert.AreEqual(0, result.GetIndex(2));
         }
-        
+
         [TestMethod]
-        public void WhenSortResultConstructedWithCommaSeparatedNumberStringThenDataReturnsSameString()
+        public void SortResultConstructedWithList()
         {
-            string input = "3,2,1,0";
+            List<int> input = new List<int>() {3, 2, 1, 0};
             SortResult result = new SortResult(input);
-            Assert.AreEqual(input, result.Data);
+            CollectionAssert.AreEqual(input, result.GetOrder());
         }
 
         [TestMethod]
         public void WhenSwapWithValidArgumentThenTheOrderIsChanged()
         {
-            SortResult result = new SortResult("2,1,0");
+            SortResult result = new SortResult( new List<int>() {2, 1, 0} );
             Assert.IsTrue(result.IsValid);
             Assert.AreEqual(2, result.GetIndex(0));
             Assert.AreEqual(1, result.GetIndex(1));
@@ -94,7 +87,7 @@ public void WhenSwapWithValidArgumentThenTheOrderIsChanged()
         [ExpectedException(typeof(ArgumentOutOfRangeException))]
         public void WhenSwapWithOutOfBoundArgumentThenExceptionIsThrown()
         {
-            SortResult result = new SortResult("2,1,0");
+            SortResult result = new SortResult( new List<int>() { 2, 1, 0} );
             Assert.IsTrue(result.IsValid);
             Assert.AreEqual(2, result.GetIndex(0));
             Assert.AreEqual(1, result.GetIndex(1));
@@ -106,7 +99,7 @@ public void WhenSwapWithOutOfBoundArgumentThenExceptionIsThrown()
         [TestMethod]
         public void WhenInvertOrderThenTheOrderIsChanged()
         {
-            SortResult result = new SortResult("2,0,1");
+            SortResult result = new SortResult( new List<int>() { 2, 0, 1} );
             Assert.IsTrue(result.IsValid);
             Assert.AreEqual(2, result.GetIndex(0));
             Assert.AreEqual(0, result.GetIndex(1));
@@ -123,7 +116,7 @@ public void WhenInvertOrderThenTheOrderIsChanged()
         [TestMethod]
         public void WhenInvertOrderIsCalledTwiceThenTheOrderIsUnchanged()
         {
-            SortResult result = new SortResult("2,0,1");
+            SortResult result = new SortResult(new List<int>() { 2, 0, 1 });
             Assert.IsTrue(result.IsValid);
             Assert.AreEqual(2, result.GetIndex(0));
             Assert.AreEqual(0, result.GetIndex(1));
@@ -142,7 +135,7 @@ public void WhenInvertOrderIsCalledTwiceThenTheOrderIsUnchanged()
         [ExpectedException(typeof(ArgumentOutOfRangeException))]
         public void WhenGetIndexWithOutOfBoundArgumentThenExceptionIsThrown()
         {
-            SortResult result = new SortResult("2,1,0");
+            SortResult result = new SortResult(new List<int>() { 2, 1, 0 });
             Assert.IsTrue(result.IsValid);
             result.GetIndex(3);
         }
diff --git a/DsmSuite.DsmViewer.Application.Test/Stubs/StubbedSortAlgorithm.cs b/DsmSuite.DsmViewer.Application.Test/Stubs/StubbedSortAlgorithm.cs
@@ -1,10 +1,11 @@
 ﻿using DsmSuite.DsmViewer.Application.Sorting;
+using System.Collections.Generic;
 
 namespace DsmSuite.DsmViewer.Application.Test.Stubs
 {
     public class StubbedSortAlgorithm : ISortAlgorithm
     {
-        private const string SortResult = "2,0,1";
+        private List<int> SortResult = new List<int>() {2,0,1};
 
         public StubbedSortAlgorithm(object[] args) { }
 
diff --git a/DsmSuite.DsmViewer.Application/Actions/Base/ActionAttributes.cs b/DsmSuite.DsmViewer.Application/Actions/Base/ActionAttributes.cs
@@ -1,4 +1,7 @@
-﻿using System.Collections.Generic;
+﻿using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace DsmSuite.DsmViewer.Application.Actions.Base
 {
@@ -29,6 +32,21 @@ public void SetNullableInt(string memberName, int? memberValue)
             }
         }
 
+        public void SetListInt(string memberName, List<int> list)
+        {
+            StringBuilder s = new StringBuilder();
+
+            for (int i = 0; i < list.Count; i++)
+            {
+                s.Append(list[i]);
+                if (i < list.Count - 1)
+                    s.Append(',');
+            }
+
+            _data[RemoveUnderscore(memberName)] = s.ToString();
+        }
+
+
         public IReadOnlyDictionary<string, string> Data => _data;
 
         private static string RemoveUnderscore(string memberName)
diff --git a/DsmSuite.DsmViewer.Application/Actions/Base/ActionReadOnlyAttributes.cs b/DsmSuite.DsmViewer.Application/Actions/Base/ActionReadOnlyAttributes.cs
@@ -1,5 +1,7 @@
-﻿using System.Collections.Generic;
+﻿using System.Collections;
+using System.Collections.Generic;
 using DsmSuite.DsmViewer.Model.Interfaces;
+using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace DsmSuite.DsmViewer.Application.Actions.Base
 {
@@ -38,6 +40,23 @@ public int GetInt(string memberName)
             return value;
         }
 
+        public List<int> GetListInt(string memberName)
+        {
+            List<int> list = new List<int>();
+            string s = _data.GetValueOrDefault(RemoveUnderscore(memberName));
+
+            foreach (string item in s.Split(','))
+            {
+                int value;
+                if (int.TryParse(item, out value))
+                {
+                    list.Add(value);
+                }
+            }
+
+            return list;
+        }
+
         public IDsmElement GetElement(string memberName)
         {
             int id = GetInt(memberName);
diff --git a/DsmSuite.DsmViewer.Application/Actions/Element/ElementSortAction.cs b/DsmSuite.DsmViewer.Application/Actions/Element/ElementSortAction.cs
@@ -13,7 +13,7 @@ public class ElementSortAction : IAction
         private readonly IActionContext _actionContext;
         private readonly IDsmElement _element;
         private readonly string _algorithm;
-        private string _order;
+        private List<int> _order;
 
         public const ActionType RegisteredType = ActionType.ElementSort;
 
@@ -27,7 +27,7 @@ public ElementSortAction(IDsmModel model, IActionContext context, IReadOnlyDicti
 
                 _element = attributes.GetElement(nameof(_element));
                 _algorithm = attributes.GetString(nameof(_algorithm));
-                _order = attributes.GetString(nameof(_order));
+                _order = attributes.GetListInt(nameof(_order));
             }
         }
 
@@ -36,7 +36,7 @@ public ElementSortAction(IDsmModel model, IDsmElement element, string algorithm)
             _model = model;
             _element = element;
             _algorithm = algorithm;
-            _order = "";
+            _order = null;
         }
 
         public ActionType Type => RegisteredType;
@@ -48,7 +48,7 @@ public object Do()
             ISortAlgorithm sortAlgorithm = SortAlgorithmFactory.CreateAlgorithm(_model, _element, _algorithm);
             SortResult sortResult = sortAlgorithm.Sort();
             _model.ReorderChildren(_element, sortResult);
-            _order = sortResult.Data;
+            _order = sortResult.GetOrder();
 
             _model.AssignElementOrder();
 
@@ -79,7 +79,7 @@ public IReadOnlyDictionary<string, string> Data
                 ActionAttributes attributes = new ActionAttributes();
                 attributes.SetInt(nameof(_element), _element.Id);
                 attributes.SetString(nameof(_algorithm), _algorithm);
-                attributes.SetString(nameof(_order), _order);
+                attributes.SetListInt(nameof(_order), _order);
                 return attributes.Data;
             }
         }
diff --git a/DsmSuite.DsmViewer.Application/Sorting/SortResult.cs b/DsmSuite.DsmViewer.Application/Sorting/SortResult.cs

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,11 @@`
`1`	`1`	`using DsmSuite.DsmViewer.Application.Sorting;`
	`2`	`+using System.Collections.Generic;`
`2`	`3`
`3`	`4`	`namespace DsmSuite.DsmViewer.Application.Test.Stubs`
`4`	`5`	`{`
`5`	`6`	`public class StubbedSortAlgorithm : ISortAlgorithm`
`6`	`7`	`{`
`7`		`- private const string SortResult = "2,0,1";`
	`8`	`+ private List<int> SortResult = new List<int>() {2,0,1};`
`8`	`9`
`9`	`10`	`public StubbedSortAlgorithm(object[] args) { }`
`10`	`11`