746 lines
26 KiB
Python
746 lines
26 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This file is part of the investment-module from m-ds for Tryton.
|
|
# The COPYRIGHT file at the top level of this repository contains the
|
|
# full copyright notices and license terms.
|
|
|
|
from trytond.tests.test_tryton import ModuleTestCase, with_transaction
|
|
from trytond.pool import Pool
|
|
from trytond.modules.company.tests import create_company
|
|
from trytond.transaction import Transaction
|
|
from decimal import Decimal
|
|
from datetime import time, date, datetime
|
|
|
|
|
|
class AssetTestCase(ModuleTestCase):
|
|
'Test asset module'
|
|
module = 'investment'
|
|
|
|
def prep_asset_company(self):
|
|
""" get/create company
|
|
"""
|
|
Company = Pool().get('company.company')
|
|
|
|
company = Company.search([])
|
|
if len(company) > 0:
|
|
company = company[0]
|
|
else :
|
|
company = create_company(name='m-ds')
|
|
return company
|
|
|
|
def prep_asset_product(self, name='Product 1', description=None, unit='u', unit_name='Units'):
|
|
""" create product
|
|
"""
|
|
pool = Pool()
|
|
Product = pool.get('product.template')
|
|
Uom = pool.get('product.uom')
|
|
|
|
uom, = Uom.search([('symbol', '=', unit)])
|
|
prod_templ, = Product.create([{
|
|
'name': name,
|
|
'type': 'assets',
|
|
'list_price': Decimal('1.0'),
|
|
'default_uom': uom.id,
|
|
'products': [('create', [{
|
|
'description': description,
|
|
}])],
|
|
}])
|
|
self.assertEqual(prod_templ.default_uom.symbol, unit)
|
|
self.assertEqual(prod_templ.products[0].description, description)
|
|
return prod_templ.products[0]
|
|
|
|
def prep_asset_item(self, company, product):
|
|
""" create asset
|
|
"""
|
|
pool = Pool()
|
|
Asset = pool.get('investment.asset')
|
|
|
|
asset, = Asset.create([{
|
|
'company': company.id,
|
|
'product': product.id,
|
|
'currency': company.currency.id,
|
|
'currency_digits': 4,
|
|
'uom': product.default_uom.id,
|
|
}])
|
|
self.assertEqual(asset.rec_name, '%s - - usd/%s [-]' % (
|
|
product.rec_name,
|
|
asset.uom.rec_name,
|
|
))
|
|
self.assertEqual(asset.currency.rec_name, 'usd')
|
|
self.assertEqual(asset.currency_digits, 4)
|
|
self.assertEqual(asset.product.rec_name, product.name)
|
|
self.assertEqual(asset.uom.symbol, product.default_uom.symbol)
|
|
return asset
|
|
|
|
@with_transaction()
|
|
def test_asset_create(self):
|
|
""" create asset
|
|
"""
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
|
|
@with_transaction()
|
|
def test_asset_rec_name(self):
|
|
""" create asset
|
|
"""
|
|
Asset = Pool().get('investment.asset')
|
|
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
|
|
self.assertEqual(asset.rec_name, 'Product 1 - - usd/Unit [-]')
|
|
|
|
Asset.write(*[
|
|
[asset],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 15),
|
|
'rate': Decimal('2.45'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(asset.rec_name, 'Product 1 - 2.4500 usd/Unit [05/15/2022]')
|
|
self.assertEqual(Asset.search_count([('name', '=', 'Product 1')]), 1)
|
|
|
|
@with_transaction()
|
|
def test_asset_percentages_dateselect1(self):
|
|
""" create asset, add rates, check selection of
|
|
specific date - fixed date
|
|
"""
|
|
Asset = Pool().get('investment.asset')
|
|
cursor = Transaction().connection.cursor()
|
|
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset1 = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
self.assertEqual(asset1.rec_name, 'Product 1 - - usd/Unit [-]')
|
|
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 15),
|
|
'rate': Decimal('2.45'),
|
|
}, {
|
|
'date': date(2022, 5, 16),
|
|
'rate': Decimal('2.6'),
|
|
}, {
|
|
'date': date(2022, 5, 12),
|
|
'rate': Decimal('2.0'),
|
|
}, {
|
|
'date': date(2022, 5, 3),
|
|
'rate': Decimal('3.6'),
|
|
}])],
|
|
},
|
|
])
|
|
self.assertEqual(asset1.rec_name, 'Product 1 - 2.6000 usd/Unit [05/16/2022]')
|
|
self.assertEqual(len(asset1.rates), 4)
|
|
self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
|
|
self.assertEqual(asset1.rates[1].date, date(2022, 5, 15))
|
|
self.assertEqual(asset1.rates[2].date, date(2022, 5, 12))
|
|
self.assertEqual(asset1.rates[3].date, date(2022, 5, 3))
|
|
|
|
# query fixed date
|
|
tab_percent = Asset.get_percentage_sql(['day1'], select_date = False)
|
|
query = tab_percent.select(
|
|
tab_percent.id,
|
|
tab_percent.date,
|
|
tab_percent.day1,
|
|
where=(tab_percent.date==date(2022, 5, 16)) & \
|
|
(tab_percent.id==asset1.id),
|
|
)
|
|
cursor.execute(*query)
|
|
records = cursor.fetchall()
|
|
|
|
# there should be one record, three colums
|
|
self.assertEqual(len(records), 1)
|
|
self.assertEqual(len(records[0]), 3)
|
|
self.assertEqual(records[0][0], asset1.id)
|
|
self.assertEqual(records[0][1], date(2022, 5, 16))
|
|
self.assertEqual(records[0][2].quantize(Decimal('0.01')), Decimal('6.12'))
|
|
|
|
@with_transaction()
|
|
def test_asset_percentages_dateselect2(self):
|
|
""" create asset, add rates, check selection of
|
|
specific date - date-column
|
|
"""
|
|
pool = Pool()
|
|
Asset = pool.get('investment.asset')
|
|
Rate = pool.get('investment.rate')
|
|
tab_rate = Rate.__table__()
|
|
cursor = Transaction().connection.cursor()
|
|
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset1 = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
asset2 = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 15),
|
|
'rate': Decimal('2.45'),
|
|
}, {
|
|
'date': date(2022, 5, 16),
|
|
'rate': Decimal('2.6'),
|
|
}, {
|
|
'date': date(2022, 5, 12),
|
|
'rate': Decimal('2.0'),
|
|
}, {
|
|
'date': date(2022, 5, 3),
|
|
'rate': Decimal('3.6'),
|
|
}])],
|
|
},
|
|
[asset2],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 17),
|
|
'rate': Decimal('1.5'),
|
|
}, {
|
|
'date': date(2022, 5, 16),
|
|
'rate': Decimal('2.0'),
|
|
}, {
|
|
'date': date(2022, 5, 15),
|
|
'rate': Decimal('2.5'),
|
|
}, {
|
|
'date': date(2022, 5, 14),
|
|
'rate': Decimal('3.0'),
|
|
}, {
|
|
'date': date(2022, 5, 13),
|
|
'rate': Decimal('3.5'),
|
|
}, {
|
|
'date': date(2022, 5, 12),
|
|
'rate': Decimal('4.0'),
|
|
}, {
|
|
'date': date(2022, 5, 11),
|
|
'rate': Decimal('4.5'),
|
|
}, ])],
|
|
},
|
|
])
|
|
self.assertEqual(asset1.rec_name, 'Product 1 - 2.6000 usd/Unit [05/16/2022]')
|
|
self.assertEqual(len(asset1.rates), 4)
|
|
self.assertEqual(asset2.rec_name, 'Product 1 - 1.5000 usd/Unit [05/17/2022]')
|
|
self.assertEqual(len(asset2.rates), 7)
|
|
self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
|
|
self.assertEqual(asset1.rates[1].date, date(2022, 5, 15))
|
|
self.assertEqual(asset1.rates[2].date, date(2022, 5, 12))
|
|
self.assertEqual(asset1.rates[3].date, date(2022, 5, 3))
|
|
|
|
# query date-column
|
|
tab_percent = Asset.get_percentage_sql(['day1'], select_date = False)
|
|
query = tab_rate.join(tab_percent,
|
|
condition=(tab_percent.id_rate == tab_rate.id)
|
|
).select(
|
|
tab_percent.id,
|
|
tab_percent.date,
|
|
tab_percent.day1,
|
|
where=tab_percent.id==asset1.id,
|
|
order_by=[tab_percent.date.asc]
|
|
)
|
|
cursor.execute(*query)
|
|
records = cursor.fetchall()
|
|
|
|
# there should be 4x records, three colums
|
|
self.assertEqual(len(records), 4)
|
|
self.assertEqual(len(records[0]), 3)
|
|
self.assertEqual(records[0][0], asset1.id)
|
|
self.assertEqual(records[0][1], date(2022, 5, 3))
|
|
self.assertEqual(records[0][2], None)
|
|
|
|
self.assertEqual(records[1][0], asset1.id)
|
|
self.assertEqual(records[1][1], date(2022, 5, 12))
|
|
self.assertEqual(records[1][2], None)
|
|
|
|
self.assertEqual(records[2][0], asset1.id)
|
|
self.assertEqual(records[2][1], date(2022, 5, 15))
|
|
self.assertEqual(records[2][2].quantize(Decimal('0.01')), Decimal('22.5'))
|
|
|
|
self.assertEqual(records[3][0], asset1.id)
|
|
self.assertEqual(records[3][1], date(2022, 5, 16))
|
|
self.assertEqual(records[3][2].quantize(Decimal('0.01')), Decimal('6.12'))
|
|
|
|
@with_transaction()
|
|
def test_asset_percentages_daterange(self):
|
|
""" create asset, add rates, check selection of
|
|
value
|
|
"""
|
|
Asset = Pool().get('investment.asset')
|
|
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset1 = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
asset2 = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
|
|
self.assertEqual(asset1.rec_name, 'Product 1 - - usd/Unit [-]')
|
|
self.assertEqual(asset2.rec_name, 'Product 1 - - usd/Unit [-]')
|
|
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 15),
|
|
'rate': Decimal('2.45'),
|
|
}, {
|
|
'date': date(2022, 5, 16),
|
|
'rate': Decimal('2.6'),
|
|
}])],
|
|
},
|
|
[asset2],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 14),
|
|
'rate': Decimal('5.75'),
|
|
}, {
|
|
'date': date(2022, 5, 15),
|
|
'rate': Decimal('5.25'),
|
|
}])],
|
|
},
|
|
])
|
|
self.assertEqual(asset1.rec_name, 'Product 1 - 2.6000 usd/Unit [05/16/2022]')
|
|
self.assertEqual(asset2.rec_name, 'Product 1 - 5.2500 usd/Unit [05/15/2022]')
|
|
self.assertEqual(asset1.change_day1, Decimal('6.12'))
|
|
self.assertEqual(asset2.change_day1, Decimal('-8.7'))
|
|
self.assertEqual(asset1.change_month1, None)
|
|
self.assertEqual(asset2.change_month1, None)
|
|
self.assertEqual(asset1.change_month3, None)
|
|
self.assertEqual(asset2.change_month3, None)
|
|
self.assertEqual(asset1.change_month6, None)
|
|
self.assertEqual(asset2.change_month6, None)
|
|
self.assertEqual(asset1.change_month12, None)
|
|
self.assertEqual(asset2.change_month12, None)
|
|
|
|
# check ordering
|
|
assets = Asset.search([
|
|
('change_day1', '!=', Decimal('0.0')),
|
|
], order=[('change_day1', 'ASC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].change_day1, Decimal('-8.7'))
|
|
self.assertEqual(assets[1].change_day1, Decimal('6.12'))
|
|
|
|
assets = Asset.search([
|
|
('change_day1', '!=', Decimal('0.0')),
|
|
], order=[('change_day1', 'DESC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].change_day1, Decimal('6.12'))
|
|
self.assertEqual(assets[1].change_day1, Decimal('-8.7'))
|
|
|
|
# check 5-day-range
|
|
# four days
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'rates': [('write', [asset1.rates[1]], {
|
|
'date': date(2022, 5, 12),
|
|
})],
|
|
}])
|
|
self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
|
|
self.assertEqual(asset1.rates[1].date, date(2022, 5, 12))
|
|
self.assertEqual(asset1.change_day1, Decimal('6.12'))
|
|
# five days
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'rates': [('write', [asset1.rates[1]], {
|
|
'date': date(2022, 5, 11),
|
|
})],
|
|
}])
|
|
self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
|
|
self.assertEqual(asset1.rates[1].date, date(2022, 5, 11))
|
|
self.assertEqual(asset1.change_day1, Decimal('6.12'))
|
|
# six days
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'rates': [('write', [asset1.rates[1]], {
|
|
'date': date(2022, 5, 10),
|
|
})],
|
|
}])
|
|
self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
|
|
self.assertEqual(asset1.rates[1].date, date(2022, 5, 10))
|
|
self.assertEqual(asset1.change_day1, None)
|
|
|
|
@with_transaction()
|
|
def test_asset_percentges_values(self):
|
|
""" create asset, add rates, check percentages
|
|
"""
|
|
Asset = Pool().get('investment.asset')
|
|
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset1 = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
|
|
self.assertEqual(asset1.rec_name, 'Product 1 - - usd/Unit [-]')
|
|
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 15),
|
|
'rate': Decimal('2.45'),
|
|
}, {
|
|
'date': date(2022, 5, 16),
|
|
'rate': Decimal('2.6'),
|
|
}, {
|
|
'date': date(2022, 4, 14),
|
|
'rate': Decimal('2.2'),
|
|
}, {
|
|
'date': date(2022, 2, 14),
|
|
'rate': Decimal('2.8'),
|
|
},])],
|
|
}])
|
|
self.assertEqual(asset1.rec_name, 'Product 1 - 2.6000 usd/Unit [05/16/2022]')
|
|
self.assertEqual(len(asset1.rates), 4)
|
|
self.assertEqual(asset1.rates[0].date, date(2022, 5, 16))
|
|
self.assertEqual(asset1.rates[1].date, date(2022, 5, 15))
|
|
self.assertEqual(asset1.rates[2].date, date(2022, 4, 14))
|
|
self.assertEqual(asset1.rates[3].date, date(2022, 2, 14))
|
|
|
|
self.assertEqual(asset1.change_day1, Decimal('6.12'))
|
|
self.assertEqual(asset1.change_month1, Decimal('18.18'))
|
|
self.assertEqual(asset1.change_month3, Decimal('-7.14'))
|
|
self.assertEqual(asset1.change_month6, None)
|
|
self.assertEqual(asset1.change_month12, None)
|
|
|
|
# call order-functions
|
|
Asset.search([], order=[('change_day1', 'ASC')])
|
|
Asset.search([], order=[('change_month1', 'ASC')])
|
|
Asset.search([], order=[('change_month3', 'ASC')])
|
|
Asset.search([], order=[('change_month6', 'ASC')])
|
|
Asset.search([], order=[('change_month12', 'ASC')])
|
|
|
|
# searcher
|
|
self.assertEqual(
|
|
Asset.search_count([('change_day1', '>', Decimal('6.1'))]),
|
|
1)
|
|
self.assertEqual(
|
|
Asset.search_count([('change_day1', '>', Decimal('6.15'))]),
|
|
0)
|
|
self.assertEqual(
|
|
Asset.search_count([('change_day1', '=', Decimal('6.12'))]),
|
|
1)
|
|
|
|
self.assertEqual(
|
|
Asset.search_count([('change_month1', '>', Decimal('18.0'))]),
|
|
1)
|
|
self.assertEqual(
|
|
Asset.search_count([('change_month1', '>', Decimal('18.18'))]),
|
|
0)
|
|
self.assertEqual(
|
|
Asset.search_count([('change_month1', '=', Decimal('18.18'))]),
|
|
1)
|
|
|
|
self.assertEqual(
|
|
Asset.search_count([('change_month3', '=', Decimal('-7.14'))]),
|
|
1)
|
|
self.assertEqual(
|
|
Asset.search_count([('change_month6', '=', None)]),
|
|
1)
|
|
|
|
@with_transaction()
|
|
def test_asset_check_onlinesource_onoff(self):
|
|
""" create asset, switch online-source on/off
|
|
"""
|
|
pool = Pool()
|
|
OnlineSource = pool.get('investment.source')
|
|
Asset = pool.get('investment.asset')
|
|
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
|
|
o_source, = OnlineSource.create([{
|
|
'name': 'Source 1',
|
|
}])
|
|
|
|
self.assertEqual(asset.updtsource, None)
|
|
self.assertEqual(asset.updttime, time(14,0))
|
|
|
|
asset.updtsource = o_source
|
|
asset.updttime = time(10, 45)
|
|
asset.save()
|
|
self.assertEqual(asset.updtsource.rec_name, 'Source 1')
|
|
self.assertEqual(asset.updttime, time(10, 45))
|
|
|
|
asset.updtsource = None
|
|
asset.on_change_updtsource()
|
|
self.assertEqual(asset.updtsource, None)
|
|
self.assertEqual(asset.updttime, None)
|
|
|
|
@with_transaction()
|
|
def test_asset_check_update_select(self):
|
|
""" create asset, add online-source,
|
|
check selection of assets to update
|
|
"""
|
|
pool = Pool()
|
|
OnlineSource = pool.get('investment.source')
|
|
Asset = pool.get('investment.asset')
|
|
|
|
company = self.prep_asset_company()
|
|
product = self.prep_asset_product(
|
|
name='Product 1',
|
|
description='some asset')
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = product)
|
|
|
|
o_source, = OnlineSource.create([{
|
|
'name': 'Source 1',
|
|
}])
|
|
Asset.write(*[
|
|
[asset],
|
|
{
|
|
'updtsource': o_source.id,
|
|
'updttime': time(10, 45),
|
|
}])
|
|
|
|
with Transaction().set_context({
|
|
'qdate': date(2022, 10, 14),
|
|
}):
|
|
# re-read to make context work
|
|
asset2, = Asset.browse([asset.id])
|
|
|
|
self.assertEqual(asset2.updtsource.rec_name, 'Source 1')
|
|
self.assertEqual(asset2.updttime, time(10, 45))
|
|
self.assertEqual(len(asset2.rates), 0)
|
|
self.assertEqual(asset2.nextupdate, datetime(2022, 10, 15, 10, 45))
|
|
|
|
self.assertEqual(
|
|
Asset.search_count([('nextupdate', '<', datetime(2022, 10, 15, 10, 45))]),
|
|
0)
|
|
self.assertEqual(
|
|
Asset.search_count([('nextupdate', '>=', datetime(2022, 10, 15, 10, 45))]),
|
|
1)
|
|
|
|
# add rate at yesterday
|
|
Asset.write(*[
|
|
[asset],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 10, 14),
|
|
'rate': Decimal('1.5'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(len(asset.rates), 1)
|
|
|
|
asset2, = Asset.browse([asset.id])
|
|
self.assertEqual(asset.updtsource.rec_name, 'Source 1')
|
|
self.assertEqual(asset.updttime, time(10, 45))
|
|
self.assertEqual(len(asset.rates), 1)
|
|
self.assertEqual(asset.rates[0].date, date(2022, 10, 14))
|
|
self.assertEqual(asset.nextupdate, datetime(2022, 10, 15, 10, 45))
|
|
|
|
self.assertEqual(
|
|
Asset.search_count([('nextupdate', '<', datetime(2022, 10, 15, 10, 45))]),
|
|
0)
|
|
self.assertEqual(
|
|
Asset.search_count([('nextupdate', '>=', datetime(2022, 10, 15, 10, 45))]),
|
|
1)
|
|
|
|
# add rate at today
|
|
Asset.write(*[
|
|
[asset],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 10, 15),
|
|
'rate': Decimal('1.5'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(len(asset.rates), 2)
|
|
|
|
asset2, = Asset.browse([asset.id])
|
|
self.assertEqual(asset2.updtsource.rec_name, 'Source 1')
|
|
self.assertEqual(asset2.updttime, time(10, 45))
|
|
self.assertEqual(len(asset2.rates), 2)
|
|
self.assertEqual(asset2.rates[0].date, date(2022, 10, 15))
|
|
self.assertEqual(asset2.nextupdate, datetime(2022, 10, 16, 10, 45))
|
|
|
|
self.assertEqual(
|
|
Asset.search_count([('nextupdate', '<', datetime(2022, 10, 15, 10, 45))]),
|
|
0)
|
|
self.assertEqual(
|
|
Asset.search_count([('nextupdate', '>=', datetime(2022, 10, 15, 10, 45))]),
|
|
1)
|
|
|
|
@with_transaction()
|
|
def test_asset_indentifiers(self):
|
|
""" create asset, add identifiers
|
|
"""
|
|
pool = Pool()
|
|
Product = pool.get('product.product')
|
|
Asset = pool.get('investment.asset')
|
|
|
|
company = self.prep_asset_company()
|
|
product1 = self.prep_asset_product(
|
|
name='Product unit', unit='u')
|
|
product2 = self.prep_asset_product(
|
|
name='Product gram', unit='g')
|
|
|
|
asset1 = self.prep_asset_item(
|
|
company=company,
|
|
product = product1)
|
|
asset2 = self.prep_asset_item(
|
|
company=company,
|
|
product = product2)
|
|
|
|
Product.write(*[
|
|
[product1],
|
|
{
|
|
'identifiers': [('create', [{
|
|
'type': 'wkn',
|
|
'code': '965515',
|
|
}, {
|
|
'type': 'secsymb',
|
|
'code': '1472977',
|
|
}, {
|
|
'type': 'isin',
|
|
'code': 'XC0009655157',
|
|
}, ])],
|
|
},
|
|
[product2],
|
|
{
|
|
'identifiers': [('create', [{
|
|
'type': 'wkn',
|
|
'code': '965310',
|
|
}, {
|
|
'type': 'secsymb',
|
|
'code': '1431157',
|
|
}, {
|
|
'type': 'isin',
|
|
'code': 'XC0009653103',
|
|
}, ])],
|
|
},
|
|
])
|
|
|
|
self.assertEqual(asset1.wkn, '965515')
|
|
self.assertEqual(asset1.isin, 'XC0009655157')
|
|
self.assertEqual(asset1.secsymb, '1472977')
|
|
|
|
self.assertEqual(Asset.search_count([('wkn', '=', '965515')]), 1)
|
|
self.assertEqual(Asset.search_count([('isin', '=', 'XC0009655157')]), 1)
|
|
self.assertEqual(Asset.search_count([('secsymb', '=', '1472977')]), 1)
|
|
|
|
self.assertEqual(Asset.search_count([('rec_name', '=', '965515')]), 1)
|
|
self.assertEqual(Asset.search_count([('rec_name', '=', 'XC0009655157')]), 1)
|
|
self.assertEqual(Asset.search_count([('rec_name', '=', '1472977')]), 1)
|
|
|
|
self.assertEqual(Asset.search_count([('name', '=', '965515')]), 1)
|
|
self.assertEqual(Asset.search_count([('name', '=', 'XC0009655157')]), 1)
|
|
self.assertEqual(Asset.search_count([('name', '=', '1472977')]), 1)
|
|
|
|
self.assertEqual(Asset.search_count([('name', '=', 'Product unit')]), 1)
|
|
|
|
self.assertEqual(Asset.search_count([
|
|
('wkn', 'ilike', '9655%'),
|
|
]), 1)
|
|
self.assertEqual(Asset.search_count([
|
|
('wkn', 'ilike', '965%'),
|
|
]), 2)
|
|
|
|
self.assertEqual(asset2.wkn, '965310')
|
|
self.assertEqual(asset2.isin, 'XC0009653103')
|
|
self.assertEqual(asset2.secsymb, '1431157')
|
|
|
|
# order wkn
|
|
assets = Asset.search([], order=[('wkn', 'ASC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].wkn, '965310')
|
|
self.assertEqual(assets[1].wkn, '965515')
|
|
assets = Asset.search([], order=[('wkn', 'DESC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].wkn, '965515')
|
|
self.assertEqual(assets[1].wkn, '965310')
|
|
|
|
# order isin
|
|
assets = Asset.search([], order=[('isin', 'ASC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].isin, 'XC0009653103')
|
|
self.assertEqual(assets[1].isin, 'XC0009655157')
|
|
assets = Asset.search([], order=[('wkn', 'DESC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].isin, 'XC0009655157')
|
|
self.assertEqual(assets[1].isin, 'XC0009653103')
|
|
|
|
# order secsymb
|
|
assets = Asset.search([], order=[('secsymb', 'ASC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].secsymb, '1431157')
|
|
self.assertEqual(assets[1].secsymb, '1472977')
|
|
assets = Asset.search([], order=[('wkn', 'DESC')])
|
|
self.assertEqual(len(assets), 2)
|
|
self.assertEqual(assets[0].secsymb, '1472977')
|
|
self.assertEqual(assets[1].secsymb, '1431157')
|
|
|
|
@with_transaction()
|
|
def test_asset_check_product_update(self):
|
|
""" check update of product on asset
|
|
"""
|
|
company = self.prep_asset_company()
|
|
product1 = self.prep_asset_product(
|
|
name='Product unit', unit='u')
|
|
product2 = self.prep_asset_product(
|
|
name='Product gram', unit='g')
|
|
self.assertEqual(product2.default_uom.digits, 2)
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = product1)
|
|
|
|
self.assertEqual(asset.product.rec_name, 'Product unit')
|
|
self.assertEqual(asset.product.default_uom.rec_name, 'Unit')
|
|
self.assertEqual(asset.uom.rec_name, 'Unit')
|
|
self.assertEqual(asset.currency_digits, 4)
|
|
|
|
asset.product = product2
|
|
asset.on_change_product()
|
|
asset.save()
|
|
|
|
self.assertEqual(asset.product.rec_name, 'Product gram')
|
|
self.assertEqual(asset.product.default_uom.rec_name, 'Gram')
|
|
self.assertEqual(asset.uom.rec_name, 'Gram')
|
|
|
|
asset.on_change_currency()
|
|
asset.save()
|
|
self.assertEqual(asset.currency_digits, 2)
|
|
|
|
# end AssetTestCase
|