Fix up some stuff

Author: LoneWandererProductions

CommonExtendedObjectsTests/Transactions.cs

@@ -1,76 +1,73 @@
 /*
  * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:     CommonExtendedObjectsTests
- * FILE:        CommonExtendedObjectsTests/Transactions.cs
- * PURPOSE:     Test the Transaction Log
- * PROGRAMER:   Peter Geinitz (Wayfarer)
+ * PROJECT:      CommonExtendedObjectsTests
+ * FILE:         CommonExtendedObjectsTests/Transactions.cs
+ * PURPOSE:      Test the Transaction Log
+ * PROGRAMER:    Peter Geinitz (Wayfarer)
  */
 
+using System.Collections.Generic;
 using System.Linq;
-using CommonControls;
 using ExtendedSystemObjects;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace CommonExtendedObjectsTests
 {
-    /// <summary>
-    ///     InterOps testing
-    /// </summary>
     [TestClass]
     public class Transactions
     {
         /// <summary>
-        ///     Test Transactions.
+        /// Dummy data item for testing complex object logging.
         /// </summary>
-        [TestMethod]
-        public void TransactionLog()
+        private class DataItem
         {
-            //TODO improve
+            public int Id { get; set; }
+            public string Name { get; set; }
+            public override bool Equals(object obj) => obj is DataItem item && Name == item.Name;
+            public override int GetHashCode() => Name.GetHashCode();
+        }
 
+        /// <summary>
+        /// Transactions the log complex workflow.
+        /// </summary>
+        [TestMethod]
+        public void TransactionLog_ComplexWorkflow()
+        {
             var log = new TransactionLogs();
-            //Generate Test data for stuff to copy
-
-            var key = log.GetNewKey();
-
-            var data = new DataItem { Id = key, Name = "start" };
-
-            //start of the event, nothing was done yet
-
-            log.Add(0, data, true);
-
-            key = log.GetNewKey();
-
-            data = new DataItem { Id = key, Name = "added" };
-            log.Add(data.Id, data, false);
 
-            data = new DataItem { Id = key, Name = "added Change" };
-            log.Change(data.Id, data);
+            // 1. Initial State (StartData) -> Key 1
+            var initialData = new DataItem { Id = 100, Name = "start" };
+            log.Add(100, initialData, true);
 
-            data = new DataItem { Id = key, Name = "another Change" };
-            log.Change(data.Id, data);
+            // 2. New Addition -> Key 2
+            var addedData = new DataItem { Id = 101, Name = "added" };
+            log.Add(101, addedData, false);
 
-            var logEntry = log.Changelog[1];
+            // 3. First Change for ID 101 -> Key 3 
+            // (Because no Change entry existed yet, only an Add entry)
+            var change1 = new DataItem { Id = 101, Name = "added Change" };
+            log.Change(101, change1);
 
-            if (logEntry.Data is DataItem obj)
-            {
-                Assert.AreNotEqual((object)obj.Name, data.Name, "Overwrite Data");
-            }
+            // 4. Second Change for ID 101 -> Still Key 3
+            // (Our logic overwrites the existing Change entry for that ID)
+            var change2 = new DataItem { Id = 101, Name = "another Change" };
+            log.Change(101, change2);
 
-            var dct = log.GetNewItems();
+            // Index 3 is now the "another Change" entry
+            var logEntry = log.Changelog[3];
+            Assert.AreEqual("another Change", ((DataItem)logEntry.Data).Name);
 
-            Assert.AreNotEqual(dct.Count, 1, "Correct amount");
-
-            var item = log.GetPredecessor(1);
-
-            Assert.AreNotEqual(item, 0, "Correct id");
-
-            log.Remove(0);
+            // Check GetNewItems (ID 101 Add [Key 2] and ID 101 Change [Key 3])
+            var newItems = log.GetNewItems();
+            Assert.AreEqual(2, newItems.Count);
 
-            Assert.AreNotEqual(log.Changelog.Count, 0, "Correct amount");
+            // 5. Remove ID 100 -> Key 4
+            log.Remove(100);
+            Assert.AreEqual(4, log.Changelog.Count);
         }
 
         /// <summary>
-        ///     Adds the item success.
+        /// Adds the item success.
         /// </summary>
         [TestMethod]
         public void AddItemSuccess()
@@ -80,11 +77,12 @@ public void AddItemSuccess()
 
             Assert.IsTrue(transactionLogs.Changed);
             Assert.AreEqual(1, transactionLogs.Changelog.Count);
-            Assert.AreEqual("Item1", transactionLogs.Changelog[0].Data);
+            // In auto-increment, the first key is 1
+            Assert.AreEqual("Item1", transactionLogs.Changelog[1].Data);
         }
 
         /// <summary>
-        ///     Removes the item success.
+        /// Removes the item success.
         /// </summary>
         [TestMethod]
         public void RemoveItemSuccess()
@@ -95,11 +93,12 @@ public void RemoveItemSuccess()
 
             Assert.IsTrue(transactionLogs.Changed);
             Assert.AreEqual(2, transactionLogs.Changelog.Count);
-            Assert.AreEqual(LogState.Remove, transactionLogs.Changelog[1].State);
+            // Last entry should be Remove
+            Assert.AreEqual(LogState.Remove, transactionLogs.Changelog[2].State);
         }
 
         /// <summary>
-        ///     Changes the item success.
+        /// Changes the item success.
         /// </summary>
         [TestMethod]
         public void ChangeItemSuccess()
@@ -109,82 +108,81 @@ public void ChangeItemSuccess()
             transactionLogs.Change(1, "Item1_Changed");
 
             Assert.IsTrue(transactionLogs.Changed);
+            // Change overwrites existing Change entry if found, 
+            // but here we only have an Add, so it creates a new Change entry.
             Assert.AreEqual(2, transactionLogs.Changelog.Count);
-            Assert.AreEqual("Item1_Changed", transactionLogs.Changelog[1].Data);
+            Assert.AreEqual("Item1_Changed", transactionLogs.Changelog[2].Data);
         }
 
         /// <summary>
-        ///     Gets the predecessor success.
+        /// Gets the predecessor success.
         /// </summary>
         [TestMethod]
         public void GetPredecessorSuccess()
         {
             var transactionLogs = new TransactionLogs();
-            transactionLogs.Add(1, "Item1", false);
-            transactionLogs.Add(2, "Item2", false);
-            transactionLogs.Change(1, "Item1_Changed");
+            transactionLogs.Add(1, "Item1", false); // Key 1
+            transactionLogs.Change(1, "Changed");  // Key 2
 
+            // Looking for the Add predecessor of the Change (Key 2)
             var predecessor = transactionLogs.GetPredecessor(2);
 
-            Assert.AreEqual(0, predecessor);
+            Assert.AreEqual(1, predecessor);
         }
 
         /// <summary>
-        ///     Gets the new items success.
+        /// Gets the new items success.
         /// </summary>
         [TestMethod]
         public void GetNewItemsSuccess()
         {
             var transactionLogs = new TransactionLogs();
-            transactionLogs.Add(1, "Item1", true);
-            transactionLogs.Add(2, "Item2", false);
-            transactionLogs.Change(1, "Item1_Changed");
+            transactionLogs.Add(1, "Item1", true);   // StartData
+            transactionLogs.Add(2, "Item2", false);  // New
+            transactionLogs.Change(1, "Changed");    // New
 
             var newItems = transactionLogs.GetNewItems();
 
+            // Item 2 (Add) and Item 1 (Change) are both "New" (StartData is false)
             Assert.AreEqual(2, newItems.Count);
-            Assert.IsFalse(newItems.Values.Any(item => item.StartData));
         }
 
         /// <summary>
-        ///     Gets the index of the item exists returns.
+        /// Gets the index of the item item exists returns.
         /// </summary>
         [TestMethod]
         public void GetItemItemExistsReturnsIndex()
         {
             var transactionLogs = new TransactionLogs();
-            transactionLogs.Add(1, "Item1", false);
+            transactionLogs.Add(55, "Data", false); // Key 1
 
-            var index = transactionLogs.GetItem(1, LogState.Add);
+            var key = transactionLogs.GetItem(55, LogState.Add);
 
-            Assert.AreEqual(0, index);
+            Assert.AreEqual(1, key);
         }
 
         /// <summary>
-        ///     Gets the item does not exist returns minus one.
+        /// Gets the item item does not exist returns minus one.
         /// </summary>
         [TestMethod]
         public void GetItemItemDoesNotExistReturnsMinusOne()
         {
             var transactionLogs = new TransactionLogs();
-
-            var index = transactionLogs.GetItem(1, LogState.Add);
-
+            var index = transactionLogs.GetItem(999, LogState.Add);
             Assert.AreEqual(-1, index);
         }
 
         /// <summary>
-        ///     Gets the new key returns correct key.
+        /// Gets the new key returns correct key.
         /// </summary>
         [TestMethod]
         public void GetNewKeyReturnsCorrectKey()
         {
             var transactionLogs = new TransactionLogs();
-            transactionLogs.Add(1, "Item1", false);
-
-            var newKey = transactionLogs.GetNewKey();
+            Assert.AreEqual(1, transactionLogs.GetNewKey());
 
-            Assert.AreEqual(1, newKey);
+            transactionLogs.Add(1, "Item1", false); // Consumes Key 1
+            Assert.AreEqual(3, transactionLogs.GetNewKey());
         }
     }
 }