class test_connector_session(common.TransactionCase): """ Test ConnectorSession """ def setUp(self): super(test_connector_session, self).setUp() self.context = {'lang': 'fr_FR'} self.session = ConnectorSession(self.cr, self.uid, context=self.context) def test_env(self): """ Check the session properties """ session = self.session self.assertEqual(session.cr, session.env.cr) self.assertEqual(session.uid, session.env.uid) self.assertEqual(session.context, session.env.context) self.assertEqual(session.pool, session.env.registry) def test_from_env(self): """ ConnectorSession.from_env(env) """ session = ConnectorSession.from_env(self.env) self.assertEqual(session.cr, self.env.cr) self.assertEqual(session.uid, self.env.uid) self.assertEqual(session.context, self.env.context) self.assertEqual(session.pool, self.env.registry) def test_change_user(self): """ Change the user and check if it is reverted correctly at the end """ original_uid = self.session.uid original_env = self.session.env new_uid = self.env.ref('base.user_demo').id with self.session.change_user(new_uid): # a new odoo.api.Environment is generated with the user self.assertNotEqual(self.session.env, original_env) self.assertEqual(self.session.uid, new_uid) self.assertEqual(self.session.env, original_env) self.assertEqual(self.session.uid, original_uid) def test_model_with_transaction(self): """ Use a method on a model from the pool """ user_model = self.env['res.users'] res_users = user_model.search_count([]) sess_res_users = user_model.search_count([]) self.assertEqual(sess_res_users, res_users) def test_new_model_with_transaction(self): """ Use a method on a model from the new api """ res_users = self.env['res.users'].search_count([]) sess_res_users_model = self.session.env['res.users'] sess_res_users = sess_res_users_model.search_count([]) self.assertEqual(sess_res_users, res_users) def test_change_context(self): """ Change the context, it is reverted at the end """ test_key = 'test_key' self.assertNotIn(test_key, self.session.context) with self.session.change_context({test_key: 'value'}): self.assertEqual(self.session.context.get('test_key'), 'value') self.assertNotIn(test_key, self.session.context) def test_change_context_keyword(self): """ Change the context by keyword, it is reverted at the end """ test_key = 'test_key' self.assertNotIn(test_key, self.session.context) with self.session.change_context(test_key='value'): self.assertEqual(self.session.context.get('test_key'), 'value') self.assertNotIn(test_key, self.session.context) def test_change_context_uninitialized(self): """ Change the context on a session not initialized with a context """ session = ConnectorSession.from_env(self.env) test_key = 'test_key' with session.change_context({test_key: 'value'}): self.assertEqual(session.context.get('test_key'), 'value') self.assertNotIn(test_key, session.context) def test_is_module_installed(self): """ Test on an installed module """ self.assertTrue(self.session.is_module_installed('connector')) def test_is_module_uninstalled(self): """ Test on an installed module """ self.assertFalse(self.session.is_module_installed('lambda')) def test_is_module_installed_cache_not_propagated(self): """ Test if the cache is well different for the different modules """ self.assertTrue(self.session.is_module_installed('connector')) self.assertFalse(self.session.is_module_installed('#dummy#'))
class TestJobStorageMultiCompany(common.TransactionCase): """ Test storage of jobs """ def setUp(self): super(TestJobStorageMultiCompany, self).setUp() self.session = ConnectorSession(self.cr, self.uid, context={}) self.queue_job = self.env['queue.job'] grp_connector_manager = self.ref("connector.group_connector_manager") User = self.env['res.users'] Company = self.env['res.company'] Partner = self.env['res.partner'] self.other_partner_a = Partner.create( {"name": "My Company a", "is_company": True, "email": "*****@*****.**", }) self.other_company_a = Company.create( {"name": "My Company a", "partner_id": self.other_partner_a.id, "rml_header1": "My Company Tagline", "currency_id": self.ref("base.EUR") }) self.other_user_a = User.create( {"partner_id": self.other_partner_a.id, "company_id": self.other_company_a.id, "company_ids": [(4, self.other_company_a.id)], "login": "******", "name": "my user", "groups_id": [(4, grp_connector_manager)] }) self.other_partner_b = Partner.create( {"name": "My Company b", "is_company": True, "email": "*****@*****.**", }) self.other_company_b = Company.create( {"name": "My Company b", "partner_id": self.other_partner_b.id, "rml_header1": "My Company Tagline", "currency_id": self.ref("base.EUR") }) self.other_user_b = User.create( {"partner_id": self.other_partner_b.id, "company_id": self.other_company_b.id, "company_ids": [(4, self.other_company_b.id)], "login": "******", "name": "my user 1", "groups_id": [(4, grp_connector_manager)] }) def _create_job(self): self.cr.execute('delete from queue_job') job(task_a) task_a.delay(self.session, 'res.users') stored = self.queue_job.search([]) self.assertEqual(len(stored), 1) return stored def test_job_default_company_id(self): """the default company is the one from the current user_id""" stored = self._create_job() self.assertEqual(stored.company_id.id, self.ref("base.main_company"), 'Incorrect default company_id') with self.session.change_user(self.other_user_b.id): stored = self._create_job() self.assertEqual(stored.company_id.id, self.other_company_b.id, 'Incorrect default company_id') def test_job_no_company_id(self): """ if we put an empty company_id in the context jobs are created without company_id""" with self.session.change_context({'company_id': None}): stored = self._create_job() self.assertFalse(stored.company_id, ' Company_id should be empty') def test_job_specific_company_id(self): """If a company_id specified in the context it's used by default for the job creation""" s = self.session with s.change_context({'company_id': self.other_company_a.id}): stored = self._create_job() self.assertEqual(stored.company_id.id, self.other_company_a.id, 'Incorrect company_id') def test_job_subscription(self): # if the job is created without company_id, all members of # connector.group_connector_manager must be followers User = self.env['res.users'] with self.session.change_context(company_id=None): stored = self._create_job() stored._subscribe_users() users = User.search( [('groups_id', '=', self.ref('connector.group_connector_manager'))] ) self.assertEqual(len(stored.message_follower_ids), len(users)) expected_partners = [u.partner_id for u in users] self.assertSetEqual( set(stored.message_follower_ids.mapped('partner_id')), set(expected_partners)) followers_id = stored.message_follower_ids.mapped('partner_id.id') self.assertIn(self.other_partner_a.id, followers_id) self.assertIn(self.other_partner_b.id, followers_id) # jobs created for a specific company_id are followed only by # company's members s = self.session with s.change_context(company_id=self.other_company_a.id): stored = self._create_job() stored.sudo(self.other_user_a.id)._subscribe_users() # 2 because admin + self.other_partner_a self.assertEqual(len(stored.message_follower_ids), 2) users = User.browse([SUPERUSER_ID, self.other_user_a.id]) expected_partners = [u.partner_id for u in users] self.assertSetEqual( set(stored.message_follower_ids.mapped('partner_id')), set(expected_partners)) followers_id = stored.message_follower_ids.mapped('partner_id.id') self.assertIn(self.other_partner_a.id, followers_id) self.assertNotIn(self.other_partner_b.id, followers_id)