public void M_WillFilterActualBankFileForExpenseTransactionsOnly()
        {
            // Arrange
            var mock_bank_and_bank_in_loader = new Mock <IBankAndBankInLoader>();
            var mock_actual_bank_file_io     = new Mock <IFileIO <ActualBankRecord> >();

            mock_actual_bank_file_io.Setup(x => x.Load(It.IsAny <List <string> >(), null))
            .Returns(new List <ActualBankRecord> {
                new ActualBankRecord {
                    Description = $"\"'{ReconConsts.Employer_expense_description}\""
                },
                new ActualBankRecord {
                    Description = "something else"
                }
            });
            var actual_bank_file     = new ActualBankInFile(new CSVFile <ActualBankRecord>(mock_actual_bank_file_io.Object));
            var mock_bank_in_file_io = new Mock <IFileIO <BankRecord> >();

            mock_bank_in_file_io.Setup(x => x.Load(It.IsAny <List <string> >(), null))
            .Returns(new List <BankRecord> {
                new BankRecord {
                    Type = Codes.Expenses, Description = Codes.Expenses + "1"
                }
            });
            var bank_in_file      = new GenericFile <BankRecord>(new CSVFile <BankRecord>(mock_bank_in_file_io.Object));
            var data_loading_info = new DataLoadingInformation <ActualBankRecord, BankRecord> {
                Sheet_name = MainSheetNames.Bank_in
            };
            var reconciliator = new Reconciliator <ActualBankRecord, BankRecord>(data_loading_info, actual_bank_file, bank_in_file);
            var matcher       = new BankAndBankInMatcher(this, new FakeSpreadsheetRepoFactory(), mock_bank_and_bank_in_loader.Object);

            // Act
            matcher.Filter_for_all_expense_transactions_from_actual_bank_in(reconciliator);

            // Assert
            Assert.AreEqual(1, reconciliator.Third_party_file.Records.Count);
            Assert.AreEqual(ReconConsts.Employer_expense_description, reconciliator.Third_party_file.Records[0].Description.Remove_punctuation());
        }
        public void Will_not_lose_previously_matched_records_when_files_are_refreshed()
        {
            // Arrange
            var some_other_actual_bank_description = "Some other ActualBank description";
            var some_other_bank_description        = "Some other bank description";
            var actual_bank_data = new List <ActualBankRecord>
            {
                new ActualBankRecord {
                    Description = ReconConsts.Employer_expense_description
                },
                new ActualBankRecord {
                    Description = some_other_actual_bank_description
                }
            };
            var mock_actual_bank_file_io = new Mock <IFileIO <ActualBankRecord> >();

            mock_actual_bank_file_io.Setup(x => x.Load(It.IsAny <List <string> >(), null)).Returns(actual_bank_data);
            var actual_bank_file = new GenericFile <ActualBankRecord>(new CSVFile <ActualBankRecord>(mock_actual_bank_file_io.Object));
            var bank_data        = new List <BankRecord>
            {
                new BankRecord {
                    Description = "BankRecord01", Type = Codes.Expenses
                },
                new BankRecord {
                    Description = "BankRecord02", Type = Codes.Expenses
                },
                new BankRecord {
                    Description = "BankRecord03", Type = Codes.Expenses
                },
                new BankRecord {
                    Description = some_other_bank_description, Type = "Not an expense"
                }
            };
            var mock_bank_file_io = new Mock <IFileIO <BankRecord> >();

            mock_bank_file_io.Setup(x => x.Load(It.IsAny <List <string> >(), null)).Returns(bank_data);
            var bank_file         = new GenericFile <BankRecord>(new CSVFile <BankRecord>(mock_bank_file_io.Object));
            var data_loading_info = new DataLoadingInformation <ActualBankRecord, BankRecord> {
                Sheet_name = MainSheetNames.Bank_in
            };
            var reconciliator = new Reconciliator <ActualBankRecord, BankRecord>(data_loading_info, actual_bank_file, bank_file);
            var expected_potential_matches = new List <PotentialMatch>
            {
                new PotentialMatch
                {
                    Actual_records = new List <ICSVRecord> {
                        bank_data[0], bank_data[1]
                    },
                    Console_lines = new List <ConsoleLine> {
                        new ConsoleLine {
                            Description_string = "Console Description"
                        }
                    }
                }
            };
            var mock_bank_and_bank_in_loader = new Mock <IBankAndBankInLoader>();
            var matcher = new BankAndBankInMatcher(this, new FakeSpreadsheetRepoFactory(), mock_bank_and_bank_in_loader.Object);

            matcher.Filter_for_all_expense_transactions_from_actual_bank_in(reconciliator);
            matcher.Filter_for_all_wages_rows_and_expense_transactions_from_expected_in(reconciliator);
            reconciliator.Set_match_finder((record, file) => expected_potential_matches);
            reconciliator.Set_record_matcher(matcher.Match_specified_records);
            reconciliator.Find_reconciliation_matches_for_next_third_party_record();
            reconciliator.Match_current_record(0);
            Assert.AreEqual(1, reconciliator.Third_party_file.Records.Count);
            Assert.AreEqual(2, reconciliator.Owned_file.Records.Count);
            Assert.IsFalse(reconciliator.Owned_file.Records[0].Matched);
            Assert.IsTrue(reconciliator.Owned_file.Records[1].Matched);
            Assert.IsTrue(reconciliator.Owned_file.Records[1].Description.Contains(ReconConsts.SeveralExpenses));

            // Act
            reconciliator.Refresh_files();

            // Assert
            Assert.AreEqual(2, reconciliator.Third_party_file.Records.Count);
            Assert.AreEqual(some_other_actual_bank_description, reconciliator.Third_party_file.Records[1].Description);
            Assert.AreEqual(3, reconciliator.Owned_file.Records.Count);
            Assert.IsFalse(reconciliator.Owned_file.Records[0].Matched);
            Assert.AreEqual(some_other_bank_description, reconciliator.Owned_file.Records[1].Description);
            Assert.AreEqual(actual_bank_data[0], reconciliator.Owned_file.Records[2].Match);
            Assert.IsTrue(reconciliator.Owned_file.Records[2].Matched);
            Assert.IsTrue(reconciliator.Owned_file.Records[2].Description.Contains(ReconConsts.SeveralExpenses));
        }