def test_import_sale_order_with_discount(self):
""" Import sale order with discounts"""
backend_id = self.backend_id
storeview_model = self.env['magento.storeview']
storeview = storeview_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '2')])
storeview.write({'catalog_price_tax_included': True})
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
900000696)
mag_order_model = self.env['magento.sale.order']
mag_order = mag_order_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '900000696')])
self.assertEqual(len(mag_order), 1)
order = mag_order.odoo_id
self.assertAlmostEqual(order.amount_total, 36.9500)
for line in order.order_line:
if line.name == 'Item 1':
self.assertAlmostEqual(line.discount, 11.904)
elif line.name == 'Item 2':
self.assertAlmostEqual(line.discount, 11.957)
else:
self.fail('encountered unexpected sale '
'order line %s' % line.name)
def test_10_import_sale_comment_for_edited_sale_order(self):
""" Test import of sale order comment for edited sale order
Note: the parent have been note cancel in the magento_base_response
because we want to import the both sale order.
"""
cr = self.cr
uid = self.uid
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
'900000691-1')
order_model = self.registry('magento.sale.order')
mag_order_ids = order_model.search(cr, uid, [
('backend_id', '=', backend_id),
('magento_id', '=', '900000691-1'),
])
self.assertEqual(len(mag_order_ids), 1)
order = order_model.read(cr, uid, mag_order_ids[0], ['odoo_id'])
order_id = order['odoo_id'][0]
comment_ids = self.registry('magento.sale.comment').search(
cr, uid, [
('backend_id', '=', backend_id),
('res_id', '=', order_id),
])
# The sale order 900000691 have 1 comment
# and the 900000691-1 have 2 comment
# Total is 3 comment
self.assertEqual(len(comment_ids), 3)
def test_import_product_virtual(self):
""" Virtual should fail: not yet supported """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with self.assertRaises(InvalidDataError):
import_record(self.session, 'magento.product.product',
backend_id, 144)
def test_individual_2_addresses(self):
""" Import an individual (b2c) with 2 addresses """
with mock_api(individual_2_addresses):
import_record(self.session, 'magento.res.partner', self.backend_id,
'9999255')
partner = self.model.search([('magento_id', '=', '9999255'),
('backend_id', '=', self.backend_id)])
self.assertEqual(len(partner), 1)
# Name of the billing address
self.assertEqual(partner.name, u'Mace Sébastien')
self.assertEqual(partner.type, 'default')
# billing address merged with the partner,
# second address as a contact
self.assertEqual(len(partner.child_ids), 1)
self.assertEqual(len(partner.magento_bind_ids), 1)
self.assertEqual(len(partner.magento_address_bind_ids), 1)
address_bind = partner.magento_address_bind_ids[0]
self.assertEqual(address_bind.magento_id,
'9999254',
msg="The merged address should be the "
"billing address")
self.assertEqual(partner.child_ids[0].type,
'delivery',
msg="The shipping address should be of "
"type 'delivery'")
def test_import_product_category_with_gap(self):
""" Import of a product category when parent categories are missing """
backend_id = self.backend_id
with mock_api(magento_base_responses):
import_record(self.session, 'magento.product.category', backend_id,
8)
category_model = self.env['magento.product.category']
categories = category_model.search([('backend_id', '=', backend_id)])
self.assertEqual(len(categories), 4)
def test_import_product_category(self):
""" Import of a product category """
backend_id = self.backend_id
with mock_api(magento_base_responses):
import_record(self.session, 'magento.product.category', backend_id,
1)
category_model = self.env['magento.product.category']
category = category_model.search([('backend_id', '=', backend_id)])
self.assertEqual(len(category), 1)
def test_no_address(self):
""" Import an account without any address """
with mock_api(no_address):
import_record(self.session, 'magento.res.partner', self.backend_id,
'9999253')
partner = self.model.search([('magento_id', '=', '9999253'),
('backend_id', '=', self.backend_id)])
self.assertEqual(len(partner), 1)
self.assertEqual(partner.name, 'Benjamin Le Goff')
self.assertEqual(partner.type, 'default')
self.assertEqual(len(partner.child_ids), 0)
def test_import_sale_order_no_website_id(self):
""" Import sale order: website_id is missing, happens with magento """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
900000692)
order_model = self.env['magento.sale.order']
order = order_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '900000692')])
self.assertEqual(len(order), 1)
def setUp(self):
super(TestUpdateStockQty, self).setUp()
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.product.product',
self.backend_id, 16)
product_model = self.env['magento.product.product']
self.binding_product = product_model.search([
('backend_id', '=', self.backend_id), ('magento_id', '=', '16')
])
self.assertEqual(len(self.binding_product), 1)
def test_import_product_category_missing(self):
""" Import of a simple product when the category is missing """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.product.product',
backend_id, 25)
product_model = self.env['magento.product.product']
product = product_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '25')])
self.assertEqual(len(product), 1)
def test_import_product_configurable(self):
""" Import of a configurable product : no need to import it """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.product.product',
backend_id, 126)
product_model = self.env['magento.product.product']
products = product_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '126')])
self.assertEqual(len(products), 0)
def _import_sale_order(self, increment_id, responses=None):
if responses is None:
responses = magento_base_responses
backend_id = self.backend_id
with mock_api(responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
increment_id)
MagentoOrder = self.env['magento.sale.order']
binding = MagentoOrder.search([('backend_id', '=', backend_id),
('magento_id', '=', str(increment_id))])
self.assertEqual(len(binding), 1)
return binding
def test_import_partner_category(self):
""" Import of a partner category """
backend_id = self.backend_id
with mock_api(magento_base_responses):
import_record(self.session, 'magento.res.partner.category',
backend_id, 2)
binding_model = self.env['magento.res.partner.category']
category = binding_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '2')])
self.assertEqual(len(category), 1)
self.assertEqual(category.name, 'Wholesale')
self.assertEqual(category.tax_class_id, 3)
def test_import_sale_order_with_prefix(self):
""" Import sale order with prefix """
backend = self.backend_model.browse(self.backend_id)
backend.write({'sale_prefix': 'EC'})
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend.id,
900000693)
order_model = self.env['magento.sale.order']
order = order_model.search([('backend_id', '=', backend.id),
('magento_id', '=', '900000693')])
self.assertEqual(len(order), 1)
self.assertEqual(order.name, 'EC900000693')
def test_import_sale_order(self):
""" Import sale order: check """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
900000691)
order_model = self.env['magento.sale.order']
order = order_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '900000691')])
self.assertEqual(len(order), 1)
self.assertEqual(
order.payment_term, self.payment_term,
"If the payment term is empty, the onchanges have not"
" been applied.")
def setUp(self):
super(SetUpMagentoWithSaleOrder, self).setUp()
cr = self.cr
uid = self.uid
mag_order_model = self.registry('magento.sale.order')
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order',
self.backend_id, 900000691)
mag_order_ids = mag_order_model.search(cr, uid, [
('backend_id', '=', self.backend_id),
('magento_id', '=', '900000691'),
])
self.mag_order = mag_order_model.browse(cr, uid, mag_order_ids[0])
def test_import_existing_partner_category(self):
""" Bind of an existing category with same name"""
binding_model = self.env['magento.res.partner.category']
category_model = self.env['res.partner.category']
existing_category = category_model.create({'name': 'Wholesale'})
backend_id = self.backend_id
with mock_api(magento_base_responses):
import_record(self.session, 'magento.res.partner.category',
backend_id, 2)
category = binding_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '2')])
self.assertEqual(len(category), 1)
self.assertEqual(category.odoo_id, existing_category)
self.assertEqual(category.name, 'Wholesale')
self.assertEqual(category.tax_class_id, 3)
def test_company_1_address(self):
""" Import an company (b2b) with 1 address """
with mock_api(company_1_address):
import_record(self.session, 'magento.res.partner', self.backend_id,
'9999256')
partner = self.model.search([('magento_id', '=', '9999256'),
('backend_id', '=', self.backend_id)])
self.assertEqual(len(partner), 1)
# Company of the billing address
self.assertEqual(partner.name, 'Marechal')
self.assertEqual(partner.type, 'default')
# all addresses as contacts
self.assertEqual(len(partner.child_ids), 1)
self.assertEqual(len(partner.magento_bind_ids), 1)
self.assertEqual(len(partner.magento_address_bind_ids), 0)
self.assertEqual(partner.child_ids[0].type,
'invoice',
msg="The billing address should be of "
"type 'invoice'")
def test_individual_1_address(self):
""" Import an individual (b2c) with 1 billing address """
with mock_api(individual_1_address):
import_record(self.session, 'magento.res.partner', self.backend_id,
'9999254')
partner = self.model.search([('magento_id', '=', '9999254'),
('backend_id', '=', self.backend_id)])
self.assertEqual(len(partner), 1)
# Name of the billing address
self.assertEqual(partner.name, 'Ferreira Margaux')
self.assertEqual(partner.type, 'default')
# billing address merged with the partner
self.assertEqual(len(partner.child_ids), 0)
self.assertEqual(len(partner.magento_bind_ids), 1)
self.assertEqual(len(partner.magento_address_bind_ids), 1)
address_bind = partner.magento_address_bind_ids[0]
self.assertEqual(address_bind.magento_id,
'9999253',
msg="The merged address should be the "
"billing address")
def test_import_sale_order_with_configurable(self):
""" Import sale order with configurable product """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
900000694)
mag_order_model = self.env['magento.sale.order']
mag_order = mag_order_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '900000694')])
self.assertEqual(len(mag_order), 1)
mag_order_line_model = self.env['magento.sale.order.line']
mag_order_line = mag_order_line_model.search([
('backend_id', '=', backend_id),
('magento_order_id', '=', mag_order.id)
])
self.assertEqual(len(mag_order_line), 1)
order_line = mag_order_line.odoo_id
price_unit = order_line.price_unit
self.assertAlmostEqual(price_unit, 41.0500)
def test_import_sale_order_with_taxes_included(self):
""" Import sale order with taxes included """
backend_id = self.backend_id
storeview_model = self.env['magento.storeview']
storeview = storeview_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '1')])
storeview.write({'catalog_price_tax_included': True})
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
900000695)
mag_order_model = self.env['magento.sale.order']
mag_order = mag_order_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '900000695')])
self.assertEqual(len(mag_order), 1)
order = mag_order.odoo_id
amount_total = order.amount_total
# 97.5 is the amount_total if connector takes correctly included
# tax prices.
self.assertAlmostEqual(amount_total, 97.5000)
def setUp(self):
super(TestExportPicking, self).setUp()
binding_model = self.env['magento.sale.order']
# import a sales order
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order',
self.backend_id, 900000691)
self.order_binding = binding_model.search([
('backend_id', '=', self.backend_id),
('magento_id', '=', '900000691'),
])
self.assertEquals(len(self.order_binding), 1)
self.order_binding.ignore_exceptions = True
# generate sale's picking
self.order_binding.odoo_id.action_button_confirm()
self.picking = self.order_binding.picking_ids
self.assertEquals(len(self.picking), 1)
magento_shop = self.picking.sale_id.magento_bind_ids[0].store_id
magento_shop.send_picking_done_mail = True
def test_10_import_sale_comment(self):
""" Test import of sale order comment"""
cr = self.cr
uid = self.uid
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
900000695)
order_model = self.registry('magento.sale.order')
mag_order_ids = order_model.search(cr, uid, [
('backend_id', '=', backend_id),
('magento_id', '=', '900000695'),
])
self.assertEqual(len(mag_order_ids), 1)
order = order_model.read(cr, uid, mag_order_ids[0], ['odoo_id'])
order_id = order['odoo_id'][0]
comment_ids = self.registry('magento.sale.comment').search(
cr, uid, [('backend_id', '=', backend_id),
('res_id', '=', order_id)])
self.assertEqual(len(comment_ids), 2)
def setUp(self):
super(TestImportAddressBook, self).setUp()
self.backend_model = self.env['magento.backend']
self.session = ConnectorSession(self.env.cr,
self.env.uid,
context=self.env.context)
self.model = self.env['magento.res.partner']
self.address_model = self.env['magento.address']
warehouse_id = self.env.ref('stock.warehouse0').id
self.backend_id = self.backend_model.create({
'name': 'Test Magento Address book',
'version': '1.7',
'location': 'http://anyurl',
'username': '******',
'warehouse_id': warehouse_id,
'password': '******'
}).id
with mock_api(magento_base_responses):
import_batch(self.session, 'magento.website', self.backend_id)
import_batch(self.session, 'magento.store', self.backend_id)
import_batch(self.session, 'magento.storeview', self.backend_id)
import_record(self.session, 'magento.res.partner.category',
self.backend_id, 1)
def test_company_2_addresses(self):
""" Import an company (b2b) with 2 addresses """
with mock_api(company_2_addresses):
import_record(self.session, 'magento.res.partner', self.backend_id,
'9999257')
partner = self.model.search([('magento_id', '=', '9999257'),
('backend_id', '=', self.backend_id)])
self.assertEqual(len(partner), 1)
# Company of the billing address
self.assertEqual(partner.name, 'Bertin')
self.assertEqual(partner.type, 'default')
# all addresses as contacts
self.assertEqual(len(partner.child_ids), 2)
self.assertEqual(len(partner.magento_bind_ids), 1)
self.assertEqual(len(partner.magento_address_bind_ids), 0)
def get_address(magento_id):
address = self.address_model.search([
('magento_id', '=', magento_id),
('backend_id', '=', self.backend_id)
])
self.assertEqual(len(address), 1)
return address
# billing address
address = get_address('9999257')
self.assertEqual(address.type,
'invoice',
msg="The billing address should be of "
"type 'invoice'")
# shipping address
address = get_address('9999258')
self.assertEqual(address.type,
'delivery',
msg="The shipping address should be of "
"type 'delivery'")
def setUp(self):
super(TestImportProductImage, self).setUp()
backend_model = self.env['magento.backend']
warehouse = self.env.ref('stock.warehouse0')
self.backend_id = backend_model.create({
'name': 'Test Magento',
'version': '1.7',
'location': 'http://anyurl',
'username': '******',
'warehouse_id': warehouse.id,
'password': '******'
}).id
self.session = ConnectorSession(self.env.cr,
self.env.uid,
context=self.env.context)
with mock_api(magento_base_responses):
import_batch(self.session, 'magento.website', self.backend_id)
import_batch(self.session, 'magento.store', self.backend_id)
import_batch(self.session, 'magento.storeview', self.backend_id)
import_record(self.session, 'magento.product.category',
self.backend_id, 1)
self.product_model = self.env['magento.product.product']
def setUp(self):
super(TestExportInvoice, self).setUp()
backend_model = self.env['magento.backend']
self.mag_sale_model = self.env['magento.sale.order']
self.session = ConnectorSession(self.env.cr,
self.env.uid,
context=self.env.context)
warehouse = self.env.ref('stock.warehouse0')
self.backend = backend = backend_model.create({
'name':
'Test Magento',
'version':
'1.7',
'location':
'http://anyurl',
'username':
'******',
'warehouse_id':
warehouse.id,
'password':
'******'
})
# payment method needed to import a sale order
workflow = self.env.ref('sale_automatic_workflow.manual_validation')
journal = self.env.ref('account.check_journal')
self.payment_method = self.env['payment.method'].create({
'name':
'checkmo',
'create_invoice_on':
False,
'workflow_process_id':
workflow.id,
'import_rule':
'always',
'journal_id':
journal.id
})
self.journal = self.env.ref('account.bank_journal')
self.pay_account = self.env.ref('account.cash')
self.period = self.env.ref('account.period_10')
# import the base informations
with mock_api(magento_base_responses):
import_batch(self.session, 'magento.website', backend.id)
import_batch(self.session, 'magento.store', backend.id)
import_batch(self.session, 'magento.storeview', backend.id)
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend.id,
900000691)
self.stores = self.backend.mapped('website_ids.store_ids')
sales = self.mag_sale_model.search([('backend_id', '=', backend.id),
('magento_id', '=', '900000691')])
self.assertEqual(len(sales), 1)
self.mag_sale = sales
# ignore exceptions on the sale order
self.mag_sale.ignore_exceptions = True
self.mag_sale.odoo_id.action_button_confirm()
sale = self.mag_sale.odoo_id
invoice_id = sale.action_invoice_create()
assert invoice_id
self.invoice_model = self.env['account.invoice']
self.invoice = self.invoice_model.browse(invoice_id)
