add more side-effects

Author: groma84

code/.idea/.idea.CSharpRefactor/.idea/contentModel.xml

@@ -6,27 +6,26 @@
 
 namespace CSharpRefactor.Tests
 {
-    public class InvoicesTest
+    public class InvoicesParserTest
     {
         [Fact]
         public void ReadInvoices__No_Input_Files__Empty_Result()
         {
-            var actual = Invoices.ReadInvoices(new string[] {}, null, () => false);
+            var sut = new InvoicesParser(new string[] {}, null, null);
+            var actual = sut.ReadAndParseInvoices();
             Assert.Empty(actual);
         }
 
         [Fact]
         public void ReadInvoices__Valid_Input_File_No_Discount__Amount_Is_Read()
         {
             const string path = "invoice1.txt";
-            var actual = Invoices.ReadInvoices(new string[]
-            {
-                path
-            }, null, () => false);
+            var sut = new InvoicesParser(new string[] {path}, null, null);
+            var actual = sut.ReadAndParseInvoices();
 
-            var expected = new Dictionary<string, ParseResult>()
+            var expected = new Dictionary<string, InvoiceParseResult>()
             {
-                {path, new ParseResult(42m, null)}
+                {path, new InvoiceParseResult(0, 42m, null)}
             };
 
             Assert.Equal(expected, actual);

code/.idea/.idea.CSharpRefactor/.idea/workspace.xml

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace CSharpRefactor.Tests
+{
+    public class InvoicesSumTest
+    {
+        [Fact]
+        public void Sum__Empty_Input__Zero()
+        {
+            var sut = new InvoiceSum(new InvoiceParseResult[] {});
+            var actual = sut.Sum();
+            var expected = new InvoicesSum(0m, 0m);
+            Assert.Equal(expected, actual);
+        }
+    }
+}

code/CSharpRefactor.Tests/InvoicesTest.cs renamed to code/CSharpRefactor.Tests/InvoicesParserTest.cs

@@ -0,0 +1,70 @@
+namespace CSharpRefactor
+{
+    public class InvoiceParseResult
+    {
+        public int Id;
+        public decimal? Amount;
+        public decimal? DiscountedAmount;
+        public string ErrorText;
+
+        public InvoiceParseResult(int id, decimal? amount, decimal? discountedAmount)
+        {
+            Id = id;
+            Amount = amount;
+            DiscountedAmount = discountedAmount;
+            ErrorText = null;
+        }
+        
+        public InvoiceParseResult(int id, string errorText)
+        {
+            Id = id;
+            Amount = null;
+            DiscountedAmount = null;
+            ErrorText = errorText;
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked // Overflow is fine, just wrap
+            {
+                int hash = 17;
+                hash = hash * 23 + Id.GetHashCode();
+                
+                // Suitable nullity checks etc, of course :)
+                if (Amount.HasValue)
+                {
+                    hash = hash * 23 + Amount.Value.GetHashCode();
+                }
+                
+                if (DiscountedAmount.HasValue)
+                {
+                    hash = hash * 23 + DiscountedAmount.Value.GetHashCode();
+                }
+                
+                if (ErrorText != null)
+                {
+                    hash = hash * 23 + ErrorText.GetHashCode();
+                }
+                return hash;
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            var item = obj as InvoiceParseResult;
+
+            if (item == null)
+            {
+                return false;
+            }
+
+            return 
+                Id.Equals(item.Id)
+                && (Amount.HasValue && item.Amount.HasValue && Amount.Equals(item.Amount))
+                || (!Amount.HasValue && !item.Amount.HasValue)
+                && (DiscountedAmount.HasValue && item.DiscountedAmount.HasValue && DiscountedAmount.Equals(item.DiscountedAmount))
+                || (!DiscountedAmount.HasValue && !item.DiscountedAmount.HasValue)
+                && ErrorText.Equals(item.ErrorText);
+        }
+    }
+}

code/CSharpRefactor.Tests/InvoicesSumTest.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+
+namespace CSharpRefactor
+{
+    public class InvoiceSum
+    {
+        private readonly IEnumerable<InvoiceParseResult> _invoices;
+
+        public InvoiceSum(IEnumerable<InvoiceParseResult> invoices)
+        {
+            _invoices = invoices;
+        }
+
+        public InvoicesSum Sum()
+        {
+            var sum = 0m;
+            var discountedSum = 0m;
+
+            // what should happen if errorText is non-empty, but there is an amount nonetheless?
+            foreach (var invoice in _invoices)
+            {
+                sum += invoice.Amount ?? 0;
+                discountedSum += invoice.DiscountedAmount ?? 0;
+            }
+            
+            return new InvoicesSum(sum, discountedSum);
+        }
+    }
+}