def test_34_import_sale_order_with_taxes_included(self):
""" Import a sale order with taxes included """
backend_id = self.backend_id
self.backend_model.write(self.cr, self.uid, self.backend_id,
{'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.registry('magento.sale.order')
mag_order_ids = mag_order_model.search(self.cr,
self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '900000695')])
self.assertEqual(len(mag_order_ids), 1)
order_id = mag_order_model.read(self.cr,
self.uid,
mag_order_ids[0],
['openerp_id'])['openerp_id']
order_model = self.registry('sale.order')
amount_total = order_model.read(self.cr,
self.uid,
order_id[0],
['amount_total'])['amount_total']
#97.5 is the amount_total if connector takes correctly included tax prices.
self.assertEqual(amount_total, 97.5000)
self.backend_model.write(self.cr, self.uid, self.backend_id,
{'catalog_price_tax_included': False})
def test_35_import_sale_order_with_discount(self):
""" Import sale order with discounts"""
backend_id = self.backend_id
self.backend_model.write(self.cr, self.uid, self.backend_id,
{'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.registry('magento.sale.order')
mag_order_ids = mag_order_model.search(
self.cr, self.uid, [('backend_id', '=', backend_id),
('magento_id', '=', '900000696')])
self.assertEqual(len(mag_order_ids), 1)
order_id = mag_order_model.read(self.cr, self.uid, mag_order_ids[0],
['openerp_id'])['openerp_id']
order_model = self.registry('sale.order')
order = order_model.browse(self.cr, self.uid, order_id[0])
self.assertEqual(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)
self.backend_model.write(self.cr, self.uid, self.backend_id,
{'catalog_price_tax_included': False})
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.openerp_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], ['openerp_id'])
order_id = order['openerp_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_33_import_sale_order_with_configurable(self):
""" Import a 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.registry('magento.sale.order')
mag_order_ids = mag_order_model.search(self.cr,
self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '900000694')])
mag_order_line_model = self.registry('magento.sale.order.line')
mag_order_line_ids = mag_order_line_model.search(self.cr,
self.uid,
[('backend_id', '=', backend_id),
('magento_order_id', '=', mag_order_ids[0])])
self.assertEqual(len(mag_order_ids), 1)
self.assertEqual(len(mag_order_line_ids), 1)
order_line_id = mag_order_line_model.read(self.cr,
self.uid,
mag_order_line_ids[0],
['openerp_id'])['openerp_id']
order_line_model = self.registry('sale.order.line')
price_unit = order_line_model.read(self.cr,
self.uid,
order_line_id[0],
['price_unit'])['price_unit']
self.assertEqual(price_unit, 41.0500)
def setUp(self):
super(test_export_invoice, self).setUp()
cr, uid = self.cr, self.uid
backend_model = self.registry('magento.backend')
self.mag_sale_model = self.registry('magento.sale.order')
self.session = ConnectorSession(cr, uid)
data_model = self.registry('ir.model.data')
self.get_ref = partial(data_model.get_object_reference,
cr, uid)
__, warehouse_id = self.get_ref('stock', 'warehouse0')
backend_id = backend_model.create(
cr,
uid,
{'name': 'Test Magento',
'version': '1.7',
'location': 'http://anyurl',
'username': '******',
'warehouse_id': warehouse_id,
'password': '******'})
self.backend = backend_model.browse(cr, uid, backend_id)
# payment method needed to import a sale order
__, workflow_id = self.get_ref('sale_automatic_workflow',
'manual_validation')
__, journal_id = self.get_ref('account',
'check_journal')
self.payment_method_id = self.registry('payment.method').create(
cr, uid,
{'name': 'checkmo',
'create_invoice_on': False,
'workflow_process_id': workflow_id,
'import_rule': 'always',
'journal_id': journal_id})
__, self.journal_id = self.get_ref('account', 'bank_journal')
__, self.pay_account_id = self.get_ref('account', 'cash')
__, self.period_id = self.get_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)
sale_ids = self.mag_sale_model.search(
cr, uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '900000691')])
self.assertEqual(len(sale_ids), 1)
self.mag_sale = self.mag_sale_model.browse(cr, uid, sale_ids[0])
# ignore exceptions on the sale order
self.mag_sale.write({'ignore_exceptions': True})
self.mag_sale.openerp_id.action_button_confirm()
self.mag_sale.refresh() # update to manual state
self.sale_id = self.mag_sale.openerp_id.id
sale_obj = self.registry('sale.order')
invoice_id = sale_obj.action_invoice_create(cr, uid, [self.sale_id])
assert invoice_id
self.invoice_model = self.registry('account.invoice')
self.invoice = self.invoice_model.browse(cr, uid, invoice_id)
def setUp(self):
super(SetUpMagentoSynchronizedWithAttribute, self).setUp()
with mock_api(magento_attribute_responses):
import_record(self.session, 'magento.attribute.set',
self.backend_id, '9')
mag_attr_set_model = self.registry('magento.attribute.set')
attr_set_model = self.registry('attribute.set')
attr_group_model = self.registry('attribute.group')
cr, uid = self.cr, self.uid
self.default_mag_attr_set_id = '9'
mag_attr_set_ids = mag_attr_set_model.search(cr, uid, [
('magento_id', '=', self.default_mag_attr_set_id),
('backend_id', '=', self.backend_id),
])
mag_attr_set_id = mag_attr_set_ids[0]
self.registry('magento.backend').write(cr, uid, self.backend_id, {
'attribute_set_tpl_id': mag_attr_set_id
})
attr_set_id = attr_set_model.create(cr, uid, {
'name': 'Default Attribute Set',
}, {'force_model': 'product.template'})
mag_attr_set_model.write(cr, uid, mag_attr_set_id, {
'openerp_id': attr_set_id,
})
self.default_attr_set_id = attr_set_id
self.attr_group_id = attr_group_model.create(
cr, uid, {
'attribute_set_id': attr_set_id,
'name': 'openerp',
}, {'force_model': 'product.template'})
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.openerp_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_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 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], ['openerp_id'])
order_id = order['openerp_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_34_import_sale_order_with_taxes_included(self):
""" Import sale order with taxes included """
backend_id = self.backend_id
storeview_model = self.registry('magento.storeview')
storeview_id = storeview_model.search(self.cr, self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '1')])
storeview_model.write(self.cr, self.uid, storeview_id,
{'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.registry('magento.sale.order')
mag_order_ids = mag_order_model.search(
self.cr, self.uid, [('backend_id', '=', backend_id),
('magento_id', '=', '900000695')])
self.assertEqual(len(mag_order_ids), 1)
order_id = mag_order_model.read(self.cr, self.uid, mag_order_ids[0],
['openerp_id'])['openerp_id']
order_model = self.registry('sale.order')
amount_total = order_model.read(self.cr, self.uid, order_id[0],
['amount_total'])['amount_total']
# 97.5 is the amount_total if connector takes correctly included
# tax prices.
self.assertEqual(amount_total, 97.5000)
storeview_model.write(self.cr, self.uid, storeview_id,
{'catalog_price_tax_included': False})
def test_16_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_12_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')
cr, uid = self.cr, self.uid
partner_ids = self.model.search(cr, uid,
[('magento_id', '=', '9999255'),
('backend_id', '=', self.backend_id)])
self.assertEqual(len(partner_ids), 1)
partner = self.model.browse(cr, uid, partner_ids[0])
# 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_14_import_product_configurable(self):
""" Configurable 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, 126)
def test_16_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_00_setup(self):
""" Import the informations required for the customers """
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 setUp(self):
super(test_export_invoice, self).setUp()
cr, uid = self.cr, self.uid
backend_model = self.registry('magento.backend')
self.mag_sale_model = self.registry('magento.sale.order')
self.session = ConnectorSession(cr, uid)
self.session.context['__test_no_commit'] = True
data_model = self.registry('ir.model.data')
self.get_ref = partial(data_model.get_object_reference, cr, uid)
__, warehouse_id = self.get_ref('stock', 'warehouse0')
backend_id = backend_model.create(
cr, uid, {
'name': 'Test Magento',
'version': '1.7',
'location': 'http://anyurl',
'username': '******',
'warehouse_id': warehouse_id,
'password': '******'
})
self.backend = backend_model.browse(cr, uid, backend_id)
# payment method needed to import a sale order
__, workflow_id = self.get_ref('sale_automatic_workflow',
'manual_validation')
__, journal_id = self.get_ref('account', 'check_journal')
self.payment_method_id = self.registry('payment.method').create(
cr, uid, {
'name': 'checkmo',
'create_invoice_on': False,
'workflow_process_id': workflow_id,
'import_rule': 'always',
'journal_id': journal_id
})
__, self.journal_id = self.get_ref('account', 'bank_journal')
__, self.pay_account_id = self.get_ref('account', 'cash')
__, self.period_id = self.get_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)
sale_ids = self.mag_sale_model.search(
cr, uid, [('backend_id', '=', backend_id),
('magento_id', '=', '900000691')])
self.assertEqual(len(sale_ids), 1)
self.mag_sale = self.mag_sale_model.browse(cr, uid, sale_ids[0])
# ignore exceptions on the sale order
self.mag_sale.write({'ignore_exceptions': True})
self.mag_sale.openerp_id.action_button_confirm()
self.mag_sale.refresh() # update to manual state
self.sale_id = self.mag_sale.openerp_id.id
sale_obj = self.registry('sale.order')
invoice_id = sale_obj.action_invoice_create(cr, uid, [self.sale_id])
assert invoice_id
self.invoice_model = self.registry('account.invoice')
self.invoice = self.invoice_model.browse(cr, uid, invoice_id)
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_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 import_product(responses):
with mock_api([responses, magento_base_responses]):
with mock_urlopen_image():
import_record(self.session, 'magento.product.product',
self.backend_id, 122)
binding = self.env['magento.product.product'].search(
[('backend_id', '=', self.backend_id),
('magento_id', '=', 122),
],
)
return binding
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(TestExportPrice, self).setUp()
with mock_api([simple_product_and_images,
magento_base_responses]), mock_urlopen_image():
import_record(self.session, 'magento.product.product',
self.backend_id, 122)
self.binding = self.env['magento.product.product'].search(
[('backend_id', '=', self.backend_id),
('magento_id', '=', 122),
],
)
def test_import_product_virtual(self):
""" Virtual products are created as service products """
backend_id = self.backend_id
with mock_api(magento_base_responses):
import_record(self.session, 'magento.product.product', backend_id,
144)
product_model = self.env['magento.product.product']
product = product_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '144')])
self.assertEqual(product.type, 'service')
def test_10_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.registry('magento.product.category')
category_ids = category_model.search(self.cr, self.uid,
[('backend_id', '=', backend_id)])
self.assertEqual(len(category_ids), 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_10_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.registry('magento.product.category')
category_ids = category_model.search(
self.cr, self.uid, [('backend_id', '=', backend_id)])
self.assertEqual(len(category_ids), 1)
def _import_sale_order(self, increment_id):
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.sale.order', backend_id,
increment_id)
MagentoOrder = self.registry('magento.sale.order')
binding_ids = MagentoOrder.search(
self.cr, self.uid, [('backend_id', '=', backend_id),
('magento_id', '=', str(increment_id))])
self.assertEqual(len(binding_ids), 1)
return MagentoOrder.browse(self.cr, self.uid, binding_ids[0])
def test_31_import_sale_order_no_website_id(self):
""" Import a 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.registry('magento.sale.order')
order_ids = order_model.search(self.cr, self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '900000692')])
self.assertEqual(len(order_ids), 1)
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 _import_order(self):
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session,
'magento.sale.order',
self.backend_id, 900000691)
binding_model = self.env['magento.sale.order']
return binding_model.search(
[('backend_id', '=', self.backend_id),
('magento_id', '=', '900000691'),
]
)
def test_30_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.registry('magento.sale.order')
order_ids = order_model.search(self.cr, self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '900000691')])
self.assertEqual(len(order_ids), 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 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_12_import_product(self):
""" Import of a simple product """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session, 'magento.product.product',
backend_id, 16)
product_model = self.registry('magento.product.product')
product_ids = product_model.search(self.cr, self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '16')])
self.assertEqual(len(product_ids), 1)
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_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 test_import_product(self):
""" Import of a simple product """
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session,
'magento.product.product',
backend_id, 16)
product_model = self.env['magento.product.product']
product = product_model.search([('backend_id', '=', backend_id),
('magento_id', '=', '16')])
self.assertEqual(len(product), 1)
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_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_31_import_sale_order_no_website_id(self):
""" Import a 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.registry('magento.sale.order')
order_ids = order_model.search(self.cr,
self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '900000692')])
self.assertEqual(len(order_ids), 1)
def test_30_import_sale_order(self):
""" Import a 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.registry('magento.sale.order')
order_ids = order_model.search(self.cr,
self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '900000691')])
self.assertEqual(len(order_ids), 1)
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.openerp_id.action_button_confirm()
sale = self.mag_sale.openerp_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)
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 _import_sale_order(self, increment_id):
backend_id = self.backend_id
with mock_api(magento_base_responses):
with mock_urlopen_image():
import_record(self.session,
'magento.sale.order',
backend_id, increment_id)
MagentoOrder = self.registry('magento.sale.order')
binding_ids = MagentoOrder.search(
self.cr,
self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', str(increment_id))])
self.assertEqual(len(binding_ids), 1)
return MagentoOrder.browse(self.cr, self.uid, binding_ids[0])
def test_13_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.registry('magento.product.product')
product_ids = product_model.search(self.cr,
self.uid,
[('backend_id', '=', backend_id),
('magento_id', '=', '25')])
self.assertEqual(len(product_ids), 1)
def test_10_import_attribute_set(self):
""" Import the default attribute set"""
with mock_api(magento_attribute_responses):
import_record(self.session, 'magento.attribute.set',
self.backend_id, '9')
mag_attr_obj = self.registry('magento.attribute.set')
cr, uid = self.cr, self.uid
mag_attr_set_ids = mag_attr_obj.search(cr, uid, [
('magento_id', '=', '9'),
('backend_id', '=', self.backend_id),
])
self.assertEqual(len(mag_attr_set_ids), 1)
mag_attr_set = mag_attr_obj.browse(cr, uid, mag_attr_set_ids[0])
self.assertEqual(mag_attr_set.attribute_set_name, 'Default')
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 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_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_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.openerp_id, existing_category)
self.assertEqual(category.name, 'Wholesale')
self.assertEqual(category.tax_class_id, 3)
