def test_storyerror_highlight(patch, storyerror, error): """ Ensures StoryError.highlight produces the correct text. """ patch.many(StoryError, ["get_line", "int_line", "symbols"]) error.column = "1" result = storyerror.highlight() highlight = StoryError.symbols() args = (storyerror.int_line(), StoryError.get_line().replace(), highlight) assert result == "{}| {}\n{}".format(*args)
def test_storyerror_highlight(patch, storyerror, error): """ Ensures StoryError.highlight produces the correct text. """ patch.many(StoryError, ['get_line', 'int_line', 'symbols']) error.column = '1' result = storyerror.highlight() highlight = StoryError.symbols() args = (storyerror.int_line(), StoryError.get_line().replace(), highlight) assert result == '{}| {}\n{}'.format(*args)
def test_storyerror_internal(patch): """ Ensures that an internal error gets properly constructed """ patch.object(StoryError, 'unnamed_error') e = StoryError.internal_error(Exception('ICE happened')) msg = ( 'Internal error occured: ICE happened\n' 'Please report at https://github.com/storyscript/storyscript/issues') StoryError.unnamed_error.assert_called_with(msg) assert e == StoryError.internal_error(msg)
def test_exceptions_storyerror_compile_template_tree(patch, error): patch.object(StoryError, 'tree_template') error.item.data = 'data' result = error.compile_template() args = (error.item, error.item.line()) StoryError.tree_template.assert_called_with(*args) assert result == StoryError.tree_template()
def test_storyerror_echo(patch, storyerror): """ Ensures StoryError.echo prints StoryError.message """ patch.object(click, 'echo') patch.object(StoryError, 'message') storyerror.echo() click.echo.assert_called_with(StoryError.message())
def test_storyerror_unnamed_error(patch): patch.init(StoryError) patch.init(CompilerError) e = StoryError.unnamed_error('Unknown error happened') assert isinstance(e, StoryError) assert CompilerError.__init__.call_count == 1 assert isinstance(StoryError.__init__.call_args[0][0], CompilerError) assert StoryError.__init__.call_args[0][1] is None
def test_exceptions_storyerror_compile_template_dict(patch, error): """ Ensures compile_template can handle dictionary items. """ patch.object(StoryError, 'tree_template') error.item = {'value': 'value', 'line': '1'} result = error.compile_template() StoryError.tree_template.assert_called_with('value', '1') assert result == StoryError.tree_template()
def test_parser_parser_unexpected_token(capsys, patch, magic, parser): patch.init(StoryError) patch.object(StoryError, 'message') patch.many(Parser, ['lark', 'transformer']) Parser.lark().parse.side_effect = UnexpectedToken(magic(), 'exp', 0, 1) with raises(SystemExit): parser.parse('source', debug=False) out, err = capsys.readouterr() assert out == '{}\n'.format(StoryError.message())
def test_storyerror_internal(patch): """ Ensures that an internal error gets properly constructed """ patch.init(StoryError) e = Exception('.ICE.') error = StoryError.internal_error(e) assert isinstance(error, StoryError) StoryError.__init__.assert_called_with(e, story=None)
def test_storyerror_internal_message(patch): """ Ensures that the internal error message gets properly built """ error = Exception('.ICE.') expected = ( 'Internal error occured: .ICE.\n' 'Please report at https://github.com/storyscript/storyscript/issues') assert StoryError._internal_error(error) == expected
def test_storyerror_header(patch, storyerror, error): """ Ensures StoryError.header returns the correct text. """ patch.object(click, 'style') patch.object(StoryError, 'name') template = 'Error: syntax error in {} at line {}, column {}' result = storyerror.header() click.style.assert_called_with(StoryError.name(), bold=True) assert result == template.format(click.style(), error.line, error.column)
def test_exceptions_storyerror_compile_template_input(patch, magic, error): """ Ensures compile_template can handle UnexpectedInput items. """ patch.object(StoryError, 'token_template') error.item.context = 'context' result = error.compile_template() args = (error.item.context, error.item.line, error.item.column) StoryError.token_template.assert_called_with(*args) assert result == StoryError.token_template()
def test_exceptions_storyerror_compile_template_error(patch, magic, error): """ Ensures compile_template can handle UnexpectedToken items. """ patch.object(StoryError, 'token_template') error.item.token = magic() result = error.compile_template() args = (error.item.token.value, error.item.line, error.item.column) StoryError.token_template.assert_called_with(*args) assert result == StoryError.token_template()
def test_storyerror_create_error(patch): """ Ensures that Errors without Tokens can be created """ patch.init(StoryError) patch.init(CompilerError) error = StoryError.create_error('error_code') assert isinstance(error, StoryError) CompilerError.__init__.assert_called_with('error_code', format_args={}) assert isinstance(StoryError.__init__.call_args[0][0], CompilerError) assert StoryError.__init__.call_args[0][1] is None
def test_storyerror_create_error_kwargs(patch): """ Ensures that Errors without Tokens can be created and kwargs are passed on. """ patch.init(StoryError) patch.init(CompilerError) error = StoryError.create_error('error_code', a=0) assert isinstance(error, StoryError) CompilerError.__init__.assert_called_with('error_code', format={'a': 0}) assert isinstance(StoryError.__init__.call_args[0][0], CompilerError) assert StoryError.__init__.call_args[0][1] is None
def test_api_load_story_error(patch, magic): """ Ensures Api.loads handles unknown errors """ patch.init(Story) patch.object(Story, "from_stream") Story.from_stream.side_effect = StoryError.internal_error(".error.") stream = magic() s = Api.load(stream) e = s.errors()[0] assert e.message().startswith("E0001: Internal error occured: .error.")
def test_run_story_error(magic, patch): endpoint = magic() se = StoryError(None, None) patch.init(Story) patch.object(Diagnostics, 'to_error') patch.object(Api, 'loads') Api.loads().errors.return_value = [se] d = Diagnostics(endpoint=endpoint) doc = Document(uri='.my.uri.', text='a = 0') d.run(ws=magic(), doc=doc) d.to_error.assert_called_with(se) endpoint.notify.assert_called_with('textDocument/publishDiagnostics', { 'uri': doc.uri, 'diagnostics': [Diagnostics.to_error()], })
def test_run_story_error_internal(magic, patch): endpoint = magic() se = StoryError(None, None) patch.init(Story) patch.object(Diagnostics, "to_error") patch.object(Api, "loads") Api.loads().errors.return_value = [se] d = Diagnostics(endpoint=endpoint) doc = Document(uri=".my.uri.", text="a = 0") d.run(ws=magic(), doc=doc) d.to_error.assert_not_called() endpoint.notify.assert_called_with("textDocument/publishDiagnostics", { "uri": doc.uri, "diagnostics": [], })
def test_storyerror_init_path(): storyerror = StoryError('error', 'story', path='hello.story') assert storyerror.path == 'hello.story'
def storyerror(error, magic): story = magic() return StoryError(error, story)
def test_exceptions_storyerror_message_reason(patch, error): patch.many(StoryError, ['compile_template', 'escape_string', 'reason']) error.error_type = 'else' result = error.message() assert result == '{}. Reason: {}'.format(StoryError.escape_string(), StoryError.reason())
def test_exceptions_storyerror_message(patch, error): patch.many(StoryError, ['compile_template', 'escape_string']) result = error.message() StoryError.escape_string.assert_called_with(StoryError.compile_template()) assert result == StoryError.escape_string()
def test_exceptions_storyerror_str_(patch, error): patch.object(StoryError, 'message', return_value='pretty') assert str(error) == StoryError.message()
def test_exceptions_storyerror_escape_string(magic): string = magic() assert StoryError.escape_string(string) == string.encode().decode()
def error(magic): return StoryError('unknown', magic(spec=['line', 'column']))
def storyerror(error): return StoryError(error, 'story')
def test_exceptions_storyerror_init(): error = StoryError('unknown', 'item') assert error.error_type == 'unknown' assert error.item == 'item' assert issubclass(StoryError, SyntaxError)
result = runner.run(test.test, args=args, exit_code=expected_exit_code) test.compile_app.assert_called_with('my_app', debug) if mock_tree_as_none: assert result.stdout == '' elif no_stories_found: assert 'No stories found' in result.stdout else: assert 'Looking good!' in result.stdout assert 'a1.story' in result.stdout assert 'a2.story' in result.stdout @mark.parametrize('force_compilation_error,compilation_exc', [(True, StoryError('E100', 'a.story', path='foo')), (True, BaseException('oh no!')), (False, None)]) @mark.parametrize('nested_dir', [True, False]) def test_compile_app(runner, patch, init_sample_app_in_cwd, pre_init_cli_runner, nested_dir, force_compilation_error, compilation_exc): app_name_for_analytics = 'my_special_app' patch.object(cli, 'get_asyncy_yaml', return_value='asyncy_yml_content') patch.object(cli, 'track') patch.object(click, 'echo') if force_compilation_error: patch.object(App, 'compile', side_effect=compilation_exc)
def test_exceptions_storyerror_compile_template(patch, error): patch.object(StoryError, 'token_template') result = error.compile_template() args = (error.item, error.item.line, error.item.column) StoryError.token_template.assert_called_with(*args) assert result == StoryError.token_template()