async def test_lexicon_throw(logger, story, args): story.tree = { '1': { 'method': 'throw', 'ln': '1', 'col_start': '1', 'col_end': '2', 'args': args } } with pytest.raises(StoryscriptError): Lexicon.throw(logger, story, story.tree['1'])
async def test_lexicon_set_mutation(patch, logger, story): story.context = {} patch.object(story, 'line') patch.object(Lexicon, 'line_number_or_none') patch.object(Mutations, 'mutate') line = { 'ln': '1', 'name': ['out'], 'args': [ 'values', { '$OBJECT': 'mutation' } ], 'next': '2' } Mutations.mutate.return_value = 'mutated_result' result = await Lexicon.set(logger, story, line) story.resolve.assert_called_with(line['args'][0]) story.end_line.assert_called_with( line['ln'], assign={'paths': ['out'], '$OBJECT': 'path'}, output='mutated_result') story.line.assert_called_with(line['next']) Mutations.mutate.assert_called_with(line['args'][1], story.resolve(), story, line) assert result == Lexicon.line_number_or_none()
def test__is_if_condition_true(patch, story): line = { 'args': ['my_condition'] } patch.object(story, 'resolve', return_value='condition_result') assert Lexicon._is_if_condition_true(story, line) == 'condition_result' story.resolve.assert_called_with('my_condition', encode=False)
async def test_if_condition_elif_else(patch, logger, story, line, method): line['method'] = method patch.object(Lexicon, 'line_number_or_none') patch.object(story, 'next_block') ret = await Lexicon.if_condition(logger, story, line) story.next_block.assert_called_with(line) Lexicon.line_number_or_none.assert_called_with(story.next_block()) assert ret == Lexicon.line_number_or_none()
async def test_lexicon_for_loop(patch, logger, story, line, async_mock, execute_block_return): iterated_over_items = [] async def execute_block(our_logger, our_story, our_line): iterated_over_items.append(story.context['element']) assert our_logger == logger assert our_story == story assert our_line == line return execute_block_return patch.object(Lexicon, 'execute', new=async_mock()) patch.object(Lexicon, 'line_number_or_none') patch.object(Lexicon, 'execute_block', side_effect=execute_block) patch.object(story, 'next_block') line['args'] = [ {'$OBJECT': 'path', 'paths': ['elements']} ] line['output'] = ['element'] story.context = {'elements': ['one', 'two', 'three']} story.resolve.return_value = ['one', 'two', 'three'] story.environment = {} result = await Lexicon.for_loop(logger, story, line) if execute_block_return == LineSentinels.BREAK: assert iterated_over_items == ['one'] assert result == Lexicon.line_number_or_none(story.next_block(line)) elif LineSentinels.is_sentinel(execute_block_return): assert iterated_over_items == ['one'] assert result == execute_block_return else: assert iterated_over_items == story.context['elements'] assert result == Lexicon.line_number_or_none(story.next_block(line)) # Ensure no leakage of the element assert story.context.get('element') is None
async def test_lexicon_execute_streaming_container(patch, story, async_mock): line = { 'enter': '10', 'ln': '9', LineConstants.service: 'foo', 'output': 'output', 'next': '11' } patch.object(Services, 'start_container', new=async_mock()) patch.object(Lexicon, 'line_number_or_none') patch.many(story, ['end_line', 'line']) Metrics.container_start_seconds_total = Mock() ret = await Lexicon.execute(story.logger, story, line) Services.start_container.mock.assert_called_with(story, line) story.end_line.assert_called_with( line['ln'], output=Services.start_container.mock.return_value, assign={'paths': line.get('output')}) Metrics.container_start_seconds_total.labels().observe.assert_called_once() story.line.assert_called_with(line['next']) Lexicon.line_number_or_none.assert_called_with(story.line()) assert ret == Lexicon.line_number_or_none()
async def test_lexicon_execute(patch, logger, story, line, async_mock, name): line['enter'] = None if name is not None: line['name'] = [name] output = MagicMock() patch.object(Services, 'execute', new=async_mock(return_value=output)) patch.object(Lexicon, 'line_number_or_none') patch.object(story, 'line') result = await Lexicon.execute(logger, story, line) Services.execute.mock.assert_called_with(story, line) if name is not None: story.end_line.assert_called_with(line['ln'], output=output, assign={'paths': [name]}) else: story.end_line.assert_called_with(line['ln'], output=output, assign=None) story.line.assert_called_with(line['next']) assert result == Lexicon.line_number_or_none()
def test_next_line_or_none(): line = {'ln': '10'} assert Lexicon.line_number_or_none(line) == '10' assert Lexicon.line_number_or_none(None) is None
def test_lexicon_unless_false(logger, story, line): story.context = {} story.resolve.return_value = False assert Lexicon.unless_condition(logger, story, line) == line['enter']
def test_lexicon_unless(logger, story, line): story.context = {} result = Lexicon.unless_condition(logger, story, line) logger.log.assert_called_with('lexicon-unless', line, story.context) story.resolve.assert_called_with(line['args'][0], encode=False) assert result == line['exit']
def test__is_if_condition_true_complex(patch, story): line = { 'args': ['my_condition', 'my_condition_2'] } with pytest.raises(StoryscriptError): Lexicon._is_if_condition_true(story, line)