def test_bundle_bundle_trees_ebnf(patch, bundle): patch.many(Bundle, ['find_stories', 'parse', 'parser']) bundle.bundle_trees(ebnf='ebnf') Bundle.parser.assert_called_with('ebnf') Bundle.parse.assert_called_with(Bundle.find_stories(), parser=Bundle.parser(), lower=False)
def test_bundle_bundle_trees_ebnf(patch, bundle): patch.many(Bundle, ["find_stories", "parse", "parser"]) bundle.bundle_trees(ebnf="ebnf") Bundle.parser.assert_called_with("ebnf") Bundle.parse.assert_called_with(Bundle.find_stories(), parser=Bundle.parser(), lower=False)
def test_app_compile(patch, bundle): patch.object(json, 'dumps') result = App.compile('path') Bundle.from_path.assert_called_with('path', ignored_path=None) Bundle.from_path().bundle.assert_called_with(ebnf=None) json.dumps.assert_called_with(Bundle.from_path().bundle(), indent=2) assert result == json.dumps()
def test_app_compile_ebnf(patch, bundle): """ Ensures App.compile supports specifying an ebnf file """ patch.object(json, 'dumps') App.compile('path', ebnf='ebnf') Bundle.from_path().bundle.assert_called_with(ebnf='ebnf')
def test_bundle_bundle_trees(patch, bundle): patch.many(Bundle, ['find_stories', 'parse', 'parser']) result = bundle.bundle_trees() Bundle.parser.assert_called_with(None) Bundle.parse.assert_called_with(Bundle.find_stories(), parser=Bundle.parser(), lower=False) assert result == bundle.stories
def test_app_parse(bundle): """ Ensures App.parse returns the parsed bundle """ result = App.parse('path') Bundle.from_path.assert_called_with('path', ignored_path=None) Bundle.from_path().bundle_trees.assert_called_with(ebnf=None) assert result == Bundle.from_path().bundle_trees()
def parse(): files = request.json['files'] bundle = Bundle(story_files=files) bundle.parse(bundle.find_stories(), ebnf=None) resp = {} for k, v in bundle.stories.items(): resp[k] = lark_tree(v) return jsonify(resp)
def test_bundle_bundle_lower(patch, bundle, magic): patch.many(Bundle, ["find_stories", "parse", "parser"]) a_story = magic() bundle.stories = {"foo": a_story} bundle.bundle_trees(ebnf="ebnf", lower=True) Bundle.parser.assert_called_with("ebnf") Bundle.parse.assert_called_with(Bundle.find_stories(), parser=Bundle.parser(), lower=True)
def test_bundle_bundle(patch, bundle): patch.many(Bundle, ['find_stories', 'services', 'compile', 'parser']) result = bundle.bundle() Bundle.parser.assert_called_with(None) Bundle.compile.assert_called_with(Bundle.find_stories(), parser=Bundle.parser()) expected = {'stories': bundle.stories, 'services': Bundle.services(), 'entrypoint': Bundle.find_stories()} assert result == expected
def test_bundle_bundle_lower(patch, bundle, magic): patch.many(Bundle, ['find_stories', 'parse', 'parser']) a_story = magic() bundle.stories = {'foo': a_story} bundle.bundle_trees(ebnf='ebnf', lower=True) Bundle.parser.assert_called_with('ebnf') Bundle.parse.assert_called_with(Bundle.find_stories(), parser=Bundle.parser(), lower=True)
def test_bundle_from_path_directory_ignored(patch): """ Ensures Bundle.from_path accepts an ignored_path keyword argument """ patch.object(os.path, 'isdir') patch.init(Bundle) patch.many(Bundle, ['load_story', 'parse_directory']) Bundle.from_path('path', ignored_path='ignored') Bundle.parse_directory.assert_called_with('path', ignored_path='ignored')
def test_app_compile_concise(patch, bundle): patch.object(json, 'dumps') patch.object(AppModule, '_clean_dict') result = App.compile('path', concise=True) Bundle.from_path.assert_called_with('path', ignored_path=None) Bundle.from_path().bundle.assert_called_with(ebnf=None) AppModule._clean_dict.assert_called_with(Bundle.from_path().bundle()) json.dumps.assert_called_with(AppModule._clean_dict(), indent=2) assert result == json.dumps()
def test_bundle_from_path_directory_ignored(patch): """ Ensures Bundle.from_path accepts an ignored_path keyword argument """ patch.object(os.path, "isdir") patch.init(Bundle) patch.many(Bundle, ["load_story", "parse_directory"]) Bundle.from_path("path", ignored_path="ignored") Bundle.parse_directory.assert_called_with("path", ignored_path="ignored")
def test_bundle_parse_directory_ignored_path(patch, bundle): patch.object( os, "walk", return_value=[(os.path.join(".", "root"), [], ["one.story"])], ) patch.many(Bundle, ["gitignores", "ignores"]) Bundle.gitignores.return_value = [] Bundle.parse_directory("dir", ignored_path="ignored") Bundle.ignores.assert_called_with("ignored")
def test_bundle_from_path_directory(patch): """ Ensures Bundle.from_path can create a Bundle from a directory path """ patch.object(os.path, 'isdir') patch.init(Bundle) patch.many(Bundle, ['load_story', 'parse_directory']) Bundle.parse_directory.return_value = ['one.story'] Bundle.from_path('path') Bundle.parse_directory.assert_called_with('path', ignored_path=None) Bundle.load_story.assert_called_with('one.story')
def test_app_parse_lower(patch, bundle, magic): """ Ensures App.parse applies the loweror """ story = magic() Bundle.from_path().bundle_trees.return_value = {'foo.story': story} result = App.parse('path', lower=True) Bundle.from_path.assert_called_with('path', ignored_path=None) bt = Bundle.from_path().bundle_trees bt.assert_called_with(ebnf=None, lower=True) assert result == Bundle.from_path().bundle_trees(story)
def test_bundle_from_path_directory(patch): """ Ensures Bundle.from_path can create a Bundle from a directory path """ patch.object(os.path, "isdir") patch.init(Bundle) patch.many(Bundle, ["load_story", "parse_directory"]) Bundle.parse_directory.return_value = ["one.story"] Bundle.from_path("path") Bundle.parse_directory.assert_called_with("path", ignored_path=None) Bundle.load_story.assert_called_with("one.story")
def test_app_compile_first(patch, bundle): """ Ensures that the App only returns the first story """ Bundle.from_path().bundle.return_value = {'stories': {'my_story': 42}} patch.object(json, 'dumps') result = App.compile('path', first=True) Bundle.from_path.assert_called_with('path', ignored_path=None) Bundle.from_path().bundle.assert_called_with(ebnf=None) json.dumps.assert_called_with(42, indent=2) assert result == json.dumps()
def test_app_parse_preprocess(patch, bundle, magic): """ Ensures App.parse applies the preprocessor """ patch.object(Preprocessor, 'process') story = magic() Bundle.from_path().bundle_trees.return_value = {'foo.story': story} result = App.parse('path', preprocess=True) assert Preprocessor.process.call_count == 1 Bundle.from_path.assert_called_with('path', ignored_path=None) Bundle.from_path().bundle_trees.assert_called_with(ebnf=None) assert result == {'foo.story': Preprocessor.process(story)}
def test_app_compile_first_error(patch, bundle): """ Ensures that the App throws an error for --first with more than one story """ Bundle.from_path().bundle.return_value = {'stories': { 'my_story': 42, 'another_story': 43, }} patch.object(json, 'dumps') with raises(StoryError) as e: App.compile('path', first=True) assert e.value.message() == \ 'The option `--first`/-`f` can only be used if one story is complied.' Bundle.from_path.assert_called_with('path', ignored_path=None) Bundle.from_path().bundle.assert_called_with(ebnf=None)
def test_bundle_bundle(patch, bundle): patch.many(Bundle, ["find_stories", "services", "compile", "parser"]) result = bundle.bundle() Bundle.parser.assert_called_with(None) Bundle.compile.assert_called_with(Bundle.find_stories(), parser=Bundle.parser()) expected = ( { "stories": bundle.stories, "services": Bundle.services(), "entrypoint": Bundle.find_stories(), }, bundle.deprecations, ) assert result == expected
def test_bundle_parse(patch, bundle): parse = bundle.parse patch.many(Bundle, ['parse', 'load_story']) parse(['one.story'], None, lower=False) Bundle.load_story.assert_called_with('one.story') story = Bundle.load_story() assert bundle.stories['one.story'] == story.tree
def test_bundle_filter_path_ignores(): result = Bundle.filter_path( os.path.join(".", "root"), "one.story", [os.path.join("root", "one.story")], ) assert result is None
def test_bundle_parse(patch, bundle): parse = bundle.parse patch.many(Bundle, ["parse", "load_story"]) parse(["one.story"], None, lower=False) Bundle.load_story.assert_called_with("one.story") story = Bundle.load_story() assert bundle.stories["one.story"] == story.tree
def test_bundle_parse(patch, bundle): patch.many(Bundle, ['parse_modules', 'load_story']) bundle.parse(['one.story'], None) Bundle.load_story.assert_called_with('one.story') story = Bundle.load_story() Bundle.parse_modules.assert_called_with(story.modules(), None) assert bundle.stories['one.story'] == story.tree
def test_app_parse_ebnf(bundle): """ Ensures App.parse supports specifying an ebnf """ App.parse('path', ebnf='ebnf') bt = Bundle.from_path().bundle_trees bt.assert_called_with(ebnf='ebnf', lower=False)
def test_bundle_gitignores_command_not_found_oserror(patch): """ Test what happens when executing the git command failed. """ patch.object(subprocess, 'run', side_effect=OSError()) result = Bundle.gitignores() assert result == []
def test_bundle_gitignores_command_not_found(patch): """ Test what happens when there's no git command available. """ patch.object(subprocess, 'run', side_effect=FileNotFoundError()) result = Bundle.gitignores() assert result == []
def test_api_load_map(patch, magic): """ Ensures Api.load_map can compile stories from a map """ patch.init(Bundle) patch.init(Features) patch.object(Bundle, "bundle") files = {"a.story": "import 'b' as b", "b.story": "x = 0"} api_loaded = Api.load_map(files) result = api_loaded.result() deprecations = api_loaded.deprecations() Bundle.__init__.assert_called_with(story_files=files, features=ANY) assert isinstance(Bundle.__init__.call_args[1]["features"], Features) Bundle.bundle.assert_called() assert result == Bundle.bundle().results assert deprecations == Bundle.bundle().deprecations
def test_bundle_parse_directory_gitignored(patch, bundle): """ Ensures parse_directory does not return gitignored files """ patch.object(os, 'walk', return_value=[('./root', [], ['one.story'])]) patch.object(Bundle, 'gitignores') Bundle.gitignores.return_value = ['root/one.story'] assert Bundle.parse_directory('dir') == []