mirror of
https://github.com/ForgeFlow/stock-rma.git
synced 2025-01-21 12:57:49 +02:00
844 lines
32 KiB
Python
844 lines
32 KiB
Python
# © 2017 ForgeFlow
|
|
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html)
|
|
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.tests import common
|
|
|
|
|
|
class TestRma(common.SavepointCase):
|
|
""" Test the routes and the quantities """
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super(TestRma, cls).setUpClass()
|
|
|
|
cls.rma_make_picking = cls.env["rma_make_picking.wizard"]
|
|
cls.make_supplier_rma = cls.env["rma.order.line.make.supplier.rma"]
|
|
cls.rma_add_stock_move = cls.env["rma_add_stock_move"]
|
|
cls.stockpicking = cls.env["stock.picking"]
|
|
cls.rma = cls.env["rma.order"]
|
|
cls.rma_line = cls.env["rma.order.line"]
|
|
cls.rma_op = cls.env["rma.operation"]
|
|
cls.product_product_model = cls.env["product.product"]
|
|
cls.rma_cust_replace_op_id = cls.env.ref("rma.rma_operation_customer_replace")
|
|
cls.rma_sup_replace_op_id = cls.env.ref("rma.rma_operation_supplier_replace")
|
|
cls.rma_ds_replace_op_id = cls.env.ref("rma.rma_operation_ds_replace")
|
|
cls.category = cls._create_product_category(
|
|
"one_step", cls.rma_cust_replace_op_id, cls.rma_sup_replace_op_id
|
|
)
|
|
cls.product_id = cls._create_product("PT0")
|
|
cls.product_1 = cls._create_product("PT1")
|
|
cls.product_2 = cls._create_product("PT2")
|
|
cls.product_3 = cls._create_product("PT3")
|
|
cls.uom_unit = cls.env.ref("uom.product_uom_unit")
|
|
cls.env.user.company_id.group_rma_delivery_address = True
|
|
cls.env.user.company_id.group_rma_lines = True
|
|
|
|
cls.partner_id = cls.env.ref("base.res_partner_2")
|
|
cls.stock_location = cls.env.ref("stock.stock_location_stock")
|
|
wh = cls.env.ref("stock.warehouse0")
|
|
cls.stock_rma_location = wh.lot_rma_id
|
|
cls.customer_location = cls.env.ref("stock.stock_location_customers")
|
|
cls.supplier_location = cls.env.ref("stock.stock_location_suppliers")
|
|
cls.product_uom_id = cls.env.ref("uom.product_uom_unit")
|
|
# Customer RMA:
|
|
products2move = [(cls.product_1, 3), (cls.product_2, 5), (cls.product_3, 2)]
|
|
cls.rma_customer_id = cls._create_rma_from_move(
|
|
products2move, "customer", cls.env.ref("base.res_partner_2"), dropship=False
|
|
)
|
|
# Dropship:
|
|
cls.rma_droship_id = cls._create_rma_from_move(
|
|
products2move,
|
|
"customer",
|
|
cls.env.ref("base.res_partner_2"),
|
|
dropship=True,
|
|
supplier_address_id=cls.env.ref("base.res_partner_3"),
|
|
)
|
|
# Supplier RMA:
|
|
cls.rma_supplier_id = cls._create_rma_from_move(
|
|
products2move, "supplier", cls.env.ref("base.res_partner_2"), dropship=False
|
|
)
|
|
|
|
@classmethod
|
|
def _create_product_category(
|
|
cls, rma_approval_policy, rma_customer_operation_id, rma_supplier_operation_id
|
|
):
|
|
return cls.env["product.category"].create(
|
|
{
|
|
"name": "Test category",
|
|
"rma_approval_policy": rma_approval_policy,
|
|
"rma_customer_operation_id": rma_customer_operation_id.id,
|
|
"rma_supplier_operation_id": rma_supplier_operation_id.id,
|
|
}
|
|
)
|
|
|
|
@classmethod
|
|
def _create_product(cls, name):
|
|
return cls.product_product_model.create(
|
|
{"name": name, "categ_id": cls.category.id, "type": "product"}
|
|
)
|
|
|
|
@classmethod
|
|
def _create_picking(cls, partner):
|
|
return cls.stockpicking.create(
|
|
{
|
|
"partner_id": partner.id,
|
|
"picking_type_id": cls.env.ref("stock.picking_type_in").id,
|
|
"location_id": cls.stock_location.id,
|
|
"location_dest_id": cls.supplier_location.id,
|
|
}
|
|
)
|
|
|
|
@classmethod
|
|
def _create_rma_from_move(
|
|
cls, products2move, r_type, partner, dropship, supplier_address_id=None
|
|
):
|
|
picking_in = cls._create_picking(partner)
|
|
|
|
moves = []
|
|
if r_type == "customer":
|
|
for item in products2move:
|
|
move_values = cls._prepare_move(
|
|
item[0],
|
|
item[1],
|
|
cls.stock_location,
|
|
cls.customer_location,
|
|
picking_in,
|
|
)
|
|
moves.append(cls.env["stock.move"].create(move_values))
|
|
else:
|
|
for item in products2move:
|
|
move_values = cls._prepare_move(
|
|
item[0],
|
|
item[1],
|
|
cls.supplier_location,
|
|
cls.stock_rma_location,
|
|
picking_in,
|
|
)
|
|
moves.append(cls.env["stock.move"].create(move_values))
|
|
# Create the RMA from the stock_move
|
|
rma_id = cls.rma.create(
|
|
{
|
|
"reference": "0001",
|
|
"type": r_type,
|
|
"partner_id": partner.id,
|
|
"company_id": cls.env.ref("base.main_company").id,
|
|
}
|
|
)
|
|
for move in moves:
|
|
if r_type == "customer":
|
|
wizard = cls.rma_add_stock_move.new(
|
|
{
|
|
"move_ids": [(4, move.id)],
|
|
"rma_id": rma_id.id,
|
|
"partner_id": move.partner_id.id,
|
|
}
|
|
)
|
|
wizard.with_context(
|
|
{
|
|
"move_ids": [(4, move.id)],
|
|
"reference_move_id": move.id,
|
|
"customer": True,
|
|
"active_ids": rma_id.id,
|
|
"partner_id": move.partner_id.id,
|
|
"active_model": "rma.order",
|
|
}
|
|
).default_get([str(move.id), str(cls.partner_id.id)])
|
|
data = wizard.with_context(
|
|
customer=1
|
|
)._prepare_rma_line_from_stock_move(move)
|
|
|
|
else:
|
|
wizard = cls.rma_add_stock_move.new(
|
|
{
|
|
"move_ids": [(4, move.id)],
|
|
"rma_id": rma_id.id,
|
|
"partner_id": move.partner_id.id,
|
|
}
|
|
)
|
|
wizard.with_context(
|
|
{
|
|
"move_ids": [(4, move.id)],
|
|
"reference_move_id": move.id,
|
|
"active_ids": rma_id.id,
|
|
"partner_id": move.partner_id.id,
|
|
"active_model": "rma.order",
|
|
}
|
|
).default_get([str(move.id), str(cls.partner_id.id)])
|
|
data = wizard._prepare_rma_line_from_stock_move(move)
|
|
data["type"] = "supplier"
|
|
if dropship:
|
|
data.update(
|
|
customer_to_supplier=dropship,
|
|
operation_id=cls.rma_ds_replace_op_id.id,
|
|
supplier_address_id=supplier_address_id.id,
|
|
)
|
|
cls.line = cls.rma_line.create(data)
|
|
cls.line._onchange_product_id()
|
|
cls.line._onchange_operation_id()
|
|
cls.line.action_rma_to_approve()
|
|
rma_id._get_default_type()
|
|
rma_id._compute_in_shipment_count()
|
|
rma_id._compute_out_shipment_count()
|
|
rma_id._compute_supplier_line_count()
|
|
rma_id._compute_line_count()
|
|
rma_id.action_view_in_shipments()
|
|
rma_id.action_view_out_shipments()
|
|
rma_id.action_view_lines()
|
|
|
|
rma_id.partner_id.action_open_partner_rma()
|
|
rma_id.partner_id._compute_rma_line_count()
|
|
return rma_id
|
|
|
|
@classmethod
|
|
def _prepare_move(cls, product, qty, src, dest, picking_in):
|
|
location_id = src.id
|
|
|
|
return {
|
|
"name": product.name,
|
|
"partner_id": picking_in.partner_id.id,
|
|
"origin": picking_in.name,
|
|
"company_id": picking_in.picking_type_id.warehouse_id.company_id.id,
|
|
"product_id": product.id,
|
|
"product_uom": product.uom_id.id,
|
|
"state": "draft",
|
|
"product_uom_qty": qty,
|
|
"location_id": location_id,
|
|
"location_dest_id": dest.id,
|
|
"move_line_ids": [
|
|
(
|
|
0,
|
|
0,
|
|
{
|
|
"product_id": product.id,
|
|
"product_uom_id": product.uom_id.id,
|
|
"qty_done": qty,
|
|
"location_id": location_id,
|
|
"location_dest_id": dest.id,
|
|
"package_id": False,
|
|
"owner_id": False,
|
|
"lot_id": False,
|
|
},
|
|
)
|
|
],
|
|
"picking_id": picking_in.id,
|
|
}
|
|
|
|
def _check_equal_quantity(self, qty1, qty2, msg):
|
|
self.assertEquals(qty1, qty2, msg)
|
|
|
|
def test_01_rma_order_line(self):
|
|
for line in self.rma_customer_id.rma_line_ids:
|
|
line.with_context(
|
|
{"default_rma_id": line.rma_id.id}
|
|
)._default_warehouse_id()
|
|
line._default_location_id()
|
|
line._onchange_delivery_address()
|
|
line._compute_in_shipment_count()
|
|
line._compute_out_shipment_count()
|
|
|
|
# check assert if call reference_move_id onchange
|
|
self.assertEquals(line.product_id, line.reference_move_id.product_id)
|
|
self.assertEquals(line.product_qty, line.reference_move_id.product_uom_qty)
|
|
self.assertEquals(
|
|
line.location_id.location_id, line.reference_move_id.location_id
|
|
)
|
|
self.assertEquals(line.origin, line.reference_move_id.picking_id.name)
|
|
self.assertEquals(
|
|
line.delivery_address_id, line.reference_move_id.picking_partner_id
|
|
)
|
|
self.assertEquals(
|
|
line.qty_to_receive, line.reference_move_id.product_uom_qty
|
|
)
|
|
line._onchange_product_id()
|
|
line._onchange_operation_id()
|
|
# check assert if call operation_id onchange
|
|
self.assertEquals(line.operation_id.receipt_policy, line.receipt_policy)
|
|
|
|
data = {"customer_to_supplier": line.customer_to_supplier}
|
|
line = self.rma_line.new(data)
|
|
line._onchange_receipt_policy()
|
|
|
|
data = {"lot_id": line.lot_id.id}
|
|
line = self.rma_line.new(data)
|
|
line._onchange_lot_id()
|
|
|
|
line.action_view_in_shipments()
|
|
line.action_view_out_shipments()
|
|
self.rma_customer_id.action_view_supplier_lines()
|
|
with self.assertRaises(ValidationError):
|
|
line.rma_id.partner_id = self.partner_id.id
|
|
self.rma_customer_id.rma_line_ids[0].partner_id = self.env.ref(
|
|
"base.res_partner_3"
|
|
).id
|
|
self.rma_customer_id.action_view_supplier_lines()
|
|
|
|
def test_02_customer_rma(self):
|
|
self.rma_customer_id.rma_line_ids.action_rma_to_approve()
|
|
wizard = self.rma_make_picking.with_context(
|
|
{
|
|
"active_ids": self.rma_customer_id.rma_line_ids.ids,
|
|
"active_model": "rma.order.line",
|
|
"picking_type": "incoming",
|
|
"active_id": 1,
|
|
}
|
|
).create({})
|
|
wizard._create_picking()
|
|
res = self.rma_customer_id.rma_line_ids.action_view_in_shipments()
|
|
self.assertTrue("res_id" in res, "Incorrect number of pickings" "created")
|
|
picking = self.env["stock.picking"].browse(res["res_id"])
|
|
self.assertEquals(len(picking), 1, "Incorrect number of pickings created")
|
|
moves = picking.move_lines
|
|
self.assertEquals(len(moves), 3, "Incorrect number of moves created")
|
|
lines = self.rma_customer_id.rma_line_ids
|
|
lines.refresh()
|
|
self.assertEqual(
|
|
list(set(lines.mapped("qty_received"))), [0], "Wrong qty received"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_to_deliver"))), [0], "Wrong qty to deliver"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_outgoing"))), [0], "Wrong qty outgoing"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_delivered"))), [0], "Wrong qty delivered"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("in_shipment_count")), 3, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("out_shipment_count")), 0, "Incorrect Out Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_customer_id.in_shipment_count, 1, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_customer_id.out_shipment_count, 0, "Incorrect Out Shipment Count"
|
|
)
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_receive,
|
|
3,
|
|
"Wrong qty to receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_incoming,
|
|
3,
|
|
"Wrong qty incoming",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_to_receive,
|
|
5,
|
|
"Wrong qty to receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_incoming,
|
|
5,
|
|
"Wrong qty incoming",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_to_receive,
|
|
2,
|
|
"Wrong qty to receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_incoming,
|
|
2,
|
|
"Wrong qty incoming",
|
|
)
|
|
picking.action_assign()
|
|
for mv in picking.move_lines:
|
|
mv.quantity_done = mv.product_uom_qty
|
|
picking.action_done()
|
|
lines = self.rma_customer_id.rma_line_ids
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_to_receive"))), [0], "Wrong qty to_receive"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_incoming"))), [0], "Wrong qty incoming"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_outgoing"))), [0], "Wrong qty outgoing"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_delivered"))), [0], "Wrong qty delivered"
|
|
)
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_received,
|
|
3,
|
|
"Wrong qty received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_deliver,
|
|
3,
|
|
"Wrong qty to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_received,
|
|
5,
|
|
"Wrong qty received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_to_deliver,
|
|
5,
|
|
"Wrong qty to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_received,
|
|
2,
|
|
"Wrong qty received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_to_deliver,
|
|
2,
|
|
"Wrong qty to_deliver",
|
|
)
|
|
|
|
wizard = self.rma_make_picking.with_context(
|
|
{
|
|
"active_id": 1,
|
|
"active_ids": self.rma_customer_id.rma_line_ids.ids,
|
|
"active_model": "rma.order.line",
|
|
"picking_type": "outgoing",
|
|
}
|
|
).create({})
|
|
wizard._create_picking()
|
|
res = self.rma_customer_id.rma_line_ids.action_view_out_shipments()
|
|
self.assertTrue("res_id" in res, "Incorrect number of pickings" "created")
|
|
picking = self.env["stock.picking"].browse(res["res_id"])
|
|
moves = picking.move_lines
|
|
self.assertEquals(len(moves), 3, "Incorrect number of moves created")
|
|
lines = self.rma_customer_id.rma_line_ids
|
|
lines.refresh()
|
|
self.assertEqual(
|
|
list(set(lines.mapped("qty_to_receive"))), [0], "Wrong qty to_receive"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_incoming"))), [0], "Wrong qty incoming"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_delivered"))), [0], "Wrong qty delivered"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("in_shipment_count")), 3, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("out_shipment_count")), 3, "Incorrect Out Shipment Count",
|
|
)
|
|
self.assertEqual(
|
|
self.rma_customer_id.in_shipment_count, 1, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_customer_id.out_shipment_count, 1, "Incorrect Out Shipment Count"
|
|
)
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_deliver,
|
|
3,
|
|
"Wrong qty to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_outgoing,
|
|
3,
|
|
"Wrong qty outgoing",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_to_deliver,
|
|
5,
|
|
"Wrong qty to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_outgoing,
|
|
5,
|
|
"Wrong qty outgoing",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_to_deliver,
|
|
2,
|
|
"Wrong qty to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_outgoing,
|
|
2,
|
|
"Wrong qty outgoing",
|
|
)
|
|
picking.action_assign()
|
|
for mv in picking.move_lines:
|
|
mv.quantity_done = mv.product_uom_qty
|
|
picking.action_done()
|
|
lines = self.rma_customer_id.rma_line_ids
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_to_receive"))), [0], "Wrong qty to_receive"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_incoming"))), [0], "Wrong qty incoming"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_outgoing"))), [0], "Wrong qty_outgoing"
|
|
)
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_received,
|
|
3,
|
|
"Wrong qty_received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_delivered,
|
|
3,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_received,
|
|
5,
|
|
"Wrong qty_received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_delivered,
|
|
5,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_received,
|
|
2,
|
|
"Wrong qty_received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_delivered,
|
|
2,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self.line.action_rma_done()
|
|
self.assertEquals(self.line.state, "done", "Wrong State")
|
|
self.rma_customer_id.action_view_in_shipments()
|
|
self.rma_customer_id.action_view_out_shipments()
|
|
self.rma_customer_id.action_view_lines()
|
|
|
|
# DROPSHIP
|
|
def test_03_dropship(self):
|
|
for line in self.rma_droship_id.rma_line_ids:
|
|
line.operation_id = self.rma_ds_replace_op_id
|
|
line._onchange_operation_id()
|
|
line._onchange_delivery_address()
|
|
line.action_rma_to_approve()
|
|
line.action_rma_approve()
|
|
wizard = self.rma_make_picking.with_context(
|
|
{
|
|
"active_id": 1,
|
|
"active_ids": self.rma_droship_id.rma_line_ids.ids,
|
|
"active_model": "rma.order.line",
|
|
"picking_type": "incoming",
|
|
}
|
|
).create({})
|
|
wizard._create_picking()
|
|
res = self.rma_droship_id.rma_line_ids.action_view_in_shipments()
|
|
self.assertTrue("res_id" in res, "Incorrect number of pickings created")
|
|
picking = self.env["stock.picking"].browse(res["res_id"])
|
|
self.assertEquals(len(picking), 1, "Incorrect number of pickings created")
|
|
moves = picking.move_lines
|
|
self.assertEqual(len(moves), 3, "Incorrect number of moves created")
|
|
lines = self.rma_droship_id.rma_line_ids
|
|
lines.refresh()
|
|
self.assertEqual(
|
|
sum(lines.mapped("in_shipment_count")), 3, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("out_shipment_count")), 0, "Incorrect Out Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_droship_id.in_shipment_count, 1, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_droship_id.out_shipment_count, 0, "Incorrect Out Shipment Count"
|
|
)
|
|
wizard = self.make_supplier_rma.with_context(
|
|
{
|
|
"active_ids": self.rma_droship_id.rma_line_ids.ids,
|
|
"active_model": "rma.order.line",
|
|
"active_id": 1,
|
|
}
|
|
).create({})
|
|
wizard.make_supplier_rma()
|
|
lines = self.rma_droship_id.rma_line_ids.mapped("supplier_rma_line_ids")
|
|
lines.refresh()
|
|
self.assertEqual(
|
|
list(set(lines.mapped("qty_received"))), [0], "Wrong qty_received"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_outgoing"))), [0], "Wrong qty_outgoing"
|
|
)
|
|
self.assertEqual(list(set(lines.mapped("qty_delivered"))), [0], "qty_delivered")
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_deliver,
|
|
3,
|
|
"Wrong qty_to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_to_deliver,
|
|
5,
|
|
"Wrong qty_to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_to_deliver,
|
|
2,
|
|
"Wrong qty_to_deliver",
|
|
)
|
|
lines = self.rma_droship_id.rma_line_ids
|
|
lines.refresh()
|
|
self._check_equal_quantity(
|
|
lines.filtered(
|
|
lambda l: l.product_id == self.product_1
|
|
).qty_in_supplier_rma,
|
|
3,
|
|
"Wrong qty_in_supplier_rma",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(
|
|
lambda l: l.product_id == self.product_2
|
|
).qty_in_supplier_rma,
|
|
5,
|
|
"Wrong qty_in_supplier_rma",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(
|
|
lambda l: l.product_id == self.product_3
|
|
).qty_in_supplier_rma,
|
|
2,
|
|
"Wrong qty_in_supplier_rma",
|
|
)
|
|
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_to_supplier_rma"))),
|
|
[0],
|
|
"Wrong qty_to_supplier_rma",
|
|
)
|
|
|
|
for line in self.rma_droship_id.rma_line_ids:
|
|
line.action_rma_done()
|
|
self.assertEqual(line.mapped("state"), ["done"], "Wrong State")
|
|
|
|
# Supplier RMA
|
|
def test_04_supplier_rma(self):
|
|
self.rma_supplier_id.rma_line_ids.action_rma_to_approve()
|
|
self.rma_supplier_id.rma_line_ids.operation_id = self.rma_sup_replace_op_id
|
|
self.rma_supplier_id.rma_line_ids._onchange_operation_id()
|
|
self.rma_supplier_id.rma_line_ids._onchange_delivery_address()
|
|
wizard = self.rma_make_picking.with_context(
|
|
{
|
|
"active_ids": self.rma_supplier_id.rma_line_ids.ids,
|
|
"active_model": "rma.order.line",
|
|
"picking_type": "outgoing",
|
|
"active_id": 2,
|
|
}
|
|
).create({})
|
|
wizard._create_picking()
|
|
res = self.rma_supplier_id.rma_line_ids.action_view_out_shipments()
|
|
self.assertTrue("res_id" in res, "Incorrect number of pickings" "created")
|
|
picking = self.env["stock.picking"].browse(res["res_id"])
|
|
moves = picking.move_lines
|
|
self.assertEquals(len(moves), 3, "Incorrect number of moves created")
|
|
|
|
lines = self.rma_supplier_id.rma_line_ids
|
|
lines.refresh()
|
|
self.assertEqual(
|
|
list(set(lines.mapped("qty_received"))), [0], "Wrong qty_received"
|
|
)
|
|
self.assertEqual(list(set(lines.mapped("qty_delivered"))), [0], "qty_delivered")
|
|
self.assertEqual(
|
|
sum(lines.mapped("in_shipment_count")), 0, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("out_shipment_count")), 3, "Incorrect Out Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_supplier_id.in_shipment_count, 0, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_supplier_id.out_shipment_count, 1, "Incorrect Out Shipment Count"
|
|
)
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_receive,
|
|
3,
|
|
"Wrong qty_to_receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_deliver,
|
|
3,
|
|
"Wrong qty_to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_to_receive,
|
|
5,
|
|
"Wrong qty_to_receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_to_deliver,
|
|
5,
|
|
"Wrong qty_to_deliver",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_to_receive,
|
|
2,
|
|
"Wrong qty_to_receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_to_deliver,
|
|
2,
|
|
"Wrong qty_to_deliver",
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_incoming"))), [0], "Wrong qty_incoming"
|
|
)
|
|
picking.action_assign()
|
|
for mv in picking.move_lines:
|
|
mv.quantity_done = mv.product_uom_qty
|
|
picking.action_done()
|
|
self.assertEqual(
|
|
list(set(lines.mapped("qty_incoming"))), [0], "Wrong qty_incoming"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_to_deliver"))), [0], "Wrong qty_to_deliver"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_received"))), [0], "Wrong qty_received"
|
|
)
|
|
self.assertEqual(list(set(lines.mapped("qty_outgoing"))), [0], "qty_outgoing")
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_delivered,
|
|
3,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_receive,
|
|
3,
|
|
"Wrong qty_to_receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_received,
|
|
0,
|
|
"Wrong qty_received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_delivered,
|
|
5,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_received,
|
|
0,
|
|
"Wrong qty_received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_delivered,
|
|
2,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_received,
|
|
0,
|
|
"Wrong qty_received",
|
|
)
|
|
wizard = self.rma_make_picking.with_context(
|
|
{
|
|
"active_id": 1,
|
|
"active_ids": self.rma_supplier_id.rma_line_ids.ids,
|
|
"active_model": "rma.order.line",
|
|
"picking_type": "incoming",
|
|
}
|
|
).create({})
|
|
wizard._create_picking()
|
|
res = self.rma_supplier_id.rma_line_ids.action_view_in_shipments()
|
|
self.assertTrue("res_id" in res, "Incorrect number of pickings" "created")
|
|
pickings = self.env["stock.picking"].browse(res["res_id"])
|
|
self.assertEquals(len(pickings), 1, "Incorrect number of pickings created")
|
|
picking_in = pickings[0]
|
|
moves = picking_in.move_lines
|
|
self.assertEquals(len(moves), 3, "Incorrect number of moves created")
|
|
|
|
lines = self.rma_supplier_id.rma_line_ids
|
|
lines.refresh()
|
|
self.assertEqual(
|
|
list(set(lines.mapped("qty_to_deliver"))), [0], "qty_to_deliver"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("in_shipment_count")), 3, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
sum(lines.mapped("out_shipment_count")), 3, "Incorrect Out Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_supplier_id.in_shipment_count, 1, "Incorrect In Shipment Count"
|
|
)
|
|
self.assertEqual(
|
|
self.rma_supplier_id.out_shipment_count, 1, "Incorrect Out Shipment Count"
|
|
)
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_to_receive,
|
|
3,
|
|
"Wrong qty_to_receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_to_receive,
|
|
5,
|
|
"Wrong qty_to_receive",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_to_receive,
|
|
2,
|
|
"Wrong qty_to_receive",
|
|
)
|
|
picking_in.action_confirm()
|
|
picking_in.action_assign()
|
|
for mv in picking_in.move_line_ids:
|
|
mv.qty_done = mv.product_uom_qty
|
|
picking_in.action_done()
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_outgoing"))), [0], "Wrong qty_outgoing"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_incoming"))), [0], "Wrong qty_incoming"
|
|
)
|
|
self.assertEquals(
|
|
list(set(lines.mapped("qty_to_deliver"))), [0], "qty_to_deliver"
|
|
)
|
|
|
|
# product specific
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_delivered,
|
|
3,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_1).qty_received,
|
|
3,
|
|
"Wrong qty_received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_delivered,
|
|
5,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_2).qty_received,
|
|
5,
|
|
"Wrong qty_received",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_delivered,
|
|
2,
|
|
"Wrong qty_delivered",
|
|
)
|
|
self._check_equal_quantity(
|
|
lines.filtered(lambda l: l.product_id == self.product_3).qty_received,
|
|
2,
|
|
"Wrong qty_received",
|
|
)
|
|
for line in self.rma_supplier_id.rma_line_ids:
|
|
line.action_rma_done()
|
|
self.assertEqual(line.mapped("state"), ["done"], "Wrong State")
|