Esempio n. 1
0
 def test_link_existing_dep(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path, [{
         'name': 'dep',
         'url': 'https://github.com/comtihon/dep',
         'tag': '1.0.0'
     }])
     create(self.tmp_dir, {'<name>': 'dep'})
     dep_path = join(self.tmp_dir, 'dep')
     set_git_url(dep_path, 'https://github/comtihon/dep')
     set_git_tag(dep_path, '1.0.0')
     dep_builder = Builder.init_from_path(dep_path)
     self.assertEqual(True, dep_builder.build())
     dep_builder.system_config.cache.add_package_local(dep_builder.project)
     self.assertEqual(
         True,
         dep_builder.system_config.cache.exists_local(dep_builder.project))
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     dep_link_ebin = join(pack_path, 'deps', 'dep', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     erl = Static.get_erlang_version()
     real_dep = join(self.cache_dir, 'comtihon', 'dep', '1.0.0', erl,
                     'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
Esempio n. 2
0
 def test_update_erlang_relink_deps(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'dep_with_no_deps',
                   'url': 'https://github.com/comtihon/dep_with_no_deps',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'dep_with_no_deps'})
     dep_dir = join(self.tmp_dir, 'dep_with_no_deps')
     set_git_url(dep_dir, 'http://github/comtihon/dep_with_no_deps')
     set_git_tag(dep_dir, '1.0.0')  # This is not needed but pretend we really fetch it from git
     with patch.object(Static, 'get_erlang_version', return_value='18'):
         builder = Builder.init_from_path(pack_path)
         builder.populate()
         self.assertEqual(True, builder.build())
         dep_link_ebin = join(pack_path, 'deps', 'dep_with_no_deps', 'ebin')
         self.assertEqual(True, os.path.islink(dep_link_ebin))
         erl = Static.get_erlang_version()
         real_dep = join(self.cache_dir, 'comtihon', 'dep_with_no_deps', '1.0.0', erl, 'ebin')
         self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     with patch.object(Static, 'get_erlang_version', return_value='22'):
         builder = Builder.init_from_path(pack_path)
         builder.populate()
         self.assertEqual(True, builder.build())
         dep_link_ebin = join(pack_path, 'deps', 'dep_with_no_deps', 'ebin')
         self.assertEqual(True, os.path.islink(dep_link_ebin))
         erl2 = Static.get_erlang_version()
         real_dep = join(self.cache_dir, 'comtihon', 'dep_with_no_deps', '1.0.0', erl2, 'ebin')
         self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     self.assertNotEqual(erl, erl2)
Esempio n. 3
0
 def test_change_branch(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_git_url(pack_path, 'http://github/comtihon/test_app')
     set_git_tag(pack_path, '1.0.0')
     set_deps(pack_path,
              [
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'branch': 'master'}
              ])
     dep_dir = join(self.tmp_dir, 'dep')
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     dep_link_ebin = join(pack_path, 'deps', 'dep', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     erl = Static.get_erlang_version()
     real_dep = join(self.cache_dir, 'comtihon', 'dep', 'master-some_hash', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     # change dep's branch
     set_deps(pack_path,
              [
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'branch': 'develop'}
              ])
     switch_branch(dep_dir, 'develop')  # pretend new branch was fetched
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     real_dep = join(self.cache_dir, 'comtihon', 'dep', 'develop-some_hash', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
Esempio n. 4
0
 def test_change_tag_remove_using_dep(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'dep_with_dep',
                   'url': 'https://github.com/comtihon/dep_with_dep',
                   'tag': '1.0.0'},
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'dep_with_dep'})
     dep_dir = join(self.tmp_dir, 'dep_with_dep')
     set_git_url(dep_dir, 'http://github/comtihon/dep_with_dep')
     set_git_tag(dep_dir, '1.0.0')
     set_deps(dep_dir,
              [
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'dep'})
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     # Check all two deps linked to the project
     dep_link_ebin = join(pack_path, 'deps', 'dep_with_dep', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     erl = Static.get_erlang_version()
     real_dep = join(self.cache_dir, 'comtihon', 'dep_with_dep', '1.0.0', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     dep_link_ebin = join(pack_path, 'deps', 'dep', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     real_dep = join(self.cache_dir, 'comtihon', 'dep', '1.0.0', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     # Dep version was changed - dep_with_dep no longer uses dep
     set_deps(pack_path,
              [
                  {'name': 'dep_with_dep',
                   'url': 'https://github.com/comtihon/dep_with_dep',
                   'tag': '1.0.1'},
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'tag': '1.0.0'}
              ])
     set_deps(dep_dir, [])
     set_git_tag(dep_dir, '1.0.1')
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     # Check dep is linked to project, as it is used by project
     dep_link_ebin = join(pack_path, 'deps', 'dep_with_dep', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     real_dep = join(self.cache_dir, 'comtihon', 'dep_with_dep', '1.0.1', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     dep_link_ebin = join(pack_path, 'deps', 'dep', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
Esempio n. 5
0
 def test_change_tag_new_dep(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'dep_with_no_deps',
                   'url': 'https://github.com/comtihon/dep_with_no_deps',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'dep_with_no_deps'})
     dep_dir = join(self.tmp_dir, 'dep_with_no_deps')
     set_git_url(dep_dir, 'http://github/comtihon/dep_with_no_deps')
     set_git_tag(dep_dir, '1.0.0')
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     dep_link_ebin = join(pack_path, 'deps', 'dep_with_no_deps', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     erl = Static.get_erlang_version()
     real_dep = join(self.cache_dir, 'comtihon', 'dep_with_no_deps', '1.0.0', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     # Dep version was changed
     set_deps(pack_path,
              [
                  {'name': 'dep_with_no_deps',
                   'url': 'https://github.com/comtihon/dep_with_no_deps',
                   'tag': '1.0.1'}
              ])
     set_git_tag(dep_dir, '1.0.1')
     set_deps(dep_dir,
              [
                  {'name': 'new_dep',
                   'url': 'https://github.com/comtihon/new_dep',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'new_dep'})
     new_dep_dir = join(self.tmp_dir, 'new_dep')
     set_git_url(new_dep_dir, 'http://github/comtihon/new_dep')
     set_git_tag(new_dep_dir, '1.0.0')
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     dep_link_ebin = join(pack_path, 'deps', 'dep_with_no_deps', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     erl = Static.get_erlang_version()
     real_dep = join(self.cache_dir, 'comtihon', 'dep_with_no_deps', '1.0.1', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     self.assertEqual(True, builder.system_config.cache.exists_local(Package.from_path(new_dep_dir)))
     new_dep_link_ebin = join(pack_path, 'deps', 'new_dep', 'ebin')
     self.assertEqual(True, os.path.islink(new_dep_link_ebin))
     new_dep = join(self.cache_dir, 'comtihon', 'new_dep', '1.0.0', erl, 'ebin')
     self.assertEqual(new_dep, os.readlink(new_dep_link_ebin))
Esempio n. 6
0
 def test_link_with_deps(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path, [{
         'name': 'dep_with_dep',
         'url': 'https://github.com/comtihon/dep_with_dep',
         'tag': '1.0.0'
     }])
     # Create, build and add dep.
     create(self.tmp_dir, {'<name>': 'dep'})
     dep_dep_path = join(self.tmp_dir, 'dep')
     set_git_url(dep_dep_path, 'https://github/comtihon/dep')
     set_git_tag(dep_dep_path, '1.0.0')
     dep_builder = Builder.init_from_path(dep_dep_path)
     # Build dep of dep and add to cache
     dep_builder.populate()
     self.assertEqual(True, dep_builder.build())
     dep_builder.system_config.cache.add_package_local(dep_builder.project)
     self.assertEqual(
         True,
         dep_builder.system_config.cache.exists_local(dep_builder.project))
     # Create, build and add dep with dep: dep
     create(self.tmp_dir, {'<name>': 'dep_with_dep'})
     dep_path = join(self.tmp_dir, 'dep_with_dep')
     set_git_url(dep_path, 'https://github/comtihon/dep_with_dep')
     set_git_tag(dep_path, '1.0.0')
     set_deps(dep_path, [{
         'name': 'dep',
         'url': 'https://github.com/comtihon/dep',
         'tag': '1.0.0'
     }])
     dep_builder = Builder.init_from_path(dep_path)
     dep_builder.populate()
     self.assertEqual(True, dep_builder.build())
     dep_builder.system_config.cache.add_package_local(dep_builder.project)
     self.assertEqual(
         True,
         dep_builder.system_config.cache.exists_local(dep_builder.project))
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     for dep in ['dep_with_dep',
                 'dep']:  # Dep and dep's dep are linked to the project
         print('Check ' + dep)
         dep_link_ebin = join(pack_path, 'deps', dep, 'ebin')
         self.assertEqual(True, os.path.islink(dep_link_ebin))
         erl = Static.get_erlang_version()
         real_dep = join(self.cache_dir, 'comtihon', dep, '1.0.0', erl,
                         'ebin')
         self.assertEqual(real_dep, os.readlink(dep_link_ebin))
Esempio n. 7
0
 def test_versions_api(self, mock_conf):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_git_url(pack_path, 'http://github/comtihon/test_app')
     modify_config(pack_path, {'tag': '1.0.0'})
     builder = Builder.init_from_path(pack_path)
     self.assertEqual(True, builder.build())
     builder.system_config.cache.add_package_local(builder.project)
     modify_config(pack_path, {'tag': '1.1.0'})
     builder = Builder.init_from_path(pack_path)
     self.assertEqual(True, builder.build())
     builder.system_config.cache.add_package_local(builder.project)
     local_cache = builder.system_config.cache.local_cache
     self.assertEqual(['1.0.0', '1.1.0'], local_cache.get_versions('comtihon/test_app'))
     self.assertEqual([Static.get_erlang_version()], local_cache.get_erl_versions('comtihon/test_app', '1.1.0'))
Esempio n. 8
0
def package(path, arguments: dict):
    define = arguments.get('--define', '')
    builder = Builder.init_from_path(path)
    if not do_build(builder, define):
        return False
    builder.package()
    return True
Esempio n. 9
0
 def test_link_multiple_deps(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'a_with_dep_a2',
                   'url': 'https://github.com/comtihon/a_with_dep_a2',
                   'tag': '1.0.0'},
                  {'name': 'b_with_no_deps',
                   'url': 'https://github.com/comtihon/b_with_no_deps',
                   'tag': '1.0.0'}
              ])
     # Create dep A with dep A2 (in tmp, as if we download them from git)
     create(self.tmp_dir, {'<name>': 'a_with_dep_a2'})
     dep_a1_path = join(self.tmp_dir, 'a_with_dep_a2')
     set_deps(dep_a1_path, [{'name': 'a2_with_no_deps',
                             'url': 'https://github.com/comtihon/a2_with_no_deps',
                             'tag': '1.0.0'}])
     # Create dep B (in tmp, as if we download them from git)
     create(self.tmp_dir, {'<name>': 'b_with_no_deps'})
     # Create dep A2 (in tmp, as if we download them from git)
     create(self.tmp_dir, {'<name>': 'a2_with_no_deps'})
     # Compile test_project
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     for dep in ['a_with_dep_a2', 'b_with_no_deps', 'a2_with_no_deps']:
         print('Check ' + dep)
         dep_link_ebin = join(pack_path, 'deps', dep, 'ebin')
         self.assertEqual(True, os.path.islink(dep_link_ebin))
         erl = Static.get_erlang_version()
         real_dep = join(self.cache_dir, 'comtihon', dep, '1.0.0', erl, 'ebin')
         self.assertEqual(real_dep, os.readlink(dep_link_ebin))
Esempio n. 10
0
 def test_project_with_test_dep_test_build(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'tag': '1.0.0'}
              ])
     set_deps(pack_path,
              [
                  {'name': 'test_dep',
                   'url': 'https://github.com/comtihon/test_dep',
                   'tag': '1.0.0'}
              ],
              'test_deps')
     create(self.tmp_dir, {'<name>': 'dep'})
     create(self.tmp_dir, {'<name>': 'test_dep'})
     builder = Builder.init_from_path(pack_path)
     builder.populate(include_test_deps=True)
     self.assertEqual(True, builder.build())
     for dep in ['dep', 'test_dep']:
         print('Check ' + dep)
         dep_link_ebin = join(pack_path, 'deps', dep, 'ebin')
         self.assertEqual(True, os.path.islink(dep_link_ebin))
         erl = Static.get_erlang_version()
         real_dep = join(self.cache_dir, 'comtihon', dep, '1.0.0', erl, 'ebin')
         self.assertEqual(real_dep, os.readlink(dep_link_ebin))
Esempio n. 11
0
 def test_release_multiple_deps(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'dep_with_dep',
                   'url': 'https://github.com/comtihon/dep_with_dep',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'dep_with_dep'})
     dep_dir = join(self.tmp_dir, 'dep_with_dep')
     set_deps(dep_dir,
              [
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'dep'})
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     path = ensure_tool(RelxTool())
     builder.system_config.cache.local_cache.add_tool('relx', path)
     self.assertEqual(True, builder.release())
     lib_dir = join(pack_path, '_rel', 'test_app', 'lib')
     self.assertEqual(True, os.path.exists(join(lib_dir, 'dep-0.0.1')))
     self.assertEqual(True, os.path.exists(join(lib_dir, 'dep_with_dep-0.0.1')))
Esempio n. 12
0
 def test_update_branch(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_git_url(pack_path, 'http://github/comtihon/test_app')
     set_git_tag(pack_path, '1.0.0')
     set_deps(pack_path,
              [
                  {'name': 'dep',
                   'url': 'https://github.com/comtihon/dep',
                   'branch': 'master'}
              ])
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     dep_link_ebin = join(pack_path, 'deps', 'dep', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     erl = Static.get_erlang_version()
     real_dep = join(self.cache_dir, 'comtihon', 'dep', 'master-some_hash', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
     # lock was set
     locks_file = join(pack_path, 'enot_locks.json')
     self.assertEqual(True, os.path.isfile(locks_file))
     with open(locks_file, 'r') as file:
         locks = json.load(file)
     self.assertEqual('master-some_hash', locks['comtihon/dep'])
     # drop all locks and do upgrade
     with patch.object(LocalCache, 'fetch', side_effect=mock_fetch_commit_3):
         upgrade(pack_path, {})
     self.assertEqual(True, os.path.isfile(locks_file))
     with open(locks_file, 'r') as file:
         locks = json.load(file)
     self.assertEqual('master-some_other_hash', locks['comtihon/dep'])
Esempio n. 13
0
def ct(path, arguments):
    log_dir = arguments['--log-dir']
    define = arguments['--define']
    builder = Builder.init_from_path(path)
    if not do_build(builder, define, test=True):
        return False
    return builder.common_test(log_dir)
Esempio n. 14
0
    def test_release_created(self, mock_conf):
        mock_conf.return_value = self.conf_file
        project_dir = join(self.test_dir, 'test_project')
        enot.__main__.create(self.test_dir, {'<name>': 'test_project'})
        builder = Builder.init_from_path(project_dir)
        builder.populate()
        builder.build()
        path = ensure_tool(RelxTool())
        builder.system_config.cache.local_cache.add_tool('relx', path)
        self.assertEqual(True, builder.release())
        self.assertEqual(True, os.path.exists(join(project_dir, '_rel')))
        rel_dir = join(project_dir, '_rel', 'test_project')
        self.assertEqual(True, os.path.exists(rel_dir))
        self.assertEqual(
            True, os.path.exists(join(rel_dir, 'lib', 'test_project-0.0.1')))
        self.assertEqual(True,
                         os.path.exists(join(rel_dir, 'releases', '0.0.1')))
        self.assertEqual(True, os.path.exists(join(project_dir, 'rel')))
        self.assertEqual(
            True, os.path.exists(join(project_dir, 'rel', 'sys.config')))
        self.assertEqual(True,
                         os.path.exists(join(project_dir, 'rel', 'vm.args')))
        rel_content = read_file(join(project_dir, 'rel', 'vm.args'))
        rel_expected = '''-name {{ app.name }}@127.0.0.1
-setcookie {{ app.name }}'''
        self.assertEqual(rel_content.strip(), rel_expected)
Esempio n. 15
0
 def test_deps_duplicates(self, mock_conf, mock_fetch):
     mock_conf.return_value = self.conf_file
     mock_fetch.side_effect = mock_fetch_package
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path, [{
         'name': 'dep1',
         'url': 'https://github.com/comtihon/dep1',
         'tag': '1.0.0'
     }, {
         'name': 'dep2',
         'url': 'https://github.com/comtihon/dep2',
         'tag': '1.0.0'
     }])
     create(self.tmp_dir, {'<name>': 'dep1'})
     dep_tmp_path = join(self.tmp_dir,
                         'dep1')  # Here dep1 and dep2 have common dep3
     set_deps(dep_tmp_path, [{
         'name': 'dep3',
         'url': 'https://github.com/comtihon/dep3',
         'tag': '1.0.0'
     }])
     create(self.tmp_dir, {'<name>': 'dep2'})
     dep_tmp_path = join(self.tmp_dir, 'dep2')
     set_deps(dep_tmp_path, [{
         'name': 'dep3',
         'url': 'https://github.com/comtihon/dep3',
         'tag': '1.0.0'
     }])
     create(self.tmp_dir, {'<name>': 'dep3'})
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(['dep1', 'dep2', 'dep3'].sort(),
                      list(builder.packages.keys()).sort())
     self.assertEqual(mock_fetch.call_count,
                      3)  # dep3 was fetched only once
Esempio n. 16
0
 def test_deps_conflict(self, mock_conf, mock_fetch):
     mock_conf.return_value = self.conf_file
     mock_fetch.side_effect = mock_fetch_package
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path, [{
         'name': 'dep1',
         'url': 'https://github.com/comtihon/dep1',
         'tag': '1.0.0'
     }, {
         'name': 'dep2',
         'url': 'https://github.com/comtihon/dep2',
         'tag': '1.0.0'
     }, {
         'name': 'dep3',
         'url': 'https://github.com/comtihon/dep3',
         'tag': '2.0.0'
     }])
     create(self.tmp_dir, {'<name>': 'dep1'})
     create(self.tmp_dir, {'<name>': 'dep2'})
     dep_tmp_path = join(self.tmp_dir, 'dep2')
     set_deps(dep_tmp_path, [{
         'name': 'dep3',
         'url': 'https://github.com/comtihon/dep3',
         'tag': '1.0.0'
     }])
     create(self.tmp_dir, {'<name>': 'dep3'})
     builder = Builder.init_from_path(pack_path)
     try:  # builder population should fail, because of conflicting dependencies.
         builder.populate()
         populated = True
     except RuntimeError:
         populated = False
     self.assertEqual(False, populated)
Esempio n. 17
0
 def test_dep_override_newer(self, mock_conf, mock_fetch):
     mock_conf.return_value = self.conf_file
     mock_fetch.side_effect = mock_fetch_package
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path, [{
         'name': 'dep2',
         'url': 'https://github.com/comtihon/dep2',
         'tag': '1.0.0'
     }, {
         'name': 'dep3',
         'url': 'https://github.com/comtihon/dep3',
         'tag': '1.0.1'
     }])
     create(self.tmp_dir, {'<name>': 'dep2'})
     dep_tmp_path = join(self.tmp_dir, 'dep2')
     set_deps(dep_tmp_path, [{
         'name': 'dep3',
         'url': 'https://github.com/comtihon/dep3',
         'tag': '1.0.0'
     }])
     create(self.tmp_dir, {'<name>': 'dep3'})
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(['dep2', 'dep3'].sort(),
                      list(builder.packages.keys()).sort())
     self.assertEqual(mock_fetch.call_count, 2)
     self.assertEqual('1.0.0', builder.packages['dep2'].git_vsn)
     self.assertEqual('1.0.1', builder.packages['dep3'].git_vsn)
Esempio n. 18
0
 def __add_to_local(self, pack_path):
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     controller = Controller()
     self.assertEqual(True,
                      controller.local_cache.add_package(builder.project))
     return builder
Esempio n. 19
0
def release(path, arguments: dict):
    define = arguments['--define']
    builder = Builder.init_from_path(path)
    if not do_build(builder,
                    define):  # TODO check if project was already built
        return False
    builder.release()
    return True
Esempio n. 20
0
 def test_add_from_path(self, mock_conf):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_git_url(pack_path, 'http://github/comtihon/test_app')
     set_git_tag(pack_path, '1.0.0')
     builder = Builder.init_from_path(pack_path)
     self.assertEqual(True, builder.build())
     self.assertEqual(False, builder.system_config.cache.exists_local(builder.project))
     builder.system_config.cache.add_package_local(builder.project)
     self.assertEqual(True, builder.system_config.cache.exists_local(builder.project))
Esempio n. 21
0
 def test_init_from_package(self, mock_conf):
     mock_conf.return_value = self.conf_file
     create(self.test_dir, {'<name>': 'my_dep'})
     pack_path = join(self.test_dir, 'my_dep')
     builder = Builder.init_from_path(pack_path)
     self.assertEqual(True, builder.build())
     builder.package()
     pack = Package.from_package(join(pack_path, 'my_dep.ep'))
     self.assertEqual('my_dep', pack.name)
     self.assertEqual('0.0.1', pack.vsn)
     self.assertEqual([], pack.deps)
Esempio n. 22
0
 def test_update_from_package(self, mock_conf):
     mock_conf.return_value = self.conf_file
     create(self.test_dir, {'<name>': 'my_dep'})
     pack_path = join(self.test_dir, 'my_dep')
     builder = Builder.init_from_path(pack_path)
     self.assertEqual(True, builder.build())
     builder.package()
     pack = Package.from_dep('my_dep', Dep('http://github/my_namespace/test_app', 'master', tag='1.0.0'))
     pack.update_from_package(join(pack_path, 'my_dep.ep'))
     self.assertEqual('my_dep', pack.name)
     self.assertEqual('0.0.1', pack.vsn)
     self.assertEqual('1.0.0', pack.git_tag)
     self.assertEqual('master', pack.git_branch)
     self.assertEqual('http://github/my_namespace/test_app', pack.url)
     self.assertEqual([], pack.deps)
Esempio n. 23
0
 def test_in_system(self, mock_conf, mock_get_cmd):
     mock_conf.return_value = self.conf_file
     mock_get_cmd.return_value = 'rebar'
     enot.__main__.create(self.test_dir, {'<name>': 'test'})
     project_dir = join(self.test_dir, 'test')
     builder = Builder.init_from_path(project_dir)
     compiler = RebarCompiler(builder.project)
     compiler.ensure_tool(builder.system_config.cache.local_cache)
     self.assertEqual(False, os.path.exists(join(self.tmp_dir, 'rebar')))
     self.assertEqual(False,
                      os.path.exists(join(self.cache_dir, 'tool', 'rebar')))
     self.assertEqual(False, os.path.islink(join(self.test_dir, 'rebar')))
     self.assertEqual(
         False,
         builder.system_config.cache.local_cache.tool_exists('rebar'))
Esempio n. 24
0
 def test_in_cache(self, mock_conf, mock_get_cmd):
     mock_conf.return_value = self.conf_file
     mock_get_cmd.return_value = False
     ensure_dir(join(self.cache_dir, 'tool'))
     with open(join(self.cache_dir, 'tool', 'rebar'),
               'w') as outfile:  # 'load' tool to cache
         outfile.write('some content')
     enot.__main__.create(self.test_dir, {'<name>': 'test'})
     project_dir = join(self.test_dir, 'test')
     builder = Builder.init_from_path(project_dir)
     compiler = RebarCompiler(builder.project)
     compiler.ensure_tool(builder.system_config.cache.local_cache)
     self.assertEqual(True, os.path.islink(join(
         project_dir, 'rebar')))  # linked to current project
     self.assertEqual(True,
                      builder.system_config.cache.local_cache.tool_exists(
                          'rebar'))  # and available in cache
Esempio n. 25
0
 def test_add_from_package(self, mock_conf):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_git_url(pack_path, 'http://github/comtihon/test_app')
     set_git_tag(pack_path, '1.0.0')
     builder = Builder.init_from_path(pack_path)
     self.assertEqual(True, builder.build())
     builder.package()
     new_package_path = join(self.test_dir, 'test_app.ep')
     # remove source project, test should work only with enot package
     copy_file(join(pack_path, 'test_app.ep'), new_package_path)
     remove_dir(pack_path)
     package = Package.from_package(new_package_path)
     self.assertEqual(False, builder.system_config.cache.exists_local(package))
     # local cache is used here to determine tmp dir
     local_cache = builder.system_config.cache.local_cache
     builder.system_config.cache.add_fetched(local_cache, package)
     self.assertEqual(True, builder.system_config.cache.exists_local(package))
Esempio n. 26
0
 def test_link_dep(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'dep_with_no_deps',
                   'url': 'https://github.com/comtihon/dep_with_no_deps',
                   'tag': '1.0.0'}
              ])
     create(self.tmp_dir, {'<name>': 'dep_with_no_deps'})
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(True, builder.build())
     dep_link_ebin = join(pack_path, 'deps', 'dep_with_no_deps', 'ebin')
     self.assertEqual(True, os.path.islink(dep_link_ebin))
     erl = Static.get_erlang_version()
     real_dep = join(self.cache_dir, 'comtihon', 'dep_with_no_deps', '1.0.0', erl, 'ebin')
     self.assertEqual(real_dep, os.readlink(dep_link_ebin))
Esempio n. 27
0
 def install(self, fullname: str, maybe_version: str or None) -> bool:
     vsn = self.get_package_version(fullname, maybe_version)
     if not self.system_config.cache.check_exists_local(fullname, vsn):
         if not self.fetch(fullname, vsn):
             warning('No ' + fullname + ':' + vsn + ' in local cache. Can\'t fetch it either.')
             info('Available versions for ' + fullname + ': ' + str(self.local_cache.get_versions(fullname)))
             return False
     erlang_vsns = self.local_cache.get_erl_versions(fullname, vsn)
     [latest_erl] = erlang_vsns[-1:]
     # populate and build deps
     builder = Builder.init_from_path(join(self.local_cache.path, fullname, vsn, latest_erl))
     builder.populate()
     builder.deps()
     if builder.project.install(self.system_config, latest_erl):
         self.__add_to_installed(fullname, vsn)
         info(fullname + ': ' + vsn + ' installed')
         return True
     return False
Esempio n. 28
0
 def test_missing(self, mock_conf, mock_get_cmd, mock_http_read):
     mock_conf.return_value = self.conf_file
     mock_get_cmd.return_value = False
     ensure_dir(self.tmp_dir)
     mock_http_read.return_value = b'some rebar binary content'
     enot.__main__.create(self.test_dir, {'<name>': 'test'})
     project_dir = join(self.test_dir, 'test')
     builder = Builder.init_from_path(project_dir)
     compiler = RebarCompiler(builder.project)
     compiler.ensure_tool(builder.system_config.cache.local_cache)
     self.assertEqual(True, os.path.exists(join(
         self.tmp_dir, 'rebar')))  # tool should be downloaded to tempdir
     self.assertEqual(True,
                      os.path.exists(join(self.cache_dir, 'tool',
                                          'rebar')))  # added to cache
     self.assertEqual(True, os.path.islink(join(
         project_dir, 'rebar')))  # linked to current project
     self.assertEqual(True,
                      builder.system_config.cache.local_cache.tool_exists(
                          'rebar'))  # and available in cache
Esempio n. 29
0
 def test_add_with_deps(self, mock_conf, _):
     mock_conf.return_value = self.conf_file
     # Create test_app with deps: A and B
     pack_path = join(self.test_dir, 'test_app')
     set_deps(pack_path,
              [
                  {'name': 'a_with_dep_a2',
                   'url': 'https://github.com/comtihon/a_with_dep_a2',
                   'tag': '1.0.0'},
                  {'name': 'b_with_no_deps',
                   'url': 'https://github.com/comtihon/b_with_no_deps',
                   'tag': '1.0.0'}
              ])
     # Create dep A with dep A2 (in tmp, as if we download them from git)
     create(self.tmp_dir, {'<name>': 'a_with_dep_a2'})
     dep_a1_path = join(self.tmp_dir, 'a_with_dep_a2')
     set_deps(dep_a1_path, [{'name': 'a2_with_no_deps',
                             'url': 'https://github.com/comtihon/a2_with_no_deps',
                             'tag': '1.0.0'}])
     set_git_url(dep_a1_path, 'http://github/comtihon/a2_with_no_deps')
     set_git_tag(dep_a1_path, '1.0.0')
     # Create dep B (in tmp, as if we download them from git)
     create(self.tmp_dir, {'<name>': 'b_with_no_deps'})
     dep_b_path = join(self.tmp_dir, 'b_with_no_deps')
     set_git_url(dep_b_path, 'http://github/comtihon/b_with_no_deps')
     set_git_tag(dep_b_path, '1.0.0')
     # Create dep A2 (in tmp, as if we download them from git)
     create(self.tmp_dir, {'<name>': 'a2_with_no_deps'})
     dep_a2_path = join(self.tmp_dir, 'a2_with_no_deps')
     set_git_url(dep_a2_path, 'http://github/comtihon/a2_with_no_deps')
     set_git_tag(dep_a2_path, '1.0.0')
     # Compile test_project
     builder = Builder.init_from_path(pack_path)
     self.assertEqual(False, builder.system_config.cache.exists_local(Package.from_path(dep_a1_path)))
     self.assertEqual(False, builder.system_config.cache.exists_local(Package.from_path(dep_b_path)))
     self.assertEqual(False, builder.system_config.cache.exists_local(Package.from_path(dep_a2_path)))
     builder.populate()
     self.assertEqual(True, builder.build())
     self.assertEqual(True, builder.system_config.cache.exists_local(Package.from_path(dep_a1_path)))
     self.assertEqual(True, builder.system_config.cache.exists_local(Package.from_path(dep_b_path)))
     self.assertEqual(True, builder.system_config.cache.exists_local(Package.from_path(dep_a2_path)))
Esempio n. 30
0
 def test_deps_prefer_newer_new_dep(self, mock_conf, mock_fetch):
     mock_conf.return_value = self.conf_file
     mock_fetch.side_effect = mock_fetch_package
     pack_path = join(self.test_dir, 'test_app')
     set_deps(
         pack_path,
         [
             {
                 'name': 'update_dep',
                 'url': 'https://github.com/comtihon/update_dep',
                 'tag': '1.0.0'
             },  # has no deps in 1.0.0
             {
                 'name': 'dep2',
                 'url': 'https://github.com/comtihon/dep2',
                 'tag': '1.0.0'
             }  # dep2 has update_dep 1.2.0 in deps
         ])
     create(self.tmp_dir, {'<name>': 'dep2'})
     dep_tmp_path = join(self.tmp_dir, 'dep2')
     set_deps(
         dep_tmp_path,
         [{
             'name': 'update_dep',
             'url': 'https://github.com/comtihon/update_dep',
             'tag': '1.2.0'
         }  # has newer version then root
          ])
     create(self.tmp_dir, {
         '<name>': 'update_dep'
     })  # dep3 will be added as a dep in 1.2.0 (see mock_fetch_package)
     create(self.tmp_dir, {'<name>': 'dep3'})
     builder = Builder.init_from_path(pack_path)
     builder.populate()
     self.assertEqual(['update_dep', 'dep2', 'dep3'].sort(),
                      list(builder.packages.keys()).sort())
     self.assertEqual('1.0.0', builder.packages['dep2'].git_vsn)
     self.assertEqual('1.2.0', builder.packages['update_dep'].git_vsn)
     self.assertEqual('1.0.0', builder.packages['dep3'].git_vsn)