manamana 0.0.1 → 0.0.2

data/test/lib/manamana/rdsl/lexer_test.rb

@@ -0,0 +1,171 @@
+require_relative '../../../test_helper'
+require 'manamana/rdsl/lexer'
+
+module ManaMana
+
+  module RDSL
+
+    describe Lexer do
+
+      it "must be defined" do
+        Lexer.wont_be_nil
+      end
+
+      it "must tokenize the group name" do
+        output = tokenize <<-EOF
+                 Create a Project
+                 ================
+                 EOF
+        tokens = [ [:GROUP, 'Create a Project'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize strings" do
+        output = tokenize <<-EOF
+                 Arbitrary text
+                 of the unusual kind
+                 EOF
+        tokens = [ [:TEXT, 'Arbitrary text of the unusual kind'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize a requirement" do
+        output = tokenize <<-EOF
+                 * A project without a name is invalid
+                 EOF
+        tokens = [ [:REQUIREMENT, 'A project without a name is invalid'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize a requirement followed by arbitrary text" do
+        output = tokenize <<-EOF
+                 * A project without a name is invalid
+
+                   Example:
+                     Arbitrary text
+                 EOF
+        tokens = [ [:REQUIREMENT, 'A project without a name is invalid'], [:TEXT, 'Example: Arbitrary text'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize a multi-line requirement" do
+        output = tokenize <<-EOF
+                 * A project without a
+                   name is invalid
+                 EOF
+        tokens = [ [:REQUIREMENT, 'A project without a name is invalid'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize a multi-line requirement followed by arbitrary text" do
+        output = tokenize <<-EOF
+                 * A project without
+                   a name is invalid
+
+                   Example:
+                     Arbitrary text
+                 EOF
+        tokens = [ [:REQUIREMENT, 'A project without a name is invalid'], [:TEXT, 'Example: Arbitrary text'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize tables" do
+        output = tokenize <<-EOF
+                  | Name      | Description       |
+                  | Project A | First Project     |
+                  | Project B | Second Project    |
+                EOF
+        tokens = [
+                   [:ROW, 'Row'], [:CELL, 'Name'],      [:CELL, 'Description'],
+                   [:ROW, 'Row'], [:CELL, 'Project A'], [:CELL, 'First Project'],
+                   [:ROW, 'Row'], [:CELL, 'Project B'], [:CELL, 'Second Project']
+                 ]
+        output.must_equal tokens
+      end
+
+      it "must ignore table borders" do
+        output = tokenize <<-EOF
+                  | Name      | Description       |
+                  |-----------|-------------------|
+                  | Project A | First Project     |
+                  | Project B | Second Project    |
+                EOF
+        tokens = [
+                   [:ROW, 'Row'], [:CELL, 'Name'],      [:CELL, 'Description'],
+                   [:ROW, 'Row'], [:CELL, 'Project A'], [:CELL, 'First Project'],
+                   [:ROW, 'Row'], [:CELL, 'Project B'], [:CELL, 'Second Project']
+                 ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize requirements with placeholders" do
+        output = tokenize <<-EOF
+                 * Given <Role>
+                   <Something>
+                 EOF
+        tokens = [ [:REQUIREMENT, 'Given <Role> <Something>'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize a full requirements file" do
+        output = tokenize <<-EOF
+               Create a Project
+               ================
+
+               * Given a user has a role of <Role> in the system
+                 Then he <Can or Cannot Create> projects
+
+                 Examples:
+                   | Role  | Can or Cannot Create |
+                   | Admin | Can Create           |
+                   | User  | Cannot Create        |
+
+                 Notes:
+                   The quick brown fox jumps over the lazy
+                   dog. The quick brown fox jumps.
+               EOF
+        tokens = [
+                   [:GROUP, 'Create a Project'],
+                   [:REQUIREMENT, 'Given a user has a role of <Role> in the system Then he <Can or Cannot Create> projects'],
+                   [:TEXT, 'Examples:'],
+                   [:ROW, 'Row'], [:CELL, 'Role'], [:CELL, 'Can or Cannot Create'],
+                   [:ROW, 'Row'], [:CELL, 'Admin'], [:CELL, 'Can Create'],
+                   [:ROW, 'Row'], [:CELL, 'User'], [:CELL, 'Cannot Create'],
+                   [:TEXT, 'Notes: The quick brown fox jumps over the lazy dog. The quick brown fox jumps.']
+                 ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize a requirements file with arbitrary text right under the group name" do
+        output = tokenize <<-EOF
+                   User Login
+                   ==========
+                   (Derived from: http://www.allaboutagile.com/user-story-example/)
+
+                   As a registered user, I want to log in,
+                   so I can access subscriber content.
+
+                   Success:
+
+                     * When I check 'Remember Me' and log in succesfully,
+                       I won't have to login again next time
+                 EOF
+        tokens = [
+                   [:GROUP, 'User Login'],
+                   [:TEXT, '(Derived from: http://www.allaboutagile.com/user-story-example/)'],
+                   [:TEXT, 'As a registered user, I want to log in, so I can access subscriber content.'],
+                   [:TEXT, 'Success:'],
+                   [:REQUIREMENT, 'When I check \'Remember Me\' and log in succesfully, I won\'t have to login again next time']
+                 ]
+        output.must_equal tokens
+      end
+
+      def tokenize(data)
+        Lexer.new.tokenize(data)
+      end
+      
+    end # describe Lexer
+
+  end # module RDSL
+  
+end # module ManaMana

data/test/lib/manamana/rdsl/parser_test.rb

@@ -0,0 +1,189 @@
+require_relative '../../../test_helper'
+require 'manamana/rdsl/parser'
+
+module ManaMana
+
+  module RDSL
+
+    describe Parser do
+
+      it "must parse an empty file" do
+        output  = parse ""
+        nodes   = RootNode.new
+        output.must_equal nodes
+      end
+
+      it "must parse an empty group" do
+        output = parse <<-EOF
+                 Create a Project
+                 ================
+                 EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('Create a Project')
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse multiple empty groups" do
+        output = parse <<-EOF
+                 Create a Project
+                 ================
+
+                 Create a User
+                 =============
+                 EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('Create a Project'),
+                  GroupNode.new('Create a User')
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse requirements" do
+        output = parse <<-EOF
+                 Create a Project
+                 ================
+
+                   * Given a user with role <Role>
+               EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('Create a Project', [
+                    RequirementNode.new('Given a user with role <Role>')
+                  ])
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse a multi-line requirement" do
+        output = parse <<-EOF
+                 Create a Project
+                 ================
+
+                   * Given a
+                     user with
+                     role <Role>
+               EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('Create a Project', [
+                    RequirementNode.new("Given a user with role <Role>")
+                  ])
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse multiple non-empty groups" do
+        output = parse <<-EOF
+                 Create a Project
+                 ================
+
+                   * Projects without names are invalid
+
+                 Create a User
+                 =============
+
+                   * Users with names are valid
+                 EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('Create a Project', [
+                    RequirementNode.new('Projects without names are invalid')
+                  ]),
+                  GroupNode.new('Create a User', [
+                    RequirementNode.new('Users with names are valid')
+                  ])
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse tables" do
+        output = parse <<-EOF
+                 Create a Project
+                 ================
+
+                 * Given a
+                   user with
+                   role <Role>
+
+                   Examples:
+                    | Role | Remarks |
+                    | PM   | ARRR    |
+                    | User | RAAA    |
+               EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('Create a Project', [
+                    RequirementNode.new("Given a user with role <Role>", [
+                      ExamplesNode.new('', [
+                        RowNode.new('', ['Role', 'Remarks']),
+                        RowNode.new('', ['PM', 'ARRR']),
+                        RowNode.new('', ['User', 'RAAA'])
+                      ])
+                    ])
+                  ])
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse multiple requirements" do
+        output = parse <<-EOF
+                 Project Management
+                 ==================
+
+                 * A <Role> in the system <Can or Cannot Create> projects
+
+                     | Role | Can or Cannot Create |
+                     |------|----------------------|
+                     | PM   | Can Create           |
+                     | User | Cannot Create        |
+
+                 * An empty project is invalid
+               EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('Project Management', [
+                    RequirementNode.new("A <Role> in the system <Can or Cannot Create> projects", [
+                      ExamplesNode.new('', [
+                        RowNode.new('', ['Role', 'Can or Cannot Create']),
+                        RowNode.new('', ['PM', 'Can Create']),
+                        RowNode.new('', ['User', 'Cannot Create'])
+                      ])
+                    ]),
+                    RequirementNode.new("An empty project is invalid", [])
+                  ])
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse groups followed by arbitrary text" do
+        output = parse <<-EOF
+                   User Login
+                   ==========
+
+                   (Derived from: http://www.allaboutagile.com/user-story-example/)
+
+                   As a registered user, I want to log in,
+                   so I can access subscriber content.
+
+                   Success:
+
+                     * When I check 'Remember Me' and log in succesfully,
+                       I won't have to login again next time
+
+                     * When I uncheck 'Remember Me' and log in successfully,
+                       I should be asked to login next time
+                 EOF
+        nodes = RootNode.new('', [
+                  GroupNode.new('User Login', [
+                    RequirementNode.new('When I check \'Remember Me\' and log in succesfully, I won\'t have to login again next time'),
+                    RequirementNode.new('When I uncheck \'Remember Me\' and log in successfully, I should be asked to login next time')
+                  ])
+                ])
+        output.must_equal nodes
+      end
+
+      def parse(file, show_tokens = false)
+        Parser.new.parse(file, show_tokens)
+      end
+
+    end
+
+  end
+  
+end

data/test/lib/manamana/rdsl/requirements_node_test.rb

@@ -0,0 +1,36 @@
+require_relative '../../../test_helper'
+require 'manamana/rdsl/nodes'
+
+module ManaMana
+  
+  module RDSL
+
+    describe RequirementNode do
+
+      it "must expand examples" do
+        nodes = RequirementNode.new("A <Role> in the system <Can or Cannot Create> projects", [
+                  ExamplesNode.new('', [
+                    RowNode.new('', ['Role', 'Can or Cannot Create']),
+                    RowNode.new('', ['PM', 'Can Create']),
+                    RowNode.new('', ['User', 'Cannot Create'])
+                  ])
+                ])
+        array = [
+                  'A PM in the system Can Create projects',
+                  'A User in the system Cannot Create projects'
+                ]
+        nodes.expand.must_equal array
+      end
+
+      it "must return its name when expand is called and no examples exist" do
+        nodes = RequirementNode.new("A PM in the system can create projects")
+        array = ['A PM in the system can create projects']
+        nodes.expand.must_equal array
+      end
+
+
+    end
+
+  end
+
+end

data/test/lib/manamana/tdsl/lexer_test.rb

@@ -0,0 +1,72 @@
+require_relative '../../../test_helper'
+require 'manamana/tdsl/lexer'
+
+module ManaMana
+
+  module TDSL
+
+    describe Lexer do
+
+      section_labels = [ 'Variables', 'Preconditions', 'Cleanup', 'Script' ]
+
+      section_labels.each do |section_label|
+        it "must tokenize the #{ section_label } keyword" do
+          output = tokenize <<-EOF
+                   #{ section_label }:
+                   EOF
+          tokens = [ [section_label.upcase.to_sym, section_label] ]
+          output.must_equal tokens
+        end
+      end
+
+      it "must tokenize the test case name" do
+        output = tokenize <<-EOF
+                 Test Case:
+                 A user who is a (.+) can create tickets in it
+                 EOF
+        tokens = [ [:TEST_CASE, 'A user who is a (.+) can create tickets in it'] ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize a Variables section" do
+        output = tokenize <<-EOF
+                 Variables:
+                   * My Name       = $1
+                   * A long variable name
+                       = 'something'
+                   * Role          = role_id
+                 EOF
+        tokens = [
+                   [:VARIABLES, "Variables"],
+                     [:LINE, "My Name = $1"],
+                     [:LINE, "A long variable name = 'something'"],
+                     [:LINE, "Role = role_id"]
+                 ]
+        output.must_equal tokens
+      end
+
+      it "must tokenize lines with multiple whitespace" do
+        output = tokenize <<-EOF
+                   * Ensure that the username <My Username> exists
+                   * Ensure that the database
+                     is cleaned up of previous
+                     testing data
+                   * Ensure   that   the   app is running
+                 EOF
+        tokens = [
+                     [:LINE, "Ensure that the username <My Username> exists"],
+                     [:LINE, "Ensure that the database is cleaned up of previous testing data"],
+                     [:LINE, "Ensure that the app is running"]
+                 ]
+        output.must_equal tokens
+      end
+
+      def tokenize(data)
+        Lexer.new.tokenize(data)
+      end
+
+    end # describe Lexer
+
+  end # module TDSL
+  
+end # module ManaMana

data/test/lib/manamana/tdsl/parser_test.rb

@@ -0,0 +1,171 @@
+require_relative '../../../test_helper'
+require 'manamana/tdsl/parser'
+
+module ManaMana
+
+  module TDSL
+
+    describe Parser do
+
+      it "must parse an empty file" do
+        output  = parse ""
+        nodes   = RootNode.new
+        output.must_equal nodes
+      end
+
+      it "must parse an empty test case" do
+        output = parse <<-EOF
+                 Test Case:
+                   A user who is a (.+) can create tickets in it
+                 EOF
+        nodes = RootNode.new('', [
+                  TestCaseNode.new('A user who is a (.+) can create tickets in it')
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse multiple empty test cases" do
+        output = parse <<-EOF
+                 Test Case:
+                   A user who is a (.+) can create tickets in it
+
+                 Test Case:
+                   A user who is a (.+) cannot create tickets in it
+                 EOF
+        nodes = RootNode.new('', [
+                  TestCaseNode.new('A user who is a (.+) can create tickets in it'),
+                  TestCaseNode.new('A user who is a (.+) cannot create tickets in it')
+                ])
+        output.must_equal nodes
+      end
+
+      it "must parse the variables section" do
+        file   = <<-EOF
+                 Test Case:
+                   A user who is a Manager can create tickets in it
+
+                   Variables:
+                     * My Username = $1
+                     * My Password = my_password
+                 EOF
+        output = parse file
+        nodes  = RootNode.new('', [
+                   TestCaseNode.new('A user who is a Manager can create tickets in it', {
+                     :variables => VariablesNode.new('', [
+                       AssignmentNode.new('My Username = $1'),
+                       AssignmentNode.new('My Password = my_password')
+                     ])
+                   })
+                 ])
+        output.must_equal nodes
+      end
+
+      it "must parse the preconditions section" do
+        file   = <<-EOF
+                 Test Case:
+                   A user who is a Manager can create tickets in it
+
+                   Preconditions:
+                     * Ensure a user with username Bob exists
+                     * This is another step that
+                       wraps to the next line
+                 EOF
+        output = parse file
+        nodes  = RootNode.new('', [
+                   TestCaseNode.new('A user who is a Manager can create tickets in it', {
+                     :preconditions => PreconditionsNode.new('', [
+                       StepNode.new('Ensure a user with username Bob exists'),
+                       StepNode.new('This is another step that wraps to the next line')
+                     ])
+                   })
+                 ])
+        output.must_equal nodes
+      end
+
+      it "must parse the cleanup section" do
+        file   = <<-EOF
+                 Test Case:
+                   A user who is a Manager can create tickets in it
+
+                   Cleanup:
+                     * Delete <My Username> at exit
+                 EOF
+        output = parse file
+        nodes  = RootNode.new('', [
+                   TestCaseNode.new('A user who is a Manager can create tickets in it', {
+                     :cleanup => CleanupNode.new('', [
+                       StepNode.new('Delete <My Username> at exit')
+                     ])
+                   })
+                 ])
+        output.must_equal nodes
+      end
+
+      it "must parse the script section" do
+        file   = <<-EOF
+                 Test Case:
+                   A user who is a Manager can create tickets in it
+
+                   Script:
+                     * Click the Log Out button
+                 EOF
+        output = parse file
+        nodes  = RootNode.new('', [
+                   TestCaseNode.new('A user who is a Manager can create tickets in it', {
+                     :script => ScriptNode.new('', [
+                       StepNode.new('Click the Log Out button')
+                     ])
+                   })
+                 ])
+        output.must_equal nodes
+      end
+
+      it "must parse multiple non-empty test cases" do
+        file   = <<-EOF
+                 Test Case:
+                   A user who is a Manager can create tickets in it
+
+                   Script:
+                     * Click the Log Out button
+
+                 Test Case:
+                   A user who is a (.+) cannot create tickets
+
+                   Variables:
+                     * My Username = 'Bob'
+
+                   Script:
+                     * Click the Log Out button
+                     * Fill in the Username field with <My Username>
+                 EOF
+        output = parse file
+        nodes  = RootNode.new('', [
+                   TestCaseNode.new('A user who is a Manager can create tickets in it', {
+                     :script => ScriptNode.new('', [
+                       StepNode.new('Click the Log Out button')
+                     ])
+                   }),
+
+                   TestCaseNode.new('A user who is a (.+) cannot create tickets', {
+                     :variables => VariablesNode.new('', [
+                       AssignmentNode.new('My Username = \'Bob\'')
+                      ]),
+                     :script => ScriptNode.new('', [
+                       StepNode.new('Click the Log Out button'),
+                       StepNode.new('Fill in the Username field with <My Username>')
+                     ])
+                   })
+                 ])
+
+        output.must_equal nodes
+      end
+
+      def parse(file, show_tokens = false)
+        Parser.new.parse(file, show_tokens)
+      end
+
+    end
+
+  end
+  
+end