def setUp(self):
self.categories = [
Income('760', 'Salary'),
Expense('5.5', 'Eating Out'),
Expense('34', 'Clothes'),
Income('50', 'Savings')
]
self.strings = [
'760, Salary, New Income', '5.5, Eating Out, New Expense',
'34, Clothes, New Expense', '50, Savings, New Income'
]
self.strings1 = [
'50, Savings, New Income', '15, Food, New Expense',
'200, Deposit, New Income', '5, Sports, New Expense'
]
self.categories1 = [
Income('50', 'Savings'),
Expense('15', 'Food'),
Income('200', 'Deposit'),
Expense('5', 'Sports')
]
self.aggregator1 = AggregateData({
'=== 22-03-2018 ===': self.strings,
'=== 23-03-2018 ===': self.strings1
})
self.tracker1 = MoneyTracker(self.aggregator1)
def test_when_init_then_make_parsed_lines_into_a_dictionary(self):
test_aggregated = AggregatedMoneyTracker('money_tracker.txt')
expected_result = {
'22-03-2019': {
'Expenses': [
Expense(5.5, 'Eating Out', '22-03-2019'),
Expense(34.0, 'Clothes', '22-03-2019'),
Expense(41.79, 'Food', '22-03-2019'),
Expense(12.0, 'Eating Out', '22-03-2019'),
Expense(7.0, 'House', '22-03-2019'),
Expense(14.0, 'Pets', '22-03-2019'),
Expense(112.4, 'Bills', '22-03-2019'),
Expense(21.5, 'Transport', '22-03-2019')
],
'Incomes': [Income(760.0, 'Salary', '22-03-2019')]
},
'23-03-2019': {
'Expenses': [
Expense(15.0, 'Food', '23-03-2019'),
Expense(5.0, 'Sports', '23-03-2019')
],
'Incomes': [
Income(50.0, 'Savings', '23-03-2019'),
Income(200.0, 'Deposit', '23-03-2019')
]
}
}
self.assertEqual(test_aggregated.records, expected_result)
def test_add_income(self):
with self.subTest("with new date"):
data = self.tracker1.list_user_data()
self.tracker1.add_income("Stipendiq", 100, '22-03-2018')
self.assertTrue(
Income(100, "Stipendiq") in data['=== 22-03-2018 ==='])
with self.subTest("with old date"):
data = self.tracker1.list_user_data()
self.tracker1.add_expense("Tototo", 1.5, '22-03-2018')
self.assertTrue(
Income(1.5, "Tototo") in data['=== 22-03-2018 ==='])
def add_income(self, income_category, money, date):
new_income = Income(money, income_category)
conv_date = self.convert_date(date)
if conv_date in self.data.keys():
self.data[conv_date].append(new_income)
else:
self.data[conv_date] = [new_income]
def test_get_string_with_data(self):
self.assertEqual(MoneyTracker.get_string([1, 2, 3]), '123')
self.assertEqual(
MoneyTracker.get_string(
[Income('salary', 50),
Expense('shoes', 100)]), ('50, salary, New Income\n'
'100, shoes, New Expense\n'))
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_add_income(self):
expected = [
'760, Salary, New Income', '50, Savings, New Income',
'200, Deposit, New Income', '350, Savings, New Income'
]
self.agg.add_income(Income(350, 'Savings', '22-03-2018'))
actual = [str(income) for income in self.agg.incomes]
self.assertEqual(actual, expected)
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 __add_transaction(self, amount, transactionType, category):
if category == "New Income":
return Income(category, amount)
elif category == "New Expense":
return Expense(category, amount)
else:
raise ValueError("Transaction category must be:\n"
"New Income\n"
"New Expense\n")
def generate_categories_from_parser(self):
for item in self.data:
if '===' in item:
date = item.split('===')[1].replace(' ', '')
else:
temp = item.split(', ')
if temp[2] == 'New Income':
if '.' in temp[0]:
income = Income(float(temp[0]), temp[1], date)
else:
income = Income(int(temp[0]), temp[1], date)
self.incomes.append(income)
else:
if '.' in temp[0]:
expense = Expense(float(temp[0]), temp[1], date)
else:
expense = Expense(int(temp[0]), temp[1], date)
self.expenses.append(expense)
def create_database(self):
for line in self.raw_content:
try:
date = datetime.strptime(line, '=== %d-%m-%Y ===')
except ValueError:
amount, label, category = line.split(', ')
cat_obj = Expense(amount, label) if category == 'New Expense' \
else Income(amount, label)
self.database.append([date, cat_obj, cat_obj.CATEGORY_STR])
def __init__(self, content):
self.user_data = {}
for line in content:
if '=' in line:
curr_date = line.strip('=\n ')
self.user_data[curr_date] = {'income': [], 'expense': []}
else:
amount, label, category = line.split(', ')
amount = MoneyTracker.int_or_float(float(amount))
if 'income' in category.lower():
self.user_data[curr_date]['income'].append(Income(amount, label))
elif 'expense' in category.lower():
self.user_data[curr_date]['expense'].append(Expense(amount, label))
def test_add_record_with_date_not_in_dates_dict(self):
dates_dict_result = {
'2018,11,12': {
'income': [Income('salary', 50)],
'expence': [Expense('food', 5)]
},
'2018,11,15': {
'income': [],
'expence': [Expense('shoes', 100)]
},
'2018,11,17': {
'income': [],
'expence': [Expense('clothes', 20)]
},
'2018,5,11': {
'income': [Income('paycheck', 10)],
'expence': []
}
}
self.assertEqual(
ParseMTD.add_record(self.dates_dict, '2018,5,11',
Income('paycheck', 10)),
(dates_dict_result, '2018,5,11'))
def setUp(self):
self.dates_dict = {
'2018,11,12': {
'income': [Income('salary', 50)],
'expence': [Expense('food', 5)]
},
'2018,11,15': {
'income': [],
'expence': [Expense('shoes', 100)]
},
'2018,11,17': {
'income': [],
'expence': [Expense('clothes', 20)]
}
}
def __init__(self, file_name):
self.records = {}
data = Parser.parse_money_tracker_data(file_name)
for line in data:
if line.startswith('==='):
current_date = line[4:-5]
self.records[current_date] = {'Expenses': [], 'Incomes': []}
else:
record = line.split(', ')
if 'Income' in record[2]:
self.records[current_date]['Incomes'].append(
Income(float(record[0]), record[1], current_date))
if 'Expense' in record[2]:
self.records[current_date]['Expenses'].append(
Expense(float(record[0]), record[1], current_date))
def test_add_record_with_date_in_the_dates_dict(self):
dates_dict_result = {
'2018,11,12': {
'income': [Income('salary', 50)],
'expence': [Expense('food', 5),
Expense('computer', 2500)]
},
'2018,11,15': {
'income': [],
'expence': [Expense('shoes', 100)]
},
'2018,11,17': {
'income': [],
'expence': [Expense('clothes', 20)]
}
}
self.assertEqual(
ParseMTD.add_record(self.dates_dict, '2018,11,12',
Expense('computer', 2500)),
(dates_dict_result, '2018,11,12'))
def add_record(self, date_object, amount, label, category):
if category.title() in Income.CATEGORY_STR:
self.database.append([date_object, Income(amount, label), Income.CATEGORY_STR])
elif category.title() in Expense.CATEGORY_STR:
self.database.append([date_object, Expense(amount, label), Expense.CATEGORY_STR])
def test_eq_dunder_when_two_incomes_are_not_equal(self):
test_income1 = Income(320.5, 'Salary', '23-12-2018')
test_income2 = Income(320.5, 'Salary', '23-11-2018')
self.assertFalse(test_income1 == test_income2)
def setUp(self):
self.one = Income(620, "Salary", '22-03-18')
self.two = Income(120, "Savings", '22-03-18')
def test_when_category_then_return_category_cls_attribute(self):
test_income = Income(320.5, 'Salary', '23-12-2018')
expected_result = 'Income'
self.assertEqual(test_income.category, expected_result)
def test_str_dunder(self):
test_income = Income(320.5, 'Salary', '23-12-2018')
expected_result = '320.5, Salary, New Income'
self.assertEqual(str(test_income), expected_result)
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 test_type_init_income(self):
with self.assertRaises(TypeError):
Income([], "", '22-03-18')
Income(12, {}, '22-03-18')
def parse_income(cls, row):
checked_row = cls.income_re.match(row)
if checked_row is None:
return None
parts = checked_row.group().split(', ')
return Income(parts[1], float(parts[0]))
def test_amount_init_income(self):
with self.assertRaises(ValueError):
Income(-15, "", '22-03-18')
def test_eq_income(self):
self.assertNotEqual(self.income, Income('salary', 5))
self.assertNotEqual(self.income, Income('food', 10.55))
self.assertEqual(self.income, Income('salary', 10.55))
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_get_user_income(self):
self.assertEqual(
self.money_tracker.get_user_incomes(),
[Income('salary', 50), Income('clothes', 20)])
def setUp(self):
self.expence = Expense('food', 5)
self.income = Income('salary', 10.55)
def add_income(self, amount, record_type, date):
if date not in self.aggregated_data.records.keys():
self.aggregated_data.records[date] = {'Expenses': [], 'Incomes': []}
self.aggregated_data.records[date]['Incomes'].append(Income(float(amount), record_type, date))
