def test_main_dirname_provided_use_it(monkeypatch, capsys): can_connect_args = _monkeypatch_can_connect_to_socket_to_succeed( monkeypatch) def main_redis_url(dirname): project_dir_disable_dedicated_env(dirname) code = _parse_args_and_run_subcommand( ['anaconda-project', 'activate', '--directory', dirname]) assert code == 0 with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ services: REDIS_URL: redis """}, main_redis_url) assert can_connect_args['port'] == 6379 out, err = capsys.readouterr() assert "export PROJECT_DIR" in out assert "export REDIS_URL=redis://localhost:6379\n" in out assert "" == err
def test_provide_no_download_in_check_mode(monkeypatch): MIN_DATAFILE_CONTENT = ("downloads:\n" " DATAFILE: http://localhost/data.csv\n") def provide_download(dirname): @gen.coroutine def mock_downloader_run(self, loop): raise Exception("should not have tried to download in check mode") monkeypatch.setattr( "anaconda_project.internal.http_client.FileDownloader.run", mock_downloader_run) project = project_no_dedicated_env(dirname) result = prepare_without_interaction( project, environ=minimal_environ(PROJECT_DIR=dirname), mode=provide.PROVIDE_MODE_CHECK) assert not result with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: MIN_DATAFILE_CONTENT}, provide_download)
def test_list_default_command(capsys): def check_empty_project(dirname): code = _parse_args_and_run_subcommand([ 'anaconda-project', 'list-default-command', '--directory', dirname ]) assert code == 0 out, err = capsys.readouterr() assert '' == err assert out.strip() == 'app' with_directory_contents_completing_project_file( { DEFAULT_PROJECT_FILENAME: ("commands:\n" " app:\n" " bokeh_app: test.py\n" " 0second:\n" " notebook: test.ipynb\n" "packages:\n" " - bokeh\n" " - notebook\n") }, check_empty_project)
def test_env_var_provider_with_no_value(): def check_env_var_provider(dirname): provider = EnvVarProvider() requirement = _load_env_var_requirement(dirname, "FOO") local_state_file = LocalStateFile.load_for_directory(dirname) status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides()) context = ProvideContext(environ=dict(), local_state_file=local_state_file, default_env_spec_name='default', status=status, mode=PROVIDE_MODE_DEVELOPMENT, frontend=NullFrontend()) provider.provide(requirement, context=context) assert 'FOO' not in context.environ with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ variables: - FOO """}, check_env_var_provider)
def test_add_command_ask_type_interrupted(monkeypatch, capsys): def check_ask_type(dirname): def mock_is_interactive(): return True monkeypatch.setattr('anaconda_project.internal.cli.console_utils.stdin_is_interactive', mock_is_interactive) def mock_input(prompt): raise KeyboardInterrupt('^C') monkeypatch.setattr('anaconda_project.internal.cli.console_utils._input', mock_input) args = Args(None, 'test', 'file.py', directory=dirname) with pytest.raises(SystemExit) as excinfo: main(args) assert excinfo.value.code == 1 out, err = capsys.readouterr() assert out == '' assert err == '\nCanceling\n\n' with_directory_contents_completing_project_file({DEFAULT_PROJECT_FILENAME: ''}, check_ask_type)
def test_prepare_command_not_in_project(): def check(dirname): # create a command that isn't in the Project project = project_no_dedicated_env(dirname) command = ProjectCommand(name="foo", attributes=dict(bokeh_app="foo.py", env_spec=project.default_env_spec_name)) environ = minimal_environ() result = prepare_without_interaction(project, environ=environ, command=command) assert result.errors == [] assert result assert os.path.join(project.directory_path, 'foo.py') in result.command_exec_info.args with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ commands: decoy: description: "do not use me" unix: foobar windows: foobar """, "foo.py": "# foo"}, check)
def test_failed_download_before_connect(monkeypatch): def provide_download(dirname): @gen.coroutine def mock_downloader_run(self, loop): # if we don't even get an HTTP response, the errors are handled this way, # e.g. if the URL is bad. self._errors = ['This went horribly wrong'] raise gen.Return(None) monkeypatch.setattr( "anaconda_project.internal.http_client.FileDownloader.run", mock_downloader_run) project = project_no_dedicated_env(dirname) result = prepare_without_interaction( project, environ=minimal_environ(PROJECT_DIR=dirname)) assert not result assert ( 'missing requirement to run this project: A downloaded file which is referenced by DATAFILE.' ) in result.errors with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: DATAFILE_CONTENT}, provide_download)
def test_remove_command(monkeypatch, capsys): def check(dirname): code = _parse_args_and_run_subcommand([ 'anaconda-project', 'remove-command', 'test', '--directory', dirname ]) assert code == 0 project = Project(dirname) command = project.project_file.get_value(['commands', 'test']) assert command is None out, err = capsys.readouterr() assert out == "Removed the command 'test' from the project.\n" assert err == '' with_directory_contents_completing_project_file( { DEFAULT_PROJECT_FILENAME: 'packages: ["notebook"]\ncommands:\n test:\n notebook: file.ipynb\n' }, check)
def _test_run_command_foo(command_line, monkeypatch, capsys, file_assertion=_is_python_exe): executed = {} def mock_execvpe(file, args, env): executed['file'] = file executed['args'] = args executed['env'] = env monkeypatch.setattr('os.execvpe', mock_execvpe) def check_run_main(dirname): from os.path import abspath as real_abspath def mock_abspath(path): if path == ".": return dirname else: return real_abspath(path) monkeypatch.setattr('os.path.abspath', mock_abspath) project_dir_disable_dedicated_env(dirname) for n, i in enumerate(command_line): if i == '<DIRNAME>': command_line[n] = dirname result = _parse_args_and_run_subcommand(command_line) assert 1 == result assert 'file' in executed assert 'args' in executed assert 'env' in executed file_assertion(executed['file']) out, err = capsys.readouterr() assert "" == out assert "" == err return executed['args'][1:] return with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ commands: default: conda_app_entry: python --version def foo: conda_app_entry: python --version foo bar: conda_app_entry: python --version bar """}, check_run_main)
def test_prepare_and_unprepare_download(monkeypatch): def provide_download(dirname): @gen.coroutine def mock_downloader_run(self, loop): class Res: pass res = Res() res.code = 200 with open(os.path.join(dirname, 'data.csv'), 'w') as out: out.write('data') self._hash = '12345abcdef' raise gen.Return(res) monkeypatch.setattr( "anaconda_project.internal.http_client.FileDownloader.run", mock_downloader_run) project = project_no_dedicated_env(dirname) result = prepare_without_interaction( project, environ=minimal_environ(PROJECT_DIR=dirname)) assert hasattr(result, 'environ') assert 'DATAFILE' in result.environ filename = os.path.join(dirname, 'data.csv') assert os.path.exists(filename) project.frontend.reset() status = unprepare(project, result) assert project.frontend.logs == [ "Removed downloaded file %s." % filename, ("Current environment is not in %s, no need to delete it." % dirname) ] assert status.status_description == 'Success.' assert status assert not os.path.exists(filename) with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: DATAFILE_CONTENT}, provide_download)
def test_prepare_and_unprepare_two_local_redis_servers_with_failed_unprovide( monkeypatch): # this test will fail if you don't have Redis installed, since # it actually starts it. if platform.system() == 'Windows': print("Cannot start redis-server on Windows") return from anaconda_project.requirements_registry.network_util import can_connect_to_socket as real_can_connect_to_socket _monkeypatch_can_connect_to_socket_on_nonstandard_port_only( monkeypatch, real_can_connect_to_socket) def start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ()) assert result # now clean it up, but arrange for that to double-fail local_state_file = LocalStateFile.load_for_directory(dirname) local_state_file.set_service_run_state( 'REDIS_URL', {'shutdown_commands': [['false']]}) local_state_file.set_service_run_state( 'REDIS_URL_2', {'shutdown_commands': [['false']]}) local_state_file.save() status = unprepare(project, result) assert not status assert status.status_description == 'Failed to clean up REDIS_URL, REDIS_URL_2.' with_directory_contents_completing_project_file( { DEFAULT_PROJECT_FILENAME: """ services: REDIS_URL: redis REDIS_URL_2: redis """ }, start_local_redis)
def test_unprepare_download_fails(monkeypatch): def provide_download(dirname): @gen.coroutine def mock_downloader_run(self, loop): class Res: pass res = Res() res.code = 200 with open(os.path.join(dirname, 'data.csv'), 'w') as out: out.write('data') self._hash = '12345abcdef' raise gen.Return(res) monkeypatch.setattr("anaconda_project.internal.http_client.FileDownloader.run", mock_downloader_run) project = project_no_dedicated_env(dirname) result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname)) assert hasattr(result, 'environ') assert 'DATAFILE' in result.environ filename = os.path.join(dirname, 'data.csv') assert os.path.exists(filename) def mock_remove(path): raise IOError("Not gonna remove this") monkeypatch.setattr("os.remove", mock_remove) project.frontend.reset() status = unprepare(project, result) assert project.frontend.logs == [] assert status.status_description == ('Failed to remove %s: Not gonna remove this.' % filename) assert status.errors == [] assert not status assert os.path.exists(filename) monkeypatch.undo() # so os.remove isn't broken during directory cleanup with_directory_contents_completing_project_file({DEFAULT_PROJECT_FILENAME: DATAFILE_CONTENT}, provide_download)
def test_run_command_nonexistent_name(monkeypatch, capsys): def check_run_main(dirname): from os.path import abspath as real_abspath def mock_abspath(path): if path == ".": return dirname else: return real_abspath(path) monkeypatch.setattr('os.path.abspath', mock_abspath) def mock_execvpe(file, args, env): assert file == 'nope' assert args == ['nope'] raise OSError("no such file nope") monkeypatch.setattr('os.execvpe', mock_execvpe) project_dir_disable_dedicated_env(dirname) result = _parse_args_and_run_subcommand(['anaconda-project', 'run', '--directory', dirname, 'nope']) assert 1 == result out, err = capsys.readouterr() assert "" == out assert "Failed to execute 'nope'" in err with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ commands: default: conda_app_entry: python --version foo: conda_app_entry: python --version foo bar: conda_app_entry: python --version bar """}, check_run_main)
def test_provide_whitelist(monkeypatch): def check(dirname): from anaconda_project.requirements_registry.requirements.conda_env import CondaEnvRequirement _monkeypatch_download_file(monkeypatch, dirname, filename="nope") no_foo = [('missing requirement to run this project: A downloaded file which is ' + 'referenced by FOO.'), ' Environment variable FOO is not set.'] # whitelist only the env req by class project = project_no_dedicated_env(dirname) environ = minimal_environ() result = prepare_without_interaction(project, provide_whitelist=(CondaEnvRequirement, ), environ=environ) assert result.errors == no_foo # whitelist by instance env_req = [req for req in project.requirements(None) if isinstance(req, CondaEnvRequirement)][0] result = prepare_without_interaction(project, provide_whitelist=(env_req, ), environ=environ) assert result.errors == no_foo # whitelist by variable name result = prepare_without_interaction(project, provide_whitelist=(env_req.env_var, ), environ=environ) assert result.errors == no_foo # whitelist the download result = prepare_without_interaction( project, provide_whitelist=(env_req, project.download_requirements(None)[0]), environ=environ) assert result.errors == [] assert 'FOO' in result.environ with_directory_contents_completing_project_file( { DEFAULT_PROJECT_FILENAME: """ downloads: FOO: "http://example.com/nope" """ }, check)
def test_main(monkeypatch, capsys): def mock_conda_create(prefix, pkgs, channels): raise RuntimeError("this test should not create an environment in %s with pkgs %r" % (prefix, pkgs)) monkeypatch.setattr('anaconda_project.internal.conda_api.create', mock_conda_create) executed = {} def mock_execvpe(file, args, env): executed['file'] = file executed['args'] = args executed['env'] = env monkeypatch.setattr('os.execvpe', mock_execvpe) def check_run_main(dirname): project_dir_disable_dedicated_env(dirname) result = main(Args(directory=dirname)) assert 1 == result assert 'file' in executed assert 'args' in executed assert 'env' in executed assert executed['file'].endswith(python_exe) assert executed['args'][0].endswith(python_exe) assert '--version' == executed['args'][1] with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ commands: default: conda_app_entry: python --version """}, check_run_main) out, err = capsys.readouterr() assert "" == out assert "" == err
def test_remove_download_dir(capsys, monkeypatch): def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) code = _parse_args_and_run_subcommand( ['anaconda-project', 'remove-download', 'TEST_FILE']) project = Project(dirname) assert not project.downloads(project.default_env_spec_name) assert code == 0 out, err = capsys.readouterr() filename = os.path.join(dirname, 'foo') assert ( "Removed downloaded file %s.\nRemoved TEST_FILE from the project file.\n" % filename) == out assert '' == err with_directory_contents_completing_project_file( { DEFAULT_PROJECT_FILENAME: "downloads:\n TEST_FILE: http://localhost/foo.zip", 'foo/data.txt': 'data here' }, check)
def test_remove_platforms_from_specific_environment(capsys, monkeypatch): def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) params = _monkeypatch_remove_platforms( monkeypatch, SimpleStatus(success=True, description='Installed ok.')) code = _parse_args_and_run_subcommand([ 'anaconda-project', 'remove-platforms', '--env-spec', 'foo', 'bar' ]) assert code == 0 out, err = capsys.readouterr() assert ( 'Installed ok.\n' + 'Removed platforms from environment foo in project file: bar.\n' ) == out assert '' == err assert 1 == len(params['args']) assert dict(env_spec_name='foo', platforms=['bar']) == params['kwargs'] with_directory_contents_completing_project_file(dict(), check)
def test_add_pip_packages_to_all_environments(capsys, monkeypatch): def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) params = _monkeypatch_add_packages( monkeypatch, SimpleStatus(success=True, description='Installed ok.')) code = _parse_args_and_run_subcommand( ['anaconda-project', 'add-packages', '--pip', 'a', 'b']) assert code == 0 out, err = capsys.readouterr() assert ('Installed ok.\n' + 'Added packages to project file: a, b.\n') == out assert '' == err assert 1 == len(params['args']) assert dict(env_spec_name=None, packages=['a', 'b'], channels=None, pip=True) == params['kwargs'] with_directory_contents_completing_project_file(dict(), check)
def test_add_env_spec_with_packages(capsys, monkeypatch): def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) params = _monkeypatch_add_env_spec( monkeypatch, SimpleStatus(success=True, description='Environment looks good.')) code = _parse_args_and_run_subcommand([ 'anaconda-project', 'add-env-spec', '--name', 'foo', '--channel', 'c1', '--channel=c2', 'a', 'b' ]) assert code == 0 out, err = capsys.readouterr() assert ('Environment looks good.\n' + 'Added environment foo to the project file.\n') == out assert '' == err assert 1 == len(params['args']) assert dict(name='foo', packages=['a', 'b'], channels=['c1', 'c2']) == params['kwargs'] with_directory_contents_completing_project_file(dict(), check)
def test_do_not_start_local_redis_server_in_check_mode(monkeypatch, capsys): can_connect_args_list = _monkeypatch_can_connect_to_socket_always_succeeds_on_nonstandard( monkeypatch) def no_start_local_redis(dirname): project = project_no_dedicated_env(dirname) result = _prepare_printing_errors(project, environ=minimal_environ(), mode=provide.PROVIDE_MODE_CHECK) assert not result assert 3 == len(can_connect_args_list) with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ services: REDIS_URL: redis """}, no_start_local_redis) out, err = capsys.readouterr() assert "Could not connect to system default Redis." in err assert "REDIS_URL" in err assert "missing requirement" in err assert "" == out
def test_unset_variable_command(monkeypatch): params = [] def mock_unset_variables(project, _vars): params.append(_vars) return SimpleStatus(success=True, description="BOO") monkeypatch.setattr('anaconda_project.project_ops.unset_variables', mock_unset_variables) def check(dirname): res = _parse_args_and_run_subcommand(['anaconda-project', 'unset-variable', '--directory', dirname, 'foo', 'baz' ]) assert res == 0 with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ variables: - foo - baz """}, check) assert ['foo', 'baz'] == params[0]
def test_add_packages_to_specific_environment(capsys, monkeypatch): def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) params = _monkeypatch_add_packages(monkeypatch, SimpleStatus(success=True, description='Installed ok.')) code = _parse_args_and_run_subcommand(['anaconda-project', 'add-packages', '--env-spec', 'foo', '--channel', 'c1', '--channel=c2', 'a', 'b']) assert code == 0 out, err = capsys.readouterr() assert ('Installed ok.\n' + 'Added packages to environment foo in project file: a, b.\n') == out assert '' == err assert 1 == len(params['args']) assert dict(env_spec_name='foo', packages=['a', 'b'], channels=['c1', 'c2']) == params['kwargs'] with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ env_specs: foo: packages: - bar """}, check)
def test_set_variable_command_with_env_spec(monkeypatch): params = _monkeypatch_set_variables(monkeypatch) def check(dirname): res = _parse_args_and_run_subcommand([ 'anaconda-project', 'set-variable', '--env-spec', 'somespec', '--directory', dirname, 'foo=bar', 'baz=qux', 'has_two_equals=foo=bar' ]) assert res == 0 with_directory_contents_completing_project_file( { DEFAULT_PROJECT_FILENAME: """ variables: - foo - baz - has_two_equals """ }, check) assert 'somespec' == params[0] assert [('foo', 'bar'), ('baz', 'qux'), ('has_two_equals', 'foo=bar')] == params[1]
def test_prepare_download_mismatched_checksum_after_download(monkeypatch): def provide_download(dirname): @gen.coroutine def mock_downloader_run(self, loop): class Res: pass res = Res() res.code = 200 with open(os.path.join(dirname, 'data.csv'), 'w') as out: out.write('data') self._hash = 'mismatched' raise gen.Return(res) monkeypatch.setattr("anaconda_project.internal.http_client.FileDownloader.run", mock_downloader_run) project = project_no_dedicated_env(dirname) result = prepare_without_interaction(project, environ=minimal_environ(PROJECT_DIR=dirname)) assert not result assert ('Error downloading http://localhost/data.csv: mismatched hashes. ' 'Expected: 12345abcdef, calculated: mismatched') in result.errors with_directory_contents_completing_project_file({DEFAULT_PROJECT_FILENAME: DATAFILE_CONTENT}, provide_download)
def test_list_variables(capsys): def check_list_not_empty(dirname): code = _parse_args_and_run_subcommand(['anaconda-project', 'list-variables', '--directory', dirname]) assert code == 0 out, err = capsys.readouterr() expected_out = """ Variables for project: {dirname} Name{space}Description ===={space}=========== {varname} The project needs a Conda environment containing all required packages. tes2{space}A downloaded file which is referenced by tes2. test{space}A downloaded file which is referenced by test. """.format(dirname=dirname, varname=PLATFORM_ENV_VAR, space="".ljust(len(PLATFORM_ENV_VAR) - 2)).strip() + "\n" assert out == expected_out with_directory_contents_completing_project_file( { DEFAULT_PROJECT_FILENAME: ('downloads:\n' ' test: http://localhost:8000/test.tgz\n' ' tes2: http://localhost:8000/train.tgz\n') }, check_list_not_empty)
def test_main(monkeypatch, capsys): def mock_conda_create(prefix, pkgs, channels): raise RuntimeError("this test should not create an environment in %s with pkgs %r" % (prefix, pkgs)) monkeypatch.setattr('anaconda_project.internal.conda_api.create', mock_conda_create) can_connect_args = _monkeypatch_can_connect_to_socket_to_succeed(monkeypatch) def main_redis_url(dirname): project_dir_disable_dedicated_env(dirname) main(Args(directory=dirname)) with_directory_contents_completing_project_file({DEFAULT_PROJECT_FILENAME: """ services: REDIS_URL: redis """}, main_redis_url) assert can_connect_args['port'] == 6379 out, err = capsys.readouterr() assert "export REDIS_URL=redis://localhost:6379\n" in out assert "" == err
def test_archive_command_on_simple_project(capsys): def check(dirname): archivefile = os.path.join(dirname, "foo.zip") code = _parse_args_and_run_subcommand([ 'anaconda-project', 'archive', '--directory', dirname, archivefile ]) assert code == 0 out, err = capsys.readouterr() assert (' added %s\n added %s\nCreated project archive %s\n' % (os.path.join("some_name", DEFAULT_PROJECT_FILENAME), os.path.join("some_name", "foo.py"), archivefile)) == out with zipfile.ZipFile(archivefile, mode='r') as zf: assert [os.path.basename(x) for x in sorted(zf.namelist()) ] == [DEFAULT_PROJECT_FILENAME, "foo.py"] assert os.path.exists(os.path.join(dirname, DEFAULT_PROJECT_FILENAME)) assert '' == err with_directory_contents_completing_project_file( {'foo.py': 'print("hello")\n'}, check)
def test_archive_command_on_simple_project(capsys): def check(dirname): archivefile = os.path.join(dirname, "foo.zip") code = _parse_args_and_run_subcommand(['anaconda-project', 'archive', '--directory', dirname, archivefile]) assert code == 0 unlocked_warning = ("Warning: env specs are not locked, which means they may not work " "consistently for others or when deployed.\n" " Consider using the 'anaconda-project lock' command to lock the project.") out, err = capsys.readouterr() assert (' added %s\n added %s\n%s\nCreated project archive %s\n' % (os.path.join("some_name", DEFAULT_PROJECT_FILENAME), os.path.join( "some_name", "foo.py"), unlocked_warning, archivefile)) == out with zipfile.ZipFile(archivefile, mode='r') as zf: assert [os.path.basename(x) for x in sorted(zf.namelist())] == [DEFAULT_PROJECT_FILENAME, "foo.py"] assert os.path.exists(os.path.join(dirname, DEFAULT_PROJECT_FILENAME)) assert '' == err with_directory_contents_completing_project_file({'foo.py': 'print("hello")\n'}, check)
def test_add_service(capsys, monkeypatch): def check(dirname): _monkeypatch_pwd(monkeypatch, dirname) status = SimpleStatus(success=True, description='Service added.') status.requirement = RedisRequirement(RequirementsRegistry(), env_var='REDIS_URL', options=dict(type='redis')) _monkeypatch_add_service(monkeypatch, status) code = _parse_args_and_run_subcommand( ['anaconda-project', 'add-service', 'redis']) assert code == 0 out, err = capsys.readouterr() assert ( 'Service added.\n' + 'Added service redis to the project file, its address will be in REDIS_URL.\n' ) == out assert '' == err with_directory_contents_completing_project_file(dict(), check)
def test_display_suggestions(monkeypatch, capsys): def check(dirname): project_dir_disable_dedicated_env(dirname) def mock_is_interactive(): return True monkeypatch.setattr( 'anaconda_project.internal.cli.console_utils.stdin_is_interactive', mock_is_interactive) def mock_console_input(prompt, encrypted): raise Exception("should not have been called") monkeypatch.setattr( 'anaconda_project.internal.cli.console_utils.console_input', mock_console_input) res = _parse_args_and_run_subcommand( ['anaconda-project', 'prepare', '--directory', dirname]) assert res == 0 out, err = capsys.readouterr() assert """Potential issues with this project: * anaconda-project.yml: Unknown field name 'weird_field' The project is ready to run commands. Use `anaconda-project list-commands` to see what's available. """ == out assert '' == err with_directory_contents_completing_project_file( {DEFAULT_PROJECT_FILENAME: """ packages: [] weird_field: 42 """}, check)