nutshell-crm 0.0.1

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/hooks_filtering_spec.rb

@@ -0,0 +1,227 @@
+require "spec_helper"
+
+module RSpec::Core
+  describe "config block hook filtering" do
+    describe "unfiltered hooks" do
+      it "should be ran" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all) { filters << "before all in config"}
+          c.around(:each) {|example| filters << "around each in config"; example.run}
+          c.before(:each) { filters << "before each in config"}
+          c.after(:each) { filters << "after each in config"}
+          c.after(:all) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe
+        group.example("example") {}
+        group.run
+        filters.should eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+    end
+
+    describe "hooks with single filters" do
+
+      context "with no scope specified" do
+        it "should be ran around|before|after :each if the filter matches the example group's filter" do
+          filters = []
+          RSpec.configure do |c|
+            c.around(:match => true) {|example| filters << "around each in config"; example.run}
+            c.before(:match => true) { filters << "before each in config"}
+            c.after(:match => true)  { filters << "after each in config"}
+          end
+          group = ExampleGroup.describe(:match => true)
+          group.example("example") {}
+          group.run
+          filters.should eq([
+            "around each in config",
+            "before each in config",
+            "after each in config"
+          ])
+        end
+      end
+
+      it "should be ran if the filter matches the example group's filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :match => true) { filters << "before all in config"}
+          c.around(:each, :match => true) {|example| filters << "around each in config"; example.run}
+          c.before(:each, :match => true) { filters << "before each in config"}
+          c.after(:each,  :match => true) { filters << "after each in config"}
+          c.after(:all,   :match => true) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:match => true)
+        group.example("example") {}
+        group.run
+        filters.should eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+
+      it "runs before|after :all hooks on matching nested example groups" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all, :match => true) { filters << :before_all }
+          c.after(:all, :match => true)  { filters << :after_all }
+        end
+
+        example_1_filters = example_2_filters = nil
+
+        group = ExampleGroup.describe "group" do
+          it("example 1") { example_1_filters = filters.dup }
+          describe "subgroup", :match => true do
+            it("example 2") { example_2_filters = filters.dup }
+          end
+        end
+        group.run
+
+        example_1_filters.should be_empty
+        example_2_filters.should eq([:before_all])
+        filters.should eq([:before_all, :after_all])
+      end
+
+      it "runs before|after :all hooks only on the highest level group that matches the filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all, :match => true) { filters << :before_all }
+          c.after(:all, :match => true)  { filters << :after_all }
+        end
+
+        example_1_filters = example_2_filters = example_3_filters = nil
+
+        group = ExampleGroup.describe "group", :match => true do
+          it("example 1") { example_1_filters = filters.dup }
+          describe "subgroup", :match => true do
+            it("example 2") { example_2_filters = filters.dup }
+            describe "sub-subgroup", :match => true do
+              it("example 3") { example_3_filters = filters.dup }
+            end
+          end
+        end
+        group.run
+
+        example_1_filters.should eq([:before_all])
+        example_2_filters.should eq([:before_all])
+        example_3_filters.should eq([:before_all])
+
+        filters.should eq([:before_all, :after_all])
+      end
+
+      it "should not be ran if the filter doesn't match the example group's filter" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :match => false) { filters << "before all in config"}
+          c.around(:each, :match => false) {|example| filters << "around each in config"; example.run}
+          c.before(:each, :match => false) { filters << "before each in config"}
+          c.after(:each,  :match => false) { filters << "after each in config"}
+          c.after(:all,   :match => false) { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:match => true)
+        group.example("example") {}
+        group.run
+        filters.should eq([])
+      end
+
+      context "when the hook filters apply to individual examples instead of example groups" do
+        let(:each_filters) { [] }
+        let(:all_filters) { [] }
+
+        let(:group) do
+          md = example_metadata
+          ExampleGroup.describe do
+            it("example", md) { }
+          end
+        end
+
+        def filters
+          each_filters + all_filters
+        end
+
+        before(:each) do
+          af, ef = all_filters, each_filters
+
+          RSpec.configure do |c|
+            c.before(:all,  :foo => :bar) { af << "before all in config"}
+            c.around(:each, :foo => :bar) {|example| ef << "around each in config"; example.run}
+            c.before(:each, :foo => :bar) { ef << "before each in config"}
+            c.after(:each,  :foo => :bar) { ef << "after each in config"}
+            c.after(:all,   :foo => :bar) { af << "after all in config"}
+          end
+
+          group.run
+        end
+
+        describe 'an example with matching metadata' do
+          let(:example_metadata) { { :foo => :bar } }
+
+          it "runs the `:each` hooks" do
+            each_filters.should eq([
+              'around each in config',
+              'before each in config',
+              'after each in config'
+            ])
+          end
+
+          it "does not run the `:all` hooks" do
+            all_filters.should be_empty
+          end
+        end
+
+        describe 'an example without matching metadata' do
+          let(:example_metadata) { { :foo => :bazz } }
+
+          it "does not run any of the hooks" do
+            filters.should be_empty
+          end
+        end
+      end
+    end
+
+    describe "hooks with multiple filters" do
+      it "should be ran if all hook filters match the group's filters" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :one => 1)                         { filters << "before all in config"}
+          c.around(:each, :two => 2, :one => 1)              {|example| filters << "around each in config"; example.run}
+          c.before(:each, :one => 1, :two => 2)              { filters << "before each in config"}
+          c.after(:each,  :one => 1, :two => 2, :three => 3) { filters << "after each in config"}
+          c.after(:all,   :one => 1, :three => 3)            { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
+        group.example("example") {}
+        group.run
+        filters.should eq([
+          "before all in config",
+          "around each in config",
+          "before each in config",
+          "after each in config",
+          "after all in config"
+        ])
+      end
+
+      it "should not be ran if some hook filters don't match the group's filters" do
+        filters = []
+        RSpec.configure do |c|
+          c.before(:all,  :one => 1, :four => 4)                         { filters << "before all in config"}
+          c.around(:each, :two => 2, :four => 4)                         {|example| filters << "around each in config"; example.run}
+          c.before(:each, :one => 1, :two => 2, :four => 4)              { filters << "before each in config"}
+          c.after(:each,  :one => 1, :two => 2, :three => 3, :four => 4) { filters << "after each in config"}
+          c.after(:all,   :one => 1, :three => 3, :four => 4)            { filters << "after all in config"}
+        end
+        group = ExampleGroup.describe(:one => 1, :two => 2, :three => 3)
+        group.example("example") {}
+        group.run
+        filters.should eq([])
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/hooks_spec.rb

@@ -0,0 +1,143 @@
+require "spec_helper"
+
+module RSpec::Core
+  describe Hooks do
+    class HooksHost
+      include Hooks
+    end
+
+    [:before, :after, :around].each do |type|
+      [:each, :all].each do |scope|
+        next if type == :around && scope == :all
+
+        describe "##{type}(#{scope})" do
+          it_behaves_like "metadata hash builder" do
+            define_method :metadata_hash do |*args|
+              instance = HooksHost.new
+              args.unshift scope if scope
+              hooks = instance.send(type, *args) { }
+              hooks.first.options
+            end
+          end
+        end
+      end
+
+      [true, false].each do |config_value|
+        context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to #{config_value}" do
+          before(:each) do
+            Kernel.stub(:warn)
+            RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = config_value }
+          end
+
+          describe "##{type}(no scope)" do
+            let(:instance) { HooksHost.new }
+
+            it "defaults to :each scope if no arguments are given" do
+              hooks = instance.send(type) { }
+              hook = hooks.first
+              instance.hooks[type][:each].should include(hook)
+            end
+
+            it "defaults to :each scope if the only argument is a metadata hash" do
+              hooks = instance.send(type, :foo => :bar) { }
+              hook = hooks.first
+              instance.hooks[type][:each].should include(hook)
+            end
+
+            it "raises an error if only metadata symbols are given as arguments" do
+              expect { instance.send(type, :foo, :bar) { } }.to raise_error(ArgumentError)
+            end
+          end
+        end
+      end
+    end
+
+    [:before, :after].each do |type|
+      [:each, :all, :suite].each do |scope|
+        [true, false].each do |config_value|
+          context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to #{config_value}" do
+            before(:each) do
+              RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = config_value }
+            end
+
+            describe "##{type}(#{scope.inspect})" do
+              let(:instance) { HooksHost.new }
+              let!(:hook) do
+                hooks = instance.send(type, scope) { }
+                hooks.first
+              end
+
+              it "does not make #{scope.inspect} a metadata key" do
+                hook.options.should be_empty
+              end
+
+              it "is scoped to #{scope.inspect}" do
+                instance.hooks[type][scope].should include(hook)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    describe "#around" do
+      context "when not running the example within the around block" do
+        it "does not run the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            around do |example|
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          examples.should have(0).example
+        end
+      end
+
+      context "when running the example within the around block" do
+        it "runs the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            around do |example|
+              example.run
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          examples.should have(1).example
+        end
+      end
+
+      context "when running the example within a block passed to a method" do
+        it "runs the example" do
+          examples = []
+          group = ExampleGroup.describe do
+            def yielder
+              yield
+            end
+            around do |example|
+              yielder { example.run }
+            end
+            it "foo" do
+              examples << self
+            end
+          end
+          group.run
+          examples.should have(1).example
+        end
+      end
+
+      describe Hooks::Hook do
+        it "requires a block" do
+          lambda {
+            Hooks::BeforeHook.new :foo => :bar
+          }.should raise_error("no block given for before hook")
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/kernel_extensions_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "extensions" do
+  describe "debugger" do
+    it "is defined on Kernel" do
+      Kernel.should respond_to(:debugger)
+    end
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/let_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe "#let" do
+  let(:counter) do
+    Class.new do
+      def initialize
+        @count = 0
+      end
+      def count
+        @count += 1
+      end
+    end.new
+  end
+
+  let(:nil_value) do
+    @nil_value_count += 1
+    nil
+  end
+
+  it "generates an instance method" do
+    counter.count.should eq(1)
+  end
+
+  it "caches the value" do
+    counter.count.should eq(1)
+    counter.count.should eq(2)
+  end
+
+  it "caches a nil value" do
+    @nil_value_count = 0
+    nil_value
+    nil_value
+
+    @nil_value_count.should eq(1)
+  end
+end
+
+describe "#let!" do
+  let!(:creator) do
+    Class.new do
+      @count = 0
+      def self.count
+        @count += 1
+      end
+    end
+  end
+
+  it "evaluates the value non-lazily" do
+    lambda { creator.count }.should_not raise_error
+  end
+
+  it "does not interfere between tests" do
+    creator.count.should eq(1)
+  end
+end

data/vendor/bundle/gems/rspec-core-2.7.1/spec/rspec/core/metadata_spec.rb

@@ -0,0 +1,383 @@
+require 'spec_helper'
+
+module RSpec
+  module Core
+    describe Metadata do
+
+      describe "#process" do
+        Metadata::RESERVED_KEYS.each do |key|
+          it "prohibits :#{key} as a hash key" do
+            m = Metadata.new
+            expect do
+              m.process('group', key => {})
+            end.to raise_error(/:#{key} is not allowed/)
+          end
+        end
+
+        it "uses :caller if passed as part of the user metadata" do
+          m = Metadata.new
+          m.process('group', :caller => ['example_file:42'])
+          m[:example_group][:location].should eq("example_file:42")
+        end
+      end
+
+      describe "#filter_applies?" do
+
+        let(:parent_group_metadata) { Metadata.new.process('parent group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
+        let(:group_metadata) { Metadata.new(parent_group_metadata).process('group', :caller => ["foo_spec.rb:#{__LINE__}"]) }
+        let(:example_metadata) { group_metadata.for_example('example', :caller => ["foo_spec.rb:#{__LINE__}"], :if => true) }
+        let(:next_example_metadata) { group_metadata.for_example('next_example', :caller => ["foo_spec.rb:#{example_line_number + 2}"]) }
+        let(:world) { World.new }
+
+        before { RSpec.stub(:world) { world } }
+
+        shared_examples_for "matching by line number" do
+          let(:preceeding_declaration_lines) {{
+            parent_group_metadata[:example_group][:line_number] => parent_group_metadata[:example_group][:line_number],
+            group_metadata[:example_group][:line_number] => group_metadata[:example_group][:line_number],
+            example_metadata[:line_number] => example_metadata[:line_number],
+            (example_metadata[:line_number] + 1) => example_metadata[:line_number],
+            (example_metadata[:line_number] + 2) => example_metadata[:line_number] + 2,
+          }}
+          before do
+            world.should_receive(:preceding_declaration_line).at_least(:once).and_return do |v|
+              preceeding_declaration_lines[v]
+            end
+          end
+
+          it "matches the group when the line_number is the example group line number" do
+            # this call doesn't really make sense since filter_applies? is only called
+            # for example metadata not group metadata
+            group_metadata.filter_applies?(condition_key, group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the grandparent example group line number" do
+            example_metadata.filter_applies?(condition_key, parent_group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the parent example group line number" do
+            example_metadata.filter_applies?(condition_key, group_condition).should be_true
+          end
+
+          it "matches the example when the line_number is the example line number" do
+            example_metadata.filter_applies?(condition_key, example_condition).should be_true
+          end
+
+          it "matches when the line number is between this example and the next" do
+            example_metadata.filter_applies?(condition_key, between_examples_condition).should be_true
+          end
+
+          it "does not match when the line number matches the next example" do
+            example_metadata.filter_applies?(condition_key, next_example_condition).should be_false
+          end
+        end
+
+        context "with a single line number" do
+          let(:condition_key){ :line_numbers }
+          let(:parent_group_condition) { [parent_group_metadata[:example_group][:line_number]] }
+          let(:group_condition) { [group_metadata[:example_group][:line_number]] }
+          let(:example_condition) { [example_metadata[:line_number]] }
+          let(:between_examples_condition) { [group_metadata[:example_group][:line_number] + 1] }
+          let(:next_example_condition) { [example_metadata[:line_number] + 2] }
+
+          it_has_behavior "matching by line number"
+        end
+
+        context "with multiple line numbers" do
+          let(:condition_key){ :line_numbers }
+          let(:parent_group_condition) { [-1, parent_group_metadata[:example_group][:line_number]] }
+          let(:group_condition) { [-1, group_metadata[:example_group][:line_number]] }
+          let(:example_condition) { [-1, example_metadata[:line_number]] }
+          let(:between_examples_condition) { [-1, group_metadata[:example_group][:line_number] + 1] }
+          let(:next_example_condition) { [-1, example_metadata[:line_number] + 2] }
+
+          it_has_behavior "matching by line number"
+        end
+
+        context "with locations" do
+          let(:condition_key){ :locations }
+          let(:parent_group_condition) do
+            {File.expand_path(parent_group_metadata[:example_group][:file_path]) => [parent_group_metadata[:example_group][:line_number]]}
+          end
+          let(:group_condition) do
+            {File.expand_path(group_metadata[:example_group][:file_path]) => [group_metadata[:example_group][:line_number]]}
+          end
+          let(:example_condition) do
+            {File.expand_path(example_metadata[:file_path]) => [example_metadata[:line_number]]}
+          end
+          let(:between_examples_condition) do
+            {File.expand_path(group_metadata[:example_group][:file_path]) => [group_metadata[:example_group][:line_number] + 1]}
+          end
+          let(:next_example_condition) do
+            {File.expand_path(example_metadata[:file_path]) => [example_metadata[:line_number] + 2]}
+          end
+
+          it_has_behavior "matching by line number"
+
+          it "ignores location filters for other files" do
+            example_metadata.filter_applies?(:locations, {"/path/to/other_spec.rb" => [3,5,7]}).should be_true
+          end
+        end
+
+        it "matches a proc that evaluates to true" do
+          example_metadata.filter_applies?(:if, lambda { |v| v }).should be_true
+        end
+
+        it "does not match a proc that evaluates to false" do
+          example_metadata.filter_applies?(:if, lambda { |v| !v }).should be_false
+        end
+
+        it "passes the metadata hash as the second argument if a given proc expects 2 args" do
+          passed_metadata = nil
+          example_metadata.filter_applies?(:if, lambda { |v, m| passed_metadata = m })
+          passed_metadata.should eq(example_metadata)
+        end
+      end
+
+      describe "#for_example" do
+        let(:metadata)           { Metadata.new.process("group description") }
+        let(:mfe)                { metadata.for_example("example description", {:arbitrary => :options}) }
+        let(:line_number)        { __LINE__ - 1 }
+
+        it "stores the description" do
+          mfe[:description].should eq("example description")
+        end
+
+        it "stores the full_description (group description + example description)" do
+          mfe[:full_description].should eq("group description example description")
+        end
+
+        it "creates an empty execution result" do
+          mfe[:execution_result].should eq({})
+        end
+
+        it "extracts file path from caller" do
+          mfe[:file_path].should eq(__FILE__)
+        end
+
+        it "extracts line number from caller" do
+          mfe[:line_number].should eq(line_number)
+        end
+
+        it "extracts location from caller" do
+          mfe[:location].should eq("#{__FILE__}:#{line_number}")
+        end
+
+        it "uses :caller if passed as an option" do
+          example_metadata = metadata.for_example('example description', {:caller => ['example_file:42']})
+          example_metadata[:location].should eq("example_file:42")
+        end
+
+        it "merges arbitrary options" do
+          mfe[:arbitrary].should eq(:options)
+        end
+
+        it "points :example_group to the same hash object" do
+          a = metadata.for_example("foo", {})[:example_group]
+          b = metadata.for_example("bar", {})[:example_group]
+          a[:description] = "new description"
+          b[:description].should eq("new description")
+        end
+      end
+
+      describe ":describes" do
+        context "with a String" do
+          it "returns nil" do
+            m = Metadata.new
+            m.process('group')
+
+            m[:example_group][:describes].should be_nil
+          end
+        end
+
+        context "with a Symbol" do
+          it "returns nil" do
+            m = Metadata.new
+            m.process(:group)
+
+            m[:example_group][:describes].should be_nil
+          end
+        end
+
+        context "with a class" do
+          it "returns the class" do
+            m = Metadata.new
+            m.process(String)
+
+            m[:example_group][:describes].should be(String)
+          end
+        end
+
+        context "in a nested group" do
+          it "returns the parent group's described class" do
+            sm = Metadata.new
+            sm.process(String)
+
+            m = Metadata.new(sm)
+            m.process(Array)
+
+            m[:example_group][:describes].should be(String)
+          end
+
+          it "returns own described class if parent doesn't have one" do
+            sm = Metadata.new
+            sm.process("foo")
+
+            m = Metadata.new(sm)
+            m.process(Array)
+
+            m[:example_group][:describes].should be(Array)
+          end
+
+          it "can override a parent group's described class" do
+            parent = Metadata.new
+            parent.process(String)
+
+            child = Metadata.new(parent)
+            child.process(Fixnum)
+            child[:example_group][:describes] = Hash
+
+            grandchild = Metadata.new(child)
+            grandchild.process(Array)
+
+            grandchild[:example_group][:describes].should be(Hash)
+            child[:example_group][:describes].should be(Hash)
+            parent[:example_group][:describes].should be(String)
+          end
+        end
+      end
+
+      describe ":description" do
+        it "just has the example description" do
+          m = Metadata.new
+          m.process("group")
+
+          m = m.for_example("example", {})
+          m[:description].should eq("example")
+        end
+
+        context "with a string" do
+          it "provides the submitted description" do
+            m = Metadata.new
+            m.process("group")
+
+            m[:example_group][:description].should eq("group")
+          end
+        end
+
+        context "with a non-string" do
+          it "provides the submitted description" do
+            m = Metadata.new
+            m.process("group")
+
+            m[:example_group][:description].should eq("group")
+          end
+        end
+
+        context "with a non-string and a string" do
+          it "concats the args" do
+            m = Metadata.new
+            m.process(Object, 'group')
+
+            m[:example_group][:description].should eq("Object group")
+          end
+        end
+
+        context "with empty args" do
+          it "returns empty string for [:example_group][:description]" do
+            m = Metadata.new
+            m.process()
+
+            m[:example_group][:description].should eq("")
+          end
+        end
+      end
+
+      describe ":full_description" do
+        it "concats example group name and description" do
+          group_metadata = Metadata.new
+          group_metadata.process('group')
+
+          example_metadata = group_metadata.for_example("example", {})
+          example_metadata[:full_description].should eq("group example")
+        end
+
+        it "concats nested example group descriptions" do
+          parent = Metadata.new
+          parent.process('parent')
+
+          child = Metadata.new(parent)
+          child.process('child')
+
+          child[:example_group][:full_description].should eq("parent child")
+          child.for_example('example', child)[:full_description].should eq("parent child example")
+        end
+
+        %w[# . ::].each do |char|
+          context "with a 2nd arg starting with #{char}" do
+          it "removes the space" do
+            m = Metadata.new
+            m.process(Array, "#{char}method")
+            m[:example_group][:full_description].should eq("Array#{char}method")
+          end
+          end
+        end
+
+        %w[# . ::].each do |char|
+          context "with a nested description starting with #{char}" do
+            it "removes the space" do
+              parent = Metadata.new
+              parent.process("Object")
+              child = Metadata.new(parent)
+              child.process("#{char}method")
+              child[:example_group][:full_description].should eq("Object#{char}method")
+            end
+          end
+        end
+      end
+
+      describe ":file_path" do
+        it "finds the first non-rspec lib file in the caller array" do
+          m = Metadata.new
+          m.process(:caller => [
+                    "./lib/rspec/core/foo.rb",
+                    "#{__FILE__}:#{__LINE__}"
+          ])
+          m[:example_group][:file_path].should eq(__FILE__)
+        end
+      end
+
+      describe ":line_number" do
+        it "finds the line number with the first non-rspec lib file in the backtrace" do
+          m = Metadata.new
+          m.process({})
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
+        end
+
+        it "finds the line number with the first spec file with drive letter" do
+          m = Metadata.new
+          m.process(:caller => [ "C:/path/to/file_spec.rb:#{__LINE__}" ])
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
+        end
+
+        it "uses the number after the first : for ruby 1.9" do
+          m = Metadata.new
+          m.process(:caller => [ "#{__FILE__}:#{__LINE__}:999" ])
+          m[:example_group][:line_number].should eq(__LINE__ - 1)
+        end
+      end
+
+      describe "child example group" do
+        it "nests the parent's example group metadata" do
+          parent = Metadata.new
+          parent.process(Object, 'parent')
+
+          child = Metadata.new(parent)
+          child.process()
+
+          child[:example_group][:example_group].should eq(parent[:example_group])
+        end
+      end
+    end
+  end
+end