yari 0.0.2

data/lib/yari/version.rb

@@ -0,0 +1,3 @@
+module Yari
+  VERSION = "0.0.2"
+end

data/lib/yari/yari_dsl.rb

@@ -0,0 +1,125 @@
+class << self
+  def feature(name = nil, new_metadata = {}, &block)
+    raise ArgumentError.new("requires a name") if name.nil?
+
+    new_metadata = ::RSpec.configuration.feature_metadata.merge(new_metadata)
+    matching_feature = find_feature(name)
+    new_metadata[:feature_name]= name
+
+    if matching_feature
+      if matching_feature.tags.include?('@updated')
+        pending_feature(name, new_metadata, block.source_location,
+                        "Feature has been marked as updated\n \t# Update specs for this feature and remove the @updated tag\n \t# Feature file: '#{feature_path(block.source_location)}"
+        )
+      else
+        describe("Feature: #{name}", new_metadata.merge(:current_feature => matching_feature), &block)
+      end
+    else
+      pending_feature(name, new_metadata, block.source_location, "No such feature in '#{feature_path(block.source_location)}'")
+    end
+  end
+
+  private
+
+  def find_feature(name)
+    Yari.features.find do |feature|
+      feature.name == name
+    end
+  end
+
+  def feature_path(spec_location)
+    Yari.spec_to_feature(spec_location.first, false)
+  end
+
+  def pending_feature(name, new_metadata, spec_location, reason)
+    describe "Feature: #{name}", new_metadata do
+      it do |example|
+        example.metadata.merge!(
+            file_path: spec_location[0],
+            location: "#{spec_location[0]}:#{spec_location[1]}"
+        )
+        skip reason
+      end
+    end
+  end
+end
+
+module Yari
+  module DSL
+    module Rspec
+      def background(&block)
+        before(:each, &block)
+      end
+
+      def scenario(name = nil, new_metadata = {}, &block)
+        raise ArgumentError.new("requires a name") if name.nil?
+
+        matching_scenario = find_scenario(self.metadata[:current_feature], name)
+        new_metadata[:scenario_name]= name
+
+        if matching_scenario
+          if matching_scenario.tags.include?('@updated')
+            pending_scenario(name, new_metadata, block.source_location,
+                             "Scenario has been marked as updated\n \t# Update specs for this scenario and remove the @updated tag\n \t# Feature file: '#{feature_path(block.source_location)}'"
+            )
+          # elsif matching_scenario.arguments
+          #   specify "Scenario: #{name}", new_metadata do
+          #     instance_exec(*matching_scenario.arguments, &block)
+          #   end
+          else
+            specify("Scenario: #{name}", new_metadata, &block)
+          end
+        else
+          pending_scenario(name, new_metadata, block.source_location, "No such scenario in '#{feature_path(block.source_location)}'")
+        end
+      end
+
+
+      def scenario_with_test_cases(name = nil, new_metadata = {}, &block)
+        raise ArgumentError.new("requires a name") if name.nil?
+
+        matching_scenario = find_scenario(self.metadata[:current_feature], name)
+
+        if matching_scenario
+          if matching_scenario.tags.include?('@updated')
+            pending_scenario(name, new_metadata, block.source_location,
+                             "Scenario has been marked as updated\n \t# Update specs for this scenario and remove the @updated tag\n \t# Feature file: '#{feature_path(block.source_location)}'"
+            )
+          else
+            describe("Scenario: #{name}", new_metadata.merge(:scenario_name => name), &block)
+          end
+        else
+          pending_scenario(name, new_metadata, block.source_location, "No such scenario in '#{feature_path(block.source_location)}'")
+        end
+      end
+
+      def test_case(name = nil, new_metadata = {}, &block)
+        raise ArgumentError.new("requires a name") if name.nil?
+        new_metadata[:test_case_name]= name
+        specify("Test_Case: #{name}", new_metadata, &block)
+      end
+
+      private
+
+      def find_scenario(feature, name)
+        feature.scenarios.find do |scenario|
+          scenario.name == name
+        end
+      end
+
+      def feature_path(spec_location)
+        Yari.spec_to_feature(spec_location.first, false)
+      end
+
+      def pending_scenario(name, new_metadata, spec_location, reason)
+        specify name, new_metadata do |example|
+          example.metadata.merge!(
+              full_description: "Scenario: #{name}",
+              location: "#{spec_location[0]}:#{spec_location[1]}"
+          )
+          skip reason
+        end
+      end
+    end
+  end
+end

data/lib/yari/yari_loader.rb

@@ -0,0 +1,52 @@
+require 'yari'
+require 'rspec'
+
+module Yari
+  module RSpec
+    module Loader
+      def load(*paths, &block)
+
+        # Override feature exclusion filter if running features
+        if paths.any? { |path| Yari.feature?(path) }
+          ::RSpec.configuration.filter_manager.exclusions.rules.reject! do |key, value|
+            key == :feature || (key == :type && value == 'feature')
+          end
+        end
+
+        paths = paths.map do |path|
+          if Yari.feature?(path)
+            spec_path = Yari.feature_to_spec(path)
+            if File.exist?(spec_path)
+              spec_path
+            else
+              Yari::Builder.build(path).features.each do |feature|
+                ::RSpec.describe("Feature: #{feature.name}", :type => :feature, :feature => true) do
+                  it do |example|
+                    example.metadata[:location] = path << ':1'
+                    skip('No spec implemented for feature')
+                  end
+                end
+              end
+              nil
+            end
+          else
+            path
+          end
+        end.compact
+
+        # Load needed features to Yari.features array
+        paths.each do |path|
+          if Yari.feature_spec?(path)
+            feature_path = Yari.spec_to_feature(path)
+
+            if File.exists?(feature_path)
+              Yari.features += Yari::Builder.build(feature_path).features
+            end
+          end
+        end
+
+        super(*paths, &block) if paths.size > 0
+      end
+    end
+  end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Yari::Builder do
+
+  context 'a simple feature' do
+    let(:feature_file) { File.expand_path('../features/simple_feature.feature', File.dirname(__FILE__)) }
+    let(:builder) { Yari::Builder.build(feature_file) }
+    let(:feature) { builder.features.first }
+
+    it 'parses the feature' do
+      expect(feature).to be_a_kind_of(Yari::Feature)
+      expect(feature.name).to eq('A simple feature')
+    end
+
+    it 'gets all the scenarios in the feature' do
+      expect(feature.scenarios.count).to eq(4)
+      expect(feature.scenarios.first).to be_a_kind_of(Yari::Scenario)
+      expect(feature.scenarios.first.name).to eq('A simple scenario')
+    end
+
+    it 'gets tags associated with the feature' do
+      expect(feature.tags).to eq(['@feature_tag'])
+    end
+
+    it 'gets tags associated with the scenario' do
+      expect(feature.scenarios.first.tags).to eq(['@scenario_tag'])
+    end
+  end
+
+  context 'with scenario outlines' do
+    let(:feature_file) { File.expand_path('../features/scenario_outline.feature', File.dirname(__FILE__)) }
+    let(:builder) { Yari::Builder.build(feature_file) }
+    let(:feature) { builder.features.first }
+
+
+    it 'extracts scenario' do
+      expect(feature.scenarios.map(&:name)).to eq(['a simple outline'])
+      expect(feature.scenarios.first.type).to eq(:ScenarioOutline)
+    end
+
+    it 'extracts examples from an outline' do
+      expect(feature.scenarios.first.examples).to eq(Yari::Example)
+    end
+  end
+end

data/spec/features/no_feature_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+feature 'Missing feature' do
+  scenario 'This should never be executed' do
+    raise 'Scenario in spec with missing feature should not be executed'
+  end
+end

data/spec/features/no_scenario_spec.rb

@@ -0,0 +1,5 @@
+feature 'Missing scenario' do
+  scenario 'Non-existing scenario' do
+    expect(1).to eq(1)
+  end
+end

data/spec/features/scenario_outline_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+feature 'using scenario outlines' do
+  scenario 'a simple outline' do |hp, damage, state, happy|
+    expect(hp).to be_a(Float)
+    expect(damage).to be_a(Fixnum)
+    expect(state).to be_a(String)
+    expect([true, false]).to include happy
+  end
+end

data/spec/features/simple_feature_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+feature 'A simple feature' do
+  # ensure background is executed as before(:each)
+  background do
+    @number ||= 41
+    @number += 1 
+  end
+
+  scenario 'A simple scenario' do
+    expect(@number).to eq(42)
+  end
+
+  scenario 'Raising error' do
+    raise ArgumentError.new("Your argument is invalid!")
+  end
+
+  scenario 'Different metadata type', :type => :controller, :feature => false do
+    expect(RSpec.current_example.metadata[:type]).to eq(:controller)
+    expect(RSpec.current_example.metadata[:feature]).to eq(false)
+  end
+
+  scenario 'Custom metadata tag', :custom => "foobar" do
+    expect(RSpec.current_example.metadata[:custom]).to eq("foobar")
+  end
+end

data/spec/features/test_cases_spec.rb

@@ -0,0 +1,13 @@
+feature 'A feature with test cases' do
+
+  scenario_with_test_cases 'A scenario requiring multiple cases to prove' do
+    test_case 'a passing test case' do
+      fail('the first test case failed')
+    end
+
+    test_case 'a failing test case' do
+      fail('the second test case also also failed')
+    end
+  end
+
+end

data/spec/features/updated_feature_spec.rb

@@ -0,0 +1,11 @@
+# This feature should be marked as pending
+# because it is tagged as @updated in gherkin
+feature 'Updated feature' do
+  scenario 'Attack a monster with cool tag' do
+    expect(1).to eq(1)
+  end
+
+  scenario 'Attack another monster' do
+    expect(1).to eq(1)
+  end
+end

data/spec/features/updated_scenario_spec.rb

@@ -0,0 +1,11 @@
+# This feature should be marked as pending
+# because it is tagged as @updated in gherkin
+feature 'Feature with updated scenario' do
+  scenario 'Updated scenario' do
+    expect(1).to eq(1)
+  end
+
+  scenario 'Attack another monster' do
+    expect(1).to eq(1)
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe 'The CLI', :type => :integration do
+  context 'running features from features directory' do
+
+    it 'ignores --tag ~feature flag when running features' do
+      expect(%x(rspec features --tag ~feature 2>&1)).to include('11 examples, 3 failures, 3 pending')
+    end
+
+    it 'ignores --tag ~type:feature flag when running features' do
+      expect(%x(rspec features --tag ~type:feature 2>&1)).to include('11 examples, 3 failures, 3 pending')
+    end
+  end
+
+  context 'running features specs on their own' do
+    before(:all) do
+      @result = %x(rspec --tag feature --format documentation 2>&1)
+    end
+
+    it 'passes all specs' do
+      expect(@result).to include('11 examples, 3 failures, 4 pending')
+    end
+
+    it 'prepends features with "Feature: " prefix' do
+      expect(@result).to include('Feature: A simple feature')
+    end
+
+    it 'prepends scenarios with "Scenario: " prefix' do
+      expect(@result).to include('Scenario: A simple scenario')
+    end
+
+    context 'non-existing scenario' do
+      it 'shows name of non-existing scenario' do
+        expect(@result).to include("Scenario: Non-existing scenario")
+      end
+
+      it 'shows that spec implements non-existing scenario' do
+        expect(@result).to include("No such scenario in 'features/no_scenario.feature'")
+      end
+
+      it 'shows line number where missing scenario is mentioned' do
+        expect(@result).to include("/spec/features/no_scenario_spec.rb:2")
+      end
+    end
+
+    context 'non-existing feature' do
+      it 'shows name of non-existing feature' do
+        expect(@result).to include("Feature: Missing feature")
+      end
+
+      it 'shows that spec implements non-existing feature' do
+        expect(@result).to include("No such feature in 'features/no_feature.feature'")
+      end
+
+      it 'shows line number where missing scenario is mentioned' do
+        expect(@result).to include("/spec/features/no_feature_spec.rb:3")
+      end
+    end
+
+    context 'updated features and scenarios' do
+      it 'recognizes and notifies when feature is marked as @updated' do
+        expect(@result).to include('Feature has been marked as updated')
+      end
+
+      it 'recognizes and notifies when scenario is marked as @updated' do
+        expect(@result).to include('Scenario has been marked as updated')
+      end
+    end
+  end
+
+  # it "shows the correct description" do
+  #   @result.should include('A simple feature')
+  #   @result.should include('is a simple feature')
+  # end
+
+  # it "prints out failures and successes" do
+  #   @result.should include('35 examples, 3 failures, 5 pending')
+  # end
+
+  # it "includes features in backtraces" do
+  #   @result.should include('examples/errors.feature:5:in `raise error')
+  # end
+
+  # it "includes the right step name when steps call steps" do
+  #   @result.should include("No such step: 'this is an unimplemented step'")
+  # end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'coveralls'
+Coveralls.wear!
+require 'yari'

data/spec/yari_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Yari do
+  let(:feature_path) { '/project/features/awesome-def_file.feature' }
+  let(:spec_path) { '/project/spec/features/awesome-def_file_spec.rb' }
+
+  let(:short_feature_path) { 'features/awesome-def_file.feature' }
+  let(:short_spec_path) { 'spec/features/awesome-def_file_spec.rb' }
+
+  context '#feature?' do
+    it 'recognizes if path is feature path' do
+      expect(Yari.feature?(feature_path)).to eq(true)
+    end
+
+    it 'recognizes if path is not feature path' do
+      expect(Yari.feature?(spec_path)).to eq(false)
+    end
+  end
+
+  context '#feature_spec?' do
+    it 'recognizes if path is spec path' do
+      expect(Yari.feature_spec?(spec_path)).to eq(true)
+    end
+
+    it 'recognizes if path is not spec path' do
+      expect(Yari.feature_spec?(feature_path)).to eq(false)
+    end
+  end
+
+  context '#feature_to_spec' do
+    it 'properly translates feature file to spec file' do
+      expect(Yari.feature_to_spec(feature_path)).to eq(spec_path)
+    end
+
+    it 'excludes prefix when requested' do
+      expect(Yari.feature_to_spec(feature_path, false)).
+        to eq(short_spec_path)
+    end
+  end
+
+  context '#spec_to_feature' do
+    it 'properly translates spec file to feature file' do
+      expect(Yari.spec_to_feature(spec_path)).
+        to eq(feature_path)
+    end
+
+    it 'excludes prefix when requested' do
+      expect(Yari.spec_to_feature(spec_path, false)).
+        to eq(short_feature_path)
+    end
+  end
+
+  specify '#spec_to_feature and #feature_to_spec should be independent' do
+    p1 = Yari.feature_to_spec(Yari.spec_to_feature(spec_path))
+    p2 = Yari.feature_to_spec(feature_path)
+    expect(p1).to eq(p2)
+  end
+end