diff --git a/connector_carepoint/models/address_abstract.py b/connector_carepoint/models/address_abstract.py index be240cb..613d26f 100644 --- a/connector_carepoint/models/address_abstract.py +++ b/connector_carepoint/models/address_abstract.py @@ -3,13 +3,15 @@ # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html). import logging -from openerp import models, fields, api +from openerp import models, fields, api, _ from openerp.addons.connector.unit.mapper import (mapping, only_create, + ExportMapper, ) from ..unit.mapper import CarepointImportMapper from ..backend import carepoint from ..unit.import_synchronizer import CarepointImporter +from ..unit.export_synchronizer import CarepointExporter from .address import CarepointAddress @@ -139,3 +141,38 @@ def _create(self, data): self.session, binding._name, binding.id, binding.backend_id.id ) return binding + + +@carepoint +class CarepointAddressAbstractExportMapper(ExportMapper): + + @mapping + def addr_id(self, binding): + binder = self.binder_for('carepoint.carepoint.address') + rec_id = binder.to_backend(binding.address_id.id) + return {'addr_id': rec_id} + + @mapping + def static_defaults(self, binding): + return { + 'priority': 2, + 'addr_type_cn': 2, + 'app_flags': 0, + } + + +@carepoint +class CarepointAddressAbstractExporter(CarepointExporter): + + @mapping + def _export_dependencies(self): + model = self._model_name + if isinstance(model, list): + model = model[0] + _logger.debug( + _('_model_name was a list, using %s from %s') % ( + self._model_name, model, + ) + ) + self._export_dependency(self.binding_record.address_id, + model) diff --git a/connector_carepoint/tests/models/test_address_abstract.py b/connector_carepoint/tests/models/test_address_abstract.py index 2d3547c..c15bf01 100644 --- a/connector_carepoint/tests/models/test_address_abstract.py +++ b/connector_carepoint/tests/models/test_address_abstract.py @@ -191,3 +191,79 @@ def test_import_dependencies(self): 'carepoint.carepoint.address', ), ]) + + +class TestAddressAbstractExportMapper(AddressAbstractTestBase): + + def setUp(self): + super(TestAddressAbstractExportMapper, self).setUp() + self.Unit = address_abstract.CarepointAddressAbstractExportMapper + self.unit = self.Unit(self.mock_env) + self.record = mock.MagicMock() + + def test_addr_id_get_binder(self): + """ It should get binder for prescription line """ + with mock.patch.object(self.unit, 'binder_for'): + self.unit.binder_for.side_effect = EndTestException + with self.assertRaises(EndTestException): + self.unit.addr_id(self.record) + self.unit.binder_for.assert_called_once_with( + 'carepoint.carepoint.address' + ) + + def test_addr_id_to_backend(self): + """ It should get backend record for rx """ + with mock.patch.object(self.unit, 'binder_for'): + self.unit.binder_for().to_backend.side_effect = EndTestException + with self.assertRaises(EndTestException): + self.unit.addr_id(self.record) + self.unit.binder_for().to_backend.assert_called_once_with( + self.record.address_id.id, + ) + + def test_addr_id_return(self): + """ It should return formatted addr_id """ + with mock.patch.object(self.unit, 'binder_for'): + res = self.unit.addr_id(self.record) + expect = self.unit.binder_for().to_backend() + self.assertDictEqual({'addr_id': expect}, res) + + def test_static_defaults(self): + """ It should return a dict of default values """ + self.assertIsInstance( + self.unit.static_defaults(self.record), + dict, + ) + + +class TestAddressAbstractExporter(AddressAbstractTestBase): + + def setUp(self): + super(TestAddressAbstractExporter, self).setUp() + self.Unit = address_abstract.CarepointAddressAbstractExporter + self.unit = self.Unit(self.mock_env) + self.record = mock.MagicMock() + self.unit.binding_record = self.record + + def test_export_dependencies_export(self): + """ It should export all dependencies """ + with mock.patch.object(self.unit, '_export_dependency') as mk: + self.unit._export_dependencies() + mk.assert_has_calls([ + mock.call( + self.record.address_id, + self.unit._model_name, + ), + ]) + + def test_export_dependencies_list(self): + """ It should correctly handle list _model_name as list """ + with mock.patch.object(self.unit, '_export_dependency') as mk: + self.unit._model_name = ['expect'] + self.unit._export_dependencies() + mk.assert_has_calls([ + mock.call( + self.record.address_id, + self.unit._model_name[0], + ), + ]) diff --git a/connector_carepoint/tests/test_backend_adapter.py b/connector_carepoint/tests/test_backend_adapter.py index 5833438..3e3626f 100644 --- a/connector_carepoint/tests/test_backend_adapter.py +++ b/connector_carepoint/tests/test_backend_adapter.py @@ -2,6 +2,8 @@ # Copyright 2015-2016 LasLabs Inc. # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html). +import mock + from openerp.addons.connector_carepoint.unit import backend_adapter from .common import SetUpCarepointBase @@ -194,13 +196,41 @@ def test_create_creates(self): expect, ) - def test_create_returns_result(self): - """ It should return newly created record """ + def test_create_gets_pks(self): + """ It should get primary keys of model """ + with self.mock_api() as api: + model = self._init_model() + model.create({'data': 'test', 'col': 12323423}) + api().get_pks.assert_called_once_with( + api()[self.api_camel], + ) + + def test_create_gets_sequences(self): + """ It should get next sequence for PK """ + expect = mock.MagicMock() + with self.mock_api() as api: + model = self._init_model() + api().get_pks.return_value = [expect] + model.create({'data': 'test', 'col': 12323423}) + api().get_next_sequence.assert_called_once_with( + expect, + ) + + def test_create_returns_pks(self): + """ It should return comma joined PKs of new record """ + expect = ['col', 'no_exist'] with self.mock_api() as api: - res = self._init_model().create( - {'data': 'test', 'col': 12323423} + model = self._init_model() + api().get_pks.return_value = expect + expect = {'data': 'test', 'col': 12323423} + res = model.create(expect) + self.assertEqual( + '%s,%s' % ( + str(expect['col']), + api().get_next_sequence(), + ), + res, ) - self.assertEqual(api().create(), res) def test_delete_deletes(self): """ It should delete w/ proper vals """ @@ -218,14 +248,12 @@ def test_delete_returns_result(self): res = self._init_model().delete(123) self.assertEqual(api().delete(), res) - def test_write_updates(self): - """ It should update w/ proper vals """ + def test_write_gets_session(self): + """ It should get session for model """ with self.mock_api() as api: - expect = [123, {'data': 'test', 'col': 12323423}] - self._init_model().write(*expect) - api().update.assert_called_once_with( + self._init_model().write(None, None) + api()._get_session.assert_called_once_with( api()[self.api_camel], - *expect ) def test_write_returns_result(self): @@ -234,4 +262,7 @@ def test_write_returns_result(self): res = self._init_model().write( 123, {'data': 'test', 'col': 12323423}, ) - self.assertEqual(api().update(), res) + self.assertEqual( + api()._do_queries(), + res, + ) diff --git a/connector_carepoint/tests/test_base_exporter.py b/connector_carepoint/tests/test_base_exporter.py index 535b40c..9977c69 100644 --- a/connector_carepoint/tests/test_base_exporter.py +++ b/connector_carepoint/tests/test_base_exporter.py @@ -38,14 +38,18 @@ def _new_exporter(self, carepoint_id=None, binding_record=None, exporter.carepoint_id = carepoint_id exporter.binding_record = binding_record exporter.binding_id = binding_id + self.exporter = exporter return exporter def _new_record(self, sync_date=False): - return self.env[self.model].create({ + rec = self.env[self.model].create({ 'name': 'Test', 'sync_date': sync_date, 'warehouse_id': self.env.ref('stock.warehouse0').id, + 'carepoint_id': self.carepoint_id, }) + self.binding_id = rec.id + return rec def test_exporter_init_binding_id(self): """ It should init binding_id as None """ @@ -192,18 +196,6 @@ def test_run_sets_binding_id(self): self.binding_id, exporter.binding_id, ) - def test_run_gets_backend(self): - """ It should get the backend for binding """ - exporter = self._new_exporter( - carepoint_id=self.carepoint_id, - binding_record=self._new_record('2016-06-12 00:00:00'), - ) - with mock.patch.object(exporter.binder, 'to_backend') as mk: - mk.side_effect = EndTestException - with self.assertRaises(EndTestException): - exporter.run(self.binding_id) - mk.assert_called_once_with(self.binding_id) - def test_run_should_import(self): """ It should see if the record needs to be imported """ exporter = self._new_exporter( @@ -274,7 +266,7 @@ def test_run_calls_bind(self): with self.assertRaises(EndTestException): exporter.run(self.binding_id) binder.bind.assert_called_once_with( - binder.to_backend(), self.binding_id, + self.carepoint_id, self.binding_id, ) def test_run_commits_session(self): diff --git a/connector_carepoint/unit/backend_adapter.py b/connector_carepoint/unit/backend_adapter.py index e5ee2bf..dd10bf3 100644 --- a/connector_carepoint/unit/backend_adapter.py +++ b/connector_carepoint/unit/backend_adapter.py @@ -113,12 +113,20 @@ def search_read(self, attributes=None, **filters): def create(self, data): """ Wrapper to create a record on the external system - :param data: Data to create record with - :type data: dict - :rtype: :class:`sqlalchemy.ext.declarative.Declarative` + Params: + data: ``dict`` of Data to create record with + Returns: + ``str`` of external carepoint_id """ model_obj = self.__get_cp_model() - return self.carepoint.create(model_obj, data) + pks = self.carepoint.get_pks(model_obj) + out_pks = [] + for pk in pks: + if not data.get(pk): + data[pk] = self.carepoint.get_next_sequence(pk) + out_pks.append(str(data[pk])) + self.carepoint.create(model_obj, data) + return ','.join(out_pks) def write(self, _id, data): """ Update record on the external system @@ -126,10 +134,18 @@ def write(self, _id, data): :type _id: int :param data: Data to create record with :type data: dict - :rtype: :class:`sqlalchemy.ext.declarative.Declarative` + :rtype: :class:`sqlalchemy.engine.ResultProxy` """ model_obj = self.__get_cp_model() - return self.carepoint.update(model_obj, _id, data) + session = self.carepoint._get_session(model_obj) + + def __update(): + record = self.read(_id) + for key, val in data.iteritems(): + setattr(record, key, val) + return record + + return self.carepoint._do_queries(session, __update) def delete(self, _id): """ Delete record on the external system diff --git a/connector_carepoint/unit/export_synchronizer.py b/connector_carepoint/unit/export_synchronizer.py index a173c4d..6a7141c 100644 --- a/connector_carepoint/unit/export_synchronizer.py +++ b/connector_carepoint/unit/export_synchronizer.py @@ -88,7 +88,7 @@ def run(self, binding_id, *args, **kwargs): self.binding_id = binding_id self.binding_record = self._get_odoo_data() - self.carepoint_id = self.binder.to_backend(self.binding_id) + self.carepoint_id = self.binding_record.carepoint_id try: should_import = self._should_import()