lucid 0.4.1 → 0.5.1

data/spec/lucid/pending_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'lucid/interface_rb/rb_language'
-
-module Lucid
-  describe 'Pending' do
-    before(:each) do
-      l = InterfaceRb::RbLanguage.new(ContextLoader.new)
-      l.begin_rb_scenario(double('scenario').as_null_object)
-      @domain= l.current_domain
-    end
-
-    it 'should raise a Pending if no block is supplied' do
-      lambda {
-        @domain.pending 'TODO'
-      }.should raise_error(Lucid::Pending, /TODO/)
-    end
-
-    it 'should raise a Pending if a supplied block fails as expected' do
-      lambda {
-        @domain.pending 'TODO' do
-          raise 'that is a problem'
-        end
-      }.should raise_error(Lucid::Pending, /TODO/)
-    end
-
-    it 'should raise a Pending if a supplied block fails as expected with a double' do
-      lambda {
-        @domain.pending 'TODO' do
-          m = double('test')
-          m.should_receive(:testing)
-          RSpec::Mocks.verify
-        end
-      }.should raise_error(Lucid::Pending, /TODO/)
-    end
-
-    it 'should raise a Pending if a supplied block starts working' do
-      lambda {
-        @domain.pending 'TODO' do
-          # Nothing happens here.
-        end
-      }.should raise_error(Lucid::Pending, /TODO/)
-    end
-
-  end
-end

data/spec/lucid/progress_spec.rb

@@ -1,34 +0,0 @@
-require_relative '../spec_helper'
-require 'lucid/formatter/progress'
-
-module Lucid
-  module Formatter
-    describe Progress do
-
-      before(:each) do
-        Lucid::Term::ANSIColor.coloring = false
-        @out = StringIO.new
-        progress = Lucid::Formatter::Progress.new(double('Runtime'), @out, {})
-        @visitor = Lucid::AST::Walker.new(nil, [progress])
-      end
-
-      describe 'visiting a table cell value without a status' do
-        it 'should take the status from the last run step' do
-          step_result = AST::StepResult.new('', '', nil, :failed, nil, 10, nil, nil)
-          step_result.accept(@visitor)
-          @visitor.visit_outline_table(double) do
-            @visitor.visit_table_cell_value('value', nil)
-          end
-          @out.string.should == "FF"
-        end
-      end
-
-      describe 'visiting a table cell which is a table header' do
-        it 'should not output anything' do
-          @visitor.visit_table_cell_value('value', :skipped_param)
-          @out.string.should == ''
-        end
-      end
-    end
-  end
-end

data/spec/lucid/rb_step_definition_spec.rb

@@ -1,127 +0,0 @@
-require_relative '../spec_helper'
-
-module Lucid
-  module InterfaceRb
-    describe RbStepDefinition do
-      let(:interface) { double('interface') }
-      let(:orchestrator) { Lucid::ContextLoader::Orchestrator.new(interface) }
-      let(:rb) { orchestrator.load_code_language('rb') }
-      let(:dsl) do
-        rb
-        Object.new.extend(Lucid::InterfaceRb::RbLucid)
-      end
-
-      before do
-        rb.before(double('scenario').as_null_object)
-        $inside = nil
-      end
-
-      def run_step(text)
-        orchestrator.step_match(text).invoke(nil)
-      end
-
-      it 'should allow calling of other steps' do
-        dsl.Given /Outside/ do
-          step 'Inside'
-        end
-        dsl.Given /Inside/ do
-          $inside = true
-        end
-
-        run_step 'Outside'
-        $inside.should == true
-      end
-
-      it 'should allow calling of other steps with inline arg' do
-        dsl.Given /Outside/ do
-          step 'Inside', Lucid::AST::Table.new([['inside']])
-        end
-
-        dsl.Given /Inside/ do |table|
-          $inside = table.raw[0][0]
-        end
-
-        run_step 'Outside'
-        $inside.should == 'inside'
-      end
-
-      context 'mapping to domain methods' do
-        it 'should call a method on the domain when specified with a symbol' do
-          rb.current_domain.should_receive(:with_symbol)
-          dsl.Given /With symbol/, :with_symbol
-          run_step 'With symbol'
-        end
-
-        it 'should call a method on a specified object' do
-          target = double('target')
-          rb.current_domain.stub(:target => target)
-          dsl.Given /With symbol on block/, :with_symbol, :on => lambda { target }
-
-          target.should_receive(:with_symbol)
-          run_step 'With symbol on block'
-        end
-
-        it 'should call a method on a specified domain attribute' do
-          target = double('target')
-          rb.current_domain.stub(:target => target)
-          dsl.Given /With symbol on symbol/, :with_symbol, :on => :target
-
-          target.should_receive(:with_symbol)
-          run_step 'With symbol on symbol'
-        end
-      end
-
-      it 'should raise Undefined when inside step is not defined' do
-        dsl.Given /Outside/ do
-          step 'Inside'
-        end
-
-        lambda { run_step 'Outside' }.should raise_error(Lucid::Undefined, 'Undefined step: "Inside"')
-      end
-
-      it 'should allow forced pending' do
-        dsl.Given /Outside/ do
-          pending('This needs to be tested.')
-        end
-
-        lambda { run_step 'Outside' }.should raise_error(Lucid::Pending, 'This needs to be tested.')
-      end
-
-      it 'should allow puts' do
-        interface.should_receive(:puts).with('testing')
-        dsl.Given /Say Something/ do
-          puts 'testing'
-        end
-        run_step 'Say Something'
-      end
-
-      it 'should recognize $arg style captures' do
-        arg_value = 'testing'
-        dsl.Given 'capture this: $arg' do |arg|
-          arg.should == arg_value
-        end
-        run_step 'capture this: testing'
-      end
-
-      it 'should have a JSON representation of the signature' do
-        RbStepDefinition.new(rb, /There are (\d+) Lucid tests/i, lambda{}, {}).to_hash.should == {'source' => "There are (\\d+) Lucid tests", 'flags' => 'i'}
-      end
-
-      it 'should raise ArityMismatchError when the number of capture groups differs from the number of step arguments' do
-        dsl.Given /No group: \w+/ do |arg|
-        end
-
-        lambda { run_step 'No group: arg' }.should raise_error(Lucid::ArityMismatchError)
-      end
-
-      it 'should not allow modification of args since it messes up nice formatting' do
-        dsl.Given /Lucid tests are (.*)/ do |status|
-          status << 'good'
-        end
-
-        lambda { run_step 'Lucid tests are good' }.should raise_error(RuntimeError, /can't modify frozen String/i)
-      end
-
-    end
-  end
-end

data/spec/lucid/rb_transform_spec.rb

@@ -1,24 +0,0 @@
-require_relative '../spec_helper'
-
-module Lucid
-  module InterfaceRb
-    describe RbTransform do
-
-      def transform(regexp)
-        RbTransform.new(nil, regexp, lambda { |a| })
-      end
-      
-      it 'converts captures groups to non-capture groups' do
-        transform(/(a|b)bc/).to_s.should == '(?:a|b)bc'
-      end
-
-      it 'leaves non-capture groups alone' do
-        transform(/(?:a|b)bc/).to_s.should == '(?:a|b)bc'
-      end
-
-      it 'strips away line anchors' do
-        transform(/^xyz$/).to_s.should == 'xyz'
-      end
-    end
-  end
-end

data/spec/lucid/regexp_argument_matcher_spec.rb

@@ -1,19 +0,0 @@
-require_relative '../spec_helper'
-
-module Lucid
-  module InterfaceRb
-    describe RegexpArgumentMatcher do
-
-      it 'should create two arguments' do
-        arguments = RegexpArgumentMatcher.arguments_from(/Lucid (\w+) (\w+)/, 'Lucid works well')
-        arguments.map{|argument| [argument.val, argument.offset]}.should == [['works', 6], ['well', 12]]
-      end
-
-      it 'should create two arguments when first group is optional' do
-        arguments = RegexpArgumentMatcher.arguments_from(/should( not)? be shown '([^']*?)'$/, "should be shown 'Login failed.'")
-        arguments.map{|argument| [argument.val, argument.offset]}.should == [[nil, nil], ['Login failed.', 17]]
-      end
-      
-    end
-  end
-end

data/spec/lucid/results_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-module Lucid
-  describe ContextLoader::Results do
-    let(:configuration) {double 'Configuration', :strict? => false}
-    let(:passed_scenario) {double 'Scenario', :status => :passed}
-    let(:failed_scenario) {double 'Scenario', :status => :failed}
-    let(:passed_step) {double 'Step', :status => :passed}
-    let(:failed_step) {double 'Step', :status => :failed}
-    let(:pending_step) {double 'Step', :status => :pending}
-    let(:undefined_step) {double 'Step', :status => :undefined}
-
-    subject {described_class.new(configuration)}
-
-    describe '#failure?' do
-      context 'feature is not work in progress' do
-        before do
-          configuration.stub(:wip? => false)
-        end
-
-        it 'should return true if a scenario failed' do
-          subject.scenario_visited(passed_scenario)
-          subject.scenario_visited(failed_scenario)
-          subject.should be_failure
-        end
-
-        it 'should return true if a step failed' do
-          subject.step_visited(failed_step)
-          subject.should be_failure
-        end
-
-        it 'should return false if there are no scenarios' do
-          subject.should_not be_failure
-        end
-
-        it 'should return false if all scenarios passed' do
-          subject.scenario_visited(passed_scenario)
-          subject.scenario_visited(passed_scenario)
-          subject.should_not be_failure
-        end
-
-        context 'configuration is strict' do
-          before do
-            configuration.stub(:strict? => true)
-          end
-
-          it 'should return true if a step is pending' do
-            subject.step_visited(pending_step)
-            subject.should be_failure
-          end
-
-          it 'should return true if a step is undefined' do
-            subject.step_visited(undefined_step)
-            subject.should be_failure
-          end
-        end
-      end
-
-      context 'feature is work in progress' do
-        before do
-          configuration.stub(:wip? => true)
-        end
-
-        it 'should return true if a scenario passed' do
-          subject.scenario_visited(passed_scenario)
-          subject.should be_failure
-        end
-
-        it 'should return false if there are no scenarios' do
-          subject.should_not be_failure
-        end
-
-        it 'should return false if all scenarios fail' do
-          subject.scenario_visited(failed_scenario)
-          subject.should_not be_failure
-        end
-      end
-    end
-
-  end
-end

data/spec/lucid/runtime_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-module Lucid
-  describe ContextLoader do
-
-    let(:options) { {} }
-    subject { ContextLoader.new(options) }
-
-    describe '#specs_paths' do
-      let(:options) { {:paths => ['specs/area1/test.spec', 'specs/area1/area2/test.spec', 'others_specs'] } }
-
-      it 'returns the value from the configuration.spec_source' do
-        subject.specs_paths.should == options[:spec_source]
-      end
-    end
-
-    describe '#configure' do
-      let(:orchestrator) { double(ContextLoader::Orchestrator).as_null_object }
-      let(:results) { double(ContextLoader::Results).as_null_object }
-      let(:new_config) { double('New Configuration') }
-
-      before(:each) do
-        ContextLoader::Orchestrator.stub(:new => orchestrator)
-        ContextLoader::Results.stub(:new => results)
-      end
-
-      it 'tells the orchestrator and results about the new configuration' do
-        orchestrator.should_receive(:configure).with(new_config)
-        results.should_receive(:configure).with(new_config)
-        subject.configure(new_config)
-      end
-
-      it '#doc_string' do
-        subject.doc_string('Testing').should == 'Testing'
-      end
-    end
-  end
-end

data/spec/lucid/sequences/sequence_conditional_spec.rb

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