[IMP] Improved Unit Test Case and Fixed Travis

rma_account/__manifest__.py

@@ -8,7 +8,7 @@
     'license': 'LGPL-3',
     'category': 'RMA',
     'summary': 'Integrates RMA with Invoice Processing',
-    'author': "Eficent",
+    'author': "Eficent, Odoo Community Association (OCA)",
     'website': 'http://www.github.com/OCA/rma',
     'depends': ['account', 'rma'],
     'demo': ['demo/rma_operation.xml'],

rma_account/models/invoice.py

@@ -8,7 +8,7 @@ from odoo import api, fields, models
 class AccountInvoice(models.Model):
     _inherit = "account.invoice"
 
-    @api.one
+    @api.depends('invoice_line_ids.rma_line_ids')
     def _compute_rma_count(self):
         for inv in self:
             rmas = self.mapped('invoice_line_ids.rma_line_ids')

rma_account/models/rma_order.py

@@ -31,11 +31,13 @@ class RmaOrder(models.Model):
 
     def _prepare_rma_line_from_inv_line(self, line):
         if self.type == 'customer':
-            operation = self.product_id.rma_customer_operation_id or \
+            operation =\
-                self.product_id.categ_id.rma_customer_operation_id
+                self.rma_line_ids.product_id.rma_customer_operation_id or \
+                self.rma_line_ids.product_id.categ_id.rma_customer_operation_id
         else:
-            operation = self.product_id.rma_supplier_operation_id or \
+            operation =\
-                self.product_id.categ_id.rma_supplier_operation_id
+                self.rma_line_ids.product_id.rma_supplier_operation_id or \
+                self.rma_line_ids.product_id.categ_id.rma_supplier_operation_id
         data = {
             'invoice_line_id': line.id,
             'product_id': line.product_id.id,
@@ -46,7 +48,7 @@ class RmaOrder(models.Model):
             'product_qty': line.quantity,
             'price_unit': line.invoice_id.currency_id.compute(
                 line.price_unit, line.currency_id, round=False),
-            'rma_id': self._origin.id
+            'rma_id': self.id
         }
         return data
 

rma_account/models/rma_order_line.py

@@ -25,16 +25,16 @@ class RmaOrderLine(models.Model):
                 lambda i: i.invoice_id.state in ('open', 'paid')).mapped(
                 'quantity'))
 
-    @api.one
     @api.depends('refund_line_ids', 'refund_line_ids.invoice_id.state',
                  'refund_policy', 'move_ids', 'move_ids.state', 'type')
     def _compute_qty_to_refund(self):
         qty = 0.0
-        if self.refund_policy == 'ordered':
+        for res in self:
-            qty = self.product_qty - self.qty_refunded
+            if res.refund_policy == 'ordered':
-        elif self.refund_policy == 'received':
+                qty = res.product_qty - res.qty_refunded
-            qty = self.qty_received - self.qty_refunded
+            elif res.refund_policy == 'received':
-        self.qty_to_refund = qty
+                qty = res.qty_received - res.qty_refunded
+            res.qty_to_refund = qty
 
     @api.multi
     def _compute_refund_count(self):
@@ -94,21 +94,21 @@ class RmaOrderLine(models.Model):
             operation = self.env['rma.operation'].search(
                 [('type', '=', self.type)], limit=1)
             if not operation:
-                raise ValidationError("Please define an operation first")
+                raise ValidationError(_("Please define an operation first"))
 
         if not operation.in_route_id or not operation.out_route_id:
             route = self.env['stock.location.route'].search(
                 [('rma_selectable', '=', True)], limit=1)
             if not route:
-                raise ValidationError("Please define an rma route")
+                raise ValidationError(_("Please define an rma route"))
 
         if not operation.in_warehouse_id or not operation.out_warehouse_id:
             warehouse = self.env['stock.warehouse'].search(
                 [('company_id', '=', self.company_id.id),
                  ('lot_rma_id', '!=', False)], limit=1)
             if not warehouse:
-                raise ValidationError("Please define a warehouse with a"
+                raise ValidationError(_("Please define a warehouse with a"
-                                      " default rma location")
+                                      " default rma location"))
         data = {
             'product_id': line.product_id.id,
             'origin': line.invoice_id.number,
@@ -189,7 +189,6 @@ class RmaOrderLine(models.Model):
         result['views'] = [(res and res.id or False, 'form')]
         result['view_id'] = res and res.id or False
         result['res_id'] = self.invoice_line_id.invoice_id.id
-
         return result
 
     @api.multi

rma_account/tests/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+# © 2017 Eficent Business and IT Consulting Services S.L.
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html)
+from . import test_rma
+from . import test_supplier_rma
+from . import test_rma_dropship

rma_account/tests/test_rma.py

@@ -0,0 +1,395 @@
+# -*- coding: utf-8 -*-
+# © 2017 Eficent Business and IT Consulting Services S.L.
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html)
+
+from openerp.tests import common
+from openerp import fields
+
+
+class TestRma(common.TransactionCase):
+
+    """ Test the routes and the quantities """
+
+    def setUp(self):
+        super(TestRma, self).setUp()
+
+        self.rma_make_picking = self.env['rma_make_picking.wizard']
+        self.make_supplier_rma = self.env["rma.order.line.make.supplier.rma"]
+        self.rma_add_stock_move = self.env['rma_add_stock_move']
+        self.stockpicking = self.env['stock.picking']
+        self.rma = self.env['rma.order']
+        self.rma_line = self.env['rma.order.line']
+        self.rma_op = self.env['rma.operation']
+        self.rma_cust_replace_op_id = self.env.ref(
+            'rma.rma_operation_customer_replace')
+        self.rma_sup_replace_op_id = self.env.ref(
+            'rma.rma_operation_supplier_replace')
+        self.product_id = self.env.ref('product.product_product_4')
+        self.product_id.product_tmpl_id.categ_id.\
+            property_stock_account_input_categ_id =\
+            self.env.ref('account.data_account_type_receivable').id
+        self.product_id.product_tmpl_id.categ_id.\
+            property_stock_account_output_categ_id =\
+            self.env.ref('account.data_account_type_expenses').id
+        self.product_1 = self.env.ref('product.product_product_25')
+        self.product_2 = self.env.ref('product.product_product_30')
+        self.product_3 = self.env.ref('product.product_product_33')
+        self.uom_unit = self.env.ref('product.product_uom_unit')
+        # assign an operation
+        self.product_1.write(
+            {'rma_customer_operation_id': self.rma_cust_replace_op_id.id,
+             'rma_supplier_operation_id': self.rma_sup_replace_op_id.id})
+        self.product_2.write(
+            {'rma_customer_operation_id': self.rma_cust_replace_op_id.id,
+             'rma_supplier_operation_id': self.rma_sup_replace_op_id.id})
+        self.product_3.write(
+            {'rma_customer_operation_id': self.rma_cust_replace_op_id.id,
+             'rma_supplier_operation_id': self.rma_sup_replace_op_id.id})
+        self.partner_id = self.env.ref('base.res_partner_12')
+        self.stock_location = self.env.ref('stock.stock_location_stock')
+        self.stock_rma_location = self.env.ref('rma.location_rma')
+        self.customer_location = self.env.ref(
+            'stock.stock_location_customers')
+        self.supplier_location = self.env.ref(
+            'stock.stock_location_suppliers')
+        self.product_uom_id = self.env.ref('product.product_uom_unit')
+        products2move = [(self.product_1, 3), (self.product_2, 5),
+                         (self.product_3, 2)]
+        self.rma_customer_id = self._create_rma_from_move(
+            products2move, 'customer', self.env.ref('base.res_partner_2'),
+            dropship=False)
+
+    def _create_picking(self, partner):
+        return self.stockpicking.create({
+            'partner_id': partner.id,
+            'picking_type_id': self.env.ref('stock.picking_type_in').id,
+            'location_id': self.stock_location.id,
+            'location_dest_id': self.supplier_location.id
+            })
+
+    def _create_rma_from_move(self, products2move, type, partner, dropship,
+                              supplier_address_id=None):
+        picking_in = self._create_picking(partner)
+
+        moves = []
+        if type == 'customer':
+            for item in products2move:
+                move_values = self._prepare_move(
+                    item[0], item[1], self.stock_location,
+                    self.customer_location, picking_in)
+                moves.append(self.env['stock.move'].create(move_values))
+        else:
+            for item in products2move:
+                move_values = self._prepare_move(
+                    item[0], item[1], self.supplier_location,
+                    self.stock_rma_location, picking_in)
+                moves.append(self.env['stock.move'].create(move_values))
+        # Create the RMA from the stock_move
+        rma_id = self.rma.create(
+            {
+                'reference': '0001',
+                'type': type,
+                'partner_id': partner.id,
+                'company_id': self.env.ref('base.main_company').id
+            })
+        rma_id._compute_invoice_refund_count()
+        rma_id._compute_invoice_count()
+
+        data = {'add_invoice_id': self._create_invoice().id}
+        new_line = self.rma.new(data)
+        new_line.on_change_invoice()
+
+        rma_id.action_view_invoice_refund()
+        rma_id.action_view_invoice()
+
+        for move in moves:
+            if type == 'customer':
+                wizard = self.rma_add_stock_move.with_context(
+                    {'stock_move_id': move.id, 'customer': True,
+                     'active_ids': rma_id.id,
+                     'active_model': 'rma.order',
+                     }
+                ).create({})
+                data = wizard._prepare_rma_line_from_stock_move(move)
+            else:
+                wizard = self.rma_add_stock_move.with_context(
+                    {'stock_move_id': move.id, 'supplier': True,
+                     'active_ids': rma_id.id,
+                     'active_model': 'rma.order',
+                     }
+                ).create({})
+                data = wizard._prepare_rma_line_from_stock_move(move)
+            if dropship:
+                data.update(customer_to_supplier=dropship,
+                            supplier_address_id=supplier_address_id.id)
+            self.line = self.rma_line.create(data)
+            # approve the RMA Line
+            self.line._compute_refund_count()
+            self.rma_line.action_rma_to_approve()
+
+            self.line.action_rma_approve()
+            self.line.action_view_invoice()
+            self.line.action_view_refunds()
+
+        # approve the RMA
+#        rma_id.action_rma_to_approve()
+#        rma_id.action_rma_approve()
+        return rma_id
+
+    def _prepare_move(self, product, qty, src, dest, picking_in):
+        res = {
+            'partner_id': self.partner_id.id,
+            'product_id': product.id,
+            'name': product.partner_ref,
+            'state': 'confirmed',
+            'product_uom': self.product_uom_id.id or product.uom_id.id,
+            'product_uom_qty': qty,
+            'origin': 'Test RMA',
+            'location_id': src.id,
+            'location_dest_id': dest.id,
+            'picking_id': picking_in.id
+        }
+        return res
+
+    def test_rma_refund(self):
+
+        self.rma_refund_item = self.env['rma.refund.item']
+        self.rma_refund = self.env['rma.refund']
+
+        self.product_id.income =\
+            self.env.ref('account.data_account_type_receivable').id
+        self.product_id.expense =\
+            self.env.ref('account.data_account_type_expenses').id
+
+        for line in self.rma_customer_id.rma_line_ids:
+            line.refund_policy = 'ordered'
+
+        refund = self.rma_refund.with_context({
+            'active_ids': self.rma_customer_id.rma_line_ids.ids,
+            'active_model': 'rma.order.line',
+            'active_id': 1
+        }).create({'description': 'Test Reason',
+                   'date_invoice': fields.datetime.now()
+                   })
+        self.rma_refund_item.create({
+            'line_id': self.rma_customer_id.rma_line_ids[0].id,
+            'rma_id': self.rma_customer_id.id,
+            'product_id': self.product_id.id,
+            'name': 'Test RMA Refund',
+            'product_qty': self.rma_customer_id.rma_line_ids[0].product_qty,
+            'wiz_id': refund.id
+        })
+        refund.invoice_refund()
+
+        data = {'invoice_line_id': self._create_invoice().invoice_line_ids.id}
+        new_line = self.rma_line.new(data)
+        new_line._onchange_invoice_line_id()
+        self.rma_customer_id.action_view_invoice_refund()
+        self.rma_customer_id.action_view_invoice()
+
+    def test_on_change_invoice_rma(self):
+
+        wizard = self.env['rma_add_invoice'].with_context({
+            'active_ids': self.rma_customer_id.ids,
+            'active_model': 'rma.order',
+            'active_id': self.rma_customer_id.id
+        }).create({'partner_id': self.partner_id.id,
+                   'rma_id': self.rma_customer_id.id,
+                   'invoice_line_ids':
+                   [(6, 0, [self._create_invoice().invoice_line_ids.id])],
+                   })
+        wizard.default_get([str(self._create_invoice().id),
+                            str(self._create_invoice().invoice_line_ids.id),
+                            str(self.partner_id.id)])
+        wizard.add_lines()
+        self.rma_customer_id.action_view_invoice_refund()
+        self.rma_customer_id.action_view_invoice()
+        self.rma_customer_id.rma_line_ids[0].\
+            invoice_id = self._create_invoice().id
+        self.rma_customer_id.action_view_invoice()
+        self.rma_customer_id.add_invoice_id = self._create_invoice().id
+        for line in self.rma_customer_id.rma_line_ids:
+            line.invoice_id.action_view_rma_supplier()
+            line.invoice_id.action_view_rma_customer()
+
+    def _create_invoice(self):
+        self.Account = self.env['account.account']
+        self.AccountInvoice = self.env['account.invoice']
+        self.AccountInvoiceLine = self.env['account.invoice.line']
+
+        self.account_receivable =\
+            self.env.ref('account.data_account_type_receivable')
+        self.account_expenses =\
+            self.env.ref('account.data_account_type_expenses')
+        invoice_account = self.Account.\
+            search([('user_type_id', '=', self.account_receivable.id)], limit=1
+                   ).id
+        invoice_line_account = self.Account.\
+            search([('user_type_id', '=', self.account_expenses.id)], limit=1
+                   ).id
+
+        invoice = self.AccountInvoice.create({
+            'partner_id': self.partner_id.id,
+            'account_id': invoice_account,
+            'type': 'in_invoice',
+        })
+
+        invoice_line = self.AccountInvoiceLine.create({
+            'product_id': self.product_1.id,
+            'quantity': 1.0,
+            'price_unit': 100.0,
+            'invoice_id': invoice.id,
+            'uom_id': 1,
+            'name': 'product that cost 100',
+            'account_id': invoice_line_account,
+        })
+        invoice._compute_rma_count()
+        invoice_line._compute_rma_count()
+        invoice.action_view_rma_customer()
+        invoice.action_view_rma_supplier()
+        return invoice
+
+    def test_customer_rma(self):
+        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({})
+        procurements = wizard._create_picking()
+        group_ids = set([proc.group_id.id for proc in procurements if
+                         proc.group_id])
+        domain = [('group_id', 'in', list(group_ids))]
+        picking = self.stockpicking.search(domain)
+        self.assertEquals(len(picking), 1,
+                          "Incorrect number of pickings created")
+        moves = picking.move_lines
+        self.assertEquals(len(moves), 3,
+                          "Incorrect number of moves created")
+        for line in self.rma_customer_id.rma_line_ids:
+            # common qtys for all products
+            self.assertEquals(line.qty_received, 0,
+                              "Wrong qty received")
+            self.assertEquals(line.qty_to_deliver, 0,
+                              "Wrong qty to deliver")
+            self.assertEquals(line.qty_outgoing, 0,
+                              "Wrong qty outgoing")
+            self.assertEquals(line.qty_delivered, 0,
+                              "Wrong qty delivered")
+            # product specific
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_to_receive, 3,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_incoming, 3,
+                                  "Wrong qty incoming")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_to_receive, 5,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_incoming, 5,
+                                  "Wrong qty incoming")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_to_receive, 2,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_incoming, 2,
+                                  "Wrong qty incoming")
+        picking.action_assign()
+        picking.do_transfer()
+        for line in self.rma_customer_id.rma_line_ids:
+            self.assertEquals(line.qty_to_receive, 0,
+                              "Wrong qty to_receive")
+            self.assertEquals(line.qty_incoming, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_outgoing, 0,
+                              "Wrong qty outgoing")
+            self.assertEquals(line.qty_delivered, 0,
+                              "Wrong qty delivered")
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_received, 3,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_to_deliver, 3,
+                                  "Wrong qty to_deliver")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_received, 5,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_to_deliver, 5,
+                                  "Wrong qty to_deliver")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_received, 2,
+                                  "Wrong qty received")
+                self.assertEquals(line.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({})
+        procurements = wizard._create_picking()
+        group_ids = set([proc.group_id.id for proc in procurements if
+                         proc.group_id])
+        domain = [('group_id', 'in', list(group_ids))]
+        pickings = self.stockpicking.search(domain)
+        self.assertEquals(len(pickings), 2,
+                          "Incorrect number of pickings created")
+        picking_out = pickings[1]
+        moves = picking_out.move_lines
+        self.assertEquals(len(moves), 3,
+                          "Incorrect number of moves created")
+        for line in self.rma_customer_id.rma_line_ids:
+            self.assertEquals(line.qty_to_receive, 0,
+                              "Wrong qty to receive")
+            self.assertEquals(line.qty_incoming, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_delivered, 0,
+                              "Wrong qty delivered")
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_to_deliver, 3,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_outgoing, 3,
+                                  "Wrong qty outgoing")
+                self.assertEquals(line.qty_received, 3,
+                                  "Wrong qty received")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_received, 5,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_to_deliver, 5,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_outgoing, 5,
+                                  "Wrong qty outgoing")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_received, 2,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_to_deliver, 2,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_outgoing, 2,
+                                  "Wrong qty outgoing")
+        picking_out.action_assign()
+        picking_out.do_transfer()
+        for line in self.rma_customer_id.rma_line_ids:
+            self.assertEquals(line.qty_to_receive, 0,
+                              "Wrong qty to receive")
+            self.assertEquals(line.qty_incoming, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_to_deliver, 0,
+                              "Wrong qty to deliver")
+            self.assertEquals(line.qty_outgoing, 0,
+                              "Wrong qty outgoing")
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_received, 3,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_delivered, 3,
+                                  "Wrong qty delivered")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_received, 5,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_delivered, 5,
+                                  "Wrong qty delivered")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_received, 2,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_delivered, 2,
+                                  "Wrong qty delivered")
+            self.line.action_rma_done()
+            self.assertEquals(self.line.state, 'done',
+                              "Wrong State")

rma_account/tests/test_rma_dropship.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+# © 2017 Eficent Business and IT Consulting Services S.L.
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html)
+
+from openerp.addons.rma.tests import test_rma
+
+
+class TestRmaDropship(test_rma.TestRma):
+
+    def setUp(self):
+        super(TestRmaDropship, self).setUp()
+        products2move = [(self.product_1, 3), (self.product_2, 5),
+                         (self.product_3, 2)]
+        self.rma_droship_id = self._create_rma_from_move(
+            products2move, 'customer', self.env.ref('base.res_partner_2'),
+            dropship=True,
+            supplier_address_id=self.env.ref('base.res_partner_3'))
+
+    def test_dropship(self):
+        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({})
+        res = wizard.make_supplier_rma()
+        supplier_rma = self.rma.browse(res['res_id'])
+        for line in supplier_rma.rma_line_ids:
+            line.action_rma_to_approve()
+            line.action_rma_approve()
+        wizard = self.rma_make_picking.with_context({
+            'active_id': 1,
+            'active_ids': supplier_rma.rma_line_ids.ids,
+            'active_model': 'rma.order.line',
+            'picking_type': 'incoming',
+        }).create({})
+        procurements = wizard._create_picking()
+        group_ids = set([proc.group_id.id for proc in procurements if
+                         proc.group_id])
+        domain = [('group_id', 'in', list(group_ids))]
+        picking = self.stockpicking.search(domain)
+        self.assertEquals(len(picking), 1,
+                          "Incorrect number of pickings created")
+        moves = picking.move_lines
+        self.assertEquals(len(moves), 3,
+                          "Incorrect number of moves created")
+        for line in supplier_rma.rma_line_ids:
+            # common qtys for all products
+            self.assertEquals(line.qty_received, 0,
+                              "Wrong qty received")
+            self.assertEquals(line.qty_outgoing, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_delivered, 0,
+                              "Wrong qty delivered")
+            # product specific
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_to_receive, 3,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 3,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_incoming, 3,
+                                  "Wrong qty outgoing")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_to_receive, 5,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 5,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_incoming, 5,
+                                  "Wrong qty outgoing")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_to_receive, 2,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 2,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_incoming, 2,
+                                  "Wrong qty outgoing")
+
+        for line in self.rma_droship_id.rma_line_ids:
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_to_supplier_rma, 0,
+                                  "Wrong qty to supplier rma")
+                self.assertEquals(line.qty_in_supplier_rma, 3,
+                                  "Wrong qty in supplier rma")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_to_supplier_rma, 0,
+                                  "Wrong qty to supplier rma")
+                self.assertEquals(line.qty_in_supplier_rma, 5,
+                                  "Wrong qty in supplier rma")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_to_supplier_rma, 0,
+                                  "Wrong qty to supplier rma")
+                self.assertEquals(line.qty_in_supplier_rma, 2,
+                                  "Wrong qty in supplier rma")
+        for line in self.rma_droship_id.rma_line_ids:
+            line.action_rma_done()
+            self.assertEquals(line.state, 'done',
+                              "Wrong State")

rma_account/tests/test_supplier_rma.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+# © 2017 Eficent Business and IT Consulting Services S.L.
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html)
+
+from openerp.addons.rma.tests import test_rma
+
+
+class TestSupplierRma(test_rma.TestRma):
+
+    def setUp(self):
+        super(TestSupplierRma, self).setUp()
+        products2move = [(self.product_1, 3), (self.product_2, 5),
+                         (self.product_3, 2)]
+        self.rma_supplier_id = self._create_rma_from_move(
+            products2move, 'supplier', self.env.ref('base.res_partner_1'),
+            dropship=False)
+
+    def test_supplier_rma(self):
+        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': 1
+        }).create({})
+        procurements = wizard._create_picking()
+        group_ids = set([proc.group_id.id for proc in procurements if
+                         proc.group_id])
+        domain = [('group_id', 'in', list(group_ids))]
+        picking = self.stockpicking.search(domain)
+        self.assertEquals(len(picking), 1,
+                          "Incorrect number of pickings created")
+        moves = picking.move_lines
+        self.assertEquals(len(moves), 3,
+                          "Incorrect number of moves created")
+        for line in self.rma_supplier_id.rma_line_ids:
+            # common qtys for all products
+            self.assertEquals(line.qty_received, 0,
+                              "Wrong qty received")
+            self.assertEquals(line.qty_incoming, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_delivered, 0,
+                              "Wrong qty delivered")
+            # product specific
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_to_receive, 3,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 3,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_outgoing, 3,
+                                  "Wrong qty outgoing")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_to_receive, 5,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 5,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_outgoing, 5,
+                                  "Wrong qty outgoing")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_to_receive, 2,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 2,
+                                  "Wrong qty to deliver")
+                self.assertEquals(line.qty_outgoing, 2,
+                                  "Wrong qty outgoing")
+
+        picking.action_assign()
+        picking.do_transfer()
+        for line in self.rma_supplier_id.rma_line_ids:
+            self.assertEquals(line.qty_incoming, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_received, 0,
+                              "Wrong qty received")
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_delivered, 3,
+                                  "Wrong qty delivered")
+                self.assertEquals(line.qty_to_receive, 3,
+                                  "Wrong qty to receive")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_outgoing, 5,
+                                  "Wrong qty delivered")
+                self.assertEquals(line.qty_to_receive, 5,
+                                  "Wrong qty to receive")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_outgoing, 2,
+                                  "Wrong qty delivered")
+                self.assertEquals(line.qty_to_receive, 2,
+                                  "Wrong qty to receive")
+        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({})
+        procurements = wizard._create_picking()
+        group_ids = set([proc.group_id.id for proc in procurements if
+                         proc.group_id])
+        domain = [('group_id', 'in', list(group_ids))]
+        pickings = self.stockpicking.search(domain)
+        self.assertEquals(len(pickings), 3,
+                          "Incorrect number of pickings created")
+        picking_out = pickings[0]
+        moves = picking_out.move_lines
+        self.assertEquals(len(moves), 2,
+                          "Incorrect number of moves created")
+        for line in self.rma_supplier_id.rma_line_ids:
+            self.assertEquals(line.qty_incoming, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_received, 0,
+                              "Wrong qty received")
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_to_receive, 3,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_incoming, 0,
+                                  "Wrong qty incoming")
+                self.assertEquals(line.qty_delivered, 3,
+                                  "Wrong qty delivered")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_to_receive, 5,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 5,
+                                  "Wrong qty to deliver")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_to_receive, 2,
+                                  "Wrong qty to receive")
+                self.assertEquals(line.qty_to_deliver, 2,
+                                  "Wrong qty to deliver")
+        picking_out.action_assign()
+        picking_out.do_transfer()
+        for line in self.rma_supplier_id.rma_line_ids[0]:
+            self.assertEquals(line.qty_to_receive, 3,
+                              "Wrong qty to receive")
+            self.assertEquals(line.qty_incoming, 0,
+                              "Wrong qty incoming")
+            self.assertEquals(line.qty_to_deliver, 0,
+                              "Wrong qty to deliver")
+            self.assertEquals(line.qty_outgoing, 3,
+                              "Wrong qty outgoing")
+            if line.product_id == self.product_1:
+                self.assertEquals(line.qty_received, 0,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_delivered, 3,
+                                  "Wrong qty delivered")
+            if line.product_id == self.product_2:
+                self.assertEquals(line.qty_received, 0,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_delivered, 5,
+                                  "Wrong qty delivered")
+            if line.product_id == self.product_3:
+                self.assertEquals(line.qty_received, 2,
+                                  "Wrong qty received")
+                self.assertEquals(line.qty_delivered, 2,
+                                  "Wrong qty delivered")
+        for line in self.rma_supplier_id.rma_line_ids:
+            line.action_rma_done()
+            self.assertEquals(line.state, 'done',
+                              "Wrong State")

rma_account/wizards/rma_refund.py

@@ -4,6 +4,7 @@
 
 from odoo import _, api, fields, models
 from odoo.exceptions import ValidationError
+from odoo.tools.safe_eval import safe_eval as eval
 import odoo.addons.decimal_precision as dp