From a6d60005014d4e5eb812c44ad628139779b4bf05 Mon Sep 17 00:00:00 2001 From: mreficent Date: Thu, 2 Mar 2017 14:31:49 +0100 Subject: [PATCH] [ADD] Adding tests --- stock_cycle_count/tests/__init__.py | 6 + .../tests/test_stock_cycle_count.py | 170 ++++++++++++++++++ 2 files changed, 176 insertions(+) create mode 100644 stock_cycle_count/tests/__init__.py create mode 100644 stock_cycle_count/tests/test_stock_cycle_count.py diff --git a/stock_cycle_count/tests/__init__.py b/stock_cycle_count/tests/__init__.py new file mode 100644 index 000000000..31b8b678b --- /dev/null +++ b/stock_cycle_count/tests/__init__.py @@ -0,0 +1,6 @@ +# -*- coding: utf-8 -*- +# Copyright 2017 Eficent Business and IT Consulting Services S.L. +# (http://www.eficent.com) +# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html). + +from . import test_stock_cycle_count diff --git a/stock_cycle_count/tests/test_stock_cycle_count.py b/stock_cycle_count/tests/test_stock_cycle_count.py new file mode 100644 index 000000000..751f3a107 --- /dev/null +++ b/stock_cycle_count/tests/test_stock_cycle_count.py @@ -0,0 +1,170 @@ +# -*- coding: utf-8 -*- +# Copyright 2017 Eficent Business and IT Consulting Services S.L. +# (http://www.eficent.com) +# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html). +from openerp.tests import common +from openerp.exceptions import ValidationError +from openerp.exceptions import AccessError + + +class TestStockCycleCount(common.TransactionCase): + + def setUp(self): + super(TestStockCycleCount, self).setUp() + self.res_users_model = self.env['res.users'] + self.stock_cycle_count_model = self.env['stock.cycle.count'] + self.stock_cycle_count_rule_model = self.env['stock.cycle.count.rule'] + self.stock_inventory_model = self.env['stock.inventory'] + self.stock_location_model = self.env['stock.location'] + self.stock_move_model = self.env['stock.move'] + self.stock_warehouse_model = self.env['stock.warehouse'] + + self.company = self.env.ref('base.main_company') + self.partner = self.env.ref('base.res_partner_1') + self.g_stock_manager = self.env.ref('stock.group_stock_manager') + self.g_stock_user = self.env.ref('stock.group_stock_user') + + self.stock_location1 = self.stock_location_model.create( + {'name': 'Place', 'usage': 'production'}) + + self.big_wh = self.stock_warehouse_model.create( + {'name': 'BIG', 'code': 'B'}) + self.small_wh = self.stock_warehouse_model.create( + {'name': 'SMALL', 'code': 'S'}) + + self.user1 = self._create_user('user_1', + [self.g_stock_manager], + self.company) + self.user2 = self._create_user('user_2', + [self.g_stock_user], + self.company) + + # rule 1: periodic rule filled + self.stock_cycle_count_rule1 = \ + self._create_stock_cycle_count_rule_periodic( + self.user1.id, 'rule_1', [2, 7]) + + # rule 2: turnover rule filled + self.stock_cycle_count_rule2 = \ + self._create_stock_cycle_count_rule_turnover( + self.user1.id, 'rule_2', [100]) + + # rule 3: accuracy rule filled + self.stock_cycle_count_rule3 = \ + self._create_stock_cycle_count_rule_accuracy( + self.user1.id, 'rule_3', [5]) + + # rule 4: zero rule filled + self.stock_cycle_count_rule4 = \ + self._create_stock_cycle_count_rule_zero( + self.user1.id, 'rule_4') + + self.stock_cycle_count1 = self._create_stock_cycle_count( + self.user1.id, 'cycle_count_1', self.stock_cycle_count_rule1, + self.stock_location1) + + self.stock_cycle_count1.action_create_inventory_adjustment() + self.stock_cycle_count1.action_view_inventory() + + self.inventory1 = self.stock_inventory_model.search([ + ('cycle_count_id', '=', self.stock_cycle_count1.id)]) + self.inventory1.prepare_inventory() + + self.inventory1.action_done() + + self.stock_cycle_count2 = self._create_stock_cycle_count( + self.user1.id, 'cycle_count_2', self.stock_cycle_count_rule1, + self.stock_location1) + self.stock_cycle_count2.do_cancel() + + self.big_wh.zero_confirmation_disabled = 1 + + def _create_user(self, login, groups, company): + """Creates a user.""" + group_ids = [group.id for group in groups] + user = self.res_users_model.create({ + 'name': login, + 'login': login, + 'password': 'demo', + 'email': 'example@yourcompany.com', + 'company_id': company.id, + 'company_ids': [(4, company.id)], + 'groups_id': [(6, 0, group_ids)] + }) + return user + + def _create_stock_cycle_count_rule_periodic(self, uid, name, values): + """Creates a Cycle Count rule of periodic type.""" + rule = self.stock_cycle_count_rule_model.sudo(uid).create({ + 'name': name, + 'rule_type': 'periodic', + 'periodic_qty_per_period': values[0], + 'periodic_count_period': values[1], + }) + return rule + + def _create_stock_cycle_count_rule_turnover(self, uid, name, values): + """Creates a Cycle Count rule of turnover type.""" + rule = self.stock_cycle_count_rule_model.sudo(uid).create({ + 'name': name, + 'rule_type': 'turnover', + 'turnover_inventory_value_threshold': values[0], + }) + return rule + + def _create_stock_cycle_count_rule_accuracy(self, uid, name, values): + """Creates a Cycle Count rule of accuracy type.""" + rule = self.stock_cycle_count_rule_model.sudo(uid).create({ + 'name': name, + 'rule_type': 'accuracy', + 'accuracy_threshold': values[0], + }) + return rule + + def _create_stock_cycle_count_rule_zero(self, uid, name): + """Creates a Cycle Count rule of zero type.""" + rule = self.stock_cycle_count_rule_model.sudo(uid).create({ + 'name': name, + 'rule_type': 'zero', + }) + return rule + + def _create_stock_cycle_count(self, uid, name, rule, location): + """Creates a Cycle Count.""" + rule = self.stock_cycle_count_model.sudo(uid).create({ + 'name': name, + 'cycle_count_rule_id': rule.id, + 'location_id': location.id, + }) + return rule + + def test_user_security(self): + with self.assertRaises(AccessError): + self.stock_cycle_count_rule1b = \ + self._create_stock_cycle_count_rule_periodic( + self.user2.id, 'rule_1b', [2, 7]) + with self.assertRaises(AccessError): + self.stock_cycle_count1.sudo(self.user2.id).unlink() + + def test_rule_periodic(self): + # constrain: periodic_qty_per_period < 1 + with self.assertRaises(ValidationError): + self.stock_cycle_count_rule0 = \ + self._create_stock_cycle_count_rule_periodic( + self.user1.id, 'rule_0', [0, 0]) + # constrain: periodic_count_period < 0 + with self.assertRaises(ValidationError): + self.stock_cycle_count_rule0 = \ + self._create_stock_cycle_count_rule_periodic( + self.user1.id, 'rule_0', [1, -1]) + + def test_rule_zero(self): + # constrain: can only have one zero confirmation rule per warehouse + with self.assertRaises(ValidationError): + self.stock_cycle_count_rule5 = \ + self._create_stock_cycle_count_rule_zero( + self.user1.id, 'rule_5') + # constrain: can only have one warehouse assigned + self.stock_cycle_count_rule4.warehouse_ids = [(4, self.big_wh.id)] + with self.assertRaises(ValidationError): + self.stock_cycle_count_rule4.warehouse_ids = [(4, self.small_wh.id)]