Example #1
0
    def test_init__skip_same_data(self, tmpdir, capsys):
        ctx = MockContext()
        project_dir = Path(str(tmpdir))
        project_build_dir = project_dir/"build"
        build_config = BuildConfig(cmake_generator="NINJA")
        cmake_project1 = CMakeProject(ctx, project_dir, project_build_dir, build_config)
        assert not project_build_dir.isdir()

        # -- STEP 1: First cmake_project.init
        with cd(project_dir):
            cmake_project1.init()

            # -- POSTCONDITIONS:
            cmake_build_filename = project_build_dir / CMakeProjectPersistConfig.FILE_BASENAME
            assert project_build_dir.exists(), "ENSURE: project_build_dir exists"
            assert cmake_build_filename.exists()
            captured = capsys.readouterr()
            assert_cmake_project_used_init_using_captured(cmake_project1, captured,
                                                          cmake_generator="NINJA")

        # -- STEP 2: Second cmake_project.init => SKIPPED
        with cd(project_dir):
            ctx.clear()
            cmake_project2 = CMakeProject(ctx, project_dir.relpath(),
                                          project_build_dir.relpath(),
                                          build_config)
            cmake_project2.init()
            captured = capsys.readouterr()
            assert ctx.last_command is None
            assert_cmake_project_skipped_reinit_using_captured(cmake_project1, captured)
Example #2
0
    def test_init__when_build_dir_exists_with_other_persistent_schema(self, tmpdir, capsys):
        ctx = MockContext()
        project_dir = Path(str(tmpdir))
        project_build_dir = project_dir/"build"
        build_config = BuildConfig(cmake_generator="ninja", cmake_build_type="debug")
        assert not project_build_dir.isdir()

        # -- STEP 1: First cmake_project.init
        with cd(project_dir):
            cmake_project1 = CMakeProject(ctx, project_dir, project_build_dir, build_config)
            cmake_project1.init()
            cmake_build_filename = project_build_dir / CMakeProjectPersistConfig.FILE_BASENAME
            assert project_build_dir.exists(), "ENSURE: project_build_dir exists"
            assert cmake_build_filename.exists()

            # -- STEP: Fake cmake-build init with other persistent data schema.
            # HINT: May occur when cmake-build is updated, but project_build_dir still exists.
            with open(cmake_build_filename, "w") as f:
                f.write("""{ "other": 123, "cmake_generator": "ninja" }""")

        # -- STEP 2: Second try to cmake_project.init()
        # ENSURE: No failure / AssertionError occurs
        with cd(project_dir):
            cmake_project2 = CMakeProject(ctx, project_dir, project_build_dir, build_config)
            assert cmake_project2.initialized
            assert not cmake_project2.needs_reinit()
            assert cmake_project2.needs_update()
            cmake_project2.init()

            assert not cmake_project2.needs_reinit()
            assert not cmake_project2.needs_update()
            captured = capsys.readouterr()
            assert_cmake_project_needed_update_using_captured(cmake_project2, captured,
                                                            cmake_generator="ninja")
Example #3
0
 def may_give_mixed_value_types(self, remote):
     remote.expect_sessions(
         Session("host1", user="******", cmd="nope"),
         Session("host2", cmd="nope"),
     )
     with cd(support):
         _run_fab("hosts-are-mixed-values")
    def test_remove_raises_oserror(self, tmp_path, monkeypatch, capsys):
        def mock_remove(p):
            raise OSError("MOCK_REMOVE: %s" % p)

        setup_workdir(tmp_path, [
            "foo/one.xxx",
            "more/two.xxx",
        ])
        problematic_file1 = tmp_path / "foo/one.xxx"
        problematic_file1 = problematic_file1.relative_to(tmp_path)
        problematic_file2 = tmp_path / "more/two.xxx"
        problematic_file2 = problematic_file2.relative_to(tmp_path)

        with cd(str(tmp_path)):
            monkeypatch.setattr("path.Path.remove_p", mock_remove)
            cleanup_files(["**/*.xxx"])

            captured = capsys.readouterr()
            print(captured.out)
            expected1 = "REMOVE: %s" % problematic_file1
            expected2 = "OSError: MOCK_REMOVE: %s" % problematic_file1
            assert expected1 in captured.out
            assert expected2 in captured.out
            expected2 = "OSError: MOCK_REMOVE: %s" % problematic_file2
            assert expected2 in captured.out
Example #5
0
 def per_project_config_files_are_loaded_before_task_parsing(self):
     # Relies on auto_dash_names being loaded at project-conf level;
     # fixes #467; when bug present, project conf is loaded _after_
     # attempt to parse tasks, causing explosion when i_have_underscores
     # is only sent to parser as i-have-underscores.
     with cd(os.path.join('configs', 'underscores')):
         expect("i_have_underscores")
Example #6
0
 def comma_separated_string_is_multiple_hosts(self, remote):
     remote.expect_sessions(
         Session('host1', cmd='nope'),
         Session('host2', cmd='nope'),
     )
     with cd(support):
         _run_fab("-H host1,host2 basic-run")
Example #7
0
 def dash_i_supplies_default_connect_kwarg_key_filename(self):
     # NOTE: the expect-identity task in tests/_support/fabfile.py
     # performs asserts about its context's .connect_kwargs value,
     # relying on other tests to prove connect_kwargs makes its way into
     # that context.
     with cd(support):
         _run_fab("-i identity.key expect-identity")
Example #8
0
 def basic_pre_and_post_tasks_still_work(self):
     with cd(support):
         # Sanity
         expect("first", "First!\n")
         expect("third", "Third!\n")
         # Real test
         expect("second", "First!\nSecond!\nThird!\n")
Example #9
0
    def test_build__auto_init_with_nonexisting_build_dir(self, tmpdir, capsys):
        ctx = MockContext()
        project_dir = Path(str(tmpdir))
        project_build_dir = project_dir/"build"
        build_config = BuildConfig(cmake_generator="ninja")
        cmake_project1 = CMakeProject(ctx, project_dir, project_build_dir, build_config)
        assert not project_build_dir.isdir()

        # -- STEP: First cmake_project.build => AUTO CMAKE-INIT: project_build_dir
        with cd(project_dir):
            assert not project_build_dir.exists()
            cmake_project1.build()

            # -- POSTCONDITIONS:
            expected_commands = [
                "cmake -G Ninja ..",
                "cmake --build .",
            ]
            assert ctx.commands == expected_commands
            cmake_build_filename = project_build_dir / CMakeProjectPersistConfig.FILE_BASENAME
            captured = capsys.readouterr()
            assert_cmake_project_used_init_using_captured(cmake_project1, captured,
                                                          cmake_generator="ninja")
            # assert "CMAKE-INIT:  build (using cmake.generator=ninja)" in captured.out
            assert "CMAKE-BUILD: build" in captured.out
            assert project_build_dir.exists()
            assert cmake_build_filename.exists()
Example #10
0
 def does_not_seek_tasks_module_if_namespace_was_given(self):
     with cd('implicit'):
         expect(
             'foo',
             err="No idea what 'foo' is!\n",
             program=Program(namespace=Collection('blank'))
         )
Example #11
0
def mezzo(ctx):
    ctx.run("mkdir -p build/jschema")
    ctx.run("cp -R jschema setup.py build/jschema")
    with cd("build"):
        ctx.run("tar cfz jschema.tar.gz jschema")
        ctx.run("mv jschema.tar.gz /opt/mezzo/dependencies")
        ctx.run("rm -rf jschema")
Example #12
0
 def may_give_Connection_init_kwarg_dicts(self, remote):
     remote.expect_sessions(
         Session("host1", user="******", cmd="nope"),
         Session("host2", cmd="nope"),
     )
     with cd(support):
         _run_fab("hosts-are-init-kwargs")
Example #13
0
 def single_string_is_single_host_and_single_exec(self, remote):
     remote.expect(host="myhost", cmd="nope")
     # In addition to just testing a base case, this checks for a really
     # dumb bug where one appends to, instead of replacing, the task
     # list during parameterization/expansion XD
     with cd(support):
         _run_fab("-H myhost basic-run")
Example #14
0
    def clean(self, args=None, options=None, init_args=None, config=None):
        """Clean the build artifacts (but: preserve CMake init)"""
        project_build_dir = posixpath_normpath(
            self.project_build_dir.relpath())
        if not self.initialized:
            print("CMAKE-CLEAN: {0} (SKIPPED: not initialized yet)".format(
                project_build_dir))
            return

        # -- ALTERNATIVE: self.build(args="clean", ensure_init=False)
        self.ensure_init(args=init_args)
        print("CMAKE-CLEAN: {0}".format(project_build_dir))
        cmake_clean_args = "clean"
        if args:
            clean_args = make_args_string(args)
            cmake_clean_args = "clean {0}".format(clean_args)

        options = options or []
        if config:
            options.append("--config {0}".format(config))
        cmake_options = " ".join(options)

        # pylint: disable=line-too-long
        with cd(self.project_build_dir):
            self.ctx.run("cmake --build . {0} -- {1}".format(
                cmake_options, cmake_clean_args))
Example #15
0
    def configure(self, **data):
        """Update CMake project build directory configuration"""
        project_build_dir = posixpath_normpath(
            self.project_build_dir.relpath())
        if not self.initialized:
            print("CMAKE-UPDATE: {0} (SKIPPED: Not initialized yet)".format(
                project_build_dir))
            return

        for name, value in data.items():
            self.config.cmake_defines[name] = value

        # cmake_generator = data.pop("cmake_generator", None)
        # self.ensure_init(cmake_generator=cmake_generator)
        print("CMAKE-CONFIGURE: {0}".format(project_build_dir))

        # more_cmake_defines = OrderedDict(data.items())
        # cmake_options = cmake_cmdline_define_options([], **data)
        # print("XXX cmake_defines: %r" % self.config.cmake_defines)
        # pylint: disable=line-too-long
        cmake_options = self.make_cmake_configure_options(**data)
        with cd(self.project_build_dir):
            relpath_to_project_dir = self.project_build_dir.relpathto(
                self.project_dir)
            relpath_to_project_dir = posixpath_normpath(relpath_to_project_dir)
            self.ctx.run("cmake {0} {1}".format(cmake_options,
                                                relpath_to_project_dir))

            # -- FINALLY: If cmake-init worked, store used cmake_generator.
            self.store_config()
Example #16
0
def docs():
    """Build html docs

    :return:
    """
    with cd('docs'):
        run('make html')
Example #17
0
        def tasks_dedupe_honors_configuration(self):
            # Kinda-sorta duplicates some tests in executor.py, but eh.
            with cd("configs"):
                # Runtime conf file
                expect(
                    "-c integration -f no-dedupe.yaml biz",
                    out="""
foo
foo
bar
biz
post1
post2
post2
""".lstrip(),
                )
                # Flag beats runtime
                expect(
                    "-c integration -f dedupe.yaml --no-dedupe biz",
                    out="""
foo
foo
bar
biz
post1
post2
post2
""".lstrip(),
                )
Example #18
0
def update_gherkin(ctx, dry_run=False):
    """Update "gherkin-languages.json" file from cucumber-repo.

    * Download "gherkin-languages.json" from cucumber repo
    * Update "gherkin-languages.json"
    * Generate "i18n.py" file from "gherkin-languages.json"
    * Update "behave/i18n.py" file (optional; not in dry-run mode)
    """
    with cd("etc/gherkin"):
        # -- BACKUP-FILE:
        gherkin_languages_file = Path("gherkin-languages.json")
        gherkin_languages_file.copy("gherkin-languages.json.SAVED")

        print('Downloading "gherkin-languages.json" from github:cucumber ...')
        download_request = requests.get(GHERKIN_LANGUAGES_URL)
        assert download_request.ok
        print('Download finished: OK (size={0})'.format(
            len(download_request.content)))
        with open(gherkin_languages_file, "wb") as f:
            f.write(download_request.content)

        print('Generating "i18n.py" ...')
        ctx.run("./convert_gherkin-languages.py")
        ctx.run("diff i18n.py ../../behave/i18n.py")
        if not dry_run:
            print("Updating behave/i18n.py ...")
            Path("i18n.py").move("../../behave/i18n.py")
Example #19
0
        def loads_fabfile_not_tasks(self):
            "Loads fabfile.py, not tasks.py"
            with cd(support):
                expect(
                    "--list",
                    """
Available tasks:

  basic-run
  build
  deploy
  expect-from-env
  expect-identities
  expect-identity
  expect-mutation
  expect-mutation-to-fail
  expect-vanilla-Context
  first
  hosts-are-host-stringlike
  hosts-are-init-kwargs
  hosts-are-mixed-values
  hosts-are-myhost
  mutate
  second
  third
  two-hosts

""".lstrip(),
                )
Example #20
0
 def per_project_config_files_are_loaded_before_task_parsing(self):
     # Relies on auto_dash_names being loaded at project-conf level;
     # fixes #467; when bug present, project conf is loaded _after_
     # attempt to parse tasks, causing explosion when i_have_underscores
     # is only sent to parser as i-have-underscores.
     with cd(os.path.join("configs", "underscores")):
         expect("i_have_underscores")
Example #21
0
    def test_cleanup_dirs_without_configfile(self, tmp_path):
        # -- SETUP:
        setup_workdir(tmp_path, [
            ".venv_DEFAULT/.dir",
            "downloads/.dir",
        ])
        my_dir1 = tmp_path / ".venv_DEFAULT"
        my_dir2 = tmp_path / "downloads"
        assert my_dir1.exists() and my_dir1.is_dir()
        assert my_dir2.exists() and my_dir2.is_dir()

        tasks_dir = tmp_path / "tasks.py"
        tasks_dir.write_text(TASKS_FILE_TEXT_USING_CLEANUP_MODULE_ONLY)
        config_dir = tmp_path / "invoke.yaml"
        assert not config_dir.exists()

        # -- EXECUTE AND VERIFY:
        with use_subprocess_coverage(tmp_path):
            with cd(str(tmp_path)):
                output = ensure_text(run_with_output("invoke cleanup.all"))

        assert not my_dir1.exists()
        assert not my_dir2.exists()
        expected1 = "RMTREE: .venv_DEFAULT"
        expected2 = "RMTREE: downloads"
        assert expected1 in output
        assert expected2 in output
Example #22
0
    def test_invoke_calls_other_cleanup_task(self, tmp_path):
        tasks_file = tmp_path / "tasks.py"
        tasks_file.write_text(u"""
from __future__ import absolute_import, print_function
from invoke import task, Collection
import invoke_cleanup as cleanup

@task
def foo_clean(ctx):
    print("CALLED: foo_clean")

namespace = Collection(foo_clean)
namespace.add_collection(Collection.from_module(cleanup), name="cleanup")
namespace.configure(cleanup.namespace.configuration())

from invoke_cleanup import cleanup_all_tasks
cleanup_all_tasks.add_task(foo_clean, name="foo_clean")
cleanup_all_tasks.configure(namespace.configuration())
""")

        # -- EXECUTE AND VERIFY:
        with use_subprocess_coverage(tmp_path):
            with cd(str(tmp_path)):
                output = ensure_text(run_with_output("invoke cleanup.all"))

        expected1 = "CLEANUP TASK: foo-clean"
        expected2 = "CALLED: foo_clean"
        assert expected1 in output
        assert expected2 in output
Example #23
0
 def dash_i_supplies_default_connect_kwarg_key_filename(self):
     # NOTE: the expect-identity task in tests/_support/fabfile.py
     # performs asserts about its context's .connect_kwargs value,
     # relying on other tests to prove connect_kwargs makes its way into
     # that context.
     with cd(support):
         _run_fab("-i identity.key expect-identity")
Example #24
0
        def tasks_dedupe_honors_configuration(self):
            # Kinda-sorta duplicates some tests in executor.py, but eh.
            with cd('configs'):
                # Runtime conf file
                expect(
                    "-c integration -f no-dedupe.yaml biz",
                    out="""
foo
foo
bar
biz
post1
post2
post2
""".lstrip())
                # Flag beats runtime
                expect(
                    "-c integration -f dedupe.yaml --no-dedupe biz",
                    out="""
foo
foo
bar
biz
post1
post2
post2
""".lstrip())
Example #25
0
    def test_with_configfile_and_cleanup_files_overrides_default(
            self, tmp_path):
        # -- SETUP:
        setup_workdir(tmp_path, [
            "one.xxx",
            "more/two.zzz",
        ])
        my_file1 = tmp_path / "one.xxx"
        my_file2 = tmp_path / "more/two.zzz"
        assert my_file1.exists() and my_file1.is_file()
        assert my_file2.exists() and my_file2.is_file()

        tasks_file = tmp_path / "tasks.py"
        tasks_file.write_text(TASKS_FILE_TEXT_USING_CLEANUP_MODULE_ONLY)
        config_file = tmp_path / "invoke.yaml"
        config_file.write_text(u"""
cleanup_all:
    files:
      - "**/*.xxx"
      - "**/*.zzz"
""")

        # -- EXECUTE AND VERIFY:
        with use_subprocess_coverage(tmp_path):
            with cd(str(tmp_path)):
                output = ensure_text(run_with_output("invoke cleanup.all"))

        assert not my_file1.exists()
        assert not my_file2.exists()
        expected1 = "REMOVE: one.xxx"
        expected2 = "REMOVE: more/two.zzz"
        assert expected1 in output
        assert expected2 in output
Example #26
0
 def basic_pre_and_post_tasks_still_work(self):
     with cd(support):
         # Sanity
         expect("first", "First!\n")
         expect("third", "Third!\n")
         # Real test
         expect("second", "First!\nSecond!\nThird!\n")
Example #27
0
 def key_filename_can_be_set_via_non_override_config_levels(self):
     # Proves/protects against #1762, where eg key_filenames gets
     # 'reset' to an empty list. Arbitrarily uses the 'yml' level of
     # test fixtures, which has a fabric.yml w/ a
     # connect_kwargs.key_filename value of [private.key, other.key].
     with cd(os.path.join(support, "yml_conf")):
         program.run("fab expect-conf-key-filename")
Example #28
0
 def comma_separated_string_is_multiple_hosts(self, remote):
     remote.expect_sessions(
         Session('host1', cmd='nope'),
         Session('host2', cmd='nope'),
     )
     with cd(support):
         _run_fab("-H host1,host2 basic-run")
Example #29
0
def pipsync(ctx):
    """
    Upgrade virtualenvironment to contain dependencies and versions
    exactly defined in requirements.txt
    """
    with cd(project_root):
        ctx.run('pip-sync requirements.txt', pty=True, echo=True)
Example #30
0
 def single_string_is_single_host_and_single_exec(self, remote):
     remote.expect(host='myhost', cmd='nope')
     # In addition to just testing a base case, this checks for a really
     # dumb bug where one appends to, instead of replacing, the task
     # list during parameterization/expansion XD
     with cd(support):
         _run_fab("-H myhost basic-run")
Example #31
0
def do(ctx, cmd, dry_run=None, **kwargs):
    run_env = kwargs.pop('env', {})
    path = kwargs.pop('path', None)

    if path:
        path = os.path.abspath(os.path.expandvars(os.path.expanduser(path)))
        if not os.path.isdir(path):
            raise NotADirectoryError(f'{path}')

    if dry_run is None:
        dry_run = env.dry_run

    if dry_run:
        cmd_str = []
        if run_env:
            env_vars = 'export ' + ' '.join(f'{k}={v}'
                                            for k, v in run_env.items())
            cmd_str.append(env_vars)
        if path:
            cmd_str.append(f'cd {path}')
        cmd_str.append(cmd)

        print(' && '.join(cmd_str))

    else:
        if not path:
            return run(cmd, env=run_env, **kwargs)
        else:
            with cd(path):
                return run(cmd, env=run_env, **kwargs)
Example #32
0
    def test_ctest(self, tmpdir, config):
        cmake_project = self.make_initialized_cmake_project(
            tmpdir, cmake_generator="ninja")
        with cd(cmake_project.project_dir):
            cmake_project.test(config=config)

        expected = "ctest -C {0}".format(config)
        assert cmake_project.ctx.last_command == expected
Example #33
0
def cf_upload(c):
    """Publish to Rackspace Cloud Files"""
    rebuild(c)
    with cd(CONFIG['deploy_path']):
        c.run('swift -v -A https://auth.api.rackspacecloud.com/v1.0 '
              '-U {cloudfiles_username} '
              '-K {cloudfiles_api_key} '
              'upload -c {cloudfiles_container} .'.format(**CONFIG))
Example #34
0
def create_test_app():
    """Create a test app structure

    :return:
    """
    mkdir(path='tests')
    with cd('tests'):
        run('django-admin.exe startproject config .')
Example #35
0
def docs(ctx):
    """Build html docs

    """
    run('sphinx-apidoc -f -o docs/modules dstack_factory')

    with cd('docs'):
        run('make html')
Example #36
0
 def cli_option_wins_over_env(self, reset_environ):
     # Set env var to load the JSON config instead of the YAML one,
     # which contains a "json" string internally.
     os.environ["INVOKE_RUNTIME_CONFIG"] = "json/invoke.json"
     with cd("configs"):
         # But run the default test task, which expects a "yaml"
         # string. If the env var won, this would explode.
         expect("-c runtime -f yaml/invoke.yaml mytask")
Example #37
0
    def test_clean(self, tmpdir, config):
        cmake_project = self.make_initialized_cmake_project(
            tmpdir, cmake_generator="ninja")
        with cd(cmake_project.project_dir):
            cmake_project.clean(config=config)

        expected = "cmake --build . --config {0} -- clean".format(config)
        assert cmake_project.ctx.last_command == expected
Example #38
0
 def executor_is_given_access_to_core_args_and_remainder(self):
     klass = Mock()
     with cd('implicit'):
         cmd = "myapp -e foo -- myremainder"
         Program(executor_class=klass).run(cmd, exit=False)
     core = klass.call_args[0][2]
     eq_(core[0].args['echo'].value, True)
     eq_(core.remainder, "myremainder")
Example #39
0
 def _expect_prompt(self, getpass, flag, key, value, prompt):
     getpass.return_value = value
     with cd(support):
         # Expect that the given key was found in the context.
         cmd = "-c prompting {} expect-connect-kwarg --key {} --val {}"
         _run_fab(cmd.format(flag, key, value))
     # Then we also expect that getpass was called w/ expected prompt
     getpass.assert_called_once_with(prompt)
Example #40
0
 def cli_option_wins_over_env(self, reset_environ):
     # Set env var to load the JSON config instead of the YAML one,
     # which contains a "json" string internally.
     os.environ["INVOKE_RUNTIME_CONFIG"] = "json/invoke.json"
     with cd("configs"):
         # But run the default test task, which expects a "yaml"
         # string. If the env var won, this would explode.
         expect("-c runtime -f yaml/invoke.yaml mytask")
Example #41
0
 def _expect_prompt(self, getpass, flag, key, value, prompt):
     getpass.return_value = value
     with cd(support):
         # Expect that the given key was found in the context.
         cmd = "-c prompting {} expect-connect-kwarg --key {} --val {}"
         _run_fab(cmd.format(flag, key, value))
     # Then we also expect that getpass was called w/ expected prompt
     getpass.assert_called_once_with(prompt)
Example #42
0
def invoke_deploy_task(config_name, app, task):
    with cd(app):
        try:
            run('inv --config ' + config_name + ' ' + task, hide='both', pty=True)
        except Failure as failure:
            cprint('{app}: task "{task}" failed'.format_map(locals()), 'red')
            cprint('Error output is:', 'red')
            print(failure.result.stdout, end='')
            raise
Example #43
0
def build(ctx, builder="html", options=""):
    """Build docs with sphinx-build"""
    sourcedir = ctx.config.sphinx.sourcedir
    destdir = Path(ctx.config.sphinx.destdir or "build")/builder
    destdir = destdir.abspath()
    with cd(sourcedir):
        destdir_relative = Path(".").relpathto(destdir)
        command = "sphinx-build {opts} -b {builder} {sourcedir} {destdir}" \
                    .format(builder=builder, sourcedir=".",
                            destdir=destdir_relative, opts=options)
        ctx.run(command)
Example #44
0
 def _run(
     self,
     flag='-S',
     file_='ssh_config/runtime.conf',
     tasks='runtime-ssh-config',
 ):
     with cd(support):
         # Relies on asserts within the task, which will bubble up as
         # it's executed in-process
         cmd = "-c runtime_fabfile {} {} -H runtime {}"
         _run_fab(cmd.format(flag, file_, tasks))
Example #45
0
def run_tests(ctx, test_module='pannier', opts='', pty=False):
    print("Cleaning out pycs")
    ctx.run('find . -type f -name \*.pyc -delete')
    with util.cd(os.path.join(LOCAL_ROOT, 'pannier_project')):
        ctx.run(
            'TESTS=true coverage run --source=pannier manage.py test {} {}'.format(
                test_module, opts
            ),
            pty=pty
        )
        ctx.run('coverage xml')
Example #46
0
        def pre_post_tasks_are_not_parameterized_across_hosts(self):
            with cd(support):
                _run_fab("-H hostA,hostB,hostC second --show-host")
                output = sys.stdout.getvalue()
                # Expect pre once, 3x main, post once, as opposed to e.g. both
                # pre and main task
                expected = """
First!
Second: hostA
Second: hostB
Second: hostC
Third!
""".lstrip()
                assert output == expected
Example #47
0
def build(ctx, builder="html", language=None, options=""):
    """Build docs with sphinx-build"""
    language = _sphinxdoc_get_language(ctx, language)
    sourcedir = ctx.config.sphinx.sourcedir
    destdir = _sphinxdoc_get_destdir(ctx, builder, language=language)
    destdir = destdir.abspath()
    with cd(sourcedir):
        destdir_relative = Path(".").relpathto(destdir)
        command = "sphinx-build {opts} -b {builder} -D language={language} {sourcedir} {destdir}" \
                    .format(builder=builder, sourcedir=".",
                            destdir=destdir_relative,
                            language=language,
                            opts=options)
        ctx.run(command)
Example #48
0
def update(ctx):
    """
    Update applications/* from git origin.
    """
    print_bold('Updating qabel-infrastructure')
    run('git pull --ff-only')
    for app in APPS:
        papp = Path(app)
        if not papp.exists():
            print_bold('Cloning', app)
            run('git clone https://github.com/Qabel/qabel-{name} {path}'.format(name=papp.name, path=papp))
            continue  # no need to pull if we just cloned
        with cd(app):
            print_bold('Updating', app)
            run('git pull --ff-only')
Example #49
0
def publish(c):
    """Publish to production"""
    update_repo()
    clean(c)
    with alter_template() as _:
        local('pelican -s publishconf.py')
    search_path = pathlib.Path(CONFIG['deploy_path'])/'tipuesearch_content.js'
    search_path_fix = pathlib.Path(CONFIG['deploy_path'])/'tipuesearch_content.json'
    if os.path.isfile(search_path):
        shutil.move(search_path, search_path_fix)
    # Detect if in local machine or in travis-ci
    if os.environ.get('TRAVIS', 'false') != 'true':
        with cd(f"{CONFIG['deploy_path']}"):
            local('git checkout master')
            local('git add --all')
            local(f'''git commit -m "{CONFIG['commit_message']}"''')
            local('git push -u github master --quiet')
    local('python ./utils/gitalk.py')
Example #50
0
def deploy():
    """
    Based on https://gist.github.com/domenic/ec8b0fc8ab45f39403dd
    """
    run("rm -rf ./site/")
    run("mkdocs build")
    with util.cd("./site/"):
        run("git init")
        run('echo ".*pyc" > .gitignore')
        run('git config user.name "Travis CI"')
        run('git config user.email "%s"' % os.environ["EMAIL"])
        run("git add .")
        run('git commit -m "Deploy to GitHub Pages"')
        run(
            'git push --force --quiet "https://{GH_TOKEN}@{GH_REF}" master:gh-pages > /dev/null 2>&1'.format(
                GH_TOKEN=os.environ["GH_TOKEN"], GH_REF=os.environ["GH_REF"]
            )
        )
Example #51
0
def deploy_docs():
    """
    Based on https://gist.github.com/domenic/ec8b0fc8ab45f39403dd
    """
    run('rm -rf ./site/')
    build_docs()
    with util.cd('./site/'):
        run('git init')
        run('echo ".*pyc" > .gitignore')
        run('git config user.name "Travis CI"')
        run('git config user.email "%s"' % os.environ['EMAIL'])
        run('git add .')
        run('git commit -m "Deploy to GitHub Pages"')
        run(
            'git push --force --quiet "https://{GH_TOKEN}@{GH_REF}" '
            'master:gh-pages > /dev/null 2>&1'.format(
                GH_TOKEN=os.environ['GH_TOKEN'],
                GH_REF=os.environ['GH_REF'],
            )
        )
Example #52
0
        def loads_fabfile_not_tasks(self):
            "Loads fabfile.py, not tasks.py"
            with cd(support):
                expect(
                    "--list",
                    """
Available tasks:

  basic-run
  build
  deploy
  expect-from-env
  expect-identities
  expect-identity
  expect-mutation
  expect-mutation-to-fail
  expect-vanilla-Context
  first
  mutate
  second
  third

""".lstrip())
Example #53
0
 def seeks_and_loads_tasks_module_by_default(self):
     with cd('implicit'):
         expect('foo', out="Hm\n")
Example #54
0
 def core_help_doesnt_get_mad_if_loading_fails(self):
     # Expects no tasks.py in root of FS
     with cd(ROOT):
         expect("--help", out="Usage: ", test=assert_contains)
Example #55
0
 def per_project_config_files_are_loaded(self):
     with cd(os.path.join('configs', 'yaml')):
         expect("mytask")
Example #56
0
 def per_project_config_files_load_with_explicit_ns(self):
     # Re: #234
     with cd(os.path.join('configs', 'yaml')):
         expect("-c explicit mytask")
Example #57
0
 def uses_executor_class_given(self):
     klass = Mock()
     with cd('implicit'):
         Program(executor_class=klass).run("myapp foo", exit=False)
     klass.assert_called_with(ANY, ANY, ANY)
     klass.return_value.execute.assert_called_with(ANY)
Example #58
0
 def runtime_config_file_honored(self):
     with cd('configs'):
         expect("-c runtime -f yaml/invoke.yaml mytask")