[FIX] connector_carepoint: Fix create and write functionality

* Add primary key injection in create
* Prefer Pk return in create to Recordset - comma join in col order
* Remove carepoint update method in favor of custom write logic
* Fix export synchronizer carepoint_id assignment

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)

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],
+                ),
+            ])

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,
+            )

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):

connector_carepoint/unit/backend_adapter.py

@@ -113,23 +113,39 @@ 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
         :param _id: Id of record to manipulate
         :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

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()