investment/tests/test_asset.py

# -*- 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]')

    @with_transaction()
    def test_asset_percentges(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)
        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_today, Decimal('6.1'))
        self.assertEqual(asset2.change_today, Decimal('-8.7'))

    @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, None)

        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.nextupdtate, datetime(2022, 10, 15, 10, 45))

            self.assertEqual(
                Asset.search_count([('nextupdtate', '<', datetime(2022, 10, 15, 10, 45))]),
                0)
            self.assertEqual(
                Asset.search_count([('nextupdtate', '>=', 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.nextupdtate, datetime(2022, 10, 15, 10, 45))

        self.assertEqual(
            Asset.search_count([('nextupdtate', '<', datetime(2022, 10, 15, 10, 45))]),
            0)
        self.assertEqual(
            Asset.search_count([('nextupdtate', '>=', 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.nextupdtate, datetime(2022, 10, 16, 10, 45))

        self.assertEqual(
            Asset.search_count([('nextupdtate', '<', datetime(2022, 10, 15, 10, 45))]),
            0)
        self.assertEqual(
            Asset.search_count([('nextupdtate', '>=', 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([
                ('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')

    @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