cubicweb/test/unittest_cwconfig.py
changeset 12547 a11119d327e4
parent 12518 12e8b65146d9
child 12567 26744ad37953
equal deleted inserted replaced
12546:465ee7fb16e3 12547:a11119d327e4
    59     with open(filepath, 'a'):
    59     with open(filepath, 'a'):
    60         pass
    60         pass
    61 
    61 
    62 
    62 
    63 @contextlib.contextmanager
    63 @contextlib.contextmanager
    64 def temp_config(appid, instance_dir, cubes_dir, cubes):
    64 def temp_config(appid, instance_dir, cubes):
    65     """context manager that create a config object with specified appid,
    65     """context manager that create a config object with specified appid,
    66     instance_dir, cubes_dir and cubes"""
    66     instance_dir and cubes"""
    67     cls = CubicWebConfiguration
    67     cls = CubicWebConfiguration
    68     old = (cls._INSTANCES_DIR, cls.CUBES_DIR, cls.CUBES_PATH,
    68     old = (cls._INSTANCES_DIR,
    69            sys.path[:], sys.meta_path[:])
    69            sys.path[:], sys.meta_path[:])
    70     old_modules = set(sys.modules)
    70     old_modules = set(sys.modules)
    71     try:
    71     try:
    72         cls._INSTANCES_DIR, cls.CUBES_DIR, cls.CUBES_PATH = (
    72         cls._INSTANCES_DIR = instance_dir
    73             instance_dir, cubes_dir, [])
       
    74         config = cls(appid)
    73         config = cls(appid)
    75         config._cubes = cubes
    74         config._cubes = cubes
    76         config.adjust_sys_path()
    75         config.adjust_sys_path()
    77         yield config
    76         yield config
    78     finally:
    77     finally:
    79         (cls._INSTANCES_DIR, cls.CUBES_DIR, cls.CUBES_PATH,
    78         (cls._INSTANCES_DIR, sys.path[:], sys.meta_path[:]) = old
    80          sys.path[:], sys.meta_path[:]) = old
       
    81         for module in set(sys.modules) - old_modules:
    79         for module in set(sys.modules) - old_modules:
    82             del sys.modules[module]
    80             del sys.modules[module]
    83 
    81 
    84 
    82 
    85 def iter_entry_points(group, name):
    83 def iter_entry_points(group, name):
   110     def setUp(self):
   108     def setUp(self):
   111         self.config = ApptestConfiguration('data', __file__)
   109         self.config = ApptestConfiguration('data', __file__)
   112         self.config._cubes = ('email', 'file')
   110         self.config._cubes = ('email', 'file')
   113 
   111 
   114     def tearDown(self):
   112     def tearDown(self):
   115         ApptestConfiguration.CUBES_PATH = []
       
   116         cleanup_sys_modules([self.datapath()])
   113         cleanup_sys_modules([self.datapath()])
   117 
   114 
   118     def test_migration_scripts_dir(self):
   115     def test_migration_scripts_dir(self):
   119         mscripts = os.listdir(self.config.migration_scripts_dir())
   116         mscripts = os.listdir(self.config.migration_scripts_dir())
   120         self.assertIn('bootstrapmigration_repository.py', mscripts)
   117         self.assertIn('bootstrapmigration_repository.py', mscripts)
   187     @patch('pkg_resources.iter_entry_points', side_effect=iter_entry_points)
   184     @patch('pkg_resources.iter_entry_points', side_effect=iter_entry_points)
   188     def test_ccplugin_modname(self, mock_iter_entry_points):
   185     def test_ccplugin_modname(self, mock_iter_entry_points):
   189         self.config.load_cwctl_plugins()
   186         self.config.load_cwctl_plugins()
   190         mock_iter_entry_points.assert_called_once_with(
   187         mock_iter_entry_points.assert_called_once_with(
   191             group='cubicweb.cubes', name=None)
   188             group='cubicweb.cubes', name=None)
   192         self.assertNotIn('cubes.mycube.ccplugin', sys.modules, sorted(sys.modules))
       
   193         self.assertIn('cubicweb_mycube.ccplugin', sys.modules, sorted(sys.modules))
   189         self.assertIn('cubicweb_mycube.ccplugin', sys.modules, sorted(sys.modules))
   194 
   190 
   195     def test_config_value_from_environment_str(self):
   191     def test_config_value_from_environment_str(self):
   196         self.assertIsNone(self.config['base-url'])
   192         self.assertIsNone(self.config['base-url'])
   197         os.environ['CW_BASE_URL'] = 'https://www.cubicweb.org'
   193         os.environ['CW_BASE_URL'] = 'https://www.cubicweb.org'
   301             join(libdir, 'cubicweb_foo', 'schema', '__init__.py'),
   297             join(libdir, 'cubicweb_foo', 'schema', '__init__.py'),
   302             join(libdir, 'cubicweb_foo', 'schema', 'a.py'),
   298             join(libdir, 'cubicweb_foo', 'schema', 'a.py'),
   303             join(libdir, 'cubicweb_foo', 'schema', 'b.py'),
   299             join(libdir, 'cubicweb_foo', 'schema', 'b.py'),
   304             # subpackages should not be loaded
   300             # subpackages should not be loaded
   305             join(libdir, 'cubicweb_foo', 'schema', 'c', '__init__.py'),
   301             join(libdir, 'cubicweb_foo', 'schema', 'c', '__init__.py'),
   306             join(libdir, 'cubes', '__init__.py'),
       
   307             join(libdir, 'cubes', 'bar', '__init__.py'),
       
   308             join(libdir, 'cubes', 'bar', 'schema.py'),
       
   309             join(libdir, '_instance_dir', 'data1', 'schema.py'),
   302             join(libdir, '_instance_dir', 'data1', 'schema.py'),
   310             join(libdir, '_instance_dir', 'data2', 'noschema.py'),
   303             join(libdir, '_instance_dir', 'data2', 'noschema.py'),
   311         ):
   304         ):
   312             create_filepath(filepath)
   305             create_filepath(filepath)
   313         expected = [
   306         expected = [
   314             ('cubicweb', 'cubicweb.schemas.bootstrap'),
   307             ('cubicweb', 'cubicweb.schemas.bootstrap'),
   315             ('cubicweb', 'cubicweb.schemas.base'),
   308             ('cubicweb', 'cubicweb.schemas.base'),
   316             ('cubicweb', 'cubicweb.schemas.workflow'),
   309             ('cubicweb', 'cubicweb.schemas.workflow'),
   317             ('cubicweb', 'cubicweb.schemas.Bookmark'),
   310             ('cubicweb', 'cubicweb.schemas.Bookmark'),
   318             ('bar', 'cubes.bar.schema'),
       
   319             ('foo', 'cubicweb_foo.schema'),
   311             ('foo', 'cubicweb_foo.schema'),
   320             ('foo', 'cubicweb_foo.schema.a'),
   312             ('foo', 'cubicweb_foo.schema.a'),
   321             ('foo', 'cubicweb_foo.schema.b'),
   313             ('foo', 'cubicweb_foo.schema.b'),
   322         ]
   314         ]
   323         # app has schema file
   315         # app has schema file
   324         instance_dir, cubes_dir = (
   316         instance_dir = join(libdir, '_instance_dir')
   325             join(libdir, '_instance_dir'), join(libdir, 'cubes'))
   317         with temp_config('data1', instance_dir, ('foo',)) as config:
   326         with temp_config('data1', instance_dir, cubes_dir,
       
   327                          ('foo', 'bar')) as config:
       
   328             self.assertEqual(pkgutil.find_loader('schema').get_filename(),
   318             self.assertEqual(pkgutil.find_loader('schema').get_filename(),
   329                              join(libdir, '_instance_dir',
   319                              join(libdir, '_instance_dir',
   330                                   'data1', 'schema.py'))
   320                                   'data1', 'schema.py'))
   331             self.assertEqual(config.schema_modnames(),
   321             self.assertEqual(config.schema_modnames(),
   332                              expected + [('data', 'schema')])
   322                              expected + [('data', 'schema')])
   333         # app doesn't have schema file
   323         # app doesn't have schema file
   334         with temp_config('data2', instance_dir, cubes_dir,
   324         with temp_config('data2', instance_dir, ('foo',)) as config:
   335                          ('foo', 'bar')) as config:
       
   336             self.assertEqual(pkgutil.find_loader('schema').get_filename(),
   325             self.assertEqual(pkgutil.find_loader('schema').get_filename(),
   337                              join(libdir, 'schema.py'))
   326                              join(libdir, 'schema.py'))
   338             self.assertEqual(config.schema_modnames(), expected)
   327             self.assertEqual(config.schema_modnames(), expected)
   339 
   328 
   340     @templibdir
   329     @templibdir
   347             # subpackages should be loaded recursively
   336             # subpackages should be loaded recursively
   348             join(libdir, 'cubicweb_foo', 'entities', 'b', '__init__.py'),
   337             join(libdir, 'cubicweb_foo', 'entities', 'b', '__init__.py'),
   349             join(libdir, 'cubicweb_foo', 'entities', 'b', 'a.py'),
   338             join(libdir, 'cubicweb_foo', 'entities', 'b', 'a.py'),
   350             join(libdir, 'cubicweb_foo', 'entities', 'b', 'c', '__init__.py'),
   339             join(libdir, 'cubicweb_foo', 'entities', 'b', 'c', '__init__.py'),
   351             join(libdir, 'cubicweb_foo', 'hooks.py'),
   340             join(libdir, 'cubicweb_foo', 'hooks.py'),
   352             join(libdir, 'cubes', '__init__.py'),
       
   353             join(libdir, 'cubes', 'bar', '__init__.py'),
       
   354             join(libdir, 'cubes', 'bar', 'hooks.py'),
       
   355             join(libdir, '_instance_dir', 'data1', 'entities.py'),
   341             join(libdir, '_instance_dir', 'data1', 'entities.py'),
   356             join(libdir, '_instance_dir', 'data2', 'hooks.py'),
   342             join(libdir, '_instance_dir', 'data2', 'hooks.py'),
   357         ):
   343         ):
   358             create_filepath(filepath)
   344             create_filepath(filepath)
   359         instance_dir, cubes_dir = (
   345         instance_dir = join(libdir, '_instance_dir')
   360             join(libdir, '_instance_dir'), join(libdir, 'cubes'))
       
   361         expected = [
   346         expected = [
   362             'cubicweb.entities',
   347             'cubicweb.entities',
   363             'cubicweb.entities.adapters',
   348             'cubicweb.entities.adapters',
   364             'cubicweb.entities.authobjs',
   349             'cubicweb.entities.authobjs',
   365             'cubicweb.entities.lib',
   350             'cubicweb.entities.lib',
   366             'cubicweb.entities.schemaobjs',
   351             'cubicweb.entities.schemaobjs',
   367             'cubicweb.entities.sources',
   352             'cubicweb.entities.sources',
   368             'cubicweb.entities.wfobjs',
   353             'cubicweb.entities.wfobjs',
   369             'cubes.bar.hooks',
       
   370             'cubicweb_foo.entities',
   354             'cubicweb_foo.entities',
   371             'cubicweb_foo.entities.a',
   355             'cubicweb_foo.entities.a',
   372             'cubicweb_foo.entities.b',
   356             'cubicweb_foo.entities.b',
   373             'cubicweb_foo.entities.b.a',
   357             'cubicweb_foo.entities.b.a',
   374             'cubicweb_foo.entities.b.c',
   358             'cubicweb_foo.entities.b.c',
   375             'cubicweb_foo.hooks',
   359             'cubicweb_foo.hooks',
   376         ]
   360         ]
   377         # data1 has entities
   361         # data1 has entities
   378         with temp_config('data1', instance_dir, cubes_dir,
   362         with temp_config('data1', instance_dir, ('foo',)) as config:
   379                          ('foo', 'bar')) as config:
       
   380             config.cube_appobject_path = set(['entities', 'hooks'])
   363             config.cube_appobject_path = set(['entities', 'hooks'])
   381             self.assertEqual(config.appobjects_modnames(),
   364             self.assertEqual(config.appobjects_modnames(),
   382                              expected + ['entities'])
   365                              expected + ['entities'])
   383         # data2 has hooks
   366         # data2 has hooks
   384         with temp_config('data2', instance_dir, cubes_dir,
   367         with temp_config('data2', instance_dir, ('foo',)) as config:
   385                          ('foo', 'bar')) as config:
       
   386             config.cube_appobject_path = set(['entities', 'hooks'])
   368             config.cube_appobject_path = set(['entities', 'hooks'])
   387             self.assertEqual(config.appobjects_modnames(),
   369             self.assertEqual(config.appobjects_modnames(),
   388                              expected + ['hooks'])
   370                              expected + ['hooks'])
   389 
   371 
   390 
   372