def test_12_return_without_refund(self): """ Do the exact thing than in `test_11_return_with_refund` except we set on False the refund and checks the sale order delivered quantity isn't changed. """ # Creates a sale order for 10 products. sale_order = self._get_new_sale_order() # Valids the sale order, then valids the delivery. sale_order.action_confirm() self.assertTrue(sale_order.picking_ids) self.assertEqual(sale_order.order_line.qty_delivered, 0) picking = sale_order.picking_ids picking.move_lines.write({'quantity_done': 10}) picking.button_validate() # Checks the delivery amount (must be 10). self.assertEqual(sale_order.order_line.qty_delivered, 10) # Creates a return from the delivery picking. return_picking_form = Form( self.env['stock.return.picking'].with_context( active_ids=picking.ids, active_id=picking.id, active_model='stock.picking')) return_wizard = return_picking_form.save() # Checks the field `to_refund` is checked, then unchecks it. self.assertEqual(return_wizard.product_return_moves.to_refund, True) self.assertEqual(return_wizard.product_return_moves.quantity, 10) return_wizard.product_return_moves.to_refund = False # Valids the return picking. res = return_wizard.create_returns() return_picking = self.env['stock.picking'].browse(res['res_id']) return_picking.move_lines.write({'quantity_done': 10}) return_picking.button_validate() # Checks the delivery amount (must still be 10). self.assertEqual(sale_order.order_line.qty_delivered, 10)
def test_unlink_mo(self): """ Try to unlink a Manufacturing Order, and check it's possible or not depending of the MO state (must be in cancel state to be unlinked, but the unlink method will try to cancel MO before unlink them). """ # Case #1: Create MO, do nothing and try to unlink it (can be deleted) manufacturing_order = self.generate_mo()[0] self.assertEqual(manufacturing_order.exists().state, 'confirmed') manufacturing_order.unlink() # Check the MO is deleted. self.assertEqual(manufacturing_order.exists().state, False) # Case #2: Create MO, make and post some production, then try to unlink # it (cannot be deleted) manufacturing_order = self.generate_mo()[0] # Produce some quantity (not all to avoid to done the MO when post inventory) produce_form = Form(self.env['mrp.product.produce'].with_context( active_id=manufacturing_order.id)) produce_form.qty_producing = 2 produce = produce_form.save() produce.do_produce() # Post Inventory manufacturing_order.post_inventory() # Unlink the MO must raises an UserError since it cannot be really cancelled self.assertEqual(manufacturing_order.exists().state, 'progress') with self.assertRaises(UserError): manufacturing_order.unlink()
def test_cancel_mo_without_routing_3(self): """ Cancel a Manufacturing Order with no routing but some productions after post inventory. """ # Create MO manufacturing_order = self.generate_mo()[0] # Produce some quantity (not all to avoid to done the MO when post inventory) produce_form = Form(self.env['mrp.product.produce'].with_context( active_id=manufacturing_order.id)) produce_form.qty_producing = 2 produce = produce_form.save() produce.do_produce() # Post Inventory manufacturing_order.post_inventory() # Cancel the MO manufacturing_order.action_cancel() # Check MO is marked as done and its SML are done or cancelled self.assertEqual(manufacturing_order.state, 'done', "MO should be in done state.") self.assertEqual( manufacturing_order.move_raw_ids[0].state, 'done', "Due to 'post_inventory', some move raw must stay in done state") self.assertEqual( manufacturing_order.move_raw_ids[1].state, 'done', "Due to 'post_inventory', some move raw must stay in done state") self.assertEqual(manufacturing_order.move_raw_ids[2].state, 'cancel', "The other move raw are cancelled like their MO.") self.assertEqual(manufacturing_order.move_raw_ids[3].state, 'cancel', "The other move raw are cancelled like their MO.") self.assertEqual( manufacturing_order.move_finished_ids[0].state, 'done', "Due to 'post_inventory', a move finished must stay in done state") self.assertEqual(manufacturing_order.move_finished_ids[1].state, 'cancel', "The other move finished is cancelled like its MO.")
def test_survey_invite(self): Answer = self.env['survey.user_input'] deadline = fields.Datetime.now() + relativedelta(months=1) self.survey.write({ 'access_mode': 'public', 'users_login_required': False }) action = self.survey.action_send_survey() invite_form = Form(self.env[action['res_model']].with_context( action['context'])) # some lowlevel checks that action is correctly configured self.assertEqual(Answer.search([('survey_id', '=', self.survey.id)]), self.env['survey.user_input']) self.assertEqual(invite_form.survey_id, self.survey) invite_form.partner_ids.add(self.customer) invite_form.deadline = fields.Datetime.to_string(deadline) invite = invite_form.save() invite.action_invite() answers = Answer.search([('survey_id', '=', self.survey.id)]) self.assertEqual(len(answers), 1) self.assertEqual(set(answers.mapped('email')), set([self.customer.email])) self.assertEqual(answers.mapped('partner_id'), self.customer) self.assertEqual(set(answers.mapped('deadline')), set([deadline]))
def test_product_produce_1(self): """ Check that no produce line are created when the consumed products are not tracked """ self.stock_location = self.env.ref('stock.stock_location_stock') mo, bom, p_final, p1, p2 = self.generate_mo() self.assertEqual(len(mo), 1, 'MO should have been created') self.env['stock.quant']._update_available_quantity( p1, self.stock_location, 100) self.env['stock.quant']._update_available_quantity( p2, self.stock_location, 5) mo.action_assign() produce_form = Form(self.env['mrp.product.produce'].with_context({ 'active_id': mo.id, 'active_ids': [mo.id], })) product_produce = produce_form.save() product_produce.do_produce() self.assertEqual( len(product_produce.produce_line_ids), 2, 'You should have produce lines even the consumed products are not tracked.' )
def test_survey_invite_authentication_nosignup(self): Answer = self.env['survey.user_input'] self.survey.write({ 'access_mode': 'public', 'users_login_required': True }) action = self.survey.action_send_survey() invite_form = Form(self.env[action['res_model']].with_context( action['context'])) with self.assertRaises( UserError ): # do not allow to add customer (partner without user) invite_form.partner_ids.add(self.customer) invite_form.partner_ids.clear() invite_form.partner_ids.add(self.user_portal.partner_id) invite_form.partner_ids.add(self.user_emp.partner_id) with self.assertRaises(UserError): invite_form.emails = '[email protected], Raoulette Vignolette <*****@*****.**>' invite_form.emails = False invite = invite_form.save() invite.action_invite() answers = Answer.search([('survey_id', '=', self.survey.id)]) self.assertEqual(len(answers), 2) self.assertEqual(set(answers.mapped('email')), set([self.user_emp.email, self.user_portal.email])) self.assertEqual( answers.mapped('partner_id'), self.user_emp.partner_id | self.user_portal.partner_id)
def test_survey_invite_authentication_signup(self): self.env["ir.config_parameter"].sudo().set_param( 'auth_signup.invitation_scope', 'b2c') self.survey.invalidate_cache() Answer = self.env['survey.user_input'] self.survey.write({ 'access_mode': 'public', 'users_login_required': True }) action = self.survey.action_send_survey() invite_form = Form(self.env[action['res_model']].with_context( action['context'])) invite_form.partner_ids.add(self.customer) invite_form.partner_ids.add(self.user_portal.partner_id) invite_form.partner_ids.add(self.user_emp.partner_id) # TDE FIXME: not sure for emails in authentication + signup # invite_form.emails = '[email protected], Raoulette Vignolette <*****@*****.**>' invite = invite_form.save() invite.action_invite() answers = Answer.search([('survey_id', '=', self.survey.id)]) self.assertEqual(len(answers), 3) self.assertEqual( set(answers.mapped('email')), set([ self.customer.email, self.user_emp.email, self.user_portal.email ])) self.assertEqual( answers.mapped('partner_id'), self.customer | self.user_emp.partner_id | self.user_portal.partner_id)
def test_survey_invite_token(self): Answer = self.env['survey.user_input'] self.survey.write({ 'access_mode': 'token', 'users_login_required': False }) action = self.survey.action_send_survey() invite_form = Form(self.env[action['res_model']].with_context( action['context'])) invite_form.partner_ids.add(self.customer) invite_form.emails = '[email protected], Raoulette Vignolette <*****@*****.**>' invite = invite_form.save() invite.action_invite() answers = Answer.search([('survey_id', '=', self.survey.id)]) self.assertEqual(len(answers), 3) self.assertEqual( set(answers.mapped('email')), set([ '*****@*****.**', '"Raoulette Vignolette" <*****@*****.**>', self.customer.email ])) self.assertEqual(answers.mapped('partner_id'), self.customer)
def test_11_return_with_refund(self): """ Creates a sale order, valids it and its delivery, then creates a return. The return must refund by default and the sale order delivered quantity must be updated. """ # Creates a sale order for 10 products. sale_order = self._get_new_sale_order() # Valids the sale order, then valids the delivery. sale_order.action_confirm() self.assertTrue(sale_order.picking_ids) self.assertEqual(sale_order.order_line.qty_delivered, 0) picking = sale_order.picking_ids picking.move_lines.write({'quantity_done': 10}) picking.button_validate() # Checks the delivery amount (must be 10). self.assertEqual(sale_order.order_line.qty_delivered, 10) # Creates a return from the delivery picking. return_picking_form = Form( self.env['stock.return.picking'].with_context( active_ids=picking.ids, active_id=picking.id, active_model='stock.picking')) return_wizard = return_picking_form.save() # Checks the field `to_refund` is checked (must be checked by default). self.assertEqual(return_wizard.product_return_moves.to_refund, True) self.assertEqual(return_wizard.product_return_moves.quantity, 10) # Valids the return picking. res = return_wizard.create_returns() return_picking = self.env['stock.picking'].browse(res['res_id']) return_picking.move_lines.write({'quantity_done': 10}) return_picking.button_validate() # Checks the delivery amount (must be 0). self.assertEqual(sale_order.order_line.qty_delivered, 0)
def test_employee_resource(self): _tz = 'Pacific/Apia' self.res_users_hr_officer.company_id.resource_calendar_id.tz = _tz Employee = self.env['hr.employee'].with_user(self.res_users_hr_officer) employee_form = Form(Employee) employee_form.name = 'Raoul Grosbedon' employee_form.work_email = '*****@*****.**' employee = employee_form.save() self.assertEqual(employee.tz, _tz)
def test_00_dropship(self): # Create a vendor supplier_dropship = self.env['res.partner'].create({'name': 'Vendor of Dropshipping test'}) # Create new product without any routes drop_shop_product = self.env['product.product'].create({ 'name': "Pen drive", 'type': "product", 'categ_id': self.env.ref('product.product_category_1').id, 'lst_price': 100.0, 'standard_price': 0.0, 'uom_id': self.env.ref('uom.product_uom_unit').id, 'uom_po_id': self.env.ref('uom.product_uom_unit').id, 'seller_ids': [(0, 0, { 'delay': 1, 'name': supplier_dropship.id, 'min_qty': 2.0 })] }) # Create a sales order with a line of 200 PCE incoming shipment, with route_id drop shipping so_form = Form(self.env['sale.order']) so_form.partner_id = self.env.ref('base.res_partner_2') so_form.payment_term_id = self.env.ref('account.account_payment_term') with mute_logger('eagle.tests.common.onchange'): # otherwise complains that there's not enough inventory and # apparently that's normal according to @jco and @sle with so_form.order_line.new() as line: line.product_id = drop_shop_product line.product_uom_qty = 200 line.price_unit = 1.00 line.route_id = self.env.ref('stock_dropshipping.route_drop_shipping') sale_order_drp_shpng = so_form.save() # Confirm sales order sale_order_drp_shpng.action_confirm() # Check the sales order created a procurement group which has a procurement of 200 pieces self.assertTrue(sale_order_drp_shpng.procurement_group_id, 'SO should have procurement group') # Check a quotation was created to a certain vendor and confirm so it becomes a confirmed purchase order purchase = self.env['purchase.order'].search([('partner_id', '=', supplier_dropship.id)]) self.assertTrue(purchase, "an RFQ should have been created by the scheduler") purchase.button_confirm() self.assertEquals(purchase.state, 'purchase', 'Purchase order should be in the approved state') self.assertEquals(len(purchase.ids), 1, 'There should be one picking') # Send the 200 pieces purchase.picking_ids.move_lines.quantity_done = purchase.picking_ids.move_lines.product_qty purchase.picking_ids.button_validate() # Check one move line was created in Customers location with 200 pieces move_line = self.env['stock.move.line'].search([ ('location_dest_id', '=', self.env.ref('stock.stock_location_customers').id), ('product_id', '=', drop_shop_product.id)]) self.assertEquals(len(move_line.ids), 1, 'There should be exactly one move line')
def test_inventory_adjustment_and_negative_quants_1(self): """Make sure negative quants from returns get wiped out with an inventory adjustment""" productA = self.env['product.product'].create({ 'name': 'Product A', 'type': 'product' }) stock_location = self.env.ref('stock.stock_location_stock') customer_location = self.env.ref('stock.stock_location_customers') # Create a picking out and force availability picking_out = self.env['stock.picking'].create({ 'partner_id': self.partner.id, 'picking_type_id': self.env.ref('stock.picking_type_out').id, 'location_id': stock_location.id, 'location_dest_id': customer_location.id, }) self.env['stock.move'].create({ 'name': productA.name, 'product_id': productA.id, 'product_uom_qty': 1, 'product_uom': productA.uom_id.id, 'picking_id': picking_out.id, 'location_id': stock_location.id, 'location_dest_id': customer_location.id, }) picking_out.action_confirm() picking_out.move_lines.quantity_done = 1 picking_out.action_done() quant = self.env['stock.quant'].search([ ('product_id', '=', productA.id), ('location_id', '=', stock_location.id) ]) self.assertEqual(len(quant), 1) stock_return_picking_form = Form( self.env['stock.return.picking'].with_context( active_ids=picking_out.ids, active_id=picking_out.ids[0], active_model='stock.picking')) stock_return_picking = stock_return_picking_form.save() stock_return_picking.product_return_moves.quantity = 1.0 stock_return_picking_action = stock_return_picking.create_returns() return_pick = self.env['stock.picking'].browse( stock_return_picking_action['res_id']) return_pick.action_assign() return_pick.move_lines.quantity_done = 1 return_pick.action_done() quant = self.env['stock.quant'].search([ ('product_id', '=', productA.id), ('location_id', '=', stock_location.id) ]) self.assertEqual(sum(quant.mapped('quantity')), 0)
def setUp(self): super(TestSubcontractingTracking, self).setUp() # 1: Create a subcontracting partner main_company_1 = self.env['res.partner'].create( {'name': 'main_partner'}) self.subcontractor_partner1 = self.env['res.partner'].create({ 'name': 'Subcontractor 1', 'parent_id': main_company_1.id, 'company_id': self.env.ref('base.main_company').id }) # 2. Create a BOM of subcontracting type # 2.1. Comp1 has tracking by lot self.comp1_sn = self.env['product.product'].create({ 'name': 'Component1', 'type': 'product', 'categ_id': self.env.ref('product.product_category_all').id, 'tracking': 'serial' }) self.comp2 = self.env['product.product'].create({ 'name': 'Component2', 'type': 'product', 'categ_id': self.env.ref('product.product_category_all').id, }) # 2.2. Finished prodcut has tracking by serial number self.finished_lot = self.env['product.product'].create({ 'name': 'finished', 'type': 'product', 'categ_id': self.env.ref('product.product_category_all').id, 'tracking': 'lot' }) bom_form = Form(self.env['mrp.bom']) bom_form.type = 'subcontract' bom_form.subcontractor_ids.add(self.subcontractor_partner1) bom_form.product_tmpl_id = self.finished_lot.product_tmpl_id with bom_form.bom_line_ids.new() as bom_line: bom_line.product_id = self.comp1_sn bom_line.product_qty = 1 with bom_form.bom_line_ids.new() as bom_line: bom_line.product_id = self.comp2 bom_line.product_qty = 1 self.bom_tracked = bom_form.save()
def _produce(self, mo, quantity=0): produce_form = Form(self.env['mrp.product.produce'].with_context({ 'active_id': mo.id, 'active_ids': [mo.id], })) if quantity: produce_form.qty_producing = quantity product_produce = produce_form.save() product_produce.do_produce()
def _make_return(self, move, quantity_to_return): stock_return_picking = Form(self.env['stock.return.picking']\ .with_context(active_ids=[move.picking_id.id], active_id=move.picking_id.id, active_model='stock.picking')) stock_return_picking = stock_return_picking.save() stock_return_picking.product_return_moves.quantity = quantity_to_return stock_return_picking_action = stock_return_picking.create_returns() return_pick = self.env['stock.picking'].browse(stock_return_picking_action['res_id']) return_pick.move_lines[0].move_line_ids[0].qty_done = quantity_to_return return_pick.action_done() return return_pick.move_lines
def test_product_produce_1(self): """Check that using a finished lot of company b in the produce wizard of a production of company a is not allowed """ product = self.env['product.product'].create({ 'name': 'p1', 'tracking': 'lot', }) component = self.env['product.product'].create({ 'name': 'p2', }) lot_b = self.env['stock.production.lot'].create({ 'product_id': product.id, 'company_id': self.company_b.id, }) self.env['mrp.bom'].create({ 'product_id': product.id, 'product_tmpl_id': product.product_tmpl_id.id, 'company_id': self.company_a.id, 'bom_line_ids': [(0, 0, {'product_id': component.id})] }) mo_form = Form(self.env['mrp.production'].with_user(self.user_a)) mo_form.product_id = product mo = mo_form.save() mo.with_user(self.user_b).action_confirm() produce_form = Form(self.env['mrp.product.produce'].with_user(self.user_b).with_context({ 'active_id': mo.id, 'active_ids': [mo.id], })) produce_form.finished_lot_id = lot_b with self.assertRaises(UserError): produce_form.save()
def test_00_product_company_level_delays(self): """ In order to check schedule date, set product's Manufacturing Lead Time and Customer Lead Time and also set company's Manufacturing Lead Time and Sales Safety Days.""" company = self.env.ref('base.main_company') # Update company with Manufacturing Lead Time and Sales Safety Days company.write({'manufacturing_lead': 3.0, 'security_lead': 3.0}) # Create sale order of product_1 order_form = Form(self.env['sale.order']) order_form.partner_id = self.partner_1 with order_form.order_line.new() as line: line.product_id = self.product_1 line.product_uom_qty = 10 order = order_form.save() # Confirm sale order order.action_confirm() # Check manufacturing order created or not manufacturing_order = self.env['mrp.production'].search([ ('product_id', '=', self.product_1.id), ('move_dest_ids', 'in', order.picking_ids[0].move_lines.ids) ]) self.assertTrue(manufacturing_order, 'Manufacturing order should be created.') # Check schedule date of picking out_date = fields.Datetime.from_string(order.date_order) + timedelta( days=self.product_1.sale_delay) - timedelta( days=company.security_lead) min_date = fields.Datetime.from_string( order.picking_ids[0].scheduled_date) self.assertAlmostEqual( min_date, out_date, delta=timedelta(seconds=1), msg= 'Schedule date of picking should be equal to: Order date + Customer Lead Time - Sales Safety Days.' ) # Check schedule date of manufacturing order mo_date = out_date - timedelta( days=self.product_1.produce_delay) - timedelta( days=company.manufacturing_lead) date_deadline = fields.Datetime.from_string( manufacturing_order.date_deadline) self.assertAlmostEqual( date_deadline, mo_date, delta=timedelta(seconds=1), msg= "Schedule date of manufacturing order should be equal to: Schedule date of picking - product's Manufacturing Lead Time - company's Manufacturing Lead Time." )
def test_rounding(self): """ In previous versions we had rounding and efficiency fields. We check if we can still do the same, but with only the rounding on the UoM""" self.product_6.uom_id.rounding = 1.0 bom_eff = self.env['mrp.bom'].create({ 'product_id': self.product_6.id, 'product_tmpl_id': self.product_6.product_tmpl_id.id, 'product_qty': 1, 'product_uom_id': self.product_6.uom_id.id, 'type': 'normal', 'bom_line_ids': [(0, 0, { 'product_id': self.product_2.id, 'product_qty': 2.03 }), (0, 0, { 'product_id': self.product_8.id, 'product_qty': 4.16 })] }) production = self.env['mrp.production'].create({ 'name': 'MO efficiency test', 'product_id': self.product_6.id, 'product_qty': 20, 'bom_id': bom_eff.id, 'product_uom_id': self.product_6.uom_id.id, }) #Check the production order has the right quantities self.assertEqual(production.move_raw_ids[0].product_qty, 41, 'The quantity should be rounded up') self.assertEqual(production.move_raw_ids[1].product_qty, 84, 'The quantity should be rounded up') # produce product produce_form = Form(self.env['mrp.product.produce'].with_context({ 'active_id': production.id, 'active_ids': [production.id], })) produce_form.product_qty = 8 produce_wizard = produce_form.save() produce_wizard.do_produce() self.assertEqual(production.move_raw_ids[0].quantity_done, 16, 'Should use half-up rounding when producing') self.assertEqual(production.move_raw_ids[1].quantity_done, 34, 'Should use half-up rounding when producing')
def test_product_produce_uom(self): plastic_laminate = self.env.ref('mrp.product_product_plastic_laminate') bom = self.env.ref('mrp.mrp_bom_plastic_laminate') dozen = self.env.ref('uom.product_uom_dozen') unit = self.env.ref('uom.product_uom_unit') plastic_laminate.tracking = 'serial' mo = self.env['mrp.production'].create({ 'name': 'Dozen Plastic Laminate', 'product_id': plastic_laminate.id, 'product_uom_id': dozen.id, 'product_qty': 1, 'bom_id': bom.id, }) final_product_lot = self.env['stock.production.lot'].create({ 'name': 'lot1', 'product_id': plastic_laminate.id, }) mo.action_assign() self.assertEqual(mo.move_raw_ids.product_qty, 12, '12 units should be reserved.') # produce product produce_form = Form(self.env['mrp.product.produce'].with_context({ 'active_id': mo.id, 'active_ids': [mo.id], })) produce_form.lot_id = final_product_lot product_produce = produce_form.save() self.assertEqual(product_produce.product_qty, 1) self.assertEqual(product_produce.product_uom_id, unit, 'Should be 1 unit since the tracking is serial.') product_produce.lot_id = final_product_lot.id product_produce.do_produce() move_line_raw = mo.move_raw_ids.mapped('move_line_ids').filtered( lambda m: m.qty_done) self.assertEqual(move_line_raw.qty_done, 1) self.assertEqual(move_line_raw.product_uom_id, unit, 'Should be 1 unit since the tracking is serial.') move_line_finished = mo.move_finished_ids.mapped( 'move_line_ids').filtered(lambda m: m.qty_done) self.assertEqual(move_line_finished.qty_done, 1) self.assertEqual(move_line_finished.product_uom_id, unit, 'Should be 1 unit since the tracking is serial.')
def test_company_no_color_change_logo(self): """When neither a logo nor the colors are set The wizard displays the colors of the report layout Changing logo means the colors on the wizard change too Emptying the logo works and doesn't change the colors""" self.company.write({ 'primary_color': False, 'secondary_color': False, 'logo': False, 'external_report_layout_id': self.env.ref('base.layout_template1').id, }) default_colors = self.default_colors with Form(self.env['base.document.layout']) as doc_layout: self.assertColors(doc_layout, default_colors) self.assertEqual(doc_layout.company_id, self.company) doc_layout.logo = self.company_imgs['overwatch']['img'] self.assertColors(doc_layout, self.company_imgs['overwatch']['colors']) doc_layout.logo = '' self.assertColors(doc_layout, self.company_imgs['overwatch']['colors']) self.assertEqual(doc_layout.logo, '')
def test_fifo_delivered_invoice_post_partial_delivery(self): """Receive 1@8, 1@10, so 2@12, standard price 12, deliver 1, invoice 2: the price used should be 10: one at 8 and one at 10.""" self.product.categ_id.property_cost_method = 'fifo' self.product.invoice_policy = 'delivery' self._fifo_in_one_eight_one_ten() # Create and confirm a sale order for 2@12 sale_order = self._so_and_confirm_two_units() # Deliver one. sale_order.picking_ids.move_lines.quantity_done = 1 wiz = sale_order.picking_ids.button_validate() wiz = self.env[wiz['res_model']].browse(wiz['res_id']) wiz.process() # upate the standard price to 12 self.product.standard_price = 12 # Invoice 2 invoice = sale_order._create_invoices() invoice_form = Form(invoice) with invoice_form.invoice_line_ids.edit(0) as invoice_line: invoice_line.quantity = 2 invoice_form.save() invoice.post() # Check the resulting accounting entries amls = invoice.line_ids self.assertEqual(len(amls), 4) stock_out_aml = amls.filtered( lambda aml: aml.account_id == self.stock_output_account) self.assertEqual(stock_out_aml.debit, 0) self.assertEqual(stock_out_aml.credit, 20) cogs_aml = amls.filtered( lambda aml: aml.account_id == self.expense_account) self.assertEqual(cogs_aml.debit, 20) self.assertEqual(cogs_aml.credit, 0) receivable_aml = amls.filtered( lambda aml: aml.account_id == self.recv_account) self.assertEqual(receivable_aml.debit, 24) self.assertEqual(receivable_aml.credit, 0) income_aml = amls.filtered( lambda aml: aml.account_id == self.income_account) self.assertEqual(income_aml.debit, 0) self.assertEqual(income_aml.credit, 24)
def test_01_warehouse_twostep_manufacturing(self): """ Warehouse testing for picking before manufacturing """ with Form(self.warehouse) as warehouse: warehouse.manufacture_steps = 'pbm' self._check_location_and_routes() self.assertEqual(len(self.warehouse.pbm_route_id.rule_ids), 2) self.assertEqual(self.warehouse.manufacture_pull_id.location_id.id, self.warehouse.lot_stock_id.id)
def test_02_warehouse_twostep_manufacturing(self): """ Warehouse testing for picking ans store after manufacturing """ with Form(self.warehouse) as warehouse: warehouse.manufacture_steps = 'pbm_sam' self._check_location_and_routes() self.assertEqual(len(self.warehouse.pbm_route_id.rule_ids), 3) self.assertEqual(self.warehouse.manufacture_pull_id.location_id.id, self.warehouse.sam_loc_id.id)
def create_account_invoice(self, invoice_type, partner, product, quantity=0.0, price_unit=0.0): """ Create an invoice as in a view by triggering its onchange methods""" invoice_form = Form( self.env['account.invoice'].with_context(type=invoice_type)) invoice_form.partner_id = partner with invoice_form.invoice_line_ids.new() as line: line.product_id = product line.quantity = quantity line.price_unit = price_unit invoice = invoice_form.save() invoice.action_invoice_open() return invoice
def _make_lc(self, move, amount): picking = move.picking_id lc = Form(self.env['stock.landed.cost']) lc.account_journal_id = self.stock_journal lc.picking_ids.add(move.picking_id) with lc.cost_lines.new() as cost_line: cost_line.product_id = self.productlc1 cost_line.price_unit = amount lc = lc.save() lc.compute_landed_cost() lc.button_validate() return lc
def test_no_expense(self): """ Test invoicing vendor bill with no policy. Check nothing happen. """ # confirm SO sale_order_line = self.env['sale.order.line'].create({ 'name': self.product_no_expense.name, 'product_id': self.product_no_expense.id, 'product_uom_qty': 2, 'qty_delivered': 1, 'product_uom': self.product_no_expense.uom_id.id, 'price_unit': self.product_no_expense.list_price, 'order_id': self.sale_order.id, }) self.sale_order._compute_tax_id() self.sale_order.action_confirm() # create invoice lines and validate it move_form = Form(self.AccountMove) move_form.partner_id = self.partner_customer_usd move_form.journal_id = self.journal_purchase with move_form.line_ids.new() as line_form: line_form.product_id = self.product_no_expense line_form.quantity = 3.0 line_form.analytic_account_id = self.analytic_account invoice_a = move_form.save() invoice_a.post() self.assertEquals( len(self.sale_order.order_line), 1, "No SO line should have been created (or removed) when validating vendor bill" ) self.assertEquals( sale_order_line.qty_delivered, 1, "The delivered quantity of SO line should not have been incremented" ) self.assertTrue(invoice_a.mapped('line_ids.analytic_line_ids'), "Analytic lines should be generated")
def test_00_create_warehouse(self): """ Warehouse testing for direct manufacturing """ with Form(self.warehouse) as warehouse: warehouse.manufacture_steps = 'mrp_one_step' self._check_location_and_routes() # Check locations of existing pull rule self.assertFalse( self.warehouse.pbm_route_id.rule_ids, 'only the update of global manufacture route should happen.') self.assertEqual(self.warehouse.manufacture_pull_id.location_id.id, self.warehouse.lot_stock_id.id)
def create_product(name, uom_id, routes=()): p = Form(self.env['product.product']) p.name = name p.type = 'product' p.uom_id = uom_id p.uom_po_id = uom_id p.route_ids.clear() for r in routes: p.route_ids.add(r) return p.save()
def test_company_colors_change_logo(self): """changes of the logo implies displaying the new computed colors""" self.company.write({ 'primary_color': '#ff0080', 'secondary_color': '#00ff00', 'logo': False, }) with Form(self.env['base.document.layout']) as doc_layout: self.assertColors(doc_layout, self.company) doc_layout.logo = self.company_imgs['eagle']['img'] self.assertColors(doc_layout, self.company_imgs['eagle']['colors'])
def test_procurement_2(self): """Check that a manufacturing order create the right procurements when the route are set on a parent category of a product""" # find a child category id all_categ_id = self.env['product.category'].search( [('parent_id', '=', None)], limit=1) child_categ_id = self.env['product.category'].search( [('parent_id', '=', all_categ_id.id)], limit=1) # set the product of `self.bom_1` to this child category for bom_line_id in self.bom_1.bom_line_ids: # check that no routes are defined on the product self.assertEquals(len(bom_line_id.product_id.route_ids), 0) # set the category of the product to a child category bom_line_id.product_id.categ_id = child_categ_id # set the MTO route to the parent category (all) self.warehouse = self.env.ref('stock.warehouse0') mto_route = self.warehouse.mto_pull_id.route_id mto_route.product_categ_selectable = True all_categ_id.write({'route_ids': [(6, 0, [mto_route.id])]}) # create MO, but check it raises error as components are in make to order and not everyone has with self.assertRaises(UserError): production_form = Form(self.env['mrp.production']) production_form.product_id = self.product_4 production_form.product_uom_id = self.product_4.uom_id production_form.product_qty = 1 production_product_4 = production_form.save() production_product_4.action_confirm()