lucid 0.1.1 → 0.2.0

data/lib/lucid/spec_file.rb

@@ -73,7 +73,9 @@ module Lucid
           if @path == "specs"
             STDOUT.puts ["\nYou don't have a 'specs' directory. This is the default specification",
                          "directory that Lucid will use if one is not specified. So either create",
-                         "that directory or specify where your test repository is located."].join("\n")
+                         "that directory or specify where your test repository is located.\n\n"].join("\n")
+            #e.message << "."
+            raise e
           else
             STDOUT.puts ["\nThere is no '#{@path}' directory. Since that is what you specified as",
                          "your spec repository, this directory must be present."].join("\n")

data/lib/lucid/step_match.rb

@@ -12,7 +12,7 @@ module Lucid
     end
 
     def args
-      @step_arguments.map{|g| g.val}
+      @step_arguments.map{|g| g.val.freeze}
     end
 
     def name

data/lib/lucid/wire_support/wire_packet.rb

@@ -23,7 +23,7 @@ module Lucid
       def to_json
         packet = [@message]
         packet << @params if @params
-        packet.to_json
+        MultiJson.dump(packet)
       end
 
       def handle_with(handler)

data/lucid.gemspec

@@ -8,22 +8,24 @@ Gem::Specification.new do |gem|
   gem.name        = 'lucid'
   gem.version     = Lucid::VERSION
   gem.authors     = ["Jeff Nyman"]
-  gem.description = "Test Description Language Execution Engine"
+  gem.description = 'Test Description Language Execution Engine'
   gem.summary     = "lucid-#{gem.version}"
-  gem.email       = ["jeffnyman@gmail.com"]
-  gem.license     = "MIT"
-  gem.homepage    = "https://github.com/jnyman/lucid"
+  gem.email       = ['jeffnyman@gmail.com']
+  gem.license     = 'MIT'
+  gem.homepage    = 'https://github.com/jnyman/lucid'
   gem.platform    = Gem::Platform::RUBY
   
-  gem.required_ruby_version = ">= 1.9.3"
-  gem.rubygems_version      = ">= 1.6.1"
+  gem.required_ruby_version = '>= 1.9.3'
+  gem.rubygems_version      = '>= 1.6.1'
 
-  gem.add_runtime_dependency 'rake', '>= 10.0.4'
   gem.add_runtime_dependency 'thor', '>= 0.18.1'
   gem.add_runtime_dependency 'builder', '>= 2.1.2'
   gem.add_runtime_dependency 'diff-lcs', '>= 1.1.3'
-  gem.add_runtime_dependency 'gherkin', '~> 2.12.0'
-  gem.add_runtime_dependency 'multi_json', '~> 1.7.5'
+  gem.add_runtime_dependency 'gherkin', '>= 2.12.0'
+  gem.add_runtime_dependency 'multi_json', '>= 1.8.0', '< 2.0'
+  
+  gem.add_development_dependency 'rspec', '>= 2.14'
+  gem.add_development_dependency 'simplecov', '>= 0.7.1'
 
   gem.post_install_message = %{
 (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)

data/spec/lucid/app_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../spec_helper'
+
+module Lucid
+  module CLI
+    describe App do
+      
+      let(:args)   { [] }
+      let(:stdin)  { StringIO.new }
+      let(:stdout) { StringIO.new }
+      let(:stderr) { StringIO.new }
+      let(:kernel) { double(:kernel) }
+      subject { App.new(args, stdin, stdout, stderr, kernel) }
+      
+      describe "start" do
+        context "passed a runtime" do
+          let(:runtime) { double('runtime').as_null_object }
+          
+          def do_start
+            subject.start(runtime)
+          end
+          
+          it "configures the runtime" do
+            configuration = double('Configuration').as_null_object
+            Configuration.stub(:new => configuration)
+            runtime.should_receive(:configure).with(configuration)
+            kernel.should_receive(:exit).with(1)
+            do_start
+          end
+          
+          it "uses that runtime for running and reporting results" do
+            results = double('results', :failure? => true)
+            runtime.should_receive(:run)
+            runtime.stub(:results).and_return(results)
+            kernel.should_receive(:exit).with(1)
+            do_start
+          end
+        end
+      end
+      
+    end
+  end
+end

data/spec/lucid/configuration_spec.rb

@@ -0,0 +1,112 @@
+require_relative '../spec_helper'
+
+module Lucid
+  module CLI
+    describe Configuration do
+      
+      module ExposeOptions
+        attr_reader :options
+      end
+      
+      def config
+        @config ||= Configuration.new(@out = StringIO.new, @error = StringIO.new).extend(ExposeOptions)
+      end
+      
+      def with_these_files(*files)
+        File.stub(:directory?).and_return(true)
+        File.stub(:file?).and_return(true)
+        Dir.stub(:[]).and_return(files)
+      end
+      
+      def with_this_configuration_file(info)
+        File.stub(:exist?).and_return(true)
+        profile_file = info.is_a?(Hash) ? info.to_yaml : info
+        IO.stub(:read).with('lucid.yml').and_return(profile_file)
+      end
+      
+      it 'should require driver.rb files first' do
+        with_these_files('/common/support/browser.rb', '/common/support/driver.rb')
+        config.parse(%w{--require /common})
+        
+        config.library_context.should == %w(
+            /common/support/driver.rb
+            /common/support/browser.rb
+        )
+      end
+      
+      it 'should not require driver.rb files when a dry run is attempted' do
+        with_these_files('/common/support/browser.rb', '/common/support/driver.rb')
+        config.parse(%w{--require /common --dry-run})
+
+        config.library_context.should == %w(
+          /common/support/browser.rb
+        )
+      end
+      
+      it 'should require files in default definition locations' do
+        with_these_files('/pages/page.rb', '/steps/steps.rb')
+        config.parse(%w{--require /specs})
+        
+        config.definition_context.should == %w(
+          /pages/page.rb
+          /steps/steps.rb
+        )
+      end
+      
+      it 'should be able to exclude files based on a specific reference' do
+        with_these_files('/common/support/browser.rb', '/common/support/driver.rb')
+        config.parse(%w{--require /common --exclude browser.rb})
+        
+        config.spec_requires.should == %w(
+          /common/support/driver.rb
+        )
+      end
+      
+      it 'should be able to exclude files based on a general pattern' do
+        with_these_files('/steps/tester.rb', '/steps/tested.rb', '/steps/testing.rb', '/steps/quality.rb')
+        config.parse(%w{--require /steps --exclude test(er|ed) --exclude quality})
+
+        config.spec_requires.should == %w(
+          /steps/testing.rb
+        )
+      end
+      
+      it 'should be able to use a --dry-run option' do
+        config.parse(%w{--dry-run})
+        config.options[:dry_run].should be_true
+      end
+      
+      it 'should be able to use a --no-source option' do
+        config.parse(%w{--no-source})
+        config.options[:source].should be_false
+      end
+      
+      it 'should be able to use a --no-matchers option' do
+        config.parse(%w{--no-matchers})
+        config.options[:matchers].should be_false
+      end
+      
+      it 'should be able to use a --quiet option' do
+        config.parse(%w{--quiet})
+        config.options[:source].should be_false
+        config.options[:matchers].should be_false
+      end
+      
+      it 'should be able to use a --verbose option' do
+        config.parse(%w{--verbose})
+        config.options[:verbose].should be_true
+      end
+
+      it 'should be able to use an --out option' do
+        config.parse(%w{--out report.txt})
+        config.formats.should == [%w(standard report.txt)]
+      end
+
+      it 'should be able to use multiple --out options' do
+        config.parse(%w{--format standard --out report1.txt --out report2.txt})
+        config.formats.should == [%w(standard report2.txt)]
+      end
+      
+    end
+  end
+end

data/spec/lucid/sequences/sequence_conditional_spec.rb

@@ -0,0 +1,74 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/lucid/sequence/sequence_template'
+
+module Sequence
+  module SequenceTemplate
+
+    describe ConditionalSection do
+
+      context 'establishing a conditional section' do
+        it 'should be created with a variable name and a boolean' do
+          expect { ConditionalSection.new('testing', false) }.not_to raise_error
+          expect { ConditionalSection.new('testing', true) }.not_to raise_error
+        end
+
+        it 'should know whether to generated based on the existence of an actual value' do
+          [false, true].each do |existence|
+            instance = ConditionalSection.new('testing', existence)
+            expect(instance.existence).to eq(existence)
+          end
+        end
+      end
+      
+      context 'generating a conditional section' do
+        let(:example_child_elements) do
+          [ StaticText.new('Test '),
+            Placeholder.new('content'),
+            EOLine.new
+          ]
+        end
+
+        subject { ConditionalSection.new('testing', true) }
+
+        it 'should know its original source text' do
+          expect(subject.to_s).to eq('<?testing>')
+        end
+
+        it 'should generate the children when conditions are met' do
+          example_child_elements.each { |child| subject.add_child(child) }
+
+          locals = { 'content' => 'found', 'testing' => 'exists' }
+          generated_text = subject.output(Object.new, locals)
+          expected_text = "Test found\n"
+          expect(generated_text).to eq(expected_text)
+        end
+        
+        it 'should generate the children even when value does not exist' do
+          instance = ConditionalSection.new('testing', false)
+          example_child_elements.each { |child| instance.add_child(child) }
+          locals = { 'content' => 'found' }
+          generated_text = instance.output(Object.new, locals)
+          expected_text = "Test found\n"
+          expect(generated_text).to eq(expected_text)
+        end
+
+        it "should generate nothing when conditions are not met" do
+          example_child_elements.each { |child| subject.add_child(child) }
+
+          locals = { 'content' => 'found' }
+          generated_text = subject.output(Object.new, locals)
+          expect(generated_text).to eq('')
+
+          instance = ConditionalSection.new('testing', false)
+          example_child_elements.each { |child| instance.add_child(child) }
+
+          locals = { 'content' => 'found', 'testing' => 'exists' }
+          generated_text = instance.output(Object.new, locals)
+          expect(generated_text).to eq('')
+        end
+      end
+      
+    end
+    
+  end
+end

data/spec/lucid/sequences/sequence_group_spec.rb

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,122 @@
+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