def test_it_returns_the_value_of_a_single_account(self):
account = AccountBuilder().set_name("name")\
.set_institution("institution")\
.set_owner("Craig")\
.set_investment("investment")\
.build()
account.import_snapshot(
EpochDateConverter().date_to_epoch("2005-12-10"), 1000)
self.portfolio.import_account(account)
line_graph = LineGraph(self.portfolio)
net_worth_values = line_graph.net_worth_vs_time(
"2005-12-09", "2005-12-11")
self.assertEqual(net_worth_values[0], {
"series": "net-worth",
"date": "2005-12-09",
"value": 0
})
self.assertEqual(net_worth_values[1], {
"series": "net-worth",
"date": "2005-12-10",
"value": 1000
})
self.assertEqual(net_worth_values[2], {
"series": "net-worth",
"date": "2005-12-11",
"value": 1000
})
def test_it_returns_the_debt_to_equity_ratio_for_a_historical_time(self):
asset = AccountBuilder().set_name("name") \
.set_institution("institution") \
.set_owner("owner") \
.set_investment("investment") \
.set_asset_class(AssetClass.NONE) \
.set_account_type(AccountType.ASSET) \
.build()
liability = AccountBuilder().set_name("name") \
.set_institution("institution") \
.set_owner("owner") \
.set_investment("investment") \
.set_asset_class(AssetClass.NONE) \
.set_account_type(AccountType.LIABILITY) \
.build()
timestamp = EpochDateConverter().date_to_epoch()
early_timestamp = timestamp - 200000
query_time = timestamp - 100000
asset.import_snapshot(timestamp, 112233)
liability.import_snapshot(early_timestamp, 223344)
portfolio = Portfolio()
portfolio.import_account(asset)
portfolio.import_account(liability)
self.assertEqual(
PortfolioAnalyzer(portfolio).debt_to_equity(
EpochDateConverter().epoch_to_date(query_time)), 1.0)
def test_it_returns_the_value_of_two_accounts(self):
account_one = AccountBuilder().set_name("name")\
.set_institution("institution")\
.set_owner("Craig")\
.set_investment("investment")\
.build()
account_two = AccountBuilder().set_name("name")\
.set_institution("institution")\
.set_owner("Samuel")\
.set_investment("investment")\
.set_liability()\
.build()
account_one.import_snapshot(
EpochDateConverter().date_to_epoch("2009-10-15"), 10)
account_two.import_snapshot(
EpochDateConverter().date_to_epoch("2009-10-17"), 1000)
self.portfolio.import_account(account_one)
self.portfolio.import_account(account_two)
line_graph = LineGraph(self.portfolio)
net_worth_values = line_graph.net_worth_vs_time(
"2009-10-13", "2009-10-19")
self.assertEqual(net_worth_values[0], {
"series": "net-worth",
"date": "2009-10-13",
"value": 0
})
self.assertEqual(net_worth_values[1], {
"series": "net-worth",
"date": "2009-10-14",
"value": 0
})
self.assertEqual(net_worth_values[2], {
"series": "net-worth",
"date": "2009-10-15",
"value": 10
})
self.assertEqual(net_worth_values[3], {
"series": "net-worth",
"date": "2009-10-16",
"value": 10
})
self.assertEqual(net_worth_values[4], {
"series": "net-worth",
"date": "2009-10-17",
"value": -990
})
self.assertEqual(net_worth_values[5], {
"series": "net-worth",
"date": "2009-10-18",
"value": -990
})
self.assertEqual(net_worth_values[6], {
"series": "net-worth",
"date": "2009-10-19",
"value": -990
})
def test_it_returns_the_debt_to_equity_ratio_for_a_portfolio_with_only_liabilities(
self):
account = AccountBuilder().set_name("name") \
.set_institution("institution") \
.set_owner("owner") \
.set_investment("investment") \
.set_asset_class(AssetClass.NONE) \
.set_account_type(AccountType.LIABILITY) \
.build()
account.import_snapshot(EpochDateConverter().date_to_epoch(), 1234)
portfolio = Portfolio()
portfolio.import_account(account)
self.assertEqual(PortfolioAnalyzer(portfolio).debt_to_equity(), 1.0)
def test_it_returns_two_assets(self):
asset_one = AccountBuilder().set_name("name one") \
.set_owner("owner one") \
.set_investment("investment one") \
.set_institution("institution one") \
.set_update_frequency(5) \
.build()
asset_two = AccountBuilder().set_name("name two") \
.set_owner("owner two") \
.set_investment("investment two") \
.set_institution("institution two") \
.set_update_frequency(3) \
.build()
asset_one.import_snapshot(EpochDateConverter().date_to_epoch('2005-11-12'), 100.50)
asset_two.import_snapshot(EpochDateConverter().date_to_epoch('2000-12-12'), 1289)
self.portfolio.import_account(asset_one)
self.portfolio.import_account(asset_two)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = {"assets": [{"lastUpdated": "2005-11-12T12:00:00-05:00", "institution": "institution one", "owner": "owner one", "account": "name one", "value": 100.50, "investment": "investment one"}, {"lastUpdated": "2000-12-12T12:00:00-05:00", "institution": "institution two", "owner": "owner two", "account": "name two", "value": 1289, "investment": "investment two"}], "liabilities": []}
self.assertEqual(balance_sheet.json(), expected_output)
def test_it_returns_a_list_of_outdated_liabilities(self):
account_one = AccountBuilder().set_name("name one") \
.set_institution("institution") \
.set_owner("owner") \
.set_investment("investment") \
.set_asset_class(AssetClass.NONE) \
.set_account_type(AccountType.LIABILITY) \
.set_update_frequency(10) \
.build()
account_two = AccountBuilder().set_name("name two") \
.set_institution("institution") \
.set_owner("owner") \
.set_investment("investment") \
.set_asset_class(AssetClass.NONE) \
.set_account_type(AccountType.LIABILITY) \
.set_update_frequency(3) \
.build()
timestamp = EpochDateConverter().date_to_epoch() - 7 * Constants.SECONDS_PER_DAY
account_one.import_snapshot(timestamp, 100)
account_two.import_snapshot(timestamp, 100)
self.portfolio.import_account(account_one)
self.portfolio.import_account(account_two)
self.assertEqual(self.portfolio.outdated_liabilities(), [account_two])
def test_it_returns_the_debt_to_equity_ratio_for_a_portfolio_with_a_mixture_of_accounts_in_nonequal_value(
self):
asset = AccountBuilder().set_name("name") \
.set_institution("institution") \
.set_owner("owner") \
.set_investment("investment") \
.set_asset_class(AssetClass.NONE) \
.set_account_type(AccountType.ASSET) \
.build()
liability = AccountBuilder().set_name("name") \
.set_institution("institution") \
.set_owner("owner") \
.set_investment("investment") \
.set_asset_class(AssetClass.NONE) \
.set_account_type(AccountType.LIABILITY) \
.build()
asset.import_snapshot(EpochDateConverter().date_to_epoch(), 1234)
liability.import_snapshot(EpochDateConverter().date_to_epoch(), 12345)
portfolio = Portfolio()
portfolio.import_account(asset)
portfolio.import_account(liability)
self.assertAlmostEqual(
PortfolioAnalyzer(portfolio).debt_to_equity(), 1.1110611)
class BalanceSheetTestCase(unittest.TestCase):
def setUp(self):
self.asset = AccountBuilder().set_name("name") \
.set_owner("owner") \
.set_investment("investment") \
.set_institution("institution") \
.set_update_frequency(3) \
.build()
self.liability = AccountBuilder().set_name("name") \
.set_owner("owner") \
.set_investment("investment") \
.set_institution("institution") \
.set_liability() \
.build()
self.portfolio = Portfolio()
def test_it_returns_a_formatted_row_for_a_balance_sheet(self):
date_difference = Constants.SECONDS_PER_DAY * 2
timestamp = EpochDateConverter().date_to_epoch()
expected_date = EpochDateConverter().epoch_to_date(timestamp - date_difference)
self.asset.import_snapshot(timestamp - date_difference, 100)
balance_sheet_row = BalanceSheet().row(self.asset)
self.assertEqual(balance_sheet_row, [expected_date, "institution", "name", "investment", "owner", "100.00"])
def test_it_returns_an_empty_balance_sheet_if_there_are_no_accounts_in_the_portfolio(self):
balance_sheet = BalanceSheet(self.portfolio)
expected_output = [["---", "---", "---", "---", "---", "---"],
["", "", "", "", "Total", "0.00"]]
self.assertEqual(balance_sheet.create(), expected_output)
def test_it_returns_a_balance_sheet_with_one_asset(self):
self.asset.import_snapshot(EpochDateConverter().date_to_epoch('2017-12-12'), 100)
self.portfolio.import_account(self.asset)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = [["2017-12-12", "institution", "name", "investment", "owner", "100.00"],
["---", "---", "---", "---", "---", "---"],
["", "", "", "", "Total", "100.00"]]
self.assertEqual(balance_sheet.create(), expected_output)
def test_it_returns_a_balance_sheet_with_one_liability(self):
self.liability.import_snapshot(EpochDateConverter().date_to_epoch('2011-1-1'), 500.12)
self.portfolio.import_account(self.liability)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = [["---", "---", "---", "---", "---", "---"],
["2011-01-01", "institution", "name", "investment", "owner", "500.12"],
["", "", "", "", "Total", "-500.12"]]
self.assertEqual(balance_sheet.create(), expected_output)
def test_it_returns_a_balance_sheet_with_an_asset_and_a_liability(self):
self.asset.import_snapshot(EpochDateConverter().date_to_epoch('2017-11-12'), 1020)
self.liability.import_snapshot(EpochDateConverter().date_to_epoch('2013-5-5'), 0.12)
self.portfolio.import_account(self.asset)
self.portfolio.import_account(self.liability)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = [["2017-11-12", "institution", "name", "investment", "owner", "1020.00"],
["---", "---", "---", "---", "---", "---"],
["2013-05-05", "institution", "name", "investment", "owner", "0.12"],
["", "", "", "", "Total", "1019.88"]]
self.assertEqual(balance_sheet.create(), expected_output)
def test_it_returns_no_assets_or_liabilities(self):
balance_sheet = BalanceSheet(self.portfolio)
expected_output = {"assets": [], "liabilities": []}
self.assertEqual(balance_sheet.json(), expected_output)
def test_it_returns_an_asset(self):
self.asset.import_snapshot(EpochDateConverter().date_to_epoch('2017-11-12'), 1020)
self.portfolio.import_account(self.asset)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = {"assets": [{"lastUpdated": "2017-11-12T12:00:00-05:00", "institution": "institution", "owner": "owner", "account": "name", "value": 1020, "investment": "investment"}], "liabilities": []}
self.assertEqual(balance_sheet.json(), expected_output)
def test_it_returns_two_assets(self):
asset_one = AccountBuilder().set_name("name one") \
.set_owner("owner one") \
.set_investment("investment one") \
.set_institution("institution one") \
.set_update_frequency(5) \
.build()
asset_two = AccountBuilder().set_name("name two") \
.set_owner("owner two") \
.set_investment("investment two") \
.set_institution("institution two") \
.set_update_frequency(3) \
.build()
asset_one.import_snapshot(EpochDateConverter().date_to_epoch('2005-11-12'), 100.50)
asset_two.import_snapshot(EpochDateConverter().date_to_epoch('2000-12-12'), 1289)
self.portfolio.import_account(asset_one)
self.portfolio.import_account(asset_two)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = {"assets": [{"lastUpdated": "2005-11-12T12:00:00-05:00", "institution": "institution one", "owner": "owner one", "account": "name one", "value": 100.50, "investment": "investment one"}, {"lastUpdated": "2000-12-12T12:00:00-05:00", "institution": "institution two", "owner": "owner two", "account": "name two", "value": 1289, "investment": "investment two"}], "liabilities": []}
self.assertEqual(balance_sheet.json(), expected_output)
def test_it_returns_a_liability(self):
self.liability.import_snapshot(EpochDateConverter().date_to_epoch('2010-01-10'), 129)
self.portfolio.import_account(self.liability)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = {"assets": [], "liabilities": [{"lastUpdated": "2010-01-10T12:00:00-05:00", "institution": "institution", "owner": "owner", "account": "name", "value": 129, "investment": "investment"}]}
self.assertEqual(balance_sheet.json(), expected_output)
def test_it_returns_two_liabilities(self):
liability_one = AccountBuilder().set_name("name one") \
.set_owner("owner one") \
.set_investment("investment one") \
.set_institution("institution one") \
.set_update_frequency(5) \
.set_liability() \
.build()
liability_two = AccountBuilder().set_name("name two") \
.set_owner("owner two") \
.set_investment("investment two") \
.set_institution("institution two") \
.set_update_frequency(3) \
.set_liability() \
.build()
liability_one.import_snapshot(EpochDateConverter().date_to_epoch('2005-11-12'), 100.50)
liability_two.import_snapshot(EpochDateConverter().date_to_epoch('2000-12-12'), 1289)
self.portfolio.import_account(liability_one)
self.portfolio.import_account(liability_two)
balance_sheet = BalanceSheet(self.portfolio)
expected_output = {"assets": [], "liabilities": [{"lastUpdated": "2005-11-12T12:00:00-05:00", "institution": "institution one", "owner": "owner one", "account": "name one", "value": 100.50, "investment": "investment one"}, {"lastUpdated": "2000-12-12T12:00:00-05:00", "institution": "institution two", "owner": "owner two", "account": "name two", "value": 1289, "investment": "investment two"}]}
self.assertEqual(balance_sheet.json(), expected_output)