Switch to "scenario testing"

5 files changed, 46 insertions, 46 deletions

diff --git a/yarnlib/__init__.py b/yarnlib/__init__.py
index 07045fc..88bf46f 100644
--- a/yarnlib/__init__.py
+++ b/yarnlib/__init__.py
@@ -17,5 +17,5 @@
 
 
 from mdparser import MarkdownParser
-from elements import Story, StoryStep, Implementation
+from elements import Scenario, ScenarioStep, Implementation
 from block_parser import BlockParser, BlockError
diff --git a/yarnlib/block_parser.py b/yarnlib/block_parser.py
index 1a600ee..84074e2 100644
--- a/yarnlib/block_parser.py
+++ b/yarnlib/block_parser.py
@@ -26,16 +26,16 @@ class BlockError(cliapp.AppException):
     pass
 
 
-# Parse a sequence of textual blocks into Story and Implementation
+# Parse a sequence of textual blocks into scenario and Implementation
 # objects, and their constituent objects.
 
 class BlockParser(object):
 
     def __init__(self):
-        self.stories = []
+        self.scenarios = []
         self.implementations = []
         self.line_parsers = {
-            'STORY': self.parse_story,
+            'SCENARIO': self.parse_scenario,
             'GIVEN': self.parse_given,
             'WHEN': self.parse_when,
             'THEN': self.parse_then,
@@ -75,15 +75,15 @@ class BlockParser(object):
 
         raise BlockError("Syntax error: unknown step: %s" % line1)
 
-    def parse_story(self, line, blocks):
-        self.stories.append(yarnlib.Story(line))
+    def parse_scenario(self, line, blocks):
+        self.scenarios.append(yarnlib.Scenario(line))
         return blocks
 
     def parse_simple(self, what, line, blocks):
-        if not self.stories:
-            raise BlockError('Syntax errror: %s before STORY' % what)
-        step = yarnlib.StoryStep(what, line)
-        self.stories[-1].steps.append(step)
+        if not self.scenarios:
+            raise BlockError('Syntax errror: %s before SCENARIO' % what)
+        step = yarnlib.ScenarioStep(what, line)
+        self.scenarios[-1].steps.append(step)
         return blocks
 
     def parse_given(self, line, blocks):
@@ -99,13 +99,13 @@ class BlockParser(object):
         return self.parse_simple('FINALLY', line, blocks)
 
     def parse_and(self, line, blocks):
-        if not self.stories:
-            raise BlockError('Syntax errror: AND before STORY')
-        story = self.stories[-1]
-        if not story.steps:
+        if not self.scenarios:
+            raise BlockError('Syntax errror: AND before SCENARIO')
+        scenario = self.scenarios[-1]
+        if not scenario.steps:
             raise BlockError(
                 'Syntax errror: AND before what it would continue')
-        step = story.steps[-1]
+        step = scenario.steps[-1]
         assert step.what in self.line_parsers
         return self.line_parsers[step.what](line, blocks)
 
diff --git a/yarnlib/block_parser_tests.py b/yarnlib/block_parser_tests.py
index 975444f..c988479 100644
--- a/yarnlib/block_parser_tests.py
+++ b/yarnlib/block_parser_tests.py
@@ -27,52 +27,52 @@ class BlockParserTests(unittest.TestCase):
         self.parser = yarnlib.BlockParser()
 
     def test_is_initially_empty(self):
-        self.assertEqual(self.parser.stories, [])
+        self.assertEqual(self.parser.scenarios, [])
         self.assertEqual(self.parser.implementations, [])
 
     def test_parses_simple_elements(self):
         self.parser.parse_blocks(
-            ['STORY foo', 'GIVEN bar',
+            ['SCENARIO foo', 'GIVEN bar',
              'WHEN foobar\nTHEN yoyo\nFINALLY yay\nAND yeehaa'])
 
-        self.assertEqual(len(self.parser.stories), 1)
+        self.assertEqual(len(self.parser.scenarios), 1)
         self.assertEqual(len(self.parser.implementations), 0)
 
-        story = self.parser.stories[0]
-        self.assertEqual(story.name, 'foo')
-        self.assertEqual(len(story.steps), 5)
-        self.assertEqual(story.steps[0].what, 'GIVEN')
-        self.assertEqual(story.steps[0].text, 'bar')
-        self.assertEqual(story.steps[1].what, 'WHEN')
-        self.assertEqual(story.steps[1].text, 'foobar')
-        self.assertEqual(story.steps[2].what, 'THEN')
-        self.assertEqual(story.steps[2].text, 'yoyo')
-        self.assertEqual(story.steps[3].what, 'FINALLY')
-        self.assertEqual(story.steps[3].text, 'yay')
-        self.assertEqual(story.steps[4].what, 'FINALLY')
-        self.assertEqual(story.steps[4].text, 'yeehaa')
+        scenario = self.parser.scenarios[0]
+        self.assertEqual(scenario.name, 'foo')
+        self.assertEqual(len(scenario.steps), 5)
+        self.assertEqual(scenario.steps[0].what, 'GIVEN')
+        self.assertEqual(scenario.steps[0].text, 'bar')
+        self.assertEqual(scenario.steps[1].what, 'WHEN')
+        self.assertEqual(scenario.steps[1].text, 'foobar')
+        self.assertEqual(scenario.steps[2].what, 'THEN')
+        self.assertEqual(scenario.steps[2].text, 'yoyo')
+        self.assertEqual(scenario.steps[3].what, 'FINALLY')
+        self.assertEqual(scenario.steps[3].text, 'yay')
+        self.assertEqual(scenario.steps[4].what, 'FINALLY')
+        self.assertEqual(scenario.steps[4].text, 'yeehaa')
 
     def test_normalises_whitespace(self):
-        self.parser.parse_blocks(['STORY   foo   bar   '])
-        self.assertEqual(self.parser.stories[0].name, 'foo bar')
+        self.parser.parse_blocks(['SCENARIO   foo   bar   '])
+        self.assertEqual(self.parser.scenarios[0].name, 'foo bar')
 
     def test_handles_empty_line(self):
-        self.parser.parse_blocks(['STORY foo\n\nGIVEN bar\nTHEN foobar'])
-        self.assertEqual(len(self.parser.stories), 1)
+        self.parser.parse_blocks(['SCENARIO foo\n\nGIVEN bar\nTHEN foobar'])
+        self.assertEqual(len(self.parser.scenarios), 1)
 
     def test_raises_error_for_unknown_step(self):
         self.assertRaises(
             yarnlib.BlockError,
             self.parser.parse_blocks,
-            ['STORY foo\nblah'])
+            ['SCENARIO foo\nblah'])
 
-    def test_raises_error_for_step_outside_story(self):
+    def test_raises_error_for_step_outside_scenario(self):
         self.assertRaises(
             yarnlib.BlockError,
             self.parser.parse_blocks,
             ['GIVEN foo'])
 
-    def test_raises_error_for_AND_before_story(self):
+    def test_raises_error_for_AND_before_scenario(self):
         self.assertRaises(
             yarnlib.BlockError,
             self.parser.parse_blocks,
@@ -82,7 +82,7 @@ class BlockParserTests(unittest.TestCase):
         self.assertRaises(
             yarnlib.BlockError,
             self.parser.parse_blocks,
-            ['STORY foo\nAND bar'])
+            ['SCENARIO foo\nAND bar'])
 
     def test_parses_implements_in_a_block_by_itself(self):
         self.parser.parse_blocks(['IMPLEMENTS GIVEN foo\ntrue'])
diff --git a/yarnlib/elements.py b/yarnlib/elements.py
index a1dea0d..9eeb1b7 100644
--- a/yarnlib/elements.py
+++ b/yarnlib/elements.py
@@ -16,9 +16,9 @@
 # =*= License: GPL-3+ =*=
 
 
-# This is a step in a story: GIVEN, WHEN, THEN, etc.
+# This is a step in a scenario: GIVEN, WHEN, THEN, etc.
 
-class StoryStep(object):
+class ScenarioStep(object):
 
     def __init__(self, what, text):
         self.what = what
@@ -26,9 +26,9 @@ class StoryStep(object):
         self.implementation = None
 
 
-# This is the story itself.
+# This is the scenario itself.
 
-class Story(object):
+class Scenario(object):
 
     def __init__(self, name):
         self.name = name
diff --git a/yarnlib/mdparser.py b/yarnlib/mdparser.py
index 6d16772..6708369 100644
--- a/yarnlib/mdparser.py
+++ b/yarnlib/mdparser.py
@@ -25,7 +25,7 @@ from markdown.treeprocessors import Treeprocessor
 #
 # Classes for Markdown parsing. See python-markdown documentation
 # for details. We want to find all top level code blocks (indented
-# four spaces in the Markdown), which we'll parse for story test
+# four spaces in the Markdown), which we'll parse for scenario test
 # stuff later on. We create a Python markdown extension and use
 # "tree processor" to analyse the parsed ElementTree at the right
 # moment for top level <pre> blocks.
@@ -50,7 +50,7 @@ class GatherCodeBlocks(Treeprocessor):
 # gatherer at the right time. It stores the list of top level
 # code blocks as the blocks attribute.
 
-class ParseStoryTestBlocks(markdown.extensions.Extension):
+class ParseScenarioTestBlocks(markdown.extensions.Extension):
 
     def extendMarkdown(self, md, md_globals):
         self.blocks = []
@@ -64,7 +64,7 @@ class MarkdownParser(object):
         self.blocks = []
 
     def parse_string(self, text):
-        ext = ParseStoryTestBlocks()
+        ext = ParseScenarioTestBlocks()
         f = StringIO.StringIO()
         markdown.markdown(text, output=f, extensions=[ext])
         self.blocks = ext.blocks