✅ Update unit tests for adding to ItemStorageSlots

Fydar · Jan 23, 2020 · cc674db · cc674db
1 parent d112b0b
commit cc674db
Show file tree

Hide file tree

Showing 3 changed files with 121 additions and 53 deletions.
diff --git a/src/RPGCore.Inventories.UnitTests/ItemStorageSlotAddingShould.cs b/src/RPGCore.Inventories.UnitTests/ItemStorageSlotAddingShould.cs
@@ -20,13 +20,15 @@ public void CompleteOnFilledFromEmpty()
 
 			var result = storageSlot.AddItem (itemToAddA);
 
-			var firstTransaction = result.Items[0];
-
-			Assert.AreEqual (TransactionStatus.Complete, result.Status);
-			Assert.AreEqual (10, firstTransaction.Quantity);
-			Assert.AreEqual (itemToAddA, firstTransaction.Item);
-			Assert.AreEqual (null, firstTransaction.FromInventory);
-			Assert.AreEqual (storageSlot, firstTransaction.ToInventory);
+			Assert.That (result.Status, Is.EqualTo(TransactionStatus.Complete));
+			Assert.That (result.Items, Has.Count.EqualTo (1));
+			Assert.That (result.Items[0], Is.EqualTo (new ItemTransaction ()
+			{
+				Quantity = 10, 
+				Item = itemToAddA,
+				FromInventory = null,
+				ToInventory = storageSlot
+			}));
 		}
 
 		[Test, Parallelizable]
@@ -45,13 +47,15 @@ public void CompleteOnFilledFromPartial()
 			storageSlot.AddItem (itemToAddA);
 			var result = storageSlot.AddItem (itemToAddB);
 
-			var firstTransaction = result.Items[0];
-
-			Assert.AreEqual (TransactionStatus.Complete, result.Status);
-			Assert.AreEqual (5, firstTransaction.Quantity);
-			Assert.AreEqual (itemToAddA, firstTransaction.Item);
-			Assert.AreEqual (null, firstTransaction.FromInventory);
-			Assert.AreEqual (storageSlot, firstTransaction.ToInventory);
+			Assert.That (result.Status, Is.EqualTo (TransactionStatus.Complete));
+			Assert.That (result.Items, Has.Count.EqualTo (1));
+			Assert.That (result.Items[0], Is.EqualTo (new ItemTransaction ()
+			{
+				Quantity = 5,
+				Item = itemToAddA,
+				FromInventory = null,
+				ToInventory = storageSlot
+			}));
 		}
 
 		[Test, Parallelizable]
@@ -70,12 +74,18 @@ public void LimitedSlotCapacityForMultipleStackableItems()
 			storageSlot.AddItem (itemToAddA);
 			var result = storageSlot.AddItem (itemToAddB);
 
-			var firstTransaction = result.Items[0];
-
-			Assert.AreEqual (5, itemToAddB.Quantity);
-			Assert.AreEqual (10, ((StackableItem)firstTransaction.Item).Quantity);
-			Assert.AreEqual (null, firstTransaction.FromInventory);
-			Assert.AreEqual (storageSlot, firstTransaction.ToInventory);
+			Assert.That (result.Status, Is.EqualTo (TransactionStatus.Partial));
+			Assert.That (result.Items, Has.Count.EqualTo (1));
+			Assert.That (result.Items[0], Is.EqualTo (new ItemTransaction ()
+			{
+				Quantity = 5,
+				Item = itemToAddA,
+				FromInventory = null,
+				ToInventory = storageSlot
+			}));
+
+			Assert.That (itemToAddB.Quantity, Is.EqualTo(5));
+			Assert.That (((StackableItem)result.Items[0].Item).Quantity, Is.EqualTo(10));
 		}
 
 		[Test, Parallelizable]
@@ -92,14 +102,18 @@ public void LimitedSlotCapacityForSingleStackableItem()
 
 			var result = storageSlot.AddItem (itemToAdd);
 
-			var firstTransaction = result.Items[0];
-
-			Assert.AreEqual (10, firstTransaction.Quantity);
-			Assert.AreEqual (10, ((StackableItem)firstTransaction.Item).Quantity);
-			Assert.AreEqual (null, firstTransaction.FromInventory);
-			Assert.AreEqual (storageSlot, firstTransaction.ToInventory);
-
-			Assert.AreEqual (5, itemToAdd.Quantity);
+			Assert.That (result.Status, Is.EqualTo (TransactionStatus.Partial));
+			Assert.That (result.Items, Has.Count.EqualTo (1));
+			Assert.That (result.Items[0], Is.EqualTo (new ItemTransaction ()
+			{
+				Quantity = 10,
+				Item = storageSlot.CurrentItem,
+				FromInventory = null,
+				ToInventory = storageSlot
+			}));
+
+			Assert.That (itemToAdd.Quantity, Is.EqualTo (5));
+			Assert.That (((StackableItem)result.Items[0].Item).Quantity, Is.EqualTo (10));
 		}
 
 		[Test, Parallelizable]
@@ -114,7 +128,7 @@ public void NoneOnTryAddStackableOfDifferentTypeAddedToOccupiedSlot()
 
 			var result = storageSlot.AddItem (newItem);
 
-			Assert.AreEqual (TransactionStatus.None, result.Status);
+			Assert.That (result, Is.EqualTo (InventoryTransaction.None));
 		}
 
 		[Test, Parallelizable]
@@ -133,7 +147,7 @@ public void NoneOnTryAddToFullStackableSlot()
 			storageSlot.AddItem (itemToAddA);
 			var result = storageSlot.AddItem (itemToAddB);
 
-			Assert.AreEqual (TransactionStatus.None, result.Status);
+			Assert.That (result, Is.EqualTo (InventoryTransaction.None));
 		}
 
 		[Test, Parallelizable]
@@ -148,7 +162,7 @@ public void NoneOnTryAddUniqueItemAddedToOccupiedSlot()
 
 			var result = storageSlot.AddItem (newItem);
 
-			Assert.AreEqual (TransactionStatus.None, result.Status);
+			Assert.That (result, Is.EqualTo (InventoryTransaction.None));
 		}
 
 		[Test, Parallelizable]
@@ -160,11 +174,20 @@ public void StoreStackableItem()
 
 			var result = storageSlot.AddItem (itemToAdd);
 
-			var firstTransaction = result.Items[0];
+			Assert.That (result.Status, Is.EqualTo (TransactionStatus.Complete));
+			Assert.That (result.Items, Has.Count.EqualTo (1));
+			Assert.That (result.Items[0], Is.EqualTo (new ItemTransaction ()
+			{
+				Quantity = 10,
+				Item = itemToAdd,
+				FromInventory = null,
+				ToInventory = storageSlot
+			}));
 
 			Assert.AreEqual (TransactionStatus.Complete, result.Status);
 			Assert.AreEqual (itemToAdd, storageSlot.CurrentItem);
 
+			var firstTransaction = result.Items[0];
 			Assert.AreEqual (null, firstTransaction.FromInventory);
 			Assert.AreEqual (storageSlot, firstTransaction.ToInventory);
 		}
@@ -180,6 +203,16 @@ public void StoreUniqueItem()
 
 			var firstTransaction = result.Items[0];
 
+			Assert.That (result.Status, Is.EqualTo (TransactionStatus.Complete));
+			Assert.That (result.Items, Has.Count.EqualTo (1));
+			Assert.That (result.Items[0], Is.EqualTo (new ItemTransaction ()
+			{
+				Quantity = 1,
+				Item = itemToAdd,
+				FromInventory = null,
+				ToInventory = storageSlot
+			}));
+
 			Assert.AreEqual (TransactionStatus.Complete, result.Status);
 			Assert.AreEqual (itemToAdd, storageSlot.CurrentItem);
 

diff --git a/src/RPGCore.Inventories/ItemTransaction.cs b/src/RPGCore.Inventories/ItemTransaction.cs
@@ -1,8 +1,10 @@
 using RPGCore.Items;
+using System;
+using System.Collections.Generic;
 
 namespace RPGCore.Inventory.Slots
 {
-	public class ItemTransaction
+	public class ItemTransaction : IEquatable<ItemTransaction>
 	{
 		public IItem Item;
 		public IInventory FromInventory;
@@ -42,5 +44,39 @@ private static ItemTransactionType CalculateType(IInventory from, IInventory to)
 				}
 			}
 		}
+
+		public override bool Equals(object obj)
+		{
+			return Equals (obj as ItemTransaction);
+		}
+
+		public bool Equals(ItemTransaction other)
+		{
+			return other != null &&
+				   EqualityComparer<IItem>.Default.Equals (Item, other.Item) &&
+				   EqualityComparer<IInventory>.Default.Equals (FromInventory, other.FromInventory) &&
+				   EqualityComparer<IInventory>.Default.Equals (ToInventory, other.ToInventory) &&
+				   Quantity == other.Quantity;
+		}
+
+		public override int GetHashCode()
+		{
+			int hashCode = -894636067;
+			hashCode = hashCode * -1521134295 + EqualityComparer<IItem>.Default.GetHashCode (Item);
+			hashCode = hashCode * -1521134295 + EqualityComparer<IInventory>.Default.GetHashCode (FromInventory);
+			hashCode = hashCode * -1521134295 + EqualityComparer<IInventory>.Default.GetHashCode (ToInventory);
+			hashCode = hashCode * -1521134295 + Quantity.GetHashCode ();
+			return hashCode;
+		}
+
+		public static bool operator ==(ItemTransaction left, ItemTransaction right)
+		{
+			return EqualityComparer<ItemTransaction>.Default.Equals (left, right);
+		}
+
+		public static bool operator !=(ItemTransaction left, ItemTransaction right)
+		{
+			return !(left == right);
+		}
 	}
 }
diff --git a/src/RPGCore.Inventories/Slots/ItemStorageSlot.cs b/src/RPGCore.Inventories/Slots/ItemStorageSlot.cs
@@ -377,26 +377,23 @@ public InventoryTransaction SetItem(IItem item)
 				throw new ArgumentNullException (nameof (item), "Cannot add \"null\" item to storage slot.");
 			}
 
+			var result = new InventoryTransactionBuilder ();
+
 			int setQuantity = 1;
 			if (item is StackableItem stackableItem)
 			{
 				setQuantity = stackableItem.Quantity;
 			}
 
-			var inventoryTransaction = new InventoryTransaction ()
-			{
-				Status = TransactionStatus.Partial,
-				Items = new List<ItemTransaction> ()
+			result.Add (
+				new ItemTransaction ()
 				{
-					new ItemTransaction()
-					{
-						FromInventory = null,
-						ToInventory = this,
-						Item = item,
-						Quantity = setQuantity
-					}
+					FromInventory = null,
+					ToInventory = this,
+					Item = item,
+					Quantity = setQuantity
 				}
-			};
+			);
 
 			if (storedItem != null)
 			{
@@ -406,18 +403,20 @@ public InventoryTransaction SetItem(IItem item)
 					previousQuantity = stackableStoredItem.Quantity;
 				}
 
-				inventoryTransaction.Items.Add (new ItemTransaction ()
-				{
-					FromInventory = this,
-					ToInventory = null,
-					Item = storedItem,
-					Quantity = previousQuantity
-				});
+				result.Add (
+					new ItemTransaction ()
+					{
+						FromInventory = this,
+						ToInventory = null,
+						Item = storedItem,
+						Quantity = previousQuantity
+					}
+				);
 			}
 
 			storedItem = item;
 
-			return inventoryTransaction;
+			return result.Build (TransactionStatus.Complete);
 		}
 
 		public InventoryTransaction Swap(IItemSlot other)