public void ConvertSingleLocalAccountToDbTypeTest()
        {
            Account localTypeAccount = new Account(2, 34, DateTime.Today,
                                                   new List <Donation>()
            {
                new Donation(101, "reason:101", 12.5, DateTime.Today, ""),
                new Donation(102, "reason:102", 12.5, DateTime.Today, ""),
                new Donation(103, "reason:103", 12.5, DateTime.Today, ""),
                new Donation(104, "reason:104", 12.5, DateTime.Today, ""),
                new Donation(105, "reason:105", 12.5, DateTime.Today, ""),
                new PaidDonation(106, "reason:106", 12.5, DateTime.Today, "", DateTime.Today),
                new PaidDonation(107, "reason:107", 12.5, DateTime.Today, "", DateTime.Today),
                new PaidDonation(108, "reason:108", 12.5, DateTime.Today, "", DateTime.Today),
                new PaidDonation(109, "reason:109", 12.5, DateTime.Today, "", DateTime.Today),
                new PaidDonation(110, "reason:110", 12.5, DateTime.Today, "", DateTime.Today)
            });
            int        personId = 1;
            t_accounts expected = t_accounts.Createt_accounts(2, 1);

            expected.monthly_total   = 34;
            expected.last_month_paid = DateTime.Today;

            t_accounts actual;

            actual = AccountAccess_Accessor.ConvertSingleLocalAccountToDbType(localTypeAccount, personId);
            Assert.AreEqual(expected.C_id, actual.C_id);
            Assert.AreEqual(expected.person_id, actual.person_id);
            Assert.AreEqual(expected.last_month_paid, actual.last_month_paid);
            Assert.AreEqual(expected.monthly_total, actual.monthly_total);
        }
        public void LookupByNonExsistentPersonIdTest()
        {
            int        personId = 0;
            t_accounts expected = null;
            t_accounts actual;

            actual = AccountAccess_Accessor.LookupByPersonId(personId);
            Assert.AreEqual(expected, actual);
        }
        public void LookupByPersonIdTest()
        {
            int        personId = 1;
            t_accounts expected = Cache.CacheData.t_accounts.First(acc => acc.C_id == personId);
            t_accounts actual;

            actual = AccountAccess_Accessor.LookupByPersonId(personId);
            Assert.AreEqual(expected, actual);
        }
        public void LookupByNonExsistentDonationTest()
        {
            Donation   donationToLookBy = new Donation(50, "reason:102", 12.5, DateTime.Today, "");;
            t_accounts expected         = null;
            t_accounts actual;

            actual = AccountAccess_Accessor.LookupByDonation(donationToLookBy);
            Assert.AreEqual(expected, actual);
        }
        public void LookupByDonationTest()
        {
            Donation   donationToLookBy = new Donation(102, "reason:102", 12.5, DateTime.Today, "");
            t_accounts expected         = Cache.CacheData.t_accounts.First(wAcc => wAcc.C_id == 2);
            t_accounts actual;

            actual = AccountAccess_Accessor.LookupByDonation(donationToLookBy);
            Assert.AreEqual(expected, actual);
        }
        public void LookupByNonExsistentDonationIdTest()
        {
            int        donationId = 0;
            t_accounts expected   = null;
            t_accounts actual;

            actual = AccountAccess_Accessor.LookupByDonation(donationId);
            Assert.AreEqual(expected, actual);
        }
        public void LookupByDonationIdTest()
        {
            int        donationId = 105;
            t_accounts expected   = AccountAccess_Accessor.LookupByAccountId(2);
            t_accounts actual;

            actual = AccountAccess_Accessor.LookupByDonation(donationId);
            Assert.AreEqual(expected, actual);
        }
        public void GetAllAccountsTest()
        {
            List <Account> expected = AccountAccess_Accessor.ConvertMultipleDbAccountsToLocalType(
                AccountAccess_Accessor.LookupAllAccounts());
            List <Account> actual;

            actual = AccountAccess.GetAllAccounts();
            CollectionAssert.AreEqual(expected, actual);
        }
        public void LookupByMonthlyPaymentTotalTest()
        {
            int monthlyTotal           = 0;
            List <t_accounts> expected = (from CurrAccount in Cache.CacheData.t_accounts
                                          where CurrAccount.monthly_total == monthlyTotal
                                          select CurrAccount).ToList();
            List <t_accounts> actual;

            actual = AccountAccess_Accessor.LookupByMonthlyPaymentTotal(monthlyTotal);
            CollectionAssert.AreEqual(expected, actual);
        }
        public void LookupByLastMonthlyPaymentDateTest()
        {
            DateTime          lastPayment = DateTime.Today;
            List <t_accounts> expected    = (from currAcc in Cache.CacheData.t_accounts
                                             where currAcc.last_month_paid == lastPayment
                                             select currAcc).ToList();
            List <t_accounts> actual;

            actual = AccountAccess_Accessor.LookupByLastMonthlyPaymentDate(lastPayment);
            CollectionAssert.AreEqual(expected, actual);
        }
        public void LookupByAccountIdTest()
        {
            int        accountId = 10;
            t_accounts expected  = t_accounts.Createt_accounts(10, 1);

            expected.monthly_total   = 0;
            expected.last_month_paid = DateTime.Today;
            t_accounts actual;

            actual = AccountAccess_Accessor.LookupByAccountId(accountId);
            Assert.AreEqual(expected.C_id, actual.C_id);
            Assert.AreEqual(expected.last_month_paid, actual.last_month_paid);
            Assert.AreEqual(expected.monthly_total, actual.monthly_total);
            Assert.AreEqual(expected.person_id, actual.person_id);
        }