lucid 0.4.1 → 0.5.1

data/spec/lucid/sequences/sequence_group_spec.rb

@@ -1,55 +0,0 @@
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/lucid/sequence/sequence_group'
-
-module Sequence
-  describe SequenceGroup do
-
-    let(:singleton) { SequenceGroup.instance() }
-
-    context 'starting state' do
-      it 'should be empty' do
-        expect(singleton.sequence_steps).to be_empty
-      end
-    end
-    
-    context 'basic operation' do
-      let(:example_steps) do
-        example = <<-EXAMPLE
-          Given the login page
-          When  the username is "<username>"
-          And   the password is "<password>"
-          And   login is clicked
-        EXAMPLE
-      end
-
-      it 'should accept the addition of a new sequence phrase' do
-        phrase = '[enter credentials]'
-        args = [phrase, example_steps, true]
-        expect { singleton.add_sequence(*args) }.not_to raise_error
-        expect(singleton).to have(1).sequence_steps
-      end
-      
-      it 'should not accept the addition of an existing sequence phrase' do
-        phrase = '[enter credentials]'
-        args = [phrase, example_steps, true]
-        msg = "A sequence with phrase '[enter credentials]' already exists."
-        expect { singleton.add_sequence(*args) }.to raise_error(Sequence::DuplicateSequenceError, msg)
-      end
-
-      it 'should return the steps of a sequence phrase' do
-        phrase = '[enter credentials]'
-        input_values = [['username', 'jnyman'], ['password', 'thx1138']]
-        generated = singleton.generate_steps(phrase, input_values)
-        expected = <<-EXAMPLE
-          Given the login page
-          When  the username is "jnyman"
-          And   the password is "thx1138"
-          And   login is clicked
-        EXAMPLE
-        expect(generated).to eq(expected)
-      end
-    end
-    
-  end
-end

data/spec/lucid/sequences/sequence_phrase_spec.rb

@@ -1,122 +0,0 @@
-require_relative '../../spec_helper'
-require_relative '../../../lib/lucid/sequence/sequence_phrase'
-
-module Sequence
-  
-  describe SequencePhrase do
-    let(:example_phrase) { 'enter login credentials as <username>' }
-
-    let(:example_template) do
-      example = <<-EXAMPLE
-        Given the login page
-        When  the username is "<username>"
-        And   the password is "<password>"
-        And   login is clicked
-      EXAMPLE
-    end
-
-    subject { SequencePhrase.new(example_phrase, example_template, true) }
-
-    context 'sequence phrase generation' do
-      it 'should be created with a phrase, steps and a data table indicator' do
-        expect { SequencePhrase.new(example_phrase, example_template, true) }.not_to raise_error
-      end
-
-      it 'should indicate that a step argument can never be assigned a value via the phrase' do
-        msg = "The step parameter 'password' does not appear in the phrase."
-        expect { SequencePhrase.new(example_phrase, example_template, false) }.to raise_error(Sequence::UnreachableStepParameter, msg)
-      end
-
-      it 'should indicate when an argument in the phrase never occurs in any steps' do
-        phrase = 'enter credentials as <tester>'
-        msg = "The phrase parameter 'tester' does not appear in any step."
-        expect { SequencePhrase.new(phrase, example_template, true) }.to raise_error(Sequence::UselessPhraseParameter, msg)
-      end
-
-      it 'should have a sequence key' do
-        expect(subject.key).to eq('enter_login_credentials_as_X_T')
-      end
-
-      it 'should establish the placeholders from the sequence phrase' do
-        expect(subject.phrase_params).to eq(%w[username])
-      end
-
-      it 'should know the placeholders from the phrase and generated template' do
-        expect(subject.values).to eq(%w[username password])
-      end
-    end
-    
-    context 'sequence phrase execution' do
-
-      let(:phrase_instance) { %Q|enter credentials as "jnyman"| }
-
-      it 'should generate the steps' do
-        text = subject.expand(phrase_instance, [ %w(password thx1138) ])
-        expectation = <<-EXAMPLE
-        Given the login page
-        When  the username is "jnyman"
-        And   the password is "thx1138"
-        And   login is clicked
-        EXAMPLE
-
-        expect(text).to eq(expectation)
-      end
-
-      it 'should generate steps even when a step argument has no value' do
-        text = subject.expand(phrase_instance, [ ])
-        expectation = <<-EXAMPLE
-        Given the login page
-        When  the username is "jnyman"
-        And   the password is ""
-        And   login is clicked
-        EXAMPLE
-
-        expect(text).to eq(expectation)
-      end
-
-      it 'should unescape any double-quotes for phrase arguments' do
-        specific_phrase = %q|enter credentials as "jnyman\""|
-        text = subject.expand(specific_phrase, [ %w(password thx1138) ])
-        expectation = <<-EXAMPLE
-        Given the login page
-        When  the username is "jnyman""
-        And   the password is "thx1138"
-        And   login is clicked
-        EXAMPLE
-
-        expect(text).to eq(expectation)
-      end
-
-      it 'should indicate when an unknown variable is used' do
-        error_message = "Unknown sequence step parameter 'unknown'."
-        args = [ %w(unknown anything) ]
-        expect { subject.expand(phrase_instance, args) }.to raise_error(UnknownParameterError, error_message)
-      end
-
-      it 'should indicate when an argument gets a value from a phrase and a table' do
-        phrase = %Q|enter credentials as "jnyman"|
-        msg = "The sequence parameter 'username' has value 'jnyman' and 'tester'."
-        args = [ %w(username tester), %w(password thx1138) ]
-        expect { subject.expand(phrase, args) }.to raise_error(AmbiguousParameterValue, msg)
-      end
-
-      it 'should expand any built-in variables' do
-        phrase = 'do nothing useful'
-        quoted_steps = <<-EXAMPLE
-        Given the following films:
-        <quotes>
-        Iron Man 3
-        World War Z
-        <quotes>
-        EXAMPLE
-
-        instance = SequencePhrase.new(phrase, quoted_steps, true)
-        actual = instance.expand(phrase, [])
-        expected = quoted_steps.gsub(/<quotes>/, '"""')
-        expect(actual).to eq(expected)
-      end
-    end
-    
-  end
-  
-end

data/spec/lucid/sequences/sequence_placeholder_spec.rb

@@ -1,56 +0,0 @@
-require_relative '../../spec_helper'
-require_relative '../../../lib/lucid/sequence/sequence_template'
-
-module Sequence
-  module SequenceTemplate
-    
-    describe Placeholder do
-      subject { Placeholder.new('testing') }
-
-      context 'establishing a placeholder' do
-        it 'should be created with a variable name' do
-          expect { Placeholder.new('testing') }.not_to raise_error
-        end
-
-        it 'should know the name of its variable' do
-          expect(subject.name).to eq('testing')
-        end
-      end
-      
-      context 'generating a placeholder' do
-        it 'should generate an empty string when an actual value is absent' do
-          generated_text = subject.output(Object.new, {})
-          expect(generated_text).to be_empty
-
-          generated_text = subject.output(Object.new, { 'testing' => nil })
-          expect(generated_text).to be_empty
-        end
-
-        it 'should generate an empty string when the context object value is absent' do
-          context = Object.new
-          def context.testing
-            nil
-          end
-          generated_text = subject.output(context, {})
-          expect(generated_text).to be_empty
-        end
-
-        it 'should render the actual value bound to the placeholder' do
-          generated_text = subject.output(Object.new, { 'testing' => 'test' })
-          expect(generated_text).to eq('test')
-        end
-
-        it 'should render the context object actual value bound to the placeholder' do
-          context = Object.new
-          def context.testing
-            'test'
-          end
-          generated_text = subject.output(context, {})
-          expect(generated_text).to eq('test')
-        end
-        
-      end
-    end
-    
-  end
-end

data/spec/lucid/sequences/sequence_section_spec.rb

@@ -1,61 +0,0 @@
-require_relative '../../spec_helper'
-require_relative '../../../lib/lucid/sequence/sequence_template'
-
-module Sequence
-  module SequenceTemplate
-    
-    describe Section do
-      subject { Section.new('testing') }
-
-      let(:example_child_elements) do
-        [ StaticText.new('Test '),
-          Placeholder.new('content'),
-          EOLine.new
-        ]
-      end
-
-      context 'establishing a section' do
-        it 'should be created with a variable name' do
-          expect { Section.new('testing') }.not_to raise_error
-        end
-
-        it 'should know the name of its variable' do
-          expect(subject.name).to eq('testing')
-        end
-
-        it 'should have no child elements by default' do
-          expect(subject).to have(0).children
-        end
-      end
-
-      context 'generating a section' do
-        it 'should add child elements' do
-          example_child_elements.each do |child|
-            subject.add_child(child)
-          end
-
-          expect(subject.children).to eq(example_child_elements)
-        end
-
-        it 'should know the names of all child placeholders' do
-          example_child_elements.each { |child| subject.add_child(child) }
-          expect(subject.variables).to eq([ 'content' ])
-          
-          parent = Section.new('added')
-          [ subject,
-            StaticText.new('Content '),
-            Placeholder.new('tested'),
-            EOLine.new
-          ].each { |child| parent.add_child(child) }
-          expect(parent.variables).to eq(%w(content tested))
-        end
-
-        it 'should expect that its subclasses generate the children elements' do
-          msg = 'Method Section.output must be implemented in subclass.'
-          expect { subject.send(:output, Object.new, {}) }.to raise_error(NotImplementedError, msg)
-        end
-      end
-    end
-    
-  end
-end

data/spec/lucid/sequences/sequence_support_spec.rb

@@ -1,65 +0,0 @@
-require_relative '../../spec_helper'
-require_relative '../../../lib/lucid/sequence/sequence_support'
-
-module Sequence
-  
-  class TestDomain
-    include Sequence::SequenceSupport
-    
-    attr_reader :seq_steps
-    
-    def steps(generated_steps)
-      @seq_steps ||= {}
-      @seq_steps << generated_steps
-    end
-  end
-  
-  describe SequenceSupport do
-    let(:domain) { TestDomain.new }
-    let(:phrase) { 'enter credentials' }
-
-    let(:example_steps) do
-      example = <<-EXAMPLE
-          Given the login page
-          When  the username is "<username>"
-          And   the password is "<password>"
-          And   login is clicked
-      EXAMPLE
-    end
-    
-    context 'defining a sequence' do
-      it 'should add a valid new sequence phrase and associated steps' do
-        expect { domain.add_sequence phrase, example_steps, true }.not_to raise_error
-      end
-
-      it 'should not add an existing sequence phrase' do
-        msg = "A sequence with phrase 'enter credentials' already exists."
-        expect { domain.add_sequence(phrase, example_steps, true) }.to raise_error(Sequence::DuplicateSequenceError, msg)
-      end
-
-      it 'should not allow a sequence to have steps with arguments and no way to use those arguments' do
-        phrase = 'fill in the credentials'
-        msg = "The step parameter 'username' does not appear in the phrase."
-        expect { domain.add_sequence(phrase, example_steps, false) }.to raise_error(Sequence::UnreachableStepParameter, msg)
-      end
-    end
-    
-    context 'invoking a sequence' do
-      it 'should not be able to invoke an unknown sequence phrase' do
-        phrase = 'fill in the credentials'
-        msg = "Unknown sequence step with phrase: 'fill in the credentials'."
-        expect { domain.invoke_sequence(phrase) }.to raise_error(Sequence::UnknownSequenceError, msg)
-      end
-    end
-    
-    context 'clearing sequences' do
-      it 'should clear all sequences from the sequence group' do
-        expect { domain.clear_sequences() }.not_to raise_error
-        expect(SequenceGroup.instance.sequence_steps).to be_empty
-      end
-            
-    end
-    
-  end
-  
-end

data/spec/lucid/sequences/sequence_template_spec.rb

@@ -1,298 +0,0 @@
-require_relative '../../spec_helper'
-require_relative '../../../lib/lucid/sequence/sequence_template'
-
-module Sequence
-  module SequenceTemplate
-    
-    describe Engine do
-
-      let(:example_template) do
-        example = <<-EXAMPLE
-          Given the login page
-          When  the username is "<user_name>"
-          And   the password is "<password>"
-          And   login is clicked
-        EXAMPLE
-      end
-      
-      let(:conditional_template) do
-        example = <<-EXAMPLE
-          When  the first name is "<first_name>"
-          And   the last name is "<last_name>"
-          <?age>
-          And   the age is "<age>"
-          </age>
-          <?ssn>
-          And   the ssn is "<ssn>"
-          </ssn>
-        EXAMPLE
-      end
-      
-      subject { Engine.new(example_template) }
-      
-      context 'parsing' do
-        def strip_chevrons(text)
-          text.gsub(/^<|>$/, '')
-        end
-        
-        it 'should parse an empty text line' do
-          expect(Engine.parse('')).to be_empty
-        end
-
-        it 'should parse a text line without a parameter' do
-          sample_text = 'a TDL statement'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(1).items
-          expect(result[0]).to eq([:static, sample_text])
-        end
-
-        it 'should parse a text line that consists of only a parameter' do
-          sample_text = '<some_parameter>'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(1).items
-          expect(result[0]).to eq([:dynamic, strip_chevrons(sample_text)])
-        end
-
-        it 'should parse a text line with a parameter at the start' do
-          sample_text = '<some_parameter> in a TDL statement'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(2).items
-          expect(result[0]).to eq([:dynamic, 'some_parameter'])
-          expect(result[1]).to eq([:static,  ' in a TDL statement'])
-        end
-
-        it 'should parse a text line with a parameter at the end' do
-          sample_text = 'a TDL statement with <some_parameter>'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(2).items
-          expect(result[0]).to eq([:static,  'a TDL statement with '])
-          expect(result[1]).to eq([:dynamic, 'some_parameter'])
-        end
-
-        it 'should parse a text line with a parameter in the middle' do
-          sample_text = 'a TDL statement with <some_parameter> in it'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(3).items
-          expect(result[0]).to eq([:static,  'a TDL statement with '])
-          expect(result[1]).to eq([:dynamic, 'some_parameter'])
-          expect(result[2]).to eq([:static,  ' in it'])
-        end
-
-        it 'should parse a text line with two separated parameters' do
-          sample_text = 'TDL with <one_parameter> and with <another_parameter> in it'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(5).items
-          expect(result[0]).to eq([:static ,  'TDL with '])
-          expect(result[1]).to eq([:dynamic, 'one_parameter'])
-          expect(result[2]).to eq([:static , ' and with '])
-          expect(result[3]).to eq([:dynamic, 'another_parameter'])
-          expect(result[4]).to eq([:static,  ' in it'])
-        end
-
-        it 'should parse a text line with two consecutive parameters' do
-          sample_text = 'TDL with <one_parameter> <another_parameter> in it'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(5).items
-          expect(result[0]).to eq([:static,  'TDL with '])
-          expect(result[1]).to eq([:dynamic, 'one_parameter'])
-          expect(result[2]).to eq([:static,  ' '])
-          expect(result[3]).to eq([:dynamic, 'another_parameter'])
-          expect(result[4]).to eq([:static,  ' in it'])
-        end
-
-        it 'should parse a text line with escaped chevrons' do
-          sample_text = 'A TDL \<parameter\> is escaped'
-          result = Engine.parse(sample_text)
-          
-          expect(result).to have(1).items
-          expect(result[0]).to eq([:static, sample_text])
-        end
-
-        it 'should parse a text line with escaped chevrons in a parameter' do
-          sample_text = 'A TDL with <some_\<\\>escaped\>_parameter> in it'
-          result = Engine.parse(sample_text)
-
-          expect(result).to have(3).items
-          expect(result[0]).to eq([:static,  'A TDL with '])
-          expect(result[1]).to eq([:dynamic, 'some_\<\\>escaped\>_parameter'])
-          expect(result[2]).to eq([:static,  ' in it'])
-        end
-
-        it 'should indicate if a parameter has a missing closing chevron' do
-          sample_text = 'A TDL with <some_parameter that is malformed'
-          error_message = "Missing closing chevron '>'."
-          expect { Engine.parse(sample_text) }.to raise_error(StandardError, error_message)
-        end
-
-        it 'should indicate if a parameter has a missing opening chevron' do
-          sample_text = 'A TDL with some_parameter> that is malformed'
-          error_message = "Missing opening chevron '<'."
-          expect { Engine.parse(sample_text) }.to raise_error(StandardError, error_message)
-        end
-
-        it 'should indicate if a text has nested opening chevrons' do
-          sample_text = 'A TDL with <<some_parameter> > that is nested'
-          error_message = "Nested opening chevron '<'."
-          expect { Engine.parse(sample_text) }.to raise_error(StandardError, error_message)
-        end
-      end
-      
-      context 'creation of source template' do
-        it 'should accept an empty template text' do
-          expect { Engine.new '' }.not_to raise_error
-        end
-
-        it 'should be created with a template text' do
-          expect { Engine.new example_template }.not_to raise_error
-        end
-
-        it 'should know the source text' do
-          expect(subject.source).to eq(example_template)
-          instance = Engine.new ''
-          expect(instance.source).to be_empty
-        end
-
-        it 'should indicate when a placeholder is empty or blank' do
-          text = example_template.sub(/user_name/, '')
-          msg = %q(An empty or blank parameter occurred in 'When  the username is "<>"'.)
-          expect { Engine.new(text) }.to raise_error(Sequence::EmptyParameterError, msg)
-        end
-
-        it 'should indicate when a placeholder contains an invalid character' do
-          text = example_template.sub(/user_name/, 'user%name')
-          msg = "The invalid element '%' occurs in the parameter 'user%name'."
-          expect { Engine.new(text)}.to raise_error(Sequence::InvalidElementError, msg)
-        end
-
-        it 'should accept conditional sections' do
-          expect { Engine.new(conditional_template) }.not_to raise_error
-          instance = Engine.new(conditional_template)
-          elements = instance.instance_variable_get(:@generated_source)
-          sections = elements.select { |e| e.is_a?(Section) }
-          names = sections.map { |e| e.to_s }
-          expect(names).to eq(%w(<?age> <?ssn>))
-        end
-
-        it 'should indicate when a section has no closing tag' do
-          text = conditional_template.sub(/<\/age>/, '')
-          msg = 'Unterminated section <?age>.'
-          expect { Engine.new(text) }.to raise_error(StandardError, msg)
-        end
-
-        it 'should indicate when a closing tag has no corresponding opening tag' do
-          text = conditional_template.sub(/<\/age>/, '</test>')
-          msg = "End of section </test> does not match current section 'age'."
-          expect { Engine.new(text) }.to raise_error(StandardError, msg)
-        end
-
-        it 'should indicate when a closing tag is found without opening tag' do
-          text = conditional_template.sub(/<\?ssn>/, '</test>')
-          msg = "End of section </test> found while no corresponding section is open."
-          expect { Engine.new(text) }.to raise_error(StandardError, msg)
-        end
-      end
-      
-      context 'rendering a template' do
-        it 'should know the parameters it contains' do
-          expect(subject.variables).to be == ['user_name', 'password']
-          instance = Engine.new ''
-          expect(instance.variables).to be_empty
-        end
-
-        it 'should generate the text with the actual values for parameters' do
-          locals = { 'user_name' => 'jnyman' }
-          generated_text = subject.output(Object.new, locals)
-          expected = <<-RESULT
-          Given the login page
-          When  the username is "jnyman"
-          And   the password is ""
-          And   login is clicked
-          RESULT
-
-          expect(generated_text).to eq(expected)
-        end
-
-        it 'should generate the text with the actual non-string values for parameters' do
-          locals = { 'user_name' => 'jnyman', 'password' => 12345 }
-          generated_text = subject.output(Object.new, locals)
-
-          expected = <<-RESULT
-          Given the login page
-          When  the username is "jnyman"
-          And   the password is "12345"
-          And   login is clicked
-          RESULT
-
-          expect(generated_text).to eq(expected)
-        end
-
-        it 'should generate the text with the actual values in context' do
-          ContextObject = Struct.new(:user_name, :password)
-          context = ContextObject.new('superb', 'tester')
-          generated_text = subject.output(context, { 'user_name' => 'jnyman' })
-
-          expected = <<-RESULT
-          Given the login page
-          When  the username is "jnyman"
-          And   the password is "tester"
-          And   login is clicked
-          RESULT
-
-          expect(generated_text).to eq(expected)
-        end
-        
-        it 'should handle an empty source template' do
-          instance = Engine.new('')
-          expect(instance.output(nil, {})).to be_empty
-        end
-
-        it 'should generate conditional sections' do
-          instance = Engine.new(conditional_template)
-          locals = { 'first_name' => 'Jeff',
-                     'last_name' => 'Nyman' ,
-                     'age' => '41'
-          }
-          generated_text = instance.output(Object.new, locals)
-          expected = <<-RESULT
-          When  the first name is "Jeff"
-          And   the last name is "Nyman"
-          And   the age is "41"
-          RESULT
-          expect(generated_text).to eq(expected)
-          
-          locals['age'] = nil
-          locals['ssn'] = '000-00-0000'
-          generated_text = instance.output(Object.new, locals)
-
-          expected = <<-RESULT
-          When  the first name is "Jeff"
-          And   the last name is "Nyman"
-          And   the ssn is "000-00-0000"
-          RESULT
-          expect(generated_text).to eq(expected)
-        end
-
-        it 'should generate multi-valued actual text from parameters' do
-          locals = { 'user_name' => %w(jnyman tester) }
-          generated_text = subject.output(Object.new, locals)
-          expected = <<-RESULT
-          Given the login page
-          When  the username is "jnyman<br/>tester"
-          And   the password is ""
-          And   login is clicked
-          RESULT
-          expect(generated_text).to eq(expected)
-        end
-      end
-      
-    end
-    
-  end
-end