1400 lines
57 KiB
Python
1400 lines
57 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This file is part of the cashbook-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.transaction import Transaction
|
|
from trytond.exceptions import UserError
|
|
from trytond.modules.cashbook.tests import CashbookTestCase
|
|
from trytond.modules.investment.tests import InvestmentTestCase
|
|
from datetime import date
|
|
from decimal import Decimal
|
|
|
|
|
|
class CbInvTestCase(CashbookTestCase, InvestmentTestCase):
|
|
'Test cashbook-investment module'
|
|
module = 'cashbook_investment'
|
|
|
|
@with_transaction()
|
|
def test_assetbook_create(self):
|
|
""" create cashbook, set 'btype' to asset
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
BType = pool.get('cashbook.type')
|
|
|
|
types = self.prep_type()
|
|
company = self.prep_company()
|
|
book, = Book.create([{
|
|
'name': 'Book 1',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
}])
|
|
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
|
|
self.assertEqual(book.name, 'Book 1')
|
|
self.assertEqual(book.rec_name, 'Book 1 | 0.00 usd | Open | 0.0000 -')
|
|
self.assertEqual(book.btype.rec_name, 'CAS - Cash')
|
|
self.assertEqual(book.state, 'open')
|
|
self.assertEqual(book.state_string, 'Open')
|
|
self.assertEqual(book.feature, 'asset')
|
|
self.assertEqual(book.quantity_digits, 4)
|
|
|
|
@with_transaction()
|
|
def test_assetbook_create_line(self):
|
|
""" create cashbook, add line
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
BType = pool.get('cashbook.type')
|
|
Asset = pool.get('investment.asset')
|
|
|
|
types = self.prep_type()
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
category = self.prep_category(cattype='in')
|
|
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
|
|
Asset.write(*[
|
|
[asset],
|
|
{
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'rate': Decimal('2.5'),
|
|
}, {
|
|
'date': date(2022, 5, 2),
|
|
'rate': Decimal('2.8'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(asset.rec_name, 'Product 1 | 2.8000 usd/u | 05/02/2022')
|
|
|
|
(usd, euro) = self.prep_2nd_currency(company)
|
|
self.assertEqual(company.currency.rec_name, 'Euro')
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book, = Book.create([{
|
|
'start_date': date(2022, 4, 1),
|
|
'name': 'Book 1',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': euro.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'quantity_digits': 3,
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'Text 1',
|
|
'category': category.id,
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('2.5'),
|
|
'party': party.id,
|
|
'quantity': Decimal('1.453'),
|
|
}, {
|
|
'date': date(2022, 5, 10),
|
|
'description': 'Text 2',
|
|
'category': category.id,
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('4.0'),
|
|
'party': party.id,
|
|
'quantity': Decimal('3.3'),
|
|
}],
|
|
)],
|
|
}])
|
|
|
|
self.assertEqual(book.name, 'Book 1')
|
|
self.assertEqual(book.rec_name, 'Book 1 | 6.50 € | Open | 4.753 u')
|
|
self.assertEqual(book.state, 'open')
|
|
self.assertEqual(book.feature, 'asset')
|
|
self.assertEqual(book.quantity_digits, 3)
|
|
self.assertEqual(book.balance_all, Decimal('6.5'))
|
|
self.assertEqual(len(book.lines), 2)
|
|
|
|
self.assertEqual(book.lines[0].amount, Decimal('2.5'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.453'))
|
|
self.assertEqual(book.lines[0].quantity_credit, Decimal('1.453'))
|
|
self.assertEqual(book.lines[0].quantity_debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity_digits, 3)
|
|
self.assertEqual(book.lines[0].quantity_uom.symbol, 'u')
|
|
|
|
self.assertEqual(book.lines[1].amount, Decimal('4.0'))
|
|
self.assertEqual(book.lines[1].quantity, Decimal('3.3'))
|
|
self.assertEqual(book.lines[1].quantity_credit, Decimal('3.3'))
|
|
self.assertEqual(book.lines[1].quantity_debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[1].quantity_digits, 3)
|
|
self.assertEqual(book.lines[1].quantity_uom.symbol, 'u')
|
|
|
|
self.assertEqual(book.symbol, '€/u')
|
|
self.assertEqual(book.asset.rec_name, 'Product 1 | 2.8000 usd/u | 05/02/2022')
|
|
|
|
# wf --> check
|
|
Line.wfcheck(book.lines)
|
|
|
|
# check quantities at cashbook
|
|
with Transaction().set_context({
|
|
'qdate': date(2022, 5, 5),
|
|
'company': company.id,
|
|
}):
|
|
book2, = Book.browse([book])
|
|
self.assertEqual(book.asset.rate, Decimal('2.8')) # usd
|
|
self.assertEqual(book2.quantity, Decimal('1.453'))
|
|
self.assertEqual(book2.quantity_all, Decimal('4.753'))
|
|
# 2.8 / 1.05 * 1.453 = 3.87466
|
|
self.assertEqual(book2.current_value, Decimal('3.87'))
|
|
self.assertEqual(book2.current_value_ref, Decimal('3.87'))
|
|
|
|
with Transaction().set_context({
|
|
'qdate': date(2022, 5, 12),
|
|
'company': company.id,
|
|
}):
|
|
book2, = Book.browse([book])
|
|
self.assertEqual(book2.quantity, Decimal('4.753'))
|
|
self.assertEqual(book2.quantity_all, Decimal('4.753'))
|
|
# 2.8 / 1.05 * 4.753 = 12.67466
|
|
self.assertEqual(book2.current_value, Decimal('12.67'))
|
|
self.assertEqual(book2.current_value_ref, Decimal('12.67'))
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_uom_and_currency_convert(self):
|
|
""" asset in US$/Ounce, cashbook in EUR/Gram
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
BType = pool.get('cashbook.type')
|
|
Asset = pool.get('investment.asset')
|
|
ProdTempl = pool.get('product.template')
|
|
Uom = pool.get('product.uom')
|
|
|
|
types = self.prep_type()
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
category = self.prep_category(cattype='in')
|
|
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
|
|
# set product to ounce
|
|
ounce, = Uom.search([('symbol', '=', 'oz')])
|
|
gram, = Uom.search([('symbol', '=', 'g')])
|
|
|
|
ProdTempl.write(*[
|
|
[asset.product.template],
|
|
{
|
|
'default_uom': ounce.id,
|
|
'name': 'Aurum',
|
|
}])
|
|
|
|
Asset.write(*[
|
|
[asset],
|
|
{
|
|
'uom': ounce.id,
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'rate': Decimal('1750.0'),
|
|
}, ])],
|
|
}])
|
|
self.assertEqual(asset.rec_name, 'Aurum | 1,750.0000 usd/oz | 05/01/2022')
|
|
|
|
(usd, euro) = self.prep_2nd_currency(company)
|
|
self.assertEqual(company.currency.rec_name, 'Euro')
|
|
self.assertEqual(asset.symbol, 'usd/oz')
|
|
|
|
book, = Book.create([{
|
|
'start_date': date(2022, 4, 1),
|
|
'name': 'Aurum-Storage',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': euro.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'asset': asset.id,
|
|
'quantity_uom': gram.id,
|
|
'quantity_digits': 3,
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'store some metal',
|
|
'category': category.id,
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('1250.0'),
|
|
'party': party.id,
|
|
'quantity': Decimal('20.0'),
|
|
}],
|
|
)],
|
|
}])
|
|
|
|
self.assertEqual(book.rec_name, 'Aurum-Storage | 1,250.00 € | Open | 20.000 g')
|
|
self.assertEqual(book.balance_all, Decimal('1250.0'))
|
|
self.assertEqual(len(book.lines), 1)
|
|
|
|
self.assertEqual(book.lines[0].amount, Decimal('1250.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('20.0'))
|
|
self.assertEqual(book.lines[0].quantity_uom.symbol, 'g')
|
|
|
|
self.assertEqual(book.symbol, '€/g')
|
|
self.assertEqual(book.asset.rec_name, 'Aurum | 1,750.0000 usd/oz | 05/01/2022')
|
|
|
|
# check quantities at cashbook
|
|
with Transaction().set_context({
|
|
'qdate': date(2022, 5, 1),
|
|
'company': company.id,
|
|
}):
|
|
book2, = Book.browse([book])
|
|
self.assertEqual(book.asset.rate, Decimal('1750.0')) # usd
|
|
self.assertEqual(book2.quantity, Decimal('20.0'))
|
|
self.assertEqual(book2.quantity_all, Decimal('20.0'))
|
|
# usd --> eur: 1750 US$ / 1.05 = 1666.666 €
|
|
# 1 ounce --> 20 gram: 1666.666 € * 20 / 28.3495 = 1175.7996 €
|
|
# bette we use 'Troy Ounce': 1 oz.tr. = 31.1034768 gram
|
|
self.assertEqual(book2.current_value, Decimal('1175.80'))
|
|
self.assertEqual(book2.current_value_ref, Decimal('1175.80'))
|
|
self.assertEqual(book2.diff_amount, Decimal('-74.20'))
|
|
self.assertEqual(book2.diff_percent, Decimal('-5.94'))
|
|
self.assertEqual(book2.current_rate, Decimal('58.79'))
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_uom_and_currency_convert2(self):
|
|
""" asset in US$/Ounce, cashbook in CHF/Gram,
|
|
company-currency EUR
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
BType = pool.get('cashbook.type')
|
|
Asset = pool.get('investment.asset')
|
|
ProdTempl = pool.get('product.template')
|
|
Uom = pool.get('product.uom')
|
|
Currency = pool.get('currency.currency')
|
|
|
|
types = self.prep_type()
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
category = self.prep_category(cattype='in')
|
|
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
|
|
# set product to ounce
|
|
ounce, = Uom.search([('symbol', '=', 'oz')])
|
|
gram, = Uom.search([('symbol', '=', 'g')])
|
|
|
|
ProdTempl.write(*[
|
|
[asset.product.template],
|
|
{
|
|
'default_uom': ounce.id,
|
|
'name': 'Aurum',
|
|
}])
|
|
|
|
Asset.write(*[
|
|
[asset],
|
|
{
|
|
'uom': ounce.id,
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'rate': Decimal('1750.0'),
|
|
}, ])],
|
|
}])
|
|
self.assertEqual(asset.rec_name, 'Aurum | 1,750.0000 usd/oz | 05/01/2022')
|
|
|
|
(usd, euro) = self.prep_2nd_currency(company)
|
|
self.assertEqual(company.currency.rec_name, 'Euro')
|
|
self.assertEqual(asset.symbol, 'usd/oz')
|
|
chf, = Currency.create([{
|
|
'name': 'Swiss Franc',
|
|
'code': 'CHF',
|
|
'numeric_code': '756',
|
|
'symbol': 'CHF',
|
|
'rounding': Decimal('0.01'),
|
|
'digits': 2,
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'rate': Decimal('0.95'),
|
|
}])],
|
|
}])
|
|
|
|
book, = Book.create([{
|
|
'start_date': date(2022, 4, 1),
|
|
'name': 'Aurum-Storage',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': chf.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'asset': asset.id,
|
|
'quantity_uom': gram.id,
|
|
'quantity_digits': 3,
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'store some metal',
|
|
'category': category.id,
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('1250.0'),
|
|
'party': party.id,
|
|
'quantity': Decimal('20.0'),
|
|
}],
|
|
)],
|
|
}])
|
|
|
|
self.assertEqual(book.rec_name, 'Aurum-Storage | 1,250.00 CHF | Open | 20.000 g')
|
|
self.assertEqual(book.balance_all, Decimal('1250.0'))
|
|
self.assertEqual(len(book.lines), 1)
|
|
|
|
self.assertEqual(book.lines[0].amount, Decimal('1250.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('20.0'))
|
|
self.assertEqual(book.lines[0].quantity_uom.symbol, 'g')
|
|
|
|
self.assertEqual(book.symbol, 'CHF/g')
|
|
self.assertEqual(book.asset.rec_name, 'Aurum | 1,750.0000 usd/oz | 05/01/2022')
|
|
|
|
# check quantities at cashbook
|
|
with Transaction().set_context({
|
|
'qdate': date(2022, 5, 1),
|
|
'company': company.id,
|
|
}):
|
|
book2, = Book.browse([book])
|
|
self.assertEqual(book.asset.rate, Decimal('1750.0')) # usd
|
|
self.assertEqual(book2.quantity, Decimal('20.0'))
|
|
self.assertEqual(book2.quantity_all, Decimal('20.0'))
|
|
# usd --> chf: 1750 US$ * 0.95 / 1.05 = 1583.333 €
|
|
# 1 ounce --> 20 gram: 1583.333 CHF * 20 / 28.3495 = 1117.0097 CHF
|
|
self.assertEqual(book2.current_value, Decimal('1117.01')) # CHF
|
|
self.assertEqual(book2.current_value_ref, Decimal('1175.80')) # EUR
|
|
self.assertEqual(book2.diff_amount, Decimal('-132.99'))
|
|
self.assertEqual(book2.diff_percent, Decimal('-10.64'))
|
|
self.assertEqual(book2.current_rate, Decimal('55.85'))
|
|
|
|
@with_transaction()
|
|
def test_assetbook_book_uom(self):
|
|
""" check default auf uom
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
BType = pool.get('cashbook.type')
|
|
|
|
company = self.prep_company()
|
|
types = self.prep_type()
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
'name': 'Asset',
|
|
'short': 'A',
|
|
}])
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book = Book(
|
|
asset = asset,
|
|
quantity_uom = None,
|
|
)
|
|
self.assertEqual(book.quantity_uom, None)
|
|
book.on_change_asset()
|
|
self.assertEqual(book.quantity_uom.rec_name, 'Unit')
|
|
|
|
@with_transaction()
|
|
def test_assetbook_book_with_asset(self):
|
|
""" create cashbook, set 'btype' to asset
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
BType = pool.get('cashbook.type')
|
|
|
|
company = self.prep_company()
|
|
types = self.prep_type()
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
'name': 'Asset',
|
|
'short': 'A',
|
|
}])
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book, = Book.create([{
|
|
'name': 'Book 1',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
}])
|
|
|
|
self.assertEqual(book.name, 'Book 1')
|
|
self.assertEqual(book.rec_name, 'Book 1 | 0.00 usd | Open | 0.0000 u')
|
|
self.assertEqual(book.btype.rec_name, 'A - Asset')
|
|
self.assertEqual(book.state, 'open')
|
|
self.assertEqual(book.feature, 'asset')
|
|
self.assertEqual(book.asset.rec_name, 'Product 1 | - usd/u | -')
|
|
self.assertEqual(book.quantity_uom.rec_name, 'Unit')
|
|
|
|
self.assertRaisesRegex(UserError,
|
|
'A value is required for field "Asset" in "Cashbook".',
|
|
Book.write,
|
|
*[
|
|
[book],
|
|
{
|
|
'asset': None,
|
|
}
|
|
])
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_sign_mismatch(self):
|
|
""" create cashbook + line, bookingtype 'in',
|
|
check detection of sign mismatch between quantity and amount
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
Category = pool.get('cashbook.category')
|
|
BType = pool.get('cashbook.type')
|
|
|
|
type_depot = self.prep_type('Depot', 'D')
|
|
BType.write(*[
|
|
[type_depot],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
|
|
category_in = self.prep_category(cattype='in')
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book, = Book.create([{
|
|
'name': 'Asset-Book',
|
|
'btype': type_depot.id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'buy some',
|
|
'category': category_in.id,
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('1.0'),
|
|
'quantity': Decimal('1.5'),
|
|
}])],
|
|
}])
|
|
|
|
self.assertEqual(book.rec_name, 'Asset-Book | 1.00 usd | Open | 1.5000 u')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].credit, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_debit, Decimal('0.0'))
|
|
|
|
self.assertRaisesRegex(UserError,
|
|
"Quantity and Amount must with same sign for line 05/01/2022|Rev|1.00 usd|buy some [Cat1].",
|
|
Book.write,
|
|
*[
|
|
[book],
|
|
{
|
|
'lines': [('write', [book.lines[0]], {
|
|
'quantity': Decimal('-1.5'),
|
|
})],
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_mvout(self):
|
|
""" create cashbook + line, bookingtype 'mvout'
|
|
transfer from cash to depot (buy asset, pay from cash)
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
Category = pool.get('cashbook.category')
|
|
BType = pool.get('cashbook.type')
|
|
|
|
type_cash = self.prep_type()
|
|
type_depot = self.prep_type('Depot', 'D')
|
|
BType.write(*[
|
|
[type_depot],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
|
|
category_in = self.prep_category(cattype='in')
|
|
category_out = self.prep_category(name='Out Category', cattype='out')
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book2, = Book.create([{
|
|
'name': 'Asset-Book',
|
|
'btype': type_depot.id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
}])
|
|
|
|
book, = Book.create([{
|
|
'name': 'Book 1',
|
|
'btype': type_cash.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'Transfer Out',
|
|
'category': category_out.id,
|
|
'bookingtype': 'mvout',
|
|
'amount': Decimal('1.0'),
|
|
'booktransf': book2.id,
|
|
'quantity': Decimal('1.5'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(book.rec_name, 'Book 1 | -1.00 usd | Open')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, None)
|
|
self.assertEqual(book.lines[0].quantity_debit, None)
|
|
self.assertEqual(book.lines[0].feature, 'gen')
|
|
self.assertEqual(book.lines[0].booktransf_feature, 'asset')
|
|
self.assertEqual(len(book2.lines), 0)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|to|-1.00 usd|Transfer Out [Asset-Book | 0.00 usd | Open | 0.0000 u]')
|
|
self.assertEqual(len(book.lines[0].references), 0)
|
|
|
|
# update quantity
|
|
Book.write(*[
|
|
[book],
|
|
{
|
|
'lines': [('write', [book.lines[0]], {'quantity': Decimal('2.5')})],
|
|
}])
|
|
self.assertEqual(book.lines[0].quantity, Decimal('2.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, None)
|
|
self.assertEqual(book.lines[0].quantity_debit, None)
|
|
|
|
# check counterpart
|
|
self.assertEqual(book.lines[0].booktransf.rec_name, 'Asset-Book | 0.00 usd | Open | 0.0000 u')
|
|
self.assertEqual(book.lines[0].booktransf.btype.feature, 'asset')
|
|
self.assertEqual(book.lines[0].booktransf_feature, 'asset')
|
|
|
|
# set line to 'checked', this creates the counterpart
|
|
Line.wfcheck(list(book.lines))
|
|
|
|
self.assertEqual(book.rec_name, 'Book 1 | -1.00 usd | Open')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|to|-1.00 usd|Transfer Out [Asset-Book | 1.00 usd | Open | 2.5000 u]')
|
|
self.assertEqual(book.lines[0].state, 'check')
|
|
self.assertEqual(book.lines[0].bookingtype, 'mvout')
|
|
self.assertEqual(book.lines[0].feature, 'gen')
|
|
self.assertEqual(book.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].credit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].debit, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('2.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, None) # feature != asset
|
|
self.assertEqual(book.lines[0].quantity_debit, None) # --> no quantity-credit/debit
|
|
self.assertEqual(book.lines[0].quantity_2nd_uom, None)
|
|
self.assertEqual(book.lines[0].factor_2nd_uom, None)
|
|
self.assertEqual(book.lines[0].quantity2nd, None)
|
|
self.assertEqual(book.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(len(book.lines[0].references), 1)
|
|
self.assertEqual(book.lines[0].reference, None)
|
|
self.assertEqual(book.lines[0].references[0].id, book2.lines[0].id)
|
|
|
|
self.assertEqual(book2.rec_name, 'Asset-Book | 1.00 usd | Open | 2.5000 u')
|
|
self.assertEqual(len(book2.lines), 1)
|
|
self.assertEqual(book2.lines[0].rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer Out [Book 1 | -1.00 usd | Open]|2.5000 u')
|
|
self.assertEqual(book2.lines[0].state, 'check')
|
|
self.assertEqual(book2.lines[0].bookingtype, 'mvin')
|
|
self.assertEqual(book2.lines[0].feature, 'asset')
|
|
self.assertEqual(book2.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].credit, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].debit, Decimal('0.0'))
|
|
self.assertEqual(book2.lines[0].quantity, Decimal('2.5'))
|
|
self.assertEqual(book2.lines[0].quantity_credit, Decimal('2.5')) # feature=asset
|
|
self.assertEqual(book2.lines[0].quantity_debit, Decimal('0.0')) # needs quantity-credit/debit
|
|
self.assertEqual(book2.lines[0].quantity_2nd_uom, None)
|
|
self.assertEqual(book2.lines[0].factor_2nd_uom, None)
|
|
self.assertEqual(book2.lines[0].quantity2nd, None)
|
|
self.assertEqual(book2.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(book2.lines[0].asset_rate, Decimal('0.4'))
|
|
self.assertEqual(book2.lines[0].reference.rec_name,
|
|
'05/01/2022|to|-1.00 usd|Transfer Out [Asset-Book | 1.00 usd | Open | 2.5000 u]')
|
|
self.assertEqual(len(book2.lines[0].references), 0)
|
|
|
|
l1 = list(book.lines)
|
|
l1.append(Line(
|
|
bookingtype = 'mvout',
|
|
amount = Decimal('2.5'),
|
|
quantity = Decimal('2.5'),
|
|
booktransf = book2,
|
|
))
|
|
book.lines = l1
|
|
book.lines[-1].on_change_quantity()
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_mvin(self):
|
|
""" create cashbook + line, bookingtype 'mvin'
|
|
transfer from depot to cash (sell asset, transfer to cash)
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
Category = pool.get('cashbook.category')
|
|
BType = pool.get('cashbook.type')
|
|
|
|
type_cash = self.prep_type()
|
|
type_depot = self.prep_type('Depot', 'D')
|
|
BType.write(*[
|
|
[type_depot],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
|
|
category_in = self.prep_category(cattype='in')
|
|
category_out = self.prep_category(name='Out Category', cattype='out')
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book2, = Book.create([{
|
|
'name': 'Asset-Book',
|
|
'btype': type_depot.id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
}])
|
|
|
|
book, = Book.create([{
|
|
'name': 'Book 1',
|
|
'btype': type_cash.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'Transfer In',
|
|
'category': category_out.id,
|
|
'bookingtype': 'mvin',
|
|
'amount': Decimal('1.0'),
|
|
'booktransf': book2.id,
|
|
'quantity': Decimal('1.5'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(book.rec_name, 'Book 1 | 1.00 usd | Open')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, None)
|
|
self.assertEqual(book.lines[0].quantity_debit, None)
|
|
self.assertEqual(book.lines[0].feature, 'gen')
|
|
self.assertEqual(book.lines[0].booktransf_feature, 'asset')
|
|
self.assertEqual(book.lines[0].splitline_has_quantity, False)
|
|
self.assertEqual(len(book2.lines), 0)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book | 0.00 usd | Open | 0.0000 u]')
|
|
self.assertEqual(len(book.lines[0].references), 0)
|
|
|
|
# check counterpart
|
|
self.assertEqual(book.lines[0].booktransf.rec_name, 'Asset-Book | 0.00 usd | Open | 0.0000 u')
|
|
self.assertEqual(book.lines[0].booktransf.btype.feature, 'asset')
|
|
self.assertEqual(book.lines[0].booktransf_feature, 'asset')
|
|
|
|
# set line to 'checked', this creates the counterpart
|
|
Line.wfcheck(list(book.lines))
|
|
|
|
self.assertEqual(book.rec_name, 'Book 1 | 1.00 usd | Open')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book | -1.00 usd | Open | -1.5000 u]')
|
|
self.assertEqual(book.lines[0].state, 'check')
|
|
self.assertEqual(book.lines[0].bookingtype, 'mvin')
|
|
self.assertEqual(book.lines[0].feature, 'gen')
|
|
self.assertEqual(book.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].credit, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, None) # feature != asset
|
|
self.assertEqual(book.lines[0].quantity_debit, None) # --> no quantity-credit/debit
|
|
self.assertEqual(book.lines[0].quantity_2nd_uom, None)
|
|
self.assertEqual(book.lines[0].factor_2nd_uom, None)
|
|
self.assertEqual(book.lines[0].quantity2nd, None)
|
|
self.assertEqual(book.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(len(book.lines[0].references), 1)
|
|
self.assertEqual(book.lines[0].reference, None)
|
|
self.assertEqual(book.lines[0].references[0].id, book2.lines[0].id)
|
|
|
|
self.assertEqual(book2.rec_name, 'Asset-Book | -1.00 usd | Open | -1.5000 u')
|
|
self.assertEqual(len(book2.lines), 1)
|
|
self.assertEqual(book2.lines[0].rec_name,
|
|
'05/01/2022|to|-1.00 usd|Transfer In [Book 1 | 1.00 usd | Open]|1.5000 u')
|
|
self.assertEqual(book2.lines[0].state, 'check')
|
|
self.assertEqual(book2.lines[0].bookingtype, 'mvout')
|
|
self.assertEqual(book2.lines[0].feature, 'asset')
|
|
self.assertEqual(book2.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].credit, Decimal('0.0'))
|
|
self.assertEqual(book2.lines[0].debit, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book2.lines[0].quantity_credit, Decimal('0.0')) # feature=asset
|
|
self.assertEqual(book2.lines[0].quantity_debit, Decimal('1.5')) # needs quantity-credit/debit
|
|
self.assertEqual(book2.lines[0].quantity_2nd_uom, None)
|
|
self.assertEqual(book2.lines[0].factor_2nd_uom, None)
|
|
self.assertEqual(book2.lines[0].quantity2nd, None)
|
|
self.assertEqual(book2.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(book2.lines[0].asset_rate, Decimal('0.6667'))
|
|
self.assertEqual(book2.lines[0].reference.rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book | -1.00 usd | Open | -1.5000 u]')
|
|
self.assertEqual(len(book2.lines[0].references), 0)
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_mvin_two_assetbooks(self):
|
|
""" create cashbook + line, bookingtype 'mvin'
|
|
transfer from depot to depot, equal uom on both cashbooks
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
Category = pool.get('cashbook.category')
|
|
BType = pool.get('cashbook.type')
|
|
|
|
type_cash = self.prep_type()
|
|
type_depot = self.prep_type('Depot', 'D')
|
|
BType.write(*[
|
|
[type_depot],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
|
|
category_in = self.prep_category(cattype='in')
|
|
category_out = self.prep_category(name='Out Category', cattype='out')
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book2, = Book.create([{
|
|
'name': 'Asset-Book 1',
|
|
'btype': type_depot.id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
}])
|
|
|
|
book, = Book.create([{
|
|
'name': 'Asset-Book 2',
|
|
'btype': type_depot.id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'Transfer In',
|
|
'category': category_out.id,
|
|
'bookingtype': 'mvin',
|
|
'amount': Decimal('1.0'),
|
|
'booktransf': book2.id,
|
|
'quantity': Decimal('1.5'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(book.rec_name, 'Asset-Book 2 | 1.00 usd | Open | 1.5000 u')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].credit, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].feature, 'asset')
|
|
self.assertEqual(book.lines[0].booktransf_feature, 'asset')
|
|
self.assertEqual(len(book2.lines), 0)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book 1 | 0.00 usd | Open | 0.0000 u]|1.5000 u')
|
|
self.assertEqual(len(book.lines[0].references), 0)
|
|
|
|
# check counterpart
|
|
self.assertEqual(book.lines[0].booktransf.rec_name, 'Asset-Book 1 | 0.00 usd | Open | 0.0000 u')
|
|
self.assertEqual(book.lines[0].booktransf.btype.feature, 'asset')
|
|
self.assertEqual(book.lines[0].booktransf_feature, 'asset')
|
|
|
|
# set line to 'checked', this creates the counterpart
|
|
Line.wfcheck(list(book.lines))
|
|
|
|
self.assertEqual(book.rec_name, 'Asset-Book 2 | 1.00 usd | Open | 1.5000 u')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book 1 | -1.00 usd | Open | -1.5000 u]|1.5000 u')
|
|
self.assertEqual(book.lines[0].state, 'check')
|
|
self.assertEqual(book.lines[0].bookingtype, 'mvin')
|
|
self.assertEqual(book.lines[0].feature, 'asset')
|
|
self.assertEqual(book.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].credit, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity_2nd_uom, None)
|
|
self.assertEqual(book.lines[0].factor_2nd_uom, None)
|
|
self.assertEqual(book.lines[0].quantity2nd, None)
|
|
self.assertEqual(book.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(len(book.lines[0].references), 1)
|
|
self.assertEqual(book.lines[0].reference, None)
|
|
self.assertEqual(book.lines[0].references[0].id, book2.lines[0].id)
|
|
|
|
self.assertEqual(book2.rec_name, 'Asset-Book 1 | -1.00 usd | Open | -1.5000 u')
|
|
self.assertEqual(len(book2.lines), 1)
|
|
self.assertEqual(book2.lines[0].rec_name,
|
|
'05/01/2022|to|-1.00 usd|Transfer In [Asset-Book 2 | 1.00 usd | Open | 1.5000 u]|1.5000 u')
|
|
self.assertEqual(book2.lines[0].state, 'check')
|
|
self.assertEqual(book2.lines[0].bookingtype, 'mvout')
|
|
self.assertEqual(book2.lines[0].feature, 'asset')
|
|
self.assertEqual(book2.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].credit, Decimal('0.0'))
|
|
self.assertEqual(book2.lines[0].debit, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book2.lines[0].quantity_credit, Decimal('0.0'))
|
|
self.assertEqual(book2.lines[0].quantity_debit, Decimal('1.5'))
|
|
self.assertEqual(book2.lines[0].quantity_2nd_uom, None)
|
|
self.assertEqual(book2.lines[0].factor_2nd_uom, None)
|
|
self.assertEqual(book2.lines[0].quantity2nd, None)
|
|
self.assertEqual(book2.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(book2.lines[0].asset_rate, Decimal('0.6667'))
|
|
self.assertEqual(book2.lines[0].reference.rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book 1 | -1.00 usd | Open | -1.5000 u]|1.5000 u')
|
|
self.assertEqual(len(book2.lines[0].references), 0)
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_mvin_two_assetbooks_diff_uom_equal_uomcat(self):
|
|
""" create cashbook + line, bookingtype 'mvin'
|
|
transfer from depot to depot,
|
|
different uom (equal uom-category) on both cashbooks
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
Category = pool.get('cashbook.category')
|
|
BType = pool.get('cashbook.type')
|
|
UOM = pool.get('product.uom')
|
|
ProdTempl = pool.get('product.template')
|
|
Asset = pool.get('investment.asset')
|
|
|
|
type_cash = self.prep_type()
|
|
type_depot = self.prep_type('Depot', 'D')
|
|
BType.write(*[
|
|
[type_depot],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
|
|
category_in = self.prep_category(cattype='in')
|
|
category_out = self.prep_category(name='Out Category', cattype='out')
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
|
|
asset1 = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
asset2 = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 2'))
|
|
|
|
uom_grams = UOM.search([('symbol', '=', 'g')])[0]
|
|
uom_ounce = UOM.search([('symbol', '=', 'oz')])[0]
|
|
ProdTempl.write(*[
|
|
[asset1.product.template],
|
|
{
|
|
'default_uom': uom_grams.id,
|
|
},
|
|
[asset2.product.template],
|
|
{
|
|
'default_uom': uom_ounce.id,
|
|
},
|
|
])
|
|
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'uom': uom_grams.id,
|
|
},
|
|
[asset2],
|
|
{
|
|
'uom': uom_ounce.id,
|
|
},
|
|
])
|
|
self.assertEqual(asset1.symbol, 'usd/g')
|
|
self.assertEqual(asset2.symbol, 'usd/oz')
|
|
|
|
book2, = Book.create([{
|
|
'name': 'Asset-Book 1',
|
|
'btype': type_depot.id,
|
|
'asset': asset1.id,
|
|
'quantity_uom': asset1.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
}])
|
|
|
|
book, = Book.create([{
|
|
'name': 'Asset-Book 2',
|
|
'btype': type_depot.id,
|
|
'asset': asset2.id,
|
|
'quantity_uom': asset2.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'Transfer In',
|
|
'category': category_out.id,
|
|
'bookingtype': 'mvin',
|
|
'amount': Decimal('1.0'),
|
|
'booktransf': book2.id,
|
|
'quantity': Decimal('1.5'),
|
|
}])],
|
|
}])
|
|
self.assertEqual(book.rec_name, 'Asset-Book 2 | 1.00 usd | Open | 1.5000 oz')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].credit, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity_uom.symbol, 'oz')
|
|
self.assertEqual(book.lines[0].quantity_uom.factor, 0.028349523125)
|
|
self.assertEqual(book.lines[0].quantity2nd.symbol, 'g')
|
|
self.assertEqual(book.lines[0].quantity2nd.factor, 0.001)
|
|
self.assertEqual(book.lines[0].quantity_2nd_uom, Decimal('42.5243')) # 1.5 oz --> g
|
|
self.assertEqual(book.lines[0].factor_2nd_uom, Decimal('28.349533333333'))
|
|
self.assertEqual(book.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(book.lines[0].feature, 'asset')
|
|
self.assertEqual(len(book2.lines), 0)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book 1 | 0.00 usd | Open | 0.0000 g]|1.5000 oz')
|
|
self.assertEqual(len(book.lines[0].references), 0)
|
|
|
|
# check counterpart
|
|
self.assertEqual(book.lines[0].booktransf.rec_name, 'Asset-Book 1 | 0.00 usd | Open | 0.0000 g')
|
|
self.assertEqual(book.lines[0].booktransf.btype.feature, 'asset')
|
|
self.assertEqual(book.lines[0].booktransf_feature, 'asset')
|
|
|
|
# set line to 'checked', this creates the counterpart
|
|
Line.wfcheck(list(book.lines))
|
|
|
|
self.assertEqual(book.rec_name, 'Asset-Book 2 | 1.00 usd | Open | 1.5000 oz')
|
|
self.assertEqual(len(book.lines), 1)
|
|
self.assertEqual(book.lines[0].rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book 1 | -1.00 usd | Open | -42.5243 g]|1.5000 oz')
|
|
self.assertEqual(book.lines[0].state, 'check')
|
|
self.assertEqual(book.lines[0].bookingtype, 'mvin')
|
|
self.assertEqual(book.lines[0].feature, 'asset')
|
|
self.assertEqual(book.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].credit, Decimal('1.0'))
|
|
self.assertEqual(book.lines[0].debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_credit, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].quantity_debit, Decimal('0.0'))
|
|
self.assertEqual(book.lines[0].quantity_2nd_uom, Decimal('42.5243'))
|
|
self.assertEqual(book.lines[0].factor_2nd_uom, Decimal('28.349533333333'))
|
|
self.assertEqual(book.lines[0].quantity2nd.symbol, 'g')
|
|
self.assertEqual(book.lines[0].quantity2nd.factor, 0.001)
|
|
self.assertEqual(book.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(len(book.lines[0].references), 1)
|
|
self.assertEqual(book.lines[0].reference, None)
|
|
self.assertEqual(book.lines[0].references[0].id, book2.lines[0].id)
|
|
|
|
self.assertEqual(book2.rec_name, 'Asset-Book 1 | -1.00 usd | Open | -42.5243 g')
|
|
self.assertEqual(len(book2.lines), 1)
|
|
self.assertEqual(book2.lines[0].rec_name,
|
|
'05/01/2022|to|-1.00 usd|Transfer In [Asset-Book 2 | 1.00 usd | Open | 1.5000 oz]|42.5243 g')
|
|
self.assertEqual(book2.lines[0].state, 'check')
|
|
self.assertEqual(book2.lines[0].bookingtype, 'mvout')
|
|
self.assertEqual(book2.lines[0].feature, 'asset')
|
|
self.assertEqual(book2.lines[0].amount, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].credit, Decimal('0.0'))
|
|
self.assertEqual(book2.lines[0].debit, Decimal('1.0'))
|
|
self.assertEqual(book2.lines[0].quantity, Decimal('42.5243'))
|
|
self.assertEqual(book2.lines[0].quantity_credit, Decimal('0.0'))
|
|
self.assertEqual(book2.lines[0].quantity_debit, Decimal('42.5243'))
|
|
self.assertEqual(book2.lines[0].quantity_2nd_uom, Decimal('1.5'))
|
|
self.assertEqual(book2.lines[0].factor_2nd_uom, Decimal('0.035273949248'))
|
|
self.assertEqual(book2.lines[0].quantity2nd.symbol, 'oz')
|
|
self.assertEqual(book2.lines[0].quantity2nd.factor, 0.028349523125)
|
|
self.assertEqual(book2.lines[0].quantity2nd_digits, 4)
|
|
self.assertEqual(book2.lines[0].asset_rate, Decimal('0.0235'))
|
|
self.assertEqual(book2.lines[0].reference.rec_name,
|
|
'05/01/2022|from|1.00 usd|Transfer In [Asset-Book 1 | -1.00 usd | Open | -42.5243 g]|1.5000 oz')
|
|
self.assertEqual(len(book2.lines[0].references), 0)
|
|
|
|
@with_transaction()
|
|
def test_assetbook_check_mvin_two_assetbooks_diff_uom_diff_uomcat(self):
|
|
""" create cashbook + line, bookingtype 'mvin'
|
|
transfer from depot to depot,
|
|
different uom (different uom-category) on both cashbooks
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
Category = pool.get('cashbook.category')
|
|
BType = pool.get('cashbook.type')
|
|
UOM = pool.get('product.uom')
|
|
ProdTempl = pool.get('product.template')
|
|
Asset = pool.get('investment.asset')
|
|
|
|
type_cash = self.prep_type()
|
|
type_depot = self.prep_type('Depot', 'D')
|
|
BType.write(*[
|
|
[type_depot],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
|
|
category_in = self.prep_category(cattype='in')
|
|
category_out = self.prep_category(name='Out Category', cattype='out')
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
|
|
asset1 = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
asset2 = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 2'))
|
|
|
|
uom_grams = UOM.search([('symbol', '=', 'g')])[0]
|
|
uom_min = UOM.search([('symbol', '=', 'min')])[0]
|
|
ProdTempl.write(*[
|
|
[asset1.product.template],
|
|
{
|
|
'default_uom': uom_grams.id,
|
|
},
|
|
[asset2.product.template],
|
|
{
|
|
'default_uom': uom_min.id,
|
|
},
|
|
])
|
|
|
|
Asset.write(*[
|
|
[asset1],
|
|
{
|
|
'uom': uom_grams.id,
|
|
},
|
|
[asset2],
|
|
{
|
|
'uom': uom_min.id,
|
|
},
|
|
])
|
|
self.assertEqual(asset1.symbol, 'usd/g')
|
|
self.assertEqual(asset2.symbol, 'usd/min')
|
|
|
|
book2, = Book.create([{
|
|
'name': 'Asset-Book 1',
|
|
'btype': type_depot.id,
|
|
'asset': asset1.id,
|
|
'quantity_uom': asset1.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
}])
|
|
|
|
book, = Book.create([{
|
|
'name': 'Asset-Book 2',
|
|
'btype': type_depot.id,
|
|
'asset': asset2.id,
|
|
'quantity_uom': asset2.uom.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'start_date': date(2022, 5, 1),
|
|
}])
|
|
|
|
self.assertRaisesRegex(UserError,
|
|
r'Cannot transfer quantities between cashbooks with different unit-categories \(Time != Weight\).',
|
|
Book.write,
|
|
*[
|
|
[book],
|
|
{
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'description': 'Transfer In',
|
|
'category': category_out.id,
|
|
'bookingtype': 'mvin',
|
|
'amount': Decimal('1.0'),
|
|
'booktransf': book2.id,
|
|
'quantity': Decimal('1.5'),
|
|
}])],
|
|
},
|
|
])
|
|
|
|
@with_transaction()
|
|
def test_assetbook_split_in_category(self):
|
|
""" splitbooking incoming with asset
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
BType = pool.get('cashbook.type')
|
|
Asset = pool.get('investment.asset')
|
|
ProdTempl = pool.get('product.template')
|
|
Uom = pool.get('product.uom')
|
|
|
|
types = self.prep_type()
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
category = self.prep_category(cattype='in')
|
|
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
book, = Book.create([{
|
|
'start_date': date(2022, 4, 1),
|
|
'name': 'Book 1',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'quantity_digits': 2,
|
|
}])
|
|
|
|
Book.write(*[
|
|
[book],
|
|
{
|
|
'lines': [('create', [{
|
|
'bookingtype': 'spin',
|
|
'date': date(2022, 5, 1),
|
|
'splitlines': [('create', [{
|
|
'amount': Decimal('5.0'),
|
|
'splittype': 'cat',
|
|
'description': 'from category',
|
|
'category': category.id,
|
|
'quantity': Decimal('1.5'),
|
|
}, {
|
|
'amount': Decimal('6.0'),
|
|
'splittype': 'cat',
|
|
'description': 'from category',
|
|
'category': category.id,
|
|
'quantity': Decimal('2.5'),
|
|
}])],
|
|
}])],
|
|
}])
|
|
|
|
self.assertEqual(book.rec_name, 'Book 1 | 11.00 usd | Open | 4.00 u')
|
|
self.assertEqual(book.balance_all, Decimal('11.0'))
|
|
self.assertEqual(len(book.lines), 1)
|
|
|
|
self.assertEqual(book.lines[0].amount, Decimal('11.0'))
|
|
self.assertEqual(book.lines[0].quantity, Decimal('4.0'))
|
|
self.assertEqual(book.lines[0].quantity_uom.symbol, 'u')
|
|
self.assertEqual(book.lines[0].splitline_has_quantity, False)
|
|
self.assertEqual(book.lines[0].rec_name, '05/01/2022|Rev/Sp|11.00 usd|- [-]|4.00 u')
|
|
|
|
self.assertEqual(len(book.lines[0].splitlines), 2)
|
|
self.assertEqual(book.lines[0].splitlines[0].splittype, 'cat')
|
|
self.assertEqual(book.lines[0].splitlines[0].amount, Decimal('5.0'))
|
|
self.assertEqual(book.lines[0].splitlines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(book.lines[0].splitlines[1].splittype, 'cat')
|
|
self.assertEqual(book.lines[0].splitlines[1].amount, Decimal('6.0'))
|
|
self.assertEqual(book.lines[0].splitlines[1].quantity, Decimal('2.5'))
|
|
|
|
@with_transaction()
|
|
def test_assetbook_split_in_category_and_assetbook(self):
|
|
""" splitbooking incoming to asset-cahbook,
|
|
from category and asset-cashbook
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook.line')
|
|
BType = pool.get('cashbook.type')
|
|
Asset = pool.get('investment.asset')
|
|
ProdTempl = pool.get('product.template')
|
|
Uom = pool.get('product.uom')
|
|
|
|
types = self.prep_type()
|
|
BType.write(*[
|
|
[types],
|
|
{
|
|
'feature': 'asset',
|
|
}])
|
|
category = self.prep_category(cattype='in')
|
|
|
|
company = self.prep_company()
|
|
party = self.prep_party()
|
|
asset = self.prep_asset_item(
|
|
company=company,
|
|
product = self.prep_asset_product(name='Product 1'))
|
|
self.assertEqual(asset.symbol, 'usd/u')
|
|
|
|
books = Book.create([{
|
|
'start_date': date(2022, 4, 1),
|
|
'name': 'Book 1',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'quantity_digits': 2,
|
|
}, {
|
|
'start_date': date(2022, 4, 1),
|
|
'name': 'Book 2',
|
|
'btype': types.id,
|
|
'company': company.id,
|
|
'currency': company.currency.id,
|
|
'number_sequ': self.prep_sequence().id,
|
|
'asset': asset.id,
|
|
'quantity_uom': asset.uom.id,
|
|
'quantity_digits': 2,
|
|
}])
|
|
|
|
Book.write(*[
|
|
[books[0]],
|
|
{
|
|
'lines': [('create', [{
|
|
'bookingtype': 'spin',
|
|
'date': date(2022, 5, 1),
|
|
'splitlines': [('create', [{
|
|
'amount': Decimal('5.0'),
|
|
'splittype': 'cat',
|
|
'description': 'from category',
|
|
'category': category.id,
|
|
'quantity': Decimal('1.5'),
|
|
}, {
|
|
'amount': Decimal('6.0'),
|
|
'splittype': 'tr',
|
|
'description': 'from cashbook',
|
|
'booktransf': books[1].id,
|
|
'quantity': Decimal('2.5'),
|
|
}])],
|
|
}])],
|
|
}])
|
|
|
|
self.assertEqual(books[0].rec_name, 'Book 1 | 11.00 usd | Open | 4.00 u')
|
|
self.assertEqual(books[0].balance_all, Decimal('11.0'))
|
|
self.assertEqual(len(books[0].lines), 1)
|
|
|
|
self.assertEqual(books[0].lines[0].amount, Decimal('11.0'))
|
|
self.assertEqual(books[0].lines[0].quantity, Decimal('4.0'))
|
|
self.assertEqual(books[0].lines[0].quantity_uom.symbol, 'u')
|
|
self.assertEqual(books[0].lines[0].splitline_has_quantity, True)
|
|
self.assertEqual(books[0].lines[0].rec_name, '05/01/2022|Rev/Sp|11.00 usd|- [-]|4.00 u')
|
|
|
|
self.assertEqual(len(books[0].lines[0].splitlines), 2)
|
|
self.assertEqual(books[0].lines[0].splitlines[0].splittype, 'cat')
|
|
self.assertEqual(books[0].lines[0].splitlines[0].amount, Decimal('5.0'))
|
|
self.assertEqual(books[0].lines[0].splitlines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(books[0].lines[0].splitlines[0].category.rec_name, 'Cat1')
|
|
self.assertEqual(books[0].lines[0].splitlines[0].booktransf, None)
|
|
self.assertEqual(books[0].lines[0].splitlines[1].splittype, 'tr')
|
|
self.assertEqual(books[0].lines[0].splitlines[1].amount, Decimal('6.0'))
|
|
self.assertEqual(books[0].lines[0].splitlines[1].quantity, Decimal('2.5'))
|
|
self.assertEqual(books[0].lines[0].splitlines[1].booktransf.rec_name,
|
|
'Book 2 | 0.00 usd | Open | 0.00 u')
|
|
self.assertEqual(len(books[0].lines[0].references), 0)
|
|
self.assertEqual(books[0].lines[0].reference, None)
|
|
|
|
self.assertEqual(books[1].rec_name, 'Book 2 | 0.00 usd | Open | 0.00 u')
|
|
self.assertEqual(books[1].balance_all, Decimal('0.0'))
|
|
self.assertEqual(len(books[1].lines), 0)
|
|
|
|
Line.wfcheck([books[0].lines[0]])
|
|
|
|
self.assertEqual(books[0].rec_name, 'Book 1 | 11.00 usd | Open | 4.00 u')
|
|
self.assertEqual(books[0].balance_all, Decimal('11.0'))
|
|
self.assertEqual(len(books[0].lines), 1)
|
|
|
|
self.assertEqual(books[0].lines[0].amount, Decimal('11.0'))
|
|
self.assertEqual(books[0].lines[0].quantity, Decimal('4.0'))
|
|
self.assertEqual(books[0].lines[0].quantity_uom.symbol, 'u')
|
|
self.assertEqual(books[0].lines[0].splitline_has_quantity, True)
|
|
self.assertEqual(books[0].lines[0].rec_name, '05/01/2022|Rev/Sp|11.00 usd|- [-]|4.00 u')
|
|
|
|
self.assertEqual(len(books[0].lines[0].splitlines), 2)
|
|
self.assertEqual(books[0].lines[0].splitlines[0].splittype, 'cat')
|
|
self.assertEqual(books[0].lines[0].splitlines[0].amount, Decimal('5.0'))
|
|
self.assertEqual(books[0].lines[0].splitlines[0].quantity, Decimal('1.5'))
|
|
self.assertEqual(books[0].lines[0].splitlines[0].category.rec_name, 'Cat1')
|
|
self.assertEqual(books[0].lines[0].splitlines[0].booktransf, None)
|
|
self.assertEqual(books[0].lines[0].splitlines[1].splittype, 'tr')
|
|
self.assertEqual(books[0].lines[0].splitlines[1].amount, Decimal('6.0'))
|
|
self.assertEqual(books[0].lines[0].splitlines[1].quantity, Decimal('2.5'))
|
|
self.assertEqual(books[0].lines[0].splitlines[1].booktransf.rec_name,
|
|
'Book 2 | -6.00 usd | Open | -2.50 u')
|
|
self.assertEqual(len(books[0].lines[0].references), 0)
|
|
self.assertEqual(books[0].lines[0].reference, None)
|
|
|
|
self.assertEqual(books[1].rec_name, 'Book 2 | 0.00 usd | Open | 0.00 u')
|
|
self.assertEqual(books[1].balance_all, Decimal('0.0'))
|
|
self.assertEqual(len(books[1].lines), 0)
|
|
|
|
# end CbInvTestCase
|