def setUp(self):
     self.agr_money_tracker = AgregatedMoneyTracker()
     self.agr_money_tracker._data = {
         '2018,11,12': {
             'income': [],
             'expence': [Expense('food', 5)]
         },
         '2018,11,15': {
             'income': [Income('salary', 50)],
             'expence': [Expense('shoes', 100)]
         },
         '2018,11,17': {
             'income': [Income('clothes', 20)],
             'expence': []
         }
     }
예제 #2
0
 def __init__(self, file_name=''):
     self._data_base = AgregatedMoneyTracker(file_name)
예제 #3
0
class MoneyTracker:
    def __init__(self, file_name=''):
        self._data_base = AgregatedMoneyTracker(file_name)

    def list_user_data(self):
        return str(self._data_base)

    def show_user_data_per_date(self, day, month, year):
        date = f'{year:04d},{month:02d},{day:02d}'
        date_expences = self._data_base.get_expences_for_date(date)
        date_income = self._data_base.get_income_for_date(date)
        return self.get_string(date_income + date_expences)

    @staticmethod
    def get_string(data):
        string = ''
        for x in data:
            string = f'{string}{str(x)}'
        return string

    def get_user_incomes(self):
        incomes = []
        for date in self._data_base.get_sorted_dates():
            incomes.extend(self._data_base.get_income_for_date(date))
        return incomes

    def get_user_expences(self):
        expences = []
        for date in self._data_base.get_sorted_dates():
            expences.extend(self._data_base.get_expences_for_date(date))
        return expences

    def show_user_incomes(self):
        return self.get_string(self.get_user_incomes())

    def show_user_expences(self):
        return self.get_string(self.get_user_expences())

    def list_income_categories(self):
        categories = ''
        for income in self.get_user_incomes():
            categories = f'{categories}{income.get_category()}\n'
        return categories

    def list_expence_categories(self):
        categories = ''
        for expence in self.get_user_expences():
            categories = f'{categories}{expence.get_category()}\n'
        return categories

    def list_user_exepences_ordered_by_categories(self):
        ordered_expences = sorted(self.get_user_expences(),
                                  key=lambda expence: expence.get_category())
        return self.get_string(ordered_expences)

    def add_income(self, day, month, year, category, amount):
        date = f'{year:04d},{month:02d},{day:02d}'
        self._data_base.set_record_for_date(date, Income(category, amount))

    def add_expence(self, day, month, year, category, amount):
        date = f'{year:04d},{month:02d},{day:02d}'
        self._data_base.set_record_for_date(date, Expense(category, amount))
class TestsAgregatedMoneyTracker(unittest.TestCase):
    def setUp(self):
        self.agr_money_tracker = AgregatedMoneyTracker()
        self.agr_money_tracker._data = {
            '2018,11,12': {
                'income': [],
                'expence': [Expense('food', 5)]
            },
            '2018,11,15': {
                'income': [Income('salary', 50)],
                'expence': [Expense('shoes', 100)]
            },
            '2018,11,17': {
                'income': [Income('clothes', 20)],
                'expence': []
            }
        }

    def test_get_sorted_dates(self):
        self.assertEqual(self.agr_money_tracker.get_sorted_dates(),
                         ['2018,11,12', '2018,11,15', '2018,11,17'])

    def test_get_date_str_invalid_data(self):
        with self.assertRaises(ValueError):
            AgregatedMoneyTracker.get_date_str('11,12,2018')

    def test_get_date_str_valid_data(self):
        self.assertEqual(AgregatedMoneyTracker.get_date_str('2018,11,12'),
                         '=== 12-11-2018 ===\n')

    def test_str_empty_data(self):
        self.assertEqual(str(AgregatedMoneyTracker()), '')

    def test_str_(self):
        expected_result = ('=== 12-11-2018 ===\n'
                           '5, food, New Expense\n'
                           '=== 15-11-2018 ===\n'
                           '50, salary, New Income\n'
                           '100, shoes, New Expense\n'
                           '=== 17-11-2018 ===\n'
                           '20, clothes, New Income\n')
        self.assertEqual(str(self.agr_money_tracker), expected_result)

    def test_set_record_date_wrong_date_format(self):
        with self.assertRaises(ValueError):
            self.agr_money_tracker.set_record_for_date(
                '12,12,2018', '5, water,'
                'New Expense\n')

    def test_set_record_for_date_with_old_date(self):
        expected_result = {
            '2018,11,12': {
                'income': [],
                'expence': [Expense('food', 5)]
            },
            '2018,11,15': {
                'income': [Income('salary', 50)],
                'expence': [Expense('shoes', 100)]
            },
            '2018,11,17': {
                'income': [Income('clothes', 20)],
                'expence': [Expense('water', 5)]
            }
        }
        self.agr_money_tracker.set_record_for_date('2018,11,17',
                                                   '5, water, New Expense\n')
        self.assertEqual(self.agr_money_tracker._data, expected_result)

    def test_set_record_for_date_with_new_date(self):
        expected_result = {
            '2018,11,12': {
                'income': [],
                'expence': [Expense('food', 5)]
            },
            '2018,11,15': {
                'income': [Income('salary', 50)],
                'expence': [Expense('shoes', 100)]
            },
            '2018,11,17': {
                'income': [Income('clothes', 20)],
                'expence': []
            },
            '2018,12,12': {
                'income': [],
                'expence': [Expense('water', 5)]
            }
        }
        self.agr_money_tracker.set_record_for_date('2018,12,12',
                                                   '5, water, New Expense\n')
        self.assertEqual(self.agr_money_tracker._data, expected_result)

    def test_set_record_for_date_with_Expense_or_Income_new_record(self):
        expected_result = {
            '2018,11,12': {
                'income': [],
                'expence': [Expense('food', 5)]
            },
            '2018,11,15': {
                'income': [Income('salary', 50)],
                'expence': [Expense('shoes', 100)]
            },
            '2018,11,17': {
                'income': [Income('clothes', 20)],
                'expence': []
            },
            '2018,12,12': {
                'income': [],
                'expence': [Expense('water', 5)]
            }
        }
        self.agr_money_tracker.set_record_for_date('2018,12,12',
                                                   Expense('water', 5))
        self.assertEqual(self.agr_money_tracker._data, expected_result)

    def test_get_expences_for_date_date_with_no_records(self):
        self.assertEqual(
            self.agr_money_tracker.get_expences_for_date('2018,'
                                                         '1,1'), [])

    def test_get_expences_for_date_date_with_records(self):
        self.assertEqual(
            self.agr_money_tracker.get_expences_for_date('2018,'
                                                         '11,15'),
            [Expense('shoes', 100)])

    def test_get_income_for_date_date_with_no_records(self):
        self.assertEqual(
            self.agr_money_tracker.get_income_for_date('2018,'
                                                       '1,1'), [])

    def test_get_income_for_date_date_with_records(self):
        self.assertEqual(
            self.agr_money_tracker.get_income_for_date('2018,'
                                                       '11,15'),
            [Income('salary', 50)])
 def test_str_empty_data(self):
     self.assertEqual(str(AgregatedMoneyTracker()), '')
 def test_get_date_str_valid_data(self):
     self.assertEqual(AgregatedMoneyTracker.get_date_str('2018,11,12'),
                      '=== 12-11-2018 ===\n')
 def test_get_date_str_invalid_data(self):
     with self.assertRaises(ValueError):
         AgregatedMoneyTracker.get_date_str('11,12,2018')