data-provider 0.1.0 → 0.2.0

data/spec/container_spec.rb

@@ -0,0 +1,792 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe DataProvider::Container do
+    # Example implementation of DataProvider::Base
+  let(:container){
+    DataProvider::Container.new.tap do |container|
+      container.provider :sum, :requires => [:array] do
+        sum = 0
+
+        (given(:array) || []).each do |number|
+          sum += number.to_i
+        end
+
+        sum
+      end
+
+      container.provider :static do
+        'StaticValue'
+      end
+
+      container.provider :billy do
+        take([:identification, :fullname])
+      end
+
+      container.provider [:identification, :firstname] do
+        'Billy'
+      end
+
+      container.provider [:identification, :lastname] do
+        'Bragg'
+      end
+
+      container.provider [:identification, :fullname] do
+        "#{scoped_take(:firstname)} #{scoped_take(:lastname)}"
+      end
+
+      container.provider [:identification, :identifier] do
+        take(:firstname)
+      end
+
+      container.provider :fullname do
+        'Stephen William Bragg'
+      end
+
+      container.provider [:identification, :id] do
+        take(:fullname)
+      end
+
+      container.provider [:identification, :ID] do
+        take(:id)
+      end
+    end
+  }
+
+  describe "#has_provider?" do
+    it 'tells if the specified provider exists' do
+      expect(container.respond_to?(:has_provider?)).to eq true
+      expect(container.has_provider?(:sum)).to eq true
+      expect(container.has_provider?(:divid)).to eq false
+    end
+  end
+
+  describe "#has_providers_with_scope?" do
+    let(:container){
+      DataProvider::Container.new.tap do |container|
+        container.provider [:a, :b ,:c]
+        container.provider :unscoped
+      end
+    }
+
+    it "return true if there are providers defined with an array identifier that start with the given prefix" do
+      expect(container.has_providers_with_scope?(:unscoped)).to eq false
+      expect(container.has_providers_with_scope?(:a)).to eq true
+      expect(container.has_providers_with_scope?([:a, :b])).to eq true
+      # scope means prefix, identfier may not be exactly the given array
+      expect(container.has_providers_with_scope?([:a, :b, :c])).to eq false
+    end
+  end
+
+  describe "#provides" do
+    let(:container){
+      DataProvider::Container.new.tap do |container|
+        container.provides({
+          :name => 'Paddy',
+          'instrument' => :bass
+        })
+      end
+    }
+    # class SimpleProviders
+    #   include DataProvider::Base
+    #   provides({
+    #     :name => 'Paddy',
+    #     'instrument' => :bass,
+    #   })
+    # end
+
+    it "lets you request all currently available simple providers when called without a parameter" do
+      expect(container.provides).to eq({
+        :name => 'Paddy',
+        'instrument' => :bass
+      })
+    end
+
+    it "lets you define simple providers" do
+      expect(container.take(:name)).to eq 'Paddy'
+      expect(container.take('instrument')).to eq :bass
+    end
+
+    it "works with has_provider?" do
+      expect(container.has_provider?(:name)).to eq true
+      expect(container.has_provider?('name')).to eq false
+      expect(container.has_provider?('instrument')).to eq true
+      expect(container.has_provider?(:instrument)).to eq false
+    end
+
+    it "lets you overwrite existing simple providers" do
+      container.provides({:name => 'Erik'})
+      expect(container.take(:name)).to eq 'Erik'
+    end
+
+    it "lets you write linked notation" do
+      expect(container.provides({:name => 'Lane'}).take(:name)).to eq 'Lane'
+    end
+
+    it "works with lambdas" do
+      expect(container.provides(:name => lambda{ 'Patrick' }).take(:name)).to eq 'Patrick'
+    end
+
+    it "works with Procs" do
+      expect(container.provides(:name => Proc.new{ 'St. Patrick' }).take(:name)).to eq 'St. Patrick'
+    end
+  end
+
+  describe "#add!" do
+    let(:odd_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provides({1 => 'one'})
+        c.provider :three do 3 end
+      end
+    }
+
+    let(:odd_overwrite_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provides({1 => 'Uno', :five => 555})
+        c.provider :three do :tres end
+      end
+    }
+
+    let(:container){
+      DataProvider::Container.new.tap do |container|
+        container.provides({2 => '1'})
+        container.provider :four do '4' end
+        container.add! odd_providers
+      end
+    }
+
+    it "lets you add providers from another container" do
+      expect(container.has_provider?(1)).to eq true
+      expect(container.has_provider?(2)).to eq true
+      expect(container.has_provider?(:three)).to eq true
+      expect(container.has_provider?(:four)).to eq true
+      # expect(BasicProviders.new.take(1)).to eq 'one'
+      expect(container.take(:three)).to eq 3
+    end
+
+    it "lets you add providers from another container at runtime" do
+      expect(container.has_provider?(:five)).to eq false
+      container.add!(odd_overwrite_providers)
+      expect(container.has_provider?(:five)).to eq true
+    end
+
+    # for the following test the providers of OddOverwriteProviders
+    # have already been added (by the previous test)
+    it "lets you overwrite providers" do
+      container.add!(odd_overwrite_providers)
+      expect(container.take(1)).to eq 'Uno'
+      expect(container.take(:three)).to eq :tres
+    end
+
+    it "includes providers which can be overwritten" do
+      cont = DataProvider::Container.new
+      cont.add! odd_providers
+      cont.provider :three do '33' end
+      expect(cont.take(:three)).to eq '33'
+    end
+  end
+
+  describe "#add" do
+    let(:odd_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provides({1 => 'one'})
+        c.provider :three do 3 end
+      end
+    }
+
+    let(:odd_overwrite_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provides({1 => 'Uno', :five => 555})
+        c.provider :three do :tres end
+      end
+    }
+
+    let(:container){
+      DataProvider::Container.new.tap do |container|
+        container.provides({2 => '1'})
+        container.provider :four do '4' end
+        container.add odd_providers
+      end
+    }
+
+    it "lets you add providers from another container" do
+      expect(container.has_provider?(1)).to eq false
+      expect(container.has_provider?(2)).to eq true
+      expect(container.has_provider?(:three)).to eq false
+      expect(container.has_provider?(:four)).to eq true
+      # expect(BasicProviders.new.take(1)).to eq 'one'
+      # expect(container.take(:three)).to eq 3
+    end
+
+    it "lets you add providers from another container at runtime" do
+      expect(container.has_provider?(:five)).to eq false
+      new_container = container.add(odd_overwrite_providers)
+      expect(container.has_provider?(:five)).to eq false
+      expect(new_container.has_provider?(:five)).to eq true
+    end
+
+    # for the following test the providers of OddOverwriteProviders
+    # have already been added (by the previous test)
+    it "lets you overwrite providers" do
+      new_container = container.add(odd_overwrite_providers)
+      expect(container.has_provider?(1)).to eq false
+      expect(new_container.take(1)).to eq 'Uno'
+      expect(container.has_provider?(:three)).to eq false
+      expect(new_container.take(:three)).to eq :tres
+    end
+
+    it "includes providers which can be overwritten" do
+      cont = DataProvider::Container.new
+      odd = cont.add odd_providers
+      odd.provider :three do '33' end
+      expect(odd.take(:three)).to eq '33'
+    end
+  end
+
+  describe "#add_scoped!" do
+    let(:child_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provider :name do "child" end
+      end
+    }
+
+    let(:grandchild_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provider :name do "grandchild" end
+        c.provider [:age] do 1 end
+        c.provides({
+          :mommy => 'Wilma',
+          :daddy => 'Fret'
+        })
+
+        c.provider :mobility do
+          'crawling'
+        end
+
+        c.provider :movement do
+          take(:mobility)
+        end
+
+        c.provider :symbol do
+          'Symbol provider'
+        end
+
+        c.provider :sym do
+          take(:symbol)
+        end
+
+        c.provider ['string'] do
+          'String provider: ' + take(:symbol)
+        end
+      end
+    }
+
+    let(:container){
+      DataProvider::Container.new.tap do |c|
+        c.provider :parent do 'parent' end
+        c.add_scoped! child_providers, :scope => :child
+        c.add_scoped! grandchild_providers, :scope => [:child, :child]
+      end
+    }
+
+    it 'let you array-prefix the providers of an included container' do
+      expect(container.has_provider?(:parent)).to eq true
+      expect(container.has_provider?(:name)).to eq false
+      expect(container.has_provider?([:child, :name])).to eq true
+      expect(container.has_provider?([:child, :age])).to eq false
+      expect(container.has_provider?([:child, :child, :name])).to eq true
+      expect(container.has_provider?([:child, :child, :age])).to eq true
+      expect(container.has_provider?([:child, :child, :mommy])).to eq true
+      expect(container.has_provider?([:child, :child, :daddy])).to eq true
+      expect(container.take([:child, :name])).to eq 'child'
+      expect(container.take([:child, :child, :name])).to eq 'grandchild'
+      expect(container.take([:child, :child, :age])).to eq 1
+      expect(container.take([:child, :child, :mommy])).to eq 'Wilma'
+      expect(container.take([:child, :child, :daddy])).to eq 'Fret'
+    end
+
+    it "#take acts like #scoped_take inside providers works for add_scoped containers as well" do
+      expect( container.take([:child, :child, :mobility]) ).to eq 'crawling'
+      expect( container.take([:child, :child, :movement]) ).to eq 'crawling'
+    end
+
+    it "doesn't act up when mixing symbols and strings in array identifiers" do
+      expect( container.take([:child, :child, 'string']) ).to eq 'String provider: Symbol provider'
+    end
+
+    it "lets #take act like #scoped_take recursively" do
+      expect( container.take([:child, :child, :sym]) ).to eq 'Symbol provider'
+    end
+
+    it 'respect provider order/priority' do
+      c1 = DataProvider::Container.new
+      c1.provider 'version' do 1 end
+
+      c2 = DataProvider::Container.new
+      c2.add! c1
+      c2.provider 'version' do 2 end
+
+      c = DataProvider::Container.new
+      c.provider 'version' do 0 end
+      c.provider ['module', 'version'] do -1 end
+      c.add_scoped! c2, :scope => 'module'
+
+      expect(c.try_take('version')).to eq 0
+      expect(c.try_take(['module', 'version'])).to eq 2
+    end
+
+    it 'works recursively' do
+      c1 = DataProvider::Container.new
+      c1.provider ['name'] do 'Johnny Blaze' end
+
+      expect(c1.provider_identifiers).to eq [['name']]
+
+      c2 = DataProvider::Container.new.add(c1)
+      expect(c2.provider_identifiers).to eq [['name']]
+
+      c3 = DataProvider::Container.new
+      c3.provider ['name'] do 'Mr. Nobody' end
+      # the next line adds the provider ['person', 'name'] to m3
+      c3.add_scoped! c2, :scope => 'person'
+
+      # providers are internally added in reverse order
+      expect(c3.provider_identifiers).to eq [['person', 'name'], ['name']]
+
+      c = DataProvider::Container.new
+      c.add_scoped! c3, :scope => 'creatures'
+
+      expect(c.has_provider?('name')).to eq false
+      expect(c.has_provider?(['name'])).to eq false
+      expect(c.has_provider?(['person', 'name'])).to eq false
+      expect(c.has_provider?(['creatures', 'person', 'name'])).to eq true
+      expect(c.take(['creatures', 'person', 'name'])).to eq 'Johnny Blaze'
+    end
+
+    it "doesn't affect the added container" do
+      c1 = DataProvider::Container.new
+      c1.provider ['name'] do 'Johnny Blaze' end
+
+      expect(c1.provider_identifiers).to eq [['name']]
+
+      c = DataProvider::Container.new
+      c.add_scoped! c1, :scope => 'prefix'
+
+      expect(c1.provider_identifiers).to eq [['name']]
+    end
+  end
+
+  describe "#add_scoped" do
+    let(:child_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provider :name do "child" end
+      end
+    }
+
+    let(:grandchild_providers){
+      DataProvider::Container.new.tap do |c|
+        c.provider :name do "grandchild" end
+        c.provider [:age] do 1 end
+        c.provides({
+          :mommy => 'Wilma',
+          :daddy => 'Fret'
+        })
+
+        c.provider :mobility do
+          'crawling'
+        end
+
+        c.provider :movement do
+          take(:mobility)
+        end
+
+        c.provider :symbol do
+          'Symbol provider'
+        end
+
+        c.provider :sym do
+          take(:symbol)
+        end
+
+        c.provider ['string'] do
+          'String provider: ' + take(:symbol)
+        end
+      end
+    }
+
+    let(:container){
+      DataProvider::Container.new.tap do |c|
+        c.provider :parent do 'parent' end
+        c.add_scoped child_providers, :scope => :child
+        c.add_scoped grandchild_providers, :scope => [:child, :child]
+      end
+    }
+
+    it 'let you array-prefix the providers of an included container' do
+      expect(container.has_provider?(:parent)).to eq true
+      expect(container.has_provider?(:name)).to eq false
+      expect(container.has_provider?([:child, :name])).to eq false
+      expect(container.has_provider?([:child, :age])).to eq false
+      expect(container.has_provider?([:child, :child, :name])).to eq false
+      expect(container.has_provider?([:child, :child, :age])).to eq false
+      expect(container.has_provider?([:child, :child, :mommy])).to eq false
+      expect(container.has_provider?([:child, :child, :daddy])).to eq false
+      # expect(container.take([:child, :name])).to eq 'child'
+      # expect(container.take([:child, :child, :name])).to eq 'grandchild'
+      # expect(container.take([:child, :child, :age])).to eq 1
+      # expect(container.take([:child, :child, :mommy])).to eq 'Wilma'
+      # expect(container.take([:child, :child, :daddy])).to eq 'Fret'
+    end
+
+    it "#take acts like #scoped_take inside providers works for add_scoped containers as well" do
+      newcontainer = container.add_scoped(child_providers, :scope => :child).add_scoped(grandchild_providers, :scope => [:child, :child])
+      expect( newcontainer.take([:child, :child, :mobility]) ).to eq 'crawling'
+      expect( newcontainer.take([:child, :child, :movement]) ).to eq 'crawling'
+    end
+
+    it "doesn't act up when mixing symbols and strings in array identifiers" do
+      newcontainer = container.add_scoped(child_providers, :scope => :child).add_scoped(grandchild_providers, :scope => [:child, :child])
+      expect( newcontainer.take([:child, :child, 'string']) ).to eq 'String provider: Symbol provider'
+    end
+
+    it "lets #take act like #scoped_take recursively" do
+      newcontainer = container.add_scoped(child_providers, :scope => :child).add_scoped(grandchild_providers, :scope => [:child, :child])
+      expect( newcontainer.take([:child, :child, :sym]) ).to eq 'Symbol provider'
+    end
+
+    it 'respect provider order/priority' do
+      c1 = DataProvider::Container.new
+      c1.provider 'version' do 1 end
+
+      c2 = DataProvider::Container.new
+      c2.add c1
+      c2.provider 'version' do 2 end
+
+      c = DataProvider::Container.new
+      c.provider 'version' do 0 end
+      c.provider ['module', 'version'] do -1 end
+      cc = c.add_scoped c2, :scope => 'module'
+
+      expect(cc.try_take('version')).to eq 0
+      expect(cc.try_take(['module', 'version'])).to eq 2
+    end
+
+    it 'works recursively' do
+      c1 = DataProvider::Container.new
+      c1.provider ['name'] do 'Johnny Blaze' end
+
+      expect(c1.provider_identifiers).to eq [['name']]
+
+      c2 = DataProvider::Container.new.add(c1)
+      expect(c2.provider_identifiers).to eq [['name']]
+
+      c3 = DataProvider::Container.new
+      c3.provider ['name'] do 'Mr. Nobody' end
+      # the next line adds the provider ['person', 'name'] to m3
+      c4 = c3.add_scoped c2, :scope => 'person'
+
+      # providers are internally added in reverse order
+      expect(c4.provider_identifiers).to eq [['person', 'name'], ['name']]
+
+      c = DataProvider::Container.new
+      cc = c.add_scoped c3, :scope => 'creatures'
+
+      expect(cc.has_provider?('name')).to eq false
+      expect(cc.has_provider?(['name'])).to eq false
+      expect(cc.has_provider?(['person', 'name'])).to eq false
+      expect(cc.has_provider?(['creatures', 'person', 'name'])).to eq false
+      ccc = cc.add_scoped c4, :scope => 'creatures'
+      expect(ccc.has_provider?(['creatures', 'person', 'name'])).to eq true
+      expect(ccc.take(['creatures', 'person', 'name'])).to eq 'Johnny Blaze'
+    end
+
+    it "doesn't affect the added container" do
+      c1 = DataProvider::Container.new
+      c1.provider ['name'] do 'Johnny Blaze' end
+
+      expect(c1.provider_identifiers).to eq [['name']]
+
+      c = DataProvider::Container.new
+      c2 = c.add_scoped c1, :scope => 'prefix'
+
+      expect(c1.provider_identifiers).to eq [['name']]
+    end
+  end
+
+  describe "#provider_missing" do
+    let(:container){
+      DataProvider::Container.new.tap do |c|
+        c.provider_missing do
+          "This provider don't exist!"
+        end
+      end
+    }
+
+    it "lets you define a default fallback provider" do
+      expect(container.has_provider?(:message)).to eq false
+      expect(container.take(:message)).to eq "This provider don't exist!"
+    end
+
+    describe "#missing_provider" do
+      it "provides the missing provider id through the missing_provider method" do
+        c = DataProvider::Container.new
+        c.provider_missing do
+          "Missing #{missing_provider}"
+        end
+
+        expect(c.take(:something)).to eq 'Missing something'
+      end
+
+      it "returns nil when called from anywhere else than the fallback provider" do
+        # expect{c.missing_provider}.to raise_error(NoMethodError)
+        expect(container.missing_provider).to eq nil
+      end
+    end
+
+    it 'calls the fallback provider when using try_take with an unknown provider' do
+      c = DataProvider::Container.new
+      c.provider_missing do
+        "fallback_#{missing_provider}"
+      end
+
+      expect(c.try_take(:cool)).to eq 'fallback_cool'
+    end     
+  end
+
+  describe "fallback_provider?" do
+    it "lets you know if a fallback provider has been registered" do
+      c = DataProvider::Container.new
+      expect(c.fallback_provider?).to eq false
+
+      c.provider_missing do
+        "New fallback!"
+      end
+
+      expect(c.fallback_provider?).to eq true
+    end
+  end
+
+  describe "#take" do
+    it 'lets you take data from a data provider instance' do
+      expect(container.give(:array => [6,9,2]).take(:sum)).to eq 17
+      expect(container.take(:static)).to eq 'StaticValue'
+    end
+
+    it 'raise a ProviderMissingException when attempting to take from unknown provider' do
+      expect{container.take(:unknown)}.to raise_error(DataProvider::ProviderMissingException)
+      expect{container.take([:identification, :foo])}.to raise_error(DataProvider::ProviderMissingException)
+    end
+
+    it 'works from within a provider block' do
+      expect(container.take(:billy)).to eq 'Billy Bragg'
+    end
+
+    it "acts like #scoped_take when used inside a provider and the specified provider isn't available" do
+      expect(container.take([:identification, :id])).to eq 'Stephen William Bragg'
+      expect(container.take([:identification, :identifier])).to eq 'Billy'
+    end
+
+    it "can act like #scoped_take recursively" do
+      expect(container.take([:identification, :ID])).to eq 'Stephen William Bragg'
+    end
+  end
+
+  describe "#try_take" do
+    it "acts like #take when the specified provider is present" do
+      expect(container.give(:array => [1,2,4]).try_take(:sum)).to eq 7
+    end
+
+    it "returns nil when the specified provider is not found" do
+      expect(container.try_take(:square_root)).to eq nil
+    end
+  end
+
+  describe "#provider_stack" do
+    let(:container){
+      DataProvider::Container.new.tap do |c|
+        c.provider :a do
+          take(:b)
+        end
+        c.provider :b do
+          take(['prefix', :c])
+        end
+        c.provider ['prefix', :c] do
+          take ['prefix', :d]
+        end
+        c.provider ['prefix', :d] do
+          provider_stack
+        end
+      end
+    }
+
+    it "gives providers an array resembling the current provider 'callstack'" do
+      expect(container.take(:a)).to eq [:a, :b, ['prefix', :c], ['prefix', :d]]
+      expect(container.take(:b)).to eq [:b, ['prefix', :c], ['prefix', :d]]
+    end
+  end
+
+  describe "#provider_id" do
+    let(:container){
+      DataProvider::Container.new.tap do |c|
+        c.provider :a do
+          take(:b)
+        end
+        c.provider :b do
+          take(['prefix', :c])
+        end
+        c.provider ['prefix', :c] do
+          take ['prefix', :d]
+        end
+        c.provider ['prefix', :d] do
+          provider_id
+        end
+      end
+    }
+
+    it "gives the id of the current provider" do
+      expect(container.take(:a)).to eq ['prefix', :d]
+      expect(container.take(['prefix', :d])).to eq ['prefix', :d]
+    end
+
+    it "gives nil when called fmor outside a provider" do
+      expect(container.provider_id).to eq nil
+    end
+  end
+
+
+  describe "#scopes" do
+    let(:container){
+      DataProvider::Container.new.tap do |c|
+        c.provider :a do
+          take(:b)
+        end
+        c.provider :b do
+          take(['prefix', :c])
+        end
+        c.provider ['prefix', :c] do
+          take :d # take also looks for :d within its own ['prefix'] scope
+        end
+        c.provider ['prefix', :d] do
+          scopes
+        end
+      end
+    }
+
+    it "gives providers an array resembling the current provider 'callstack'" do
+      expect(container.take(:a)).to eq [[], [], ['prefix'], ['prefix']]
+      expect(container.take(:b)).to eq [[], ['prefix'], ['prefix']]
+    end
+  end
+
+  describe "#scope" do
+    let(:container){
+      DataProvider::Container.new.tap do |c|
+        c.provider [:a, :b] do
+          'woeha!'
+        end
+        c.provider [:a, :b ,:c] do
+          scope
+        end
+        c.provider [:a, :b ,:eq] do
+          take scope
+        end
+      end
+    }
+
+    it 'gives providers the current scope' do
+      expect(container.take([:a,:b,:c])).to eq [:a,:b]
+    end
+
+    it "can be used by providers to call the 'parent provider'" do
+      expect(container.take([:a,:b,:eq])).to eq container.take([:a,:b])
+    end
+  end
+
+  describe "#scoped_take" do
+    it 'lets a provider call providers within its own scope' do
+      expect(container.take([:identification, :fullname])).to eq 'Billy Bragg'
+    end
+  end
+
+  describe "#give" do
+    it "lets you give data, creating a new data provider instance" do
+      updated = container.give :array => [1,80]
+      expect(container.take(:sum)).to eq 0
+      expect(updated.take(:sum)).to eq 81
+    end
+
+    it "allows for linked notation" do
+      expect(container.give(:array => [7, -3]).take(:sum)).to eq 4
+    end
+
+    it "has an add_scope alias" do
+      expect(container.add_scope(:array => [400, 20]).take(:sum)).to eq 420
+    end
+
+    it "has an add_data alias" do
+      expect(container.add_data(:array => [400, 20]).take(:sum)).to eq 420
+    end
+  end
+
+  describe "#give!" do
+    it "lets you update the current provider with additional data" do
+      container2 = container.give(:array => [1,1,90])
+      expect(container2.take(:sum)).to eq 92
+      container2.give!(:array => [3,90])
+      expect(container2.take(:sum)).to eq 93
+    end
+
+    it "allows for linked notation" do
+      expect(container.give!(:array => [3]).give!.give!(:array => [-1, -4]).take(:sum)).to eq -5
+    end
+
+    it "has an add_scope! alias" do
+      scoped = container.add_scope.add_scope!(:array => [-1, -4])
+      expect(scoped.given(:array)).to eq [-1,-4]
+      expect(scoped.take(:sum)).to eq -5
+    end
+
+    it "has an add_data! alias" do
+      scoped = container.add_data(:array => []).add_data!(:array => [5, 5])
+      expect(scoped.get_data(:array)).to eq [5,5]
+      expect(scoped.take(:sum)).to eq 10
+    end
+  end
+
+  describe '#got?' do
+    it "returns if the specified piece of data is given" do
+      c = DataProvider::Container.new.give(:name => 'John')
+      expect( c.got?(:name) ).to be true
+      expect( c.got?(:lastname) ).to be false
+      expect( c.give(:lastname => 'Doe').got?(:lastname) ).to be true
+    end
+
+    it "has an 'has_data?' alias" do
+      c = DataProvider::Container.new.give(:name => 'John')
+      expect( c.has_data?(:lastname) ).to be false
+      expect( c.has_data?(:name) ).to be true
+      expect( c.add_data(:lastname => 'Doe').has_data?(:lastname) ).to be true
+    end
+  end
+
+  describe "#given" do 
+    it "has a given method to get given data" do
+      expect(DataProvider::Container.new.give(:array => 'array').given(:array)).to eq 'array'
+    end
+
+    it "has a get_data alias" do
+      expect(DataProvider::Container.new.add_data(:foo => :bar).get_data(:foo)).to eq :bar
+    end
+  end
+
+  describe "fallback_provider?" do
+    it "lets you know if a fallback provider has been registered" do
+      c = DataProvider::Container.new
+      expect(c.fallback_provider?).to eq false
+
+      c.provider_missing do
+        "New fallback!"
+      end
+
+      expect(c.fallback_provider?).to eq true
+    end
+  end
+end