1060 lines
46 KiB
Python
1060 lines
46 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, activate_module
|
|
from trytond.pool import Pool
|
|
from trytond.transaction import Transaction
|
|
from trytond.exceptions import UserError
|
|
from trytond.modules.cashbook.tests import CashbookTestCase
|
|
from datetime import date
|
|
from decimal import Decimal
|
|
|
|
|
|
class ReportTestCase(CashbookTestCase):
|
|
'Test cashbook book report module'
|
|
module = 'cashbook_report'
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
""" add modelues
|
|
"""
|
|
super(ReportTestCase, cls).setUpClass()
|
|
activate_module(['dashboard', 'cashbook_investment'])
|
|
|
|
def prep_report_3books(self):
|
|
""" create 3x cashbooks, add bookings,
|
|
"""
|
|
pool = Pool()
|
|
Book = pool.get('cashbook.book')
|
|
ResUser = pool.get('res.user')
|
|
|
|
user_admin, = ResUser.search([])
|
|
type_cash = self.prep_type()
|
|
type_bank = self.prep_type(name='Bank', short='BK')
|
|
company = self.prep_company()
|
|
|
|
ResUser.write(*[
|
|
[user_admin],
|
|
{
|
|
'companies': [('add', [company.id])],
|
|
'company': company.id,
|
|
}])
|
|
self.assertEqual(user_admin.company.id, company.id)
|
|
|
|
(usd, euro) = self.prep_2nd_currency(company)
|
|
sequ_id = self.prep_sequence().id
|
|
category = self.prep_category(cattype='in')
|
|
party = self.prep_party()
|
|
books = Book.create([{
|
|
'name': 'Book 1',
|
|
'btype': type_cash.id,
|
|
'company': company.id,
|
|
'currency': usd.id,
|
|
'number_sequ': sequ_id,
|
|
'start_date': date(2022, 4, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 5),
|
|
'description': 'Income 1a',
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('10.0'),
|
|
'category': category.id,
|
|
'party': party.id,
|
|
}, {
|
|
'date': date(2022, 5, 5),
|
|
'description': 'Income 1b',
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('15.0'),
|
|
'category': category.id,
|
|
'party': party.id,
|
|
}])],
|
|
}, {
|
|
'name': 'Book 2',
|
|
'btype': type_cash.id,
|
|
'company': company.id,
|
|
'currency': usd.id,
|
|
'number_sequ': sequ_id,
|
|
'start_date': date(2022, 4, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 5),
|
|
'description': 'Income 2a',
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('5.0'),
|
|
'category': category.id,
|
|
'party': party.id,
|
|
}, {
|
|
'date': date(2022, 5, 5),
|
|
'description': 'Income 2b',
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('7.5'),
|
|
'category': category.id,
|
|
'party': party.id,
|
|
}])],
|
|
}, {
|
|
'name': 'Book 3',
|
|
'btype': type_bank.id,
|
|
'company': company.id,
|
|
'currency': euro.id,
|
|
'number_sequ': sequ_id,
|
|
'start_date': date(2022, 4, 1),
|
|
'lines': [('create', [{
|
|
'date': date(2022, 5, 5),
|
|
'description': 'Income 3a',
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('12.5'),
|
|
'category': category.id,
|
|
'party': party.id,
|
|
}, {
|
|
'date': date(2022, 5, 5),
|
|
'description': 'Income 3b',
|
|
'bookingtype': 'in',
|
|
'amount': Decimal('10.5'),
|
|
'category': category.id,
|
|
'party': party.id,
|
|
}])],
|
|
}])
|
|
self.assertEqual(len(books), 3)
|
|
self.assertEqual(books[0].name, 'Book 1')
|
|
self.assertEqual(books[0].btype.rec_name, 'CAS - Cash')
|
|
self.assertEqual(len(books[0].lines), 2)
|
|
self.assertEqual(books[0].balance, Decimal('25.0'))
|
|
|
|
self.assertEqual(books[1].name, 'Book 2')
|
|
self.assertEqual(books[1].btype.rec_name, 'CAS - Cash')
|
|
self.assertEqual(len(books[1].lines), 2)
|
|
self.assertEqual(books[1].balance, Decimal('12.5'))
|
|
|
|
self.assertEqual(books[2].name, 'Book 3')
|
|
self.assertEqual(books[2].btype.rec_name, 'BK - Bank')
|
|
self.assertEqual(len(books[2].lines), 2)
|
|
self.assertEqual(books[2].balance, Decimal('23.0'))
|
|
return books
|
|
|
|
@with_transaction()
|
|
def test_report_currency_hasbookings(self):
|
|
""" check detectpn of bookings @ currency
|
|
"""
|
|
pool = Pool()
|
|
Currency = pool.get('currency.currency')
|
|
Lines = pool.get('cashbook.line')
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
self.assertEqual(len(books[0].lines), 2)
|
|
self.assertEqual(books[0].currency.code, 'usd')
|
|
self.assertEqual(len(books[1].lines), 2)
|
|
self.assertEqual(books[1].currency.code, 'usd')
|
|
self.assertEqual(len(books[2].lines), 2)
|
|
self.assertEqual(books[2].currency.code, 'EUR')
|
|
|
|
euro, = Currency.search([('code', '=', 'EUR')])
|
|
self.assertEqual(euro.cashbook_hasbookings, True)
|
|
self.assertEqual(Currency.search_count([
|
|
('cashbook_hasbookings', '=', True)
|
|
]), 2)
|
|
|
|
Lines.delete(books[2].lines)
|
|
self.assertEqual(euro.cashbook_hasbookings, False)
|
|
|
|
self.assertEqual(Currency.search_count([
|
|
('cashbook_hasbookings', '=', True)
|
|
]), 1)
|
|
|
|
usd, = Currency.search([('code', '=', 'usd')])
|
|
self.assertEqual(usd.cashbook_hasbookings, True)
|
|
|
|
Lines.delete(books[0].lines)
|
|
self.assertEqual(usd.cashbook_hasbookings, True)
|
|
Lines.delete(books[1].lines)
|
|
self.assertEqual(usd.cashbook_hasbookings, False)
|
|
|
|
self.assertEqual(Currency.search_count([
|
|
('cashbook_hasbookings', '=', True)
|
|
]), 0)
|
|
|
|
@with_transaction()
|
|
def test_report_check_limited_access(self):
|
|
""" check query of cashbook-lines selected by
|
|
cashbook-type, limited by user-permissions
|
|
"""
|
|
pool = Pool()
|
|
ResUser = pool.get('res.user')
|
|
ResGroup = pool.get('res.group')
|
|
ModelData = pool.get('ir.model.data')
|
|
Currency = pool.get('currency.currency')
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
Type = pool.get('cashbook.type')
|
|
Cashbook = pool.get('cashbook.book')
|
|
Line = pool.get('cashbook_report.eval_line')
|
|
|
|
books = self.prep_report_3books()
|
|
company = self.prep_company()
|
|
|
|
# add 2x user, set owner of cashbooks to them
|
|
group_cashbook = ResGroup(ModelData.get_id('cashbook', 'group_cashbook'))
|
|
users = ResUser.create([{
|
|
'name': 'User 1',
|
|
'login': 'user1',
|
|
'password': 'test1234',
|
|
'groups': [('add', [group_cashbook.id])],
|
|
'company': company.id,
|
|
'companies': [('add', [company.id])],
|
|
}, {
|
|
'name': 'User 2',
|
|
'login': 'user2',
|
|
'password': 'test1234',
|
|
'groups': [('add', [group_cashbook.id])],
|
|
'company': company.id,
|
|
'companies': [('add', [company.id])],
|
|
}])
|
|
|
|
Cashbook.write(*[
|
|
[books[0], books[1]],
|
|
{
|
|
'owner': users[0].id,
|
|
},
|
|
[books[2]],
|
|
{
|
|
'owner': users[1].id,
|
|
},
|
|
])
|
|
|
|
# check access to data
|
|
with Transaction().set_user(users[0].id):
|
|
with Transaction().set_context({
|
|
'_check_access': True,
|
|
'company': company.id,
|
|
}):
|
|
books_owner1 = Cashbook.search([])
|
|
self.assertEqual(len(books_owner1), 2)
|
|
self.assertEqual(books_owner1[0].name, 'Book 1')
|
|
self.assertEqual(books_owner1[0].balance, Decimal('25.0'))
|
|
self.assertEqual(books_owner1[1].name, 'Book 2')
|
|
self.assertEqual(books_owner1[1].balance, Decimal('12.5'))
|
|
|
|
# add category to cashbook
|
|
Cashbook.write(*[
|
|
[books_owner1[0]],
|
|
{
|
|
'categories': [('create', [{
|
|
'name': 'Book 1, User 1'
|
|
}])],
|
|
}])
|
|
|
|
evaluation1, = Evaluation.create([{
|
|
'name': 'Evaluation User 1 - Cashbooks',
|
|
'dtype': 'cashbooks',
|
|
'cashbooks': [('add', [x.id for x in books_owner1])],
|
|
}])
|
|
self.assertEqual(len(evaluation1.cashbooks), 2)
|
|
self.assertEqual(evaluation1.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation1.line_values), 2)
|
|
self.assertEqual(evaluation1.line_values[0].name, 'Book 1 | 25.00 usd | Open')
|
|
self.assertEqual(evaluation1.line_values[0].balance, Decimal('23.81'))
|
|
self.assertEqual(evaluation1.line_values[1].name, 'Book 2 | 12.50 usd | Open')
|
|
self.assertEqual(evaluation1.line_values[1].balance, Decimal('11.9'))
|
|
|
|
evaluation2, = Evaluation.create([{
|
|
'name': 'Evaluation User 1 - Types',
|
|
'dtype': 'types',
|
|
'types': [('add', [x.id for x in Type.search([])])],
|
|
}])
|
|
self.assertEqual(len(evaluation2.types), 2)
|
|
self.assertEqual(evaluation2.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation2.line_values), 2)
|
|
self.assertEqual(evaluation2.line_values[0].name, 'BK - Bank')
|
|
self.assertEqual(evaluation2.line_values[0].balance, Decimal('0.0'))
|
|
self.assertEqual(evaluation2.line_values[1].name, 'CAS - Cash')
|
|
self.assertEqual(evaluation2.line_values[1].balance, Decimal('35.71'))
|
|
|
|
evaluation3, = Evaluation.create([{
|
|
'name': 'Evaluation User 1 - Currencies',
|
|
'dtype': 'currencies',
|
|
'currencies': [('add', [x.id for x in Currency.search([])])],
|
|
}])
|
|
self.assertEqual(len(evaluation3.currencies), 2)
|
|
self.assertEqual(evaluation3.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation3.line_values), 2)
|
|
self.assertEqual(evaluation3.line_values[0].name, 'Euro')
|
|
self.assertEqual(evaluation3.line_values[0].balance, Decimal('0.0'))
|
|
self.assertEqual(evaluation3.line_values[1].name, 'usd')
|
|
self.assertEqual(evaluation3.line_values[1].balance, Decimal('35.71'))
|
|
|
|
evaluation4, = Evaluation.create([{
|
|
'name': 'Evaluation User 1 - Categories',
|
|
'dtype': 'categories',
|
|
'categories': [('add', [x.id for x in books_owner1[0].categories])],
|
|
}])
|
|
self.assertEqual(len(evaluation4.categories), 1)
|
|
self.assertEqual(evaluation4.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation4.line_values), 1)
|
|
self.assertEqual(evaluation4.line_values[0].name, 'Book 1, User 1')
|
|
self.assertEqual(evaluation4.line_values[0].balance, Decimal('23.81'))
|
|
|
|
self.assertEqual(Evaluation.search_count([]), 4)
|
|
|
|
with Transaction().set_user(users[1].id):
|
|
with Transaction().set_context({
|
|
'_check_access': True,
|
|
'company': company.id,
|
|
}):
|
|
books_owner2 = Cashbook.search([])
|
|
self.assertEqual(len(books_owner2), 1)
|
|
self.assertEqual(books_owner2[0].name, 'Book 3')
|
|
|
|
# add category to cashbook
|
|
Cashbook.write(*[
|
|
[books_owner2[0]],
|
|
{
|
|
'categories': [('create', [{
|
|
'name': 'Book 3, User 2'
|
|
}])],
|
|
}])
|
|
|
|
evaluation1, = Evaluation.create([{
|
|
'name': 'Evaluation User 2 - Cashbooks',
|
|
'dtype': 'cashbooks',
|
|
'cashbooks': [('add', [x.id for x in books_owner2])],
|
|
}])
|
|
self.assertEqual(len(evaluation1.cashbooks), 1)
|
|
self.assertEqual(evaluation1.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation1.line_values), 1)
|
|
self.assertEqual(evaluation1.line_values[0].name, 'Book 3 | 23.00 € | Open')
|
|
self.assertEqual(evaluation1.line_values[0].balance, Decimal('23.0'))
|
|
|
|
evaluation2, = Evaluation.create([{
|
|
'name': 'Evaluation User 2 - Types',
|
|
'dtype': 'types',
|
|
'types': [('add', [x.id for x in Type.search([])])],
|
|
}])
|
|
self.assertEqual(len(evaluation2.types), 2)
|
|
self.assertEqual(evaluation2.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation2.line_values), 2)
|
|
self.assertEqual(evaluation2.line_values[0].name, 'BK - Bank')
|
|
self.assertEqual(evaluation2.line_values[0].balance, Decimal('23.0'))
|
|
self.assertEqual(evaluation2.line_values[1].name, 'CAS - Cash')
|
|
self.assertEqual(evaluation2.line_values[1].balance, Decimal('0.0'))
|
|
|
|
evaluation3, = Evaluation.create([{
|
|
'name': 'Evaluation User 2 - Currencies',
|
|
'dtype': 'currencies',
|
|
'currencies': [('add', [x.id for x in Currency.search([])])],
|
|
}])
|
|
self.assertEqual(len(evaluation3.currencies), 2)
|
|
self.assertEqual(evaluation3.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation3.line_values), 2)
|
|
self.assertEqual(evaluation3.line_values[0].name, 'Euro')
|
|
self.assertEqual(evaluation3.line_values[0].balance, Decimal('23.0'))
|
|
self.assertEqual(evaluation3.line_values[1].name, 'usd')
|
|
self.assertEqual(evaluation3.line_values[1].balance, Decimal('0.0'))
|
|
|
|
evaluation4, = Evaluation.create([{
|
|
'name': 'Evaluation User 2 - Categories',
|
|
'dtype': 'categories',
|
|
'categories': [('add', [x.id for x in books_owner2[0].categories])],
|
|
}])
|
|
self.assertEqual(len(evaluation4.categories), 1)
|
|
self.assertEqual(evaluation4.currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluation4.line_values), 1)
|
|
self.assertEqual(evaluation4.line_values[0].name, 'Book 3, User 2')
|
|
self.assertEqual(evaluation4.line_values[0].balance, Decimal('23.0'))
|
|
|
|
self.assertEqual(Evaluation.search_count([]), 4)
|
|
|
|
# outside of context
|
|
# we should have access to all 8 evaluations
|
|
evaluations = Evaluation.search([], order=[('name', 'ASC')])
|
|
self.assertEqual(len(evaluations), 8)
|
|
|
|
self.assertEqual(evaluations[0].name, 'Evaluation User 1 - Cashbooks')
|
|
self.assertEqual(len(evaluations[0].cashbooks), 2)
|
|
self.assertEqual(evaluations[0].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[0].line_values), 2)
|
|
self.assertEqual(evaluations[0].line_values[0].name, 'Book 1 | 25.00 usd | Open')
|
|
self.assertEqual(evaluations[0].line_values[0].balance, Decimal('23.81'))
|
|
self.assertEqual(evaluations[0].line_values[1].name, 'Book 2 | 12.50 usd | Open')
|
|
self.assertEqual(evaluations[0].line_values[1].balance, Decimal('11.9'))
|
|
|
|
self.assertEqual(evaluations[1].name, 'Evaluation User 1 - Categories')
|
|
self.assertEqual(len(evaluations[1].categories), 1)
|
|
self.assertEqual(evaluations[1].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[1].line_values), 1)
|
|
self.assertEqual(evaluations[1].line_values[0].name, 'Book 1, User 1')
|
|
self.assertEqual(evaluations[1].line_values[0].balance, Decimal('23.81'))
|
|
|
|
self.assertEqual(evaluations[2].name, 'Evaluation User 1 - Currencies')
|
|
self.assertEqual(len(evaluations[2].currencies), 2)
|
|
self.assertEqual(evaluations[2].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[2].line_values), 2)
|
|
self.assertEqual(evaluations[2].line_values[0].name, 'Euro')
|
|
self.assertEqual(evaluations[2].line_values[0].balance, Decimal('23.0'))
|
|
self.assertEqual(evaluations[2].line_values[1].name, 'usd')
|
|
self.assertEqual(evaluations[2].line_values[1].balance, Decimal('35.71'))
|
|
|
|
self.assertEqual(evaluations[3].name, 'Evaluation User 1 - Types')
|
|
self.assertEqual(len(evaluations[3].types), 2)
|
|
self.assertEqual(evaluations[3].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[3].line_values), 2)
|
|
self.assertEqual(evaluations[3].line_values[0].name, 'BK - Bank')
|
|
self.assertEqual(evaluations[3].line_values[0].balance, Decimal('23.0'))
|
|
self.assertEqual(evaluations[3].line_values[1].name, 'CAS - Cash')
|
|
self.assertEqual(evaluations[3].line_values[1].balance, Decimal('35.71'))
|
|
|
|
self.assertEqual(evaluations[4].name, 'Evaluation User 2 - Cashbooks')
|
|
self.assertEqual(len(evaluations[4].cashbooks), 1)
|
|
self.assertEqual(evaluations[4].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[4].line_values), 1)
|
|
self.assertEqual(evaluations[4].line_values[0].name, 'Book 3 | 23.00 € | Open')
|
|
self.assertEqual(evaluations[4].line_values[0].balance, Decimal('23.0'))
|
|
|
|
self.assertEqual(evaluations[5].name, 'Evaluation User 2 - Categories')
|
|
self.assertEqual(len(evaluations[5].categories), 1)
|
|
self.assertEqual(evaluations[5].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[5].line_values), 1)
|
|
self.assertEqual(evaluations[5].line_values[0].name, 'Book 3, User 2')
|
|
self.assertEqual(evaluations[5].line_values[0].balance, Decimal('23.0'))
|
|
|
|
self.assertEqual(evaluations[6].name, 'Evaluation User 2 - Currencies')
|
|
self.assertEqual(len(evaluations[6].currencies), 2)
|
|
self.assertEqual(evaluations[6].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[6].line_values), 2)
|
|
self.assertEqual(evaluations[6].line_values[0].name, 'Euro')
|
|
self.assertEqual(evaluations[6].line_values[0].balance, Decimal('23.0'))
|
|
self.assertEqual(evaluations[6].line_values[1].name, 'usd')
|
|
self.assertEqual(evaluations[6].line_values[1].balance, Decimal('35.71'))
|
|
|
|
self.assertEqual(evaluations[7].name, 'Evaluation User 2 - Types')
|
|
self.assertEqual(len(evaluations[7].types), 2)
|
|
self.assertEqual(evaluations[7].currency.rec_name, 'Euro')
|
|
self.assertEqual(len(evaluations[7].line_values), 2)
|
|
self.assertEqual(evaluations[7].line_values[0].name, 'BK - Bank')
|
|
self.assertEqual(evaluations[7].line_values[0].balance, Decimal('23.0'))
|
|
self.assertEqual(evaluations[7].line_values[1].name, 'CAS - Cash')
|
|
self.assertEqual(evaluations[7].line_values[1].balance, Decimal('35.71'))
|
|
|
|
@with_transaction()
|
|
def test_report_update_name_of_line(self):
|
|
""" check replace rec_name-value on line with
|
|
manually updates value
|
|
"""
|
|
pool = Pool()
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
Line = pool.get('cashbook_report.eval_line')
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'dtype': 'cashbooks',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 3)
|
|
self.assertEqual(len(evaluation.line_values), 3)
|
|
|
|
self.assertEqual(evaluation.line_values[0].name, 'Book 1 | 25.00 usd | Open')
|
|
self.assertEqual(evaluation.line_values[0].name_line, None)
|
|
|
|
# update 'name'
|
|
Line.write(*[
|
|
[evaluation.line_values[0]],
|
|
{
|
|
'name': 'Book updated',
|
|
}])
|
|
self.assertEqual(evaluation.line_values[0].name, 'Book updated')
|
|
self.assertEqual(evaluation.line_values[0].name_line, 'Book updated')
|
|
|
|
# delete 'name' value to reset to origin
|
|
Line.write(*[
|
|
[evaluation.line_values[0]],
|
|
{
|
|
'name': None,
|
|
}])
|
|
self.assertEqual(evaluation.line_values[0].name, 'Book 1 | 25.00 usd | Open')
|
|
self.assertEqual(evaluation.line_values[0].name_line, None)
|
|
|
|
@with_transaction()
|
|
def test_report_dtype_update(self):
|
|
""" check unlink of cashbooks/types/currencies
|
|
"""
|
|
pool = Pool()
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
Types = pool.get('cashbook.type')
|
|
Currency = pool.get('currency.currency')
|
|
Category = pool.get('cashbook.bookcategory')
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
|
|
categories = Category.create([{
|
|
'name': 'Cat 1',
|
|
}, {
|
|
'name': 'Cat 2',
|
|
}, {
|
|
'name': 'Cat 3',
|
|
}])
|
|
|
|
# valid
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'dtype': 'cashbooks',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 3)
|
|
self.assertEqual(len(evaluation.types), 0)
|
|
self.assertEqual(len(evaluation.currencies), 0)
|
|
self.assertEqual(len(evaluation.categories), 0)
|
|
|
|
# investment - profit/loss amount
|
|
if 'cashbooks_gldiff' in [x[0] for x in Evaluation.get_sel_etype()]:
|
|
# no change if switch between cashbook-types
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'dtype': 'cashbooks_gldiff',
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 3)
|
|
self.assertEqual(len(evaluation.types), 0)
|
|
self.assertEqual(len(evaluation.currencies), 0)
|
|
self.assertEqual(len(evaluation.categories), 0)
|
|
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'dtype': 'cashbooks_glperc',
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 3)
|
|
self.assertEqual(len(evaluation.types), 0)
|
|
self.assertEqual(len(evaluation.currencies), 0)
|
|
self.assertEqual(len(evaluation.categories), 0)
|
|
else :
|
|
print('\n--== Module "cashbook_investment" not installed ==--')
|
|
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'dtype': 'types',
|
|
'types': [('add', [x.id for x in Types.search([])])],
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 0)
|
|
self.assertEqual(len(evaluation.types), 2)
|
|
self.assertEqual(len(evaluation.currencies), 0)
|
|
self.assertEqual(len(evaluation.categories), 0)
|
|
|
|
# write same dtype again - no change
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'dtype': 'types',
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 0)
|
|
self.assertEqual(len(evaluation.types), 2)
|
|
self.assertEqual(len(evaluation.currencies), 0)
|
|
self.assertEqual(len(evaluation.categories), 0)
|
|
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'dtype': 'currencies',
|
|
'currencies': [('add', [x.id for x in Currency.search([])])],
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 0)
|
|
self.assertEqual(len(evaluation.types), 0)
|
|
self.assertEqual(len(evaluation.currencies), 2)
|
|
self.assertEqual(len(evaluation.categories), 0)
|
|
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'dtype': 'categories',
|
|
'categories': [('add', [x.id for x in Category.search([])])],
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 0)
|
|
self.assertEqual(len(evaluation.types), 0)
|
|
self.assertEqual(len(evaluation.currencies), 0)
|
|
self.assertEqual(len(evaluation.categories), 3)
|
|
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'dtype': 'cashbooks',
|
|
}])
|
|
self.assertEqual(len(evaluation.cashbooks), 0)
|
|
self.assertEqual(len(evaluation.types), 0)
|
|
self.assertEqual(len(evaluation.currencies), 0)
|
|
self.assertEqual(len(evaluation.categories), 0)
|
|
|
|
@with_transaction()
|
|
def test_report_dtype_validation(self):
|
|
""" check validation of dtype
|
|
"""
|
|
pool = Pool()
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
Types = pool.get('cashbook.type')
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
# valid
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'dtype': 'cashbooks',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
|
|
# must fail
|
|
self.assertRaisesRegex(UserError,
|
|
'A value is required for field "Data type" in "Evaluation Line Relation".',
|
|
Evaluation.create,
|
|
[{
|
|
'name': 'Evaluation 1',
|
|
'dtype': 'types', # wrong dtype
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 2',
|
|
'dtype': 'types',
|
|
'types': [('add', [x.id for x in Types.search([])])],
|
|
}])
|
|
|
|
# must fail
|
|
self.assertRaisesRegex(UserError,
|
|
'A value is required for field "Cashbook" in "Evaluation Line Relation".',
|
|
Evaluation.create,
|
|
[{
|
|
'name': 'Evaluation 3',
|
|
'dtype': 'cashbooks',
|
|
'types': [('add', [x.id for x in Types.search([])])],
|
|
}])
|
|
|
|
@with_transaction()
|
|
def test_report_check_update_of_actionviews(self):
|
|
""" create 3x cashbooks, add evaluation, check created
|
|
form + actionview
|
|
"""
|
|
pool = Pool()
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
try :
|
|
DashboardAction = pool.get('dashboard.action')
|
|
except:
|
|
print('\n--== Module "dashboard" not installed ==--')
|
|
DashboardAction = None
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
|
|
# add dashboard-action
|
|
if DashboardAction is not None:
|
|
dbaction, = DashboardAction.create([{
|
|
'user': Transaction().user,
|
|
'act_window': evaluation.dashb_actwin.id,
|
|
}])
|
|
self.assertEqual(dbaction.user.rec_name, 'Administrator')
|
|
self.assertEqual(dbaction.act_window.name, 'Evaluation 1')
|
|
|
|
self.assertEqual(evaluation.dtype, 'cashbooks')
|
|
self.assertEqual(evaluation.chart, 'pie')
|
|
self.assertEqual(evaluation.legend, True)
|
|
self.assertEqual(evaluation.maincolor, 'default')
|
|
self.assertEqual(evaluation.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation.currency.code, 'EUR')
|
|
|
|
# check uiview
|
|
self.assertEqual(evaluation.ui_view_chart.model, 'cashbook_report.eval_line')
|
|
self.assertEqual(evaluation.ui_view_chart.module, 'cashbook_report')
|
|
self.assertEqual(evaluation.ui_view_chart.priority, 10)
|
|
self.assertEqual(evaluation.ui_view_chart.type, 'graph')
|
|
# action-window for dashbord
|
|
self.assertEqual(evaluation.dashb_actwin.name, 'Evaluation 1')
|
|
self.assertEqual(evaluation.dashb_actwin.res_model,
|
|
'cashbook_report.eval_line')
|
|
self.assertEqual(evaluation.dashb_actwin.usage,
|
|
'dashboard')
|
|
self.assertEqual(evaluation.dashb_actwin.domain,
|
|
'[["evaluation", "=", %d]]' % evaluation.id)
|
|
# action-view
|
|
self.assertEqual(evaluation.dashb_actview.sequence, 10)
|
|
self.assertEqual(evaluation.dashb_actview.view.id,
|
|
evaluation.ui_view_chart.id)
|
|
self.assertEqual(evaluation.dashb_actview.act_window.id,
|
|
evaluation.dashb_actwin.id)
|
|
|
|
# update evaluation, this wil re-create the view/act-window
|
|
# and update the dashboard-view, without removing it
|
|
old_win_id = evaluation.dashb_actwin.id
|
|
Evaluation.write(*[
|
|
[evaluation],
|
|
{
|
|
'name': 'Evaluation 1a',
|
|
}])
|
|
self.assertTrue(old_win_id != evaluation.dashb_actwin.id)
|
|
|
|
if DashboardAction is not None:
|
|
self.assertEqual(DashboardAction.search_count([]), 1)
|
|
|
|
@with_transaction()
|
|
def test_report_chart_hbar_book_investment(self):
|
|
""" create 3x cashbooks, add bookings, rates
|
|
create report with cashbooks, check
|
|
"""
|
|
pool = Pool()
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
Book = pool.get('cashbook.book')
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
if 'cashbooks_gldiff' not in [x[0] for x in Evaluation.get_sel_etype()]:
|
|
print('\n--== Module "cashbook_investment" not installed ==--')
|
|
return
|
|
|
|
AccType = pool.get('cashbook.type')
|
|
Asset = pool.get('investment.asset')
|
|
Product = pool.get('product.template')
|
|
Uom = pool.get('product.uom')
|
|
CbCategory = pool.get('cashbook.bookcategory')
|
|
|
|
at, = AccType.create([{
|
|
'name': 'depot',
|
|
'short': 'D',
|
|
'feature': 'asset',
|
|
'company': company.id,
|
|
}])
|
|
|
|
prod_templ, = Product.create([{
|
|
'name': 'Aurum',
|
|
'type': 'assets',
|
|
'list_price': Decimal('1.0'),
|
|
'default_uom': Uom.search([('symbol', '=', 'u')])[0].id,
|
|
'products': [('create', [{
|
|
'description': 'Au',
|
|
}])],
|
|
}])
|
|
|
|
asset, = Asset.create([{
|
|
'company': company.id,
|
|
'product': prod_templ.products[0].id,
|
|
'currency': company.currency.id,
|
|
'currency_digits': 4,
|
|
'uom': prod_templ.default_uom.id,
|
|
'rates': [('create', [{
|
|
'date': date(2022, 5, 1),
|
|
'rate': Decimal('1750.0'),
|
|
}, ])],
|
|
}])
|
|
self.assertEqual(asset.rec_name,
|
|
'Aurum | 1,750.0000 usd/u | 05/01/2022')
|
|
|
|
books = self.prep_report_3books()
|
|
cb_cat, = CbCategory.create([{'name': 'CB Category'}])
|
|
Book.write(*[
|
|
books,
|
|
{
|
|
'btype': at.id,
|
|
'asset': asset.id,
|
|
'categories': [('add', [cb_cat.id])],
|
|
'quantity_uom': asset.uom.id,
|
|
'quantity_digits': 3,
|
|
'lines': [('write',
|
|
[books[0].lines[0].id], # usd
|
|
{'quantity': Decimal('2.0'), 'amount': Decimal('3000.0')},
|
|
[books[0].lines[1].id],
|
|
{'quantity': Decimal('2.0'), 'amount': Decimal('3100.0')},
|
|
[books[1].lines[0].id], # usd
|
|
{'quantity': Decimal('2.0'), 'amount': Decimal('3200.0')},
|
|
[books[1].lines[1].id],
|
|
{'quantity': Decimal('2.0'), 'amount': Decimal('3300.0')},
|
|
[books[2].lines[0].id], # euro
|
|
{'quantity': Decimal('2.0'), 'amount': Decimal('3300.0')},
|
|
[books[2].lines[1].id],
|
|
{'quantity': Decimal('2.0'), 'amount': Decimal('3400.0')},
|
|
)],
|
|
}])
|
|
self.assertEqual(books[0].rec_name, 'Book 1 | 6,100.00 usd | Open | 4.000 u')
|
|
self.assertEqual(books[0].current_value, Decimal('7000.0'))
|
|
self.assertEqual(books[0].diff_amount, Decimal('900.0'))
|
|
self.assertEqual(books[0].diff_percent, Decimal('14.75'))
|
|
|
|
self.assertEqual(books[1].rec_name, 'Book 2 | 6,500.00 usd | Open | 4.000 u')
|
|
self.assertEqual(books[1].current_value, Decimal('7000.0'))
|
|
self.assertEqual(books[1].diff_amount, Decimal('500.0'))
|
|
self.assertEqual(books[1].diff_percent, Decimal('7.69'))
|
|
|
|
self.assertEqual(books[2].rec_name, 'Book 3 | 6,700.00 € | Open | 4.000 u')
|
|
self.assertEqual(books[2].current_value, Decimal('6666.67'))
|
|
self.assertEqual(books[2].diff_amount, Decimal('-33.33'))
|
|
self.assertEqual(books[2].diff_percent, Decimal('-0.5'))
|
|
|
|
# evaluation: amount-difference
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'dtype': 'cashbooks_gldiff',
|
|
'chart': 'hbar',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
self.assertEqual(evaluation.dtype, 'cashbooks_gldiff')
|
|
self.assertEqual(evaluation.chart, 'hbar')
|
|
self.assertEqual(evaluation.legend, True)
|
|
self.assertEqual(evaluation.maincolor, 'default')
|
|
self.assertEqual(evaluation.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation.currency.code, 'EUR')
|
|
|
|
self.assertEqual(evaluation.line_values[0].balance, Decimal('857.14'))
|
|
self.assertEqual(evaluation.line_values[1].balance, Decimal('476.19'))
|
|
self.assertEqual(evaluation.line_values[2].balance, Decimal('-33.33'))
|
|
|
|
# evaluation: percent-difference
|
|
evaluation2, = Evaluation.create([{
|
|
'name': 'Evaluation 2',
|
|
'dtype': 'cashbooks_glperc',
|
|
'chart': 'hbar',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
self.assertEqual(evaluation2.dtype, 'cashbooks_glperc')
|
|
self.assertEqual(evaluation2.chart, 'hbar')
|
|
self.assertEqual(evaluation2.legend, True)
|
|
self.assertEqual(evaluation2.maincolor, 'default')
|
|
self.assertEqual(evaluation2.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation2.currency.code, 'EUR')
|
|
|
|
self.assertEqual(evaluation2.line_values[0].balance, Decimal('14.75'))
|
|
self.assertEqual(evaluation2.line_values[1].balance, Decimal('7.69'))
|
|
self.assertEqual(evaluation2.line_values[2].balance, Decimal('-0.5'))
|
|
|
|
# evaluation: percent-difference
|
|
evaluation3, = Evaluation.create([{
|
|
'name': 'Evaluation 3',
|
|
'dtype': 'cashbooks_glvalue',
|
|
'chart': 'hbar',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
self.assertEqual(evaluation3.dtype, 'cashbooks_glvalue')
|
|
self.assertEqual(evaluation3.chart, 'hbar')
|
|
self.assertEqual(evaluation3.legend, True)
|
|
self.assertEqual(evaluation3.maincolor, 'default')
|
|
self.assertEqual(evaluation3.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation3.currency.code, 'EUR')
|
|
|
|
self.assertEqual(evaluation3.line_values[0].balance, Decimal('6666.67'))
|
|
self.assertEqual(evaluation3.line_values[1].balance, Decimal('6666.67'))
|
|
self.assertEqual(evaluation3.line_values[2].balance, Decimal('6666.67'))
|
|
|
|
# evaluation: category-current value
|
|
evaluation4, = Evaluation.create([{
|
|
'name': 'Evaluation 4',
|
|
'dtype': 'category_glvalue',
|
|
'chart': 'hbar',
|
|
'categories': [('add', [cb_cat.id])],
|
|
}])
|
|
self.assertEqual(evaluation4.dtype, 'category_glvalue')
|
|
self.assertEqual(evaluation4.chart, 'hbar')
|
|
self.assertEqual(evaluation4.legend, True)
|
|
self.assertEqual(evaluation4.maincolor, 'default')
|
|
self.assertEqual(evaluation4.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation4.currency.code, 'EUR')
|
|
|
|
self.assertEqual(len(evaluation4.line_values), 1)
|
|
self.assertEqual(evaluation4.line_values[0].balance, Decimal('20000.01'))
|
|
|
|
# evaluation: category- difference amount
|
|
evaluation5, = Evaluation.create([{
|
|
'name': 'Evaluation 5',
|
|
'dtype': 'category_gldiff',
|
|
'chart': 'hbar',
|
|
'categories': [('add', [cb_cat.id])],
|
|
}])
|
|
self.assertEqual(evaluation5.dtype, 'category_gldiff')
|
|
self.assertEqual(evaluation5.chart, 'hbar')
|
|
self.assertEqual(evaluation5.legend, True)
|
|
self.assertEqual(evaluation5.maincolor, 'default')
|
|
self.assertEqual(evaluation5.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation5.currency.code, 'EUR')
|
|
|
|
self.assertEqual(len(evaluation5.line_values), 1)
|
|
self.assertEqual(evaluation5.line_values[0].balance, Decimal('1300.01'))
|
|
|
|
# evaluation: category- difference amount
|
|
evaluation6, = Evaluation.create([{
|
|
'name': 'Evaluation 6',
|
|
'dtype': 'category_glperc',
|
|
'chart': 'hbar',
|
|
'categories': [('add', [cb_cat.id])],
|
|
}])
|
|
self.assertEqual(evaluation6.dtype, 'category_glperc')
|
|
self.assertEqual(evaluation6.chart, 'hbar')
|
|
self.assertEqual(evaluation6.legend, True)
|
|
self.assertEqual(evaluation6.maincolor, 'default')
|
|
self.assertEqual(evaluation6.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation6.currency.code, 'EUR')
|
|
|
|
self.assertEqual(len(evaluation6.line_values), 1)
|
|
self.assertEqual(evaluation6.line_values[0].balance, Decimal('6.95'))
|
|
|
|
@with_transaction()
|
|
def test_report_chart_pie_book_red(self):
|
|
""" create 3x cashbooks, add bookings,
|
|
create report with cashbooks, check
|
|
"""
|
|
Evaluation = Pool().get('cashbook_report.evaluation')
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'cashbooks': [('add', [x.id for x in books])],
|
|
}])
|
|
self.assertEqual(evaluation.dtype, 'cashbooks')
|
|
self.assertEqual(evaluation.chart, 'pie')
|
|
self.assertEqual(evaluation.legend, True)
|
|
self.assertEqual(evaluation.maincolor, 'default')
|
|
self.assertEqual(evaluation.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation.currency.code, 'EUR')
|
|
|
|
# check uiview
|
|
self.assertEqual(evaluation.ui_view_chart.model, 'cashbook_report.eval_line')
|
|
self.assertEqual(evaluation.ui_view_chart.module, 'cashbook_report')
|
|
self.assertEqual(evaluation.ui_view_chart.priority, 10)
|
|
self.assertEqual(evaluation.ui_view_chart.type, 'graph')
|
|
self.assertEqual(evaluation.ui_view_chart.data, """<?xml version="1.0"?>
|
|
<graph type="pie" legend="1" background="#ffffc0">
|
|
<x>
|
|
<field name="name"/>
|
|
</x>
|
|
<y>
|
|
<field name="balance" fill="1" empty="0" string="Cashbooks [Amount]"/>
|
|
</y>
|
|
</graph>
|
|
""")
|
|
|
|
self.assertEqual(len(evaluation.cashbooks), 3)
|
|
self.assertEqual(evaluation.cashbooks[0].rec_name, 'Book 1 | 25.00 usd | Open')
|
|
self.assertEqual(evaluation.cashbooks[1].rec_name, 'Book 2 | 12.50 usd | Open')
|
|
self.assertEqual(evaluation.cashbooks[2].rec_name, 'Book 3 | 23.00 € | Open')
|
|
self.assertEqual(evaluation.cashbooks[0].currency.code, 'usd')
|
|
self.assertEqual(evaluation.cashbooks[1].currency.code, 'usd')
|
|
self.assertEqual(evaluation.cashbooks[2].currency.code, 'EUR')
|
|
|
|
self.assertEqual(len(evaluation.line_values), 3)
|
|
self.assertEqual(evaluation.line_values[0].name, 'Book 1 | 25.00 usd | Open')
|
|
self.assertEqual(evaluation.line_values[1].name, 'Book 2 | 12.50 usd | Open')
|
|
self.assertEqual(evaluation.line_values[2].name, 'Book 3 | 23.00 € | Open')
|
|
|
|
self.assertEqual(evaluation.line_values[0].eval_currency.code, 'EUR')
|
|
self.assertEqual(evaluation.line_values[1].eval_currency.code, 'EUR')
|
|
self.assertEqual(evaluation.line_values[2].eval_currency.code, 'EUR')
|
|
|
|
self.assertEqual(evaluation.line_values[0].balance, Decimal('23.81'))
|
|
self.assertEqual(evaluation.line_values[1].balance, Decimal('11.90'))
|
|
self.assertEqual(evaluation.line_values[2].balance, Decimal('23.00'))
|
|
|
|
@with_transaction()
|
|
def test_report_chart_pie_type_red(self):
|
|
""" create 3x cashbooks, add bookings,
|
|
create report with types of cashbooks, check
|
|
"""
|
|
pool = Pool()
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
Types = pool.get('cashbook.type')
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id, # company-currency: EUR
|
|
'date': date(2022, 5, 15),
|
|
}):
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'dtype': 'types',
|
|
'types': [('add', [x.id for x in Types.search([])])],
|
|
}])
|
|
self.assertEqual(evaluation.dtype, 'types')
|
|
self.assertEqual(evaluation.chart, 'pie')
|
|
self.assertEqual(evaluation.legend, True)
|
|
self.assertEqual(evaluation.maincolor, 'default')
|
|
self.assertEqual(evaluation.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation.currency.code, 'EUR')
|
|
|
|
# 37.50 USD, Cash
|
|
# 23.00 EUR, Bank
|
|
self.assertEqual(len(evaluation.types), 2)
|
|
self.assertEqual(evaluation.types[0].rec_name, 'BK - Bank')
|
|
self.assertEqual(evaluation.types[1].rec_name, 'CAS - Cash')
|
|
# 23.00 EUR
|
|
self.assertEqual(len(evaluation.line_values), 2)
|
|
self.assertEqual(evaluation.line_values[0].eval_currency.code, 'EUR')
|
|
self.assertEqual(evaluation.line_values[0].name, 'BK - Bank')
|
|
self.assertEqual(evaluation.line_values[0].balance, Decimal('23.0'))
|
|
|
|
# 37.50 USD --> EUR
|
|
self.assertEqual(evaluation.line_values[1].name, 'CAS - Cash')
|
|
self.assertEqual(evaluation.line_values[1].eval_currency.code, 'EUR')
|
|
self.assertEqual(evaluation.line_values[1].balance, Decimal('35.71'))
|
|
|
|
@with_transaction()
|
|
def test_report_chart_pie_currency_red(self):
|
|
""" create 3x cashbooks, add bookings,
|
|
create report with types of cashbooks, check
|
|
"""
|
|
pool = Pool()
|
|
Evaluation = pool.get('cashbook_report.evaluation')
|
|
Currency = pool.get('currency.currency')
|
|
|
|
books = self.prep_report_3books()
|
|
|
|
company = self.prep_company()
|
|
with Transaction().set_context({
|
|
'company': company.id,
|
|
}):
|
|
evaluation, = Evaluation.create([{
|
|
'name': 'Evaluation 1',
|
|
'dtype': 'currencies',
|
|
'currencies': [('add', [x.id for x in Currency.search([])])],
|
|
}])
|
|
self.assertEqual(evaluation.dtype, 'currencies')
|
|
self.assertEqual(evaluation.chart, 'pie')
|
|
self.assertEqual(evaluation.legend, True)
|
|
self.assertEqual(evaluation.maincolor, 'default')
|
|
self.assertEqual(evaluation.bgcolor, '#ffffc0')
|
|
self.assertEqual(evaluation.currency.code, 'EUR')
|
|
|
|
self.assertEqual(len(evaluation.currencies), 2)
|
|
self.assertEqual(evaluation.currencies[0].code, 'EUR')
|
|
self.assertEqual(evaluation.currencies[1].code, 'usd')
|
|
|
|
self.assertEqual(len(evaluation.line_values), 2)
|
|
self.assertEqual(evaluation.line_values[0].name, 'Euro')
|
|
self.assertEqual(evaluation.line_values[0].balance, Decimal('23.0'))
|
|
self.assertEqual(evaluation.line_values[1].name, 'usd')
|
|
self.assertEqual(evaluation.line_values[1].balance, Decimal('35.71'))
|
|
|
|
# end ReportTestCase
|