puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/spec/unit/indirector/resource_type/rest_spec.rb

@@ -1,14 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/indirector/resource_type/rest'
-
-describe Puppet::Indirector::ResourceType::Rest do
-  it "should be registered with the resource_type indirection" do
-    expect(Puppet::Indirector::Terminus.terminus_class(:resource_type, :rest)).to equal(Puppet::Indirector::ResourceType::Rest)
-  end
-
-  it "should be a subclass of Puppet::Indirector::Rest" do
-    expect(Puppet::Indirector::ResourceType::Rest.superclass).to eq(Puppet::Indirector::REST)
-  end
-end

data/spec/unit/pops/binder/binder_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-module BinderSpecModule
-  def factory()
-    Puppet::Pops::Binder::BindingsFactory
-  end
-
-  def injector(binder)
-    Puppet::Pops::Binder::Injector.new(binder)
-  end
-
-  def binder()
-    Puppet::Pops::Binder::Binder.new()
-  end
-
-  def test_layer_with_empty_bindings
-    factory.named_layer('test-layer', factory.named_bindings('test').model)
-  end
-end
-
-describe 'Binder' do
-  include BinderSpecModule
-
-  # TODO: Test binder + parent binder
-  context 'when defining layers' do
-
-#    it 'redefinition is not allowed' do
-#      expect do
-#        b = binder()
-#        b.define_layers(factory.layered_bindings(test_layer_with_empty_bindings))
-#        b.define_layers(factory.layered_bindings(test_layer_with_empty_bindings))
-#      end.to raise_error(/Cannot redefine its content/)
-#    end
-#
-#    it 'a binder should report being configured when layers have been defined' do
-#      b = binder()
-#      b.configured?().should == false
-#      b.define_layers(factory.layered_bindings(test_layer_with_empty_bindings))
-#      b.configured?().should == true
-#    end
-  end
-end

data/spec/unit/pops/binder/bindings_checker_spec.rb

@@ -1,155 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet_spec/pops'
-
-describe 'The bindings checker' do
-
-  include PuppetSpec::Pops
-
-  Issues = Puppet::Pops::Binder::BinderIssues
-  Bindings = Puppet::Pops::Binder::Bindings
-  TypeFactory = Puppet::Pops::Types::TypeFactory
-  let (:acceptor) {  Puppet::Pops::Validation::Acceptor.new() }
-
-  let (:binding) { Bindings::Binding.new() }
-
-  let (:ok_binding) {
-    b = Bindings::Binding.new()
-    b.producer = Bindings::ConstantProducerDescriptor.new()
-    b.producer.value = 'some value'
-    b.type = TypeFactory.string()
-    b
-  }
-
-  def validate(binding)
-    Puppet::Pops::Binder::BindingsValidatorFactory.new().validator(acceptor).validate(binding)
-  end
-
-  def bindings(*args)
-    b = Bindings::Bindings.new()
-    b.bindings = args
-    b
-  end
-
-  def named_bindings(name, *args)
-    b = Bindings::NamedBindings.new()
-    b.name = name
-    b.bindings = args
-    b
-  end
-
-  def layer(name, *bindings)
-    l = Bindings::NamedLayer.new()
-    l.name = name
-    l.bindings = bindings
-    l
-  end
-
-  def layered_bindings(*layers)
-    b = Bindings::LayeredBindings.new()
-    b.layers = layers
-    b
-  end
-
-  def array_multibinding()
-    b = Bindings::Multibinding.new()
-    b.producer = Bindings::ArrayMultibindProducerDescriptor.new()
-    b.type = TypeFactory.array_of_data()
-    b
-  end
-
-  def bad_array_multibinding()
-    b = array_multibinding()
-    b.type = TypeFactory.hash_of_data() # intentionally wrong!
-    b
-  end
-
-  def hash_multibinding()
-    b = Bindings::Multibinding.new()
-    b.producer = Bindings::HashMultibindProducerDescriptor.new()
-    b.type = TypeFactory.hash_of_data()
-    b
-  end
-
-  def bad_hash_multibinding()
-    b = hash_multibinding()
-    b.type = TypeFactory.array_of_data() # intentionally wrong!
-    b
-  end
-
-  it 'should complain about missing producer and type' do
-    validate(binding())
-    expect(acceptor).to have_issue(Issues::MISSING_PRODUCER)
-    expect(acceptor).to have_issue(Issues::MISSING_TYPE)
-  end
-
-  context 'when checking array multibinding' do
-    it 'should complain about non array producers' do
-      validate(bad_array_multibinding())
-      expect(acceptor).to have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
-    end
-  end
-
-  context 'when checking hash multibinding' do
-    it 'should complain about non hash producers' do
-      validate(bad_hash_multibinding())
-      expect(acceptor).to have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
-    end
-  end
-
-  context 'when checking bindings' do
-    it 'should not accept zero bindings' do
-      validate(bindings())
-      expect(acceptor).to have_issue(Issues::MISSING_BINDINGS)
-    end
-
-    it 'should accept non-zero bindings' do
-      validate(bindings(ok_binding))
-      expect(acceptor.errors_or_warnings?).to eq(false)
-    end
-
-    it 'should check contained bindings' do
-      validate(bindings(bad_array_multibinding()))
-      expect(acceptor).to have_issue(Issues::MULTIBIND_INCOMPATIBLE_TYPE)
-    end
-  end
-
-  context 'when checking named bindings' do
-    it 'should accept named bindings' do
-      validate(named_bindings('garfield', ok_binding))
-      expect(acceptor.errors_or_warnings?).to eq(false)
-    end
-
-    it 'should not accept unnamed bindings' do
-      validate(named_bindings(nil, ok_binding))
-      expect(acceptor).to have_issue(Issues::MISSING_BINDINGS_NAME)
-    end
-
-    it 'should do generic bindings check' do
-      validate(named_bindings('garfield'))
-      expect(acceptor).to have_issue(Issues::MISSING_BINDINGS)
-    end
-  end
-
-  context 'when checking layered bindings' do
-    it 'should not accept zero layers' do
-      validate(layered_bindings())
-      expect(acceptor).to have_issue(Issues::MISSING_LAYERS)
-    end
-
-    it 'should accept non-zero layers' do
-      validate(layered_bindings(layer('foo', named_bindings('bar', ok_binding))))
-      expect(acceptor.errors_or_warnings?).to eq(false)
-    end
-
-    it 'should not accept unnamed layers' do
-      validate(layered_bindings(layer(nil, named_bindings('bar', ok_binding))))
-      expect(acceptor).to have_issue(Issues::MISSING_LAYER_NAME)
-    end
-
-    it 'should accept layers without bindings' do
-      validate(layered_bindings(layer('foo')))
-      expect(acceptor).not_to have_issue(Issues::MISSING_BINDINGS_IN_LAYER)
-    end
-  end
-end

data/spec/unit/pops/binder/bindings_composer_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet_spec/pops'
-require 'puppet/plugins'
-
-describe 'BinderComposer' do
-  include PuppetSpec::Pops
-
-  def config_dir(config_name)
-    my_fixture(config_name)
-  end
-
-  let(:acceptor)    { Puppet::Pops::Validation::Acceptor.new() }
-  let(:diag)        { Puppet::Pops::Binder::Config::DiagnosticProducer.new(acceptor) }
-  let(:issues)      { Puppet::Pops::Binder::Config::Issues }
-  let(:node)        { Puppet::Node.new('localhost') }
-  let(:compiler)    { Puppet::Parser::Compiler.new(node)}
-  let(:scope)       { Puppet::Parser::Scope.new(compiler) }
-  let(:parser)      { Puppet::Pops::Parser::Parser.new() }
-  let(:factory)     { Puppet::Pops::Binder::BindingsFactory }
-
-  it 'should load default config if no config file exists' do
-    diagnostics = diag
-    composer = Puppet::Pops::Binder::BindingsComposer.new()
-    composer.compose(scope)
-  end
-
-  context "when loading a complete configuration with modules" do
-    let(:config_directory) { config_dir('ok') }
-
-    it 'should load everything without errors' do
-      Puppet.settings[:confdir] = config_directory
-      Puppet.settings[:libdir] = File.join(config_directory, 'lib')
-
-      environments = Puppet::Environments::Static.new(Puppet::Node::Environment.create(:production, [File.join(config_directory, 'modules')]))
-      Puppet.override(:environments => environments, :current_environment => environments.get('production')) do
-        # this ensure the binder is active at the right time
-        # (issues with getting a /dev/null path for "confdir" / "libdir")
-        raise "Binder not active" unless scope.compiler.activate_binder
-
-        diagnostics = diag
-        composer = Puppet::Pops::Binder::BindingsComposer.new()
-        the_scope = scope
-        the_scope['fqdn'] = 'localhost'
-        the_scope['environment'] = 'production'
-        layered_bindings = composer.compose(scope)
-        # puts Puppet::Pops::Binder::BindingsModelDumper.new().dump(layered_bindings)
-        binder = Puppet::Pops::Binder::Binder.new(layered_bindings)
-        injector = Puppet::Pops::Binder::Injector.new(binder)
-        expect(injector.lookup(scope, 'awesome_x')).to be == 'golden'
-        expect(injector.lookup(scope, 'good_x')).to be == 'golden'
-        expect(injector.lookup(scope, 'rotten_x')).to be == nil
-        expect(injector.lookup(scope, 'the_meaning_of_life')).to be == 42
-        expect(injector.lookup(scope, 'has_funny_hat')).to be == 'the pope'
-        expect(injector.lookup(scope, 'all your base')).to be == 'are belong to us'
-        expect(injector.lookup(scope, 'env_meaning_of_life')).to be == 'production thinks it is 42'
-        expect(injector.lookup(scope, '::quick::brown::fox')).to be == 'echo: quick brown fox'
-      end
-    end
-  end
-
-  # TODO: test error conditions (see BinderConfigChecker for what to test)
-
-end

data/spec/unit/pops/binder/bindings_validator_factory_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-describe 'The bindings validator factory' do
-  let(:factory) {  Puppet::Pops::Binder::BindingsValidatorFactory.new() }
-
-  it 'should instantiate a BindingsValidatorFactory' do
-    expect(factory.class).to eq(Puppet::Pops::Binder::BindingsValidatorFactory)
-  end
-
-  it 'should produce label_provider of class BindingsLabelProvider' do
-    expect(factory.label_provider.class).to eq(Puppet::Pops::Binder::BindingsLabelProvider)
-  end
-
-  it 'should produce validator of class BindingsChecker' do
-    expect(factory.validator(Puppet::Pops::Validation::Acceptor.new()).class).to eq(Puppet::Pops::Binder::BindingsChecker)
-  end
-end

data/spec/unit/pops/binder/config/binder_config_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet_spec/pops'
-
-describe 'BinderConfig' do
-  include PuppetSpec::Pops
-
-  let(:acceptor)    { Puppet::Pops::Validation::Acceptor.new() }
-  let(:diag)        { Puppet::Pops::Binder::Config::DiagnosticProducer.new(acceptor) }
-  let(:issues)      { Puppet::Pops::Binder::Config::Issues }
-
-  it 'should load default config if no config file exists' do
-    diagnostics = diag
-    config = Puppet::Pops::Binder::Config::BinderConfig.new(diagnostics)
-    expect(acceptor.errors?()).to be == false
-    expect(config.layering_config[0]['name']).to    be == 'site'
-    expect(config.layering_config[0]['include']).to be == ['confdir:/default?optional']
-    expect(config.layering_config[1]['name']).to    be == 'modules'
-    expect(config.layering_config[1]['include']).to be == ['module:/*::default', 'module:/*::metadata']
-  end
-
-  it 'should load binder_config.yaml if it exists in confdir)' do
-    Puppet::Pops::Binder::Config::BinderConfig.any_instance.stubs(:confdir).returns(my_fixture("/ok/"))
-    config = Puppet::Pops::Binder::Config::BinderConfig.new(diag)
-    expect(acceptor.errors?()).to be == false
-    expect(config.layering_config[0]['name']).to    be == 'site'
-    expect(config.layering_config[0]['include']).to be == 'confdir:/'
-    expect(config.layering_config[1]['name']).to    be == 'modules'
-    expect(config.layering_config[1]['include']).to be == 'module:/*::test/'
-    expect(config.layering_config[1]['exclude']).to be == 'module:/bad::test/'
-  end
-
-  it 'should correctly set values to default if not defined in bunder_config.yml)' do
-    Puppet::Pops::Binder::Config::BinderConfig.any_instance.stubs(:confdir).returns(my_fixture("/nolayer/"))
-    config = Puppet::Pops::Binder::Config::BinderConfig.new(diag)
-    expect(acceptor.errors?()).to be == false
-    expect(config.layering_config[0]['name']).to    be == 'site'
-  end
-
-  # TODO: test error conditions (see BinderConfigChecker for what to test)
-
-end

data/spec/unit/pops/binder/injector_spec.rb

@@ -1,768 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-module InjectorSpecModule
-  def injector(binder)
-    Puppet::Pops::Binder::Injector.new(binder)
-  end
-
-  def factory
-    Puppet::Pops::Binder::BindingsFactory
-  end
-
-  def test_layer_with_empty_bindings
-    factory.named_layer('test-layer', factory.named_bindings('test').model)
-  end
-
-  def test_layer_with_bindings(*bindings)
-    factory.named_layer('test-layer', *bindings)
-  end
-
-  def null_scope()
-    nil
-  end
-
-  def type_calculator
-    Puppet::Pops::Types::TypeCalculator
-  end
-
-  def type_factory
-    Puppet::Pops::Types::TypeFactory
-  end
-
-  # Returns a binder
-  #
-  def configured_binder
-    b = Puppet::Pops::Binder::Binder.new()
-    b
-  end
-
-  class TestDuck
-  end
-
-  class Daffy < TestDuck
-  end
-
-
-  class AngryDuck < TestDuck
-    # Supports assisted inject, returning a Donald duck as the default impl of Duck
-    def self.inject(injector, scope, binding, *args)
-      Donald.new()
-    end
-  end
-
-  class Donald < AngryDuck
-  end
-
-  class ArneAnka < AngryDuck
-    attr_reader :label
-
-    def initialize()
-      @label = 'A Swedish angry cartoon duck'
-    end
-  end
-
-  class ScroogeMcDuck < TestDuck
-    attr_reader :fortune
-
-    # Supports assisted inject, returning an ScroogeMcDuck with 1$ fortune or first arg in args
-    # Note that when injected (via instance producer, or implict assisted inject, the inject method
-    # always wins.
-    def self.inject(injector, scope, binding, *args)
-      self.new(args[0].nil? ? 1 : args[0])
-    end
-
-    def initialize(fortune)
-      @fortune = fortune
-    end
-  end
-
-  class NamedDuck < TestDuck
-    attr_reader :name
-    def initialize(name)
-      @name = name
-    end
-  end
-
-  # Test custom producer that on each produce returns a duck that is twice as rich as its predecessor
-  class ScroogeProducer < Puppet::Pops::Binder::Producers::Producer
-    attr_reader :next_capital
-    def initialize
-      @next_capital = 100
-    end
-    def produce(scope)
-      ScroogeMcDuck.new(@next_capital *= 2)
-    end
-  end
-end
-
-describe 'Injector' do
-  include InjectorSpecModule
-
-  let(:bindings)  { factory.named_bindings('test') }
-  let(:scope)     { null_scope()}
-  let(:binder)    { Puppet::Pops::Binder::Binder }
-
-  let(:lbinder)   do
-    binder.new(layered_bindings)
-  end
-
-  def duck_type
-    # create distinct instances
-    type_factory.ruby(InjectorSpecModule::TestDuck)
-  end
-
-  let(:layered_bindings) { factory.layered_bindings(test_layer_with_bindings(bindings.model)) }
-
-  context 'When created' do
-    it 'should not raise an error if binder is configured' do
-      expect { injector(lbinder) }.to_not raise_error
-    end
-
-    it 'should create an empty injector given an empty binder' do
-      expect { binder.new(layered_bindings) }.to_not raise_exception
-    end
-
-    it "should be possible to reference the TypeCalculator" do
-      expect(injector(lbinder).type_calculator.is_a?(Puppet::Pops::Types::TypeCalculator)).to eq(true)
-    end
-
-    it "should be possible to reference the KeyFactory" do
-      expect(injector(lbinder).key_factory.is_a?(Puppet::Pops::Binder::KeyFactory)).to eq(true)
-    end
-
-    it "can be created using a model" do
-      bindings.bind.name('a_string').to('42')
-      injector = Puppet::Pops::Binder::Injector.create_from_model(layered_bindings)
-      expect(injector.lookup(scope, 'a_string')).to eq('42')
-    end
-
-    it 'can be created using a block' do
-      injector = Puppet::Pops::Binder::Injector.create('test') do
-        bind.name('a_string').to('42')
-      end
-      expect(injector.lookup(scope, 'a_string')).to eq('42')
-    end
-
-    it 'can be created using a hash' do
-      injector = Puppet::Pops::Binder::Injector.create_from_hash('test', 'a_string' => '42')
-      expect(injector.lookup(scope, 'a_string')).to eq('42')
-    end
-
-    it 'can be created using an overriding injector with block' do
-      injector = Puppet::Pops::Binder::Injector.create('test') do
-        bind.name('a_string').to('42')
-      end
-      injector2 = injector.override('override') do
-        bind.name('a_string').to('43')
-      end
-      expect(injector.lookup(scope, 'a_string')).to eq('42')
-      expect(injector2.lookup(scope, 'a_string')).to eq('43')
-    end
-
-    it 'can be created using an overriding injector with hash' do
-      injector = Puppet::Pops::Binder::Injector.create_from_hash('test', 'a_string' => '42')
-      injector2 = injector.override_with_hash('override', 'a_string' => '43')
-      expect(injector.lookup(scope, 'a_string')).to eq('42')
-      expect(injector2.lookup(scope, 'a_string')).to eq('43')
-    end
-
-    it "can be created using an overriding injector with a model" do
-      injector = Puppet::Pops::Binder::Injector.create_from_hash('test', 'a_string' => '42')
-      bindings.bind.name('a_string').to('43')
-      injector2 = injector.override_with_model(layered_bindings)
-      expect(injector.lookup(scope, 'a_string')).to eq('42')
-      expect(injector2.lookup(scope, 'a_string')).to eq('43')
-    end
-  end
-
-  context "When looking up objects" do
-    it 'lookup(scope, name) finds bound object of type Data with given name' do
-      bindings.bind().name('a_string').to('42')
-      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('42')
-    end
-
-    context 'a block transforming the result can be given' do
-      it 'that transform a found value given scope and value' do
-        bindings.bind().name('a_string').to('42')
-        expect(injector(lbinder).lookup(scope, 'a_string') {|zcope, val| val + '42' }).to eq('4242')
-      end
-
-      it 'that transform a found value given only value' do
-        bindings.bind().name('a_string').to('42')
-        expect(injector(lbinder).lookup(scope, 'a_string') {|val| val + '42' }).to eq('4242')
-      end
-
-      it 'that produces a default value when entry is missing' do
-        bindings.bind().name('a_string').to('42')
-        expect(injector(lbinder).lookup(scope, 'a_non_existing_string') {|val| val ? (raise Error, "Should not happen") : '4242' }).to eq('4242')
-      end
-    end
-
-    context "and class is not bound" do
-      it "assisted inject kicks in for classes with zero args constructor" do
-        duck_type = type_factory.ruby(InjectorSpecModule::Daffy)
-        injector = injector(lbinder)
-        expect(injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::Daffy)).to eq(true)
-        expect(injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::Daffy)).to eq(true)
-      end
-
-      it "assisted inject produces same instance on lookup but not on lookup producer" do
-        duck_type = type_factory.ruby(InjectorSpecModule::Daffy)
-        injector = injector(lbinder)
-        d1 = injector.lookup(scope, duck_type)
-        d2 = injector.lookup(scope, duck_type)
-        expect(d1.equal?(d2)).to eq(true)
-
-        d1 = injector.lookup_producer(scope, duck_type).produce(scope)
-        d2 = injector.lookup_producer(scope, duck_type).produce(scope)
-        expect(d1.equal?(d2)).to eq(false)
-      end
-
-      it "assisted inject kicks in for classes with a class inject method" do
-        duck_type = type_factory.ruby(InjectorSpecModule::ScroogeMcDuck)
-        injector = injector(lbinder)
-        # Do not pass any arguments, the ScroogeMcDuck :inject method should pick 1 by default
-        # This tests zero args passed
-        expect(injector.lookup(scope, duck_type).fortune).to eq(1)
-        expect(injector.lookup_producer(scope, duck_type).produce(scope).fortune).to eq(1)
-      end
-
-      it "assisted inject selects the inject method if it exists over a zero args constructor" do
-        injector = injector(lbinder)
-        duck_type = type_factory.ruby(InjectorSpecModule::AngryDuck)
-        expect(injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::Donald)).to eq(true)
-        expect(injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::Donald)).to eq(true)
-      end
-
-      it "assisted inject selects the zero args constructor if injector is from a superclass" do
-        injector = injector(lbinder)
-        duck_type = type_factory.ruby(InjectorSpecModule::ArneAnka)
-        expect(injector.lookup(scope, duck_type).is_a?(InjectorSpecModule::ArneAnka)).to eq(true)
-        expect(injector.lookup_producer(scope, duck_type).produce(scope).is_a?(InjectorSpecModule::ArneAnka)).to eq(true)
-      end
-    end
-
-    context "and multiple layers are in use" do
-      it "a higher layer shadows anything in a lower layer" do
-        bindings1 = factory.named_bindings('test1')
-        bindings1.bind().name('a_string').to('bad stuff')
-        lower_layer =  factory.named_layer('lower-layer', bindings1.model)
-
-        bindings2 = factory.named_bindings('test2')
-        bindings2.bind().name('a_string').to('good stuff')
-        higher_layer =  factory.named_layer('higher-layer', bindings2.model)
-
-        injector = injector(binder.new(factory.layered_bindings(higher_layer, lower_layer)))
-        expect(injector.lookup(scope,'a_string')).to eq('good stuff')
-      end
-
-      it "a higher layer may not shadow a lower layer binding that is final" do
-        bindings1 = factory.named_bindings('test1')
-        bindings1.bind().final.name('a_string').to('required stuff')
-        lower_layer =  factory.named_layer('lower-layer', bindings1.model)
-
-        bindings2 = factory.named_bindings('test2')
-        bindings2.bind().name('a_string').to('contraband')
-        higher_layer =  factory.named_layer('higher-layer', bindings2.model)
-        expect {
-         injector = injector(binder.new(factory.layered_bindings(higher_layer, lower_layer)))
-        }.to raise_error(/Override of final binding not allowed/)
-      end
-    end
-
-    context "and dealing with Data types" do
-      let(:lbinder) { binder.new(layered_bindings) }
-
-      it "should treat all data as same type w.r.t. key" do
-        bindings.bind().name('a_string').to('42')
-        bindings.bind().name('an_int').to(43)
-        bindings.bind().name('a_float').to(3.14)
-        bindings.bind().name('a_boolean').to(true)
-        bindings.bind().name('an_array').to([1,2,3])
-        bindings.bind().name('a_hash').to({'a'=>1,'b'=>2,'c'=>3})
-
-        injector = injector(lbinder)
-        expect(injector.lookup(scope,'a_string')).to  eq('42')
-        expect(injector.lookup(scope,'an_int')).to    eq(43)
-        expect(injector.lookup(scope,'a_float')).to   eq(3.14)
-        expect(injector.lookup(scope,'a_boolean')).to eq(true)
-        expect(injector.lookup(scope,'an_array')).to  eq([1,2,3])
-        expect(injector.lookup(scope,'a_hash')).to    eq({'a'=>1,'b'=>2,'c'=>3})
-      end
-
-      it "should provide type-safe lookup of given type/name" do
-        bindings.bind().string().name('a_string').to('42')
-        bindings.bind().integer().name('an_int').to(43)
-        bindings.bind().float().name('a_float').to(3.14)
-        bindings.bind().boolean().name('a_boolean').to(true)
-        bindings.bind().array_of_data().name('an_array').to([1,2,3])
-        bindings.bind().hash_of_data().name('a_hash').to({'a'=>1,'b'=>2,'c'=>3})
-
-        injector = injector(lbinder)
-
-        # Check lookup using implied Data type
-        expect(injector.lookup(scope,'a_string')).to  eq('42')
-        expect(injector.lookup(scope,'an_int')).to    eq(43)
-        expect(injector.lookup(scope,'a_float')).to   eq(3.14)
-        expect(injector.lookup(scope,'a_boolean')).to eq(true)
-        expect(injector.lookup(scope,'an_array')).to  eq([1,2,3])
-        expect(injector.lookup(scope,'a_hash')).to    eq({'a'=>1,'b'=>2,'c'=>3})
-
-        # Check lookup using expected type
-        expect(injector.lookup(scope,type_factory.string(), 'a_string')).to        eq('42')
-        expect(injector.lookup(scope,type_factory.integer(), 'an_int')).to         eq(43)
-        expect(injector.lookup(scope,type_factory.float(),'a_float')).to           eq(3.14)
-        expect(injector.lookup(scope,type_factory.boolean(),'a_boolean')).to       eq(true)
-        expect(injector.lookup(scope,type_factory.array_of_data(),'an_array')).to  eq([1,2,3])
-        expect(injector.lookup(scope,type_factory.hash_of_data(),'a_hash')).to     eq({'a'=>1,'b'=>2,'c'=>3})
-
-        # Check lookup using wrong type
-        expect { injector.lookup(scope,type_factory.integer(), 'a_string')}.to raise_error(/Type error/)
-        expect { injector.lookup(scope,type_factory.string(), 'an_int')}.to raise_error(/Type error/)
-        expect { injector.lookup(scope,type_factory.string(),'a_float')}.to raise_error(/Type error/)
-        expect { injector.lookup(scope,type_factory.string(),'a_boolean')}.to raise_error(/Type error/)
-        expect { injector.lookup(scope,type_factory.string(),'an_array')}.to raise_error(/Type error/)
-        expect { injector.lookup(scope,type_factory.string(),'a_hash')}.to raise_error(/Type error/)
-      end
-    end
-  end
-
-  context "When looking up producer" do
-    it 'the value is produced by calling produce(scope)' do
-      bindings.bind().name('a_string').to('42')
-      expect(injector(lbinder).lookup_producer(scope, 'a_string').produce(scope)).to eq('42')
-    end
-
-    context 'a block transforming the result can be given' do
-      it 'that transform a found value given scope and producer' do
-        bindings.bind().name('a_string').to('42')
-        expect(injector(lbinder).lookup_producer(scope, 'a_string') {|zcope, p| p.produce(zcope) + '42' }).to eq('4242')
-      end
-
-      it 'that transform a found value given only producer' do
-        bindings.bind().name('a_string').to('42')
-        expect(injector(lbinder).lookup_producer(scope, 'a_string') {|p| p.produce(scope) + '42' }).to eq('4242')
-      end
-
-      it 'that can produce a default value when entry is not found' do
-        bindings.bind().name('a_string').to('42')
-        expect(injector(lbinder).lookup_producer(scope, 'a_non_existing_string') {|p| p ? (raise Error,"Should not happen") : '4242' }).to eq('4242')
-      end
-    end
-  end
-
-  context "When dealing with singleton vs. non singleton" do
-    it "should produce the same instance when producer is a singleton" do
-      bindings.bind().name('a_string').to('42')
-      injector = injector(lbinder)
-      a = injector.lookup(scope, 'a_string')
-      b = injector.lookup(scope, 'a_string')
-      expect(a.equal?(b)).to eq(true)
-    end
-
-    it "should produce different instances when producer is a non singleton producer" do
-      bindings.bind().name('a_string').to_series_of('42')
-      injector = injector(lbinder)
-      a = injector.lookup(scope, 'a_string')
-      b = injector.lookup(scope, 'a_string')
-      expect(a).to eq('42')
-      expect(b).to eq('42')
-      expect(a.equal?(b)).to eq(false)
-    end
-  end
-
-  context "When using the lookup producer" do
-    it "should lookup again to produce a value" do
-      bindings.bind().name('a_string').to_lookup_of('another_string')
-      bindings.bind().name('another_string').to('hello')
-      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('hello')
-    end
-
-    it "should produce nil if looked up key does not exist" do
-      bindings.bind().name('a_string').to_lookup_of('non_existing')
-      expect(injector(lbinder).lookup(scope, 'a_string')).to eq(nil)
-    end
-
-    it "should report an error if lookup loop is detected" do
-      bindings.bind().name('a_string').to_lookup_of('a_string')
-      expect { injector(lbinder).lookup(scope, 'a_string') }.to raise_error(/Lookup loop/)
-    end
-  end
-
-  context "When using the hash lookup producer" do
-    it "should lookup a key in looked up hash" do
-      data_hash = type_factory.hash_of_data()
-      bindings.bind().name('a_string').to_hash_lookup_of(data_hash, 'a_hash', 'huey')
-      bindings.bind().name('a_hash').to({'huey' => 'red', 'dewey' => 'blue', 'louie' => 'green'})
-      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('red')
-    end
-
-    it "should produce nil if looked up entry does not exist" do
-      data_hash = type_factory.hash_of_data()
-      bindings.bind().name('a_string').to_hash_lookup_of(data_hash, 'non_existing_entry', 'huey')
-      bindings.bind().name('a_hash').to({'huey' => 'red', 'dewey' => 'blue', 'louie' => 'green'})
-      expect(injector(lbinder).lookup(scope, 'a_string')).to eq(nil)
-    end
-  end
-
-  context "When using the first found producer" do
-    it "should lookup until it finds a value, but not further" do
-      bindings.bind().name('a_string').to_first_found('b_string', 'c_string', 'g_string')
-      bindings.bind().name('c_string').to('hello')
-      bindings.bind().name('g_string').to('Oh, mrs. Smith...')
-      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('hello')
-    end
-
-    it "should lookup until it finds a value using mix of type and name, but not further" do
-      bindings.bind().name('a_string').to_first_found('b_string', [type_factory.string, 'c_string'], 'g_string')
-      bindings.bind().name('c_string').to('hello')
-      bindings.bind().name('g_string').to('Oh, mrs. Smith...')
-      expect(injector(lbinder).lookup(scope, 'a_string')).to eq('hello')
-    end
-  end
-
-  context "When producing instances" do
-    it "should lookup an instance of a class without arguments" do
-      bindings.bind().type(duck_type).name('the_duck').to(InjectorSpecModule::Daffy)
-      expect(injector(lbinder).lookup(scope, duck_type, 'the_duck').is_a?(InjectorSpecModule::Daffy)).to eq(true)
-    end
-
-    it "should lookup an instance of a class with arguments" do
-      bindings.bind().type(duck_type).name('the_duck').to(InjectorSpecModule::ScroogeMcDuck, 1234)
-      injector = injector(lbinder)
-
-      the_duck = injector.lookup(scope, duck_type, 'the_duck')
-      expect(the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck)).to eq(true)
-      expect(the_duck.fortune).to eq(1234)
-    end
-
-    it "singleton producer should not be recreated between lookups" do
-      bindings.bind().type(duck_type).name('the_duck').to_producer(InjectorSpecModule::ScroogeProducer)
-      injector = injector(lbinder)
-
-      the_duck = injector.lookup(scope, duck_type, 'the_duck')
-      expect(the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck)).to eq(true)
-      expect(the_duck.fortune).to eq(200)
-
-      # singleton, do it again to get next value in series - it is the producer that is a singleton
-      # not the produced value
-      the_duck = injector.lookup(scope, duck_type, 'the_duck')
-      expect(the_duck.is_a?(InjectorSpecModule::ScroogeMcDuck)).to eq(true)
-      expect(the_duck.fortune).to eq(400)
-
-      duck_producer = injector.lookup_producer(scope, duck_type, 'the_duck')
-      expect(duck_producer.produce(scope).fortune).to eq(800)
-    end
-
-    it "series of producers should recreate producer on each lookup and lookup_producer" do
-      bindings.bind().type(duck_type).name('the_duck').to_producer_series(InjectorSpecModule::ScroogeProducer)
-      injector = injector(lbinder)
-
-      duck_producer = injector.lookup_producer(scope, duck_type, 'the_duck')
-      expect(duck_producer.produce(scope).fortune()).to eq(200)
-      expect(duck_producer.produce(scope).fortune()).to eq(400)
-
-      # series, each lookup gets a new producer (initialized to produce 200)
-      duck_producer = injector.lookup_producer(scope, duck_type, 'the_duck')
-      expect(duck_producer.produce(scope).fortune()).to eq(200)
-      expect(duck_producer.produce(scope).fortune()).to eq(400)
-
-      expect(injector.lookup(scope, duck_type, 'the_duck').fortune()).to eq(200)
-      expect(injector.lookup(scope, duck_type, 'the_duck').fortune()).to eq(200)
-    end
-  end
-
-  context "When working with multibind" do
-    context "of hash kind" do
-      it "a multibind produces contributed items keyed by their bound key-name" do
-        hash_of_duck = type_factory.hash_of(duck_type)
-        multibind_id = "ducks"
-
-        bindings.multibind(multibind_id).type(hash_of_duck).name('donalds_nephews')
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('nephew1').to(InjectorSpecModule::NamedDuck, 'Huey')
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('nephew2').to(InjectorSpecModule::NamedDuck, 'Dewey')
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('nephew3').to(InjectorSpecModule::NamedDuck, 'Louie')
-
-        injector = injector(lbinder)
-        the_ducks = injector.lookup(scope, hash_of_duck, "donalds_nephews")
-        expect(the_ducks.size).to eq(3)
-        expect(the_ducks['nephew1'].name).to eq('Huey')
-        expect(the_ducks['nephew2'].name).to eq('Dewey')
-        expect(the_ducks['nephew3'].name).to eq('Louie')
-      end
-
-      it "is an error to not bind contribution with a name" do
-        hash_of_duck = type_factory.hash_of(duck_type)
-        multibind_id = "ducks"
-
-        bindings.multibind(multibind_id).type(hash_of_duck).name('donalds_nephews')
-        # missing name
-        bindings.bind.in_multibind(multibind_id).type(duck_type).to(InjectorSpecModule::NamedDuck, 'Huey')
-        bindings.bind.in_multibind(multibind_id).type(duck_type).to(InjectorSpecModule::NamedDuck, 'Dewey')
-
-        expect {
-          the_ducks = injector(lbinder).lookup(scope, hash_of_duck, "donalds_nephews")
-        }.to raise_error(/must have a name/)
-      end
-
-      it "is an error to bind with duplicate key when using default (priority) conflict resolution" do
-        hash_of_duck = type_factory.hash_of(duck_type)
-        multibind_id = "ducks"
-
-        bindings.multibind(multibind_id).type(hash_of_duck).name('donalds_nephews')
-        # missing name
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('foo').to(InjectorSpecModule::NamedDuck, 'Huey')
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('foo').to(InjectorSpecModule::NamedDuck, 'Dewey')
-
-        expect {
-          the_ducks = injector(lbinder).lookup(scope, hash_of_duck, "donalds_nephews")
-        }.to raise_error(/Duplicate key/)
-      end
-
-      it "is not an error to bind with duplicate key when using (ignore) conflict resolution" do
-        hash_of_duck = type_factory.hash_of(duck_type)
-        multibind_id = "ducks"
-
-        bindings.multibind(multibind_id).type(hash_of_duck).name('donalds_nephews').producer_options(:conflict_resolution => :ignore)
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('foo').to(InjectorSpecModule::NamedDuck, 'Huey')
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('foo').to(InjectorSpecModule::NamedDuck, 'Dewey')
-
-        expect {
-          the_ducks = injector(lbinder).lookup(scope, hash_of_duck, "donalds_nephews")
-        }.to_not raise_error
-      end
-
-      it "should produce detailed type error message" do
-        hash_of_integer = type_factory.hash_of(type_factory.integer())
-
-        multibind_id = "ints"
-        mb = bindings.multibind(multibind_id).type(hash_of_integer).name('donalds_family')
-        bindings.bind.in_multibind(multibind_id).name('nephew').to('Huey')
-
-        expect { ducks = injector(lbinder).lookup(scope, 'donalds_family')
-        }.to raise_error(%r{expected: Integer, got: String})
-      end
-
-      it "should be possible to combine hash multibind contributions with append on conflict" do
-        # This case uses a multibind of individual strings, but combines them
-        # into an array bound to a hash key
-        # (There are other ways to do this - e.g. have the multibind lookup a multibind
-        # of array type to which nephews are contributed).
-        #
-        hash_of_data = type_factory.hash_of_data()
-        multibind_id = "ducks"
-        mb = bindings.multibind(multibind_id).type(hash_of_data).name('donalds_family')
-        mb.producer_options(:conflict_resolution => :append)
-
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Huey')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Dewey')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Louie')
-        bindings.bind.in_multibind(multibind_id).name('uncles').to('Scrooge McDuck')
-        bindings.bind.in_multibind(multibind_id).name('uncles').to('Ludwig Von Drake')
-
-        ducks = injector(lbinder).lookup(scope, 'donalds_family')
-
-        expect(ducks['nephews']).to eq(['Huey', 'Dewey', 'Louie'])
-        expect(ducks['uncles']).to eq(['Scrooge McDuck', 'Ludwig Von Drake'])
-      end
-
-      it "should be possible to combine hash multibind contributions with append, flat, and uniq, on conflict" do
-        # This case uses a multibind of individual strings, but combines them
-        # into an array bound to a hash key
-        # (There are other ways to do this - e.g. have the multibind lookup a multibind
-        # of array type to which nephews are contributed).
-        #
-        hash_of_data = type_factory.hash_of_data()
-        multibind_id = "ducks"
-        mb = bindings.multibind(multibind_id).type(hash_of_data).name('donalds_family')
-        mb.producer_options(:conflict_resolution => :append, :flatten => true, :uniq => true)
-
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Huey')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Huey')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Dewey')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to(['Huey', ['Louie'], 'Dewey'])
-        bindings.bind.in_multibind(multibind_id).name('uncles').to('Scrooge McDuck')
-        bindings.bind.in_multibind(multibind_id).name('uncles').to('Ludwig Von Drake')
-
-        ducks = injector(lbinder).lookup(scope, 'donalds_family')
-
-        expect(ducks['nephews']).to eq(['Huey', 'Dewey', 'Louie'])
-        expect(ducks['uncles']).to eq(['Scrooge McDuck', 'Ludwig Von Drake'])
-      end
-
-      it "should fail attempts to append, perform  uniq or flatten on type incompatible multibind hash" do
-        hash_of_integer = type_factory.hash_of(type_factory.integer())
-        ids = ["ducks1", "ducks2", "ducks3"]
-        mb = bindings.multibind(ids[0]).type(hash_of_integer).name('broken_family0')
-        mb.producer_options(:conflict_resolution => :append)
-        mb = bindings.multibind(ids[1]).type(hash_of_integer).name('broken_family1')
-        mb.producer_options(:flatten => :true)
-        mb = bindings.multibind(ids[2]).type(hash_of_integer).name('broken_family2')
-        mb.producer_options(:uniq => :true)
-
-        injector = injector(binder.new(factory.layered_bindings(test_layer_with_bindings(bindings.model))))
-        expect { injector.lookup(scope, 'broken_family0')}.to raise_error(/:conflict_resolution => :append/)
-        expect { injector.lookup(scope, 'broken_family1')}.to raise_error(/:flatten/)
-        expect { injector.lookup(scope, 'broken_family2')}.to raise_error(/:uniq/)
-      end
-
-      it "a higher priority contribution wins when resolution is :merge" do
-        # THIS TEST MAY DEPEND ON HASH ORDER SINCE PRIORITY BASED ON CATEGORY IS REMOVED
-        hash_of_data = type_factory.hash_of_data()
-        multibind_id = "hashed_ducks"
-
-        bindings.multibind(multibind_id).type(hash_of_data).name('donalds_nephews').producer_options(:conflict_resolution => :merge)
-
-        mb1 = bindings.bind.in_multibind(multibind_id)
-        mb1.name('nephew').to({'name' => 'Huey', 'is' => 'winner'})
-
-        mb2 = bindings.bind.in_multibind(multibind_id)
-        mb2.name('nephew').to({'name' => 'Dewey', 'is' => 'looser', 'has' => 'cap'})
-
-        the_ducks = injector(binder.new(layered_bindings)).lookup(scope, "donalds_nephews");
-        expect(the_ducks['nephew']['name']).to eq('Huey')
-        expect(the_ducks['nephew']['is']).to eq('winner')
-        expect(the_ducks['nephew']['has']).to eq('cap')
-      end
-    end
-
-    context "of array kind" do
-      it "an array multibind produces contributed items, names are allowed but ignored" do
-        array_of_duck = type_factory.array_of(duck_type)
-        multibind_id = "ducks"
-
-        bindings.multibind(multibind_id).type(array_of_duck).name('donalds_nephews')
-        # one with name (ignored, expect no error)
-        bindings.bind.in_multibind(multibind_id).type(duck_type).name('nephew1').to(InjectorSpecModule::NamedDuck, 'Huey')
-        # two without name
-        bindings.bind.in_multibind(multibind_id).type(duck_type).to(InjectorSpecModule::NamedDuck, 'Dewey')
-        bindings.bind.in_multibind(multibind_id).type(duck_type).to(InjectorSpecModule::NamedDuck, 'Louie')
-
-        the_ducks = injector(lbinder).lookup(scope, array_of_duck, "donalds_nephews")
-        expect(the_ducks.size).to eq(3)
-        expect(the_ducks.collect {|d| d.name }.sort).to eq(['Dewey', 'Huey', 'Louie'])
-      end
-
-      it "should be able to make result contain only unique entries" do
-        # This case uses a multibind of individual strings, and combines them
-        # into an array of unique values
-        #
-        array_of_data = type_factory.array_of_data()
-        multibind_id = "ducks"
-        mb = bindings.multibind(multibind_id).type(array_of_data).name('donalds_family')
-        # turn off priority on named to not trigger conflict as all additions have the same precedence
-        # (could have used the default for unnamed and add unnamed entries).
-        mb.producer_options(:priority_on_named => false, :uniq => true)
-
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Huey')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Dewey')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Dewey') # duplicate
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Louie')
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Louie') # duplicate
-        bindings.bind.in_multibind(multibind_id).name('nephews').to('Louie') # duplicate
-
-        ducks = injector(lbinder).lookup(scope, 'donalds_family')
-        expect(ducks).to eq(['Huey', 'Dewey', 'Louie'])
-      end
-
-      it "should be able to contribute elements and arrays of elements and flatten 1 level" do
-        # This case uses a multibind of individual strings and arrays, and combines them
-        # into an array of flattened
-        #
-        array_of_string = type_factory.array_of(type_factory.string())
-
-        multibind_id = "ducks"
-        mb = bindings.multibind(multibind_id).type(array_of_string).name('donalds_family')
-        # flatten one level
-        mb.producer_options(:flatten => 1)
-
-        bindings.bind.in_multibind(multibind_id).to('Huey')
-        bindings.bind.in_multibind(multibind_id).to('Dewey')
-        bindings.bind.in_multibind(multibind_id).to('Louie') # duplicate
-        bindings.bind.in_multibind(multibind_id).to(['Huey', 'Dewey', 'Louie'])
-
-        ducks = injector(lbinder).lookup(scope, 'donalds_family')
-        expect(ducks).to eq(['Huey', 'Dewey', 'Louie', 'Huey', 'Dewey', 'Louie'])
-      end
-
-      it "should produce detailed type error message" do
-        array_of_integer = type_factory.array_of(type_factory.integer())
-
-        multibind_id = "ints"
-        mb = bindings.multibind(multibind_id).type(array_of_integer).name('donalds_family')
-        bindings.bind.in_multibind(multibind_id).to('Huey')
-
-        expect { ducks = injector(lbinder).lookup(scope, 'donalds_family')
-        }.to raise_error(%r{expected: Integer, or Array\[Integer\], got: String})
-      end
-    end
-
-    context "When using multibind in multibind" do
-      it "a hash multibind can be contributed to another" do
-        hash_of_data = type_factory.hash_of_data()
-        mb1_id = 'data1'
-        mb2_id = 'data2'
-        top = bindings.multibind(mb1_id).type(hash_of_data).name("top")
-        detail = bindings.multibind(mb2_id).type(hash_of_data).name("detail").in_multibind(mb1_id)
-
-        bindings.bind.in_multibind(mb1_id).name('a').to(10)
-        bindings.bind.in_multibind(mb1_id).name('b').to(20)
-        bindings.bind.in_multibind(mb2_id).name('a').to(30)
-        bindings.bind.in_multibind(mb2_id).name('b').to(40)
-        expect( injector(lbinder).lookup(scope, "top") ).to eql({'detail' => {'a' => 30, 'b' => 40}, 'a' => 10, 'b' => 20})
-      end
-    end
-
-    context "When looking up entries requiring evaluation" do
-      let(:node)     { Puppet::Node.new('localhost') }
-      let(:compiler) { Puppet::Parser::Compiler.new(node)}
-      let(:scope)    { Puppet::Parser::Scope.new(compiler) }
-      let(:parser)   { Puppet::Pops::Parser::Parser.new() }
-
-      it "should be possible to lookup a concatenated string" do
-        scope['duck'] = 'Donald Fauntleroy Duck'
-        expr = parser.parse_string('"Hello $duck"').current()
-        bindings.bind.name('the_duck').to(expr)
-        expect(injector(lbinder).lookup(scope, 'the_duck')).to eq('Hello Donald Fauntleroy Duck')
-      end
-
-      it "should be possible to post process lookup with a puppet lambda" do
-        model = parser.parse_string('fake() |$value| {$value + 1 }').current
-        bindings.bind.name('an_int').to(42).producer_options( :transformer => model.body.lambda)
-        expect(injector(lbinder).lookup(scope, 'an_int')).to eq(43)
-      end
-
-      it "should be possible to post process lookup with a ruby proc" do
-        transformer = lambda {|value| value + 1 }
-        bindings.bind.name('an_int').to(42).producer_options( :transformer => transformer)
-        expect(injector(lbinder).lookup(scope, 'an_int')).to eq(43)
-      end
-    end
-  end
-
-  context "When there are problems with configuration" do
-    let(:lbinder) { binder.new(layered_bindings) }
-
-    it "reports error for surfacing abstract bindings" do
-      bindings.bind.abstract.name('an_int')
-      expect{injector(lbinder).lookup(scope, 'an_int') }.to raise_error(/The abstract binding .* was not overridden/)
-    end
-
-    it "does not report error for abstract binding that is ovrridden" do
-      bindings.bind.abstract.name('an_int')
-      bindings.bind.override.name('an_int').to(142)
-      expect{ injector(lbinder).lookup(scope, 'an_int') }.to_not raise_error
-    end
-
-    it "reports error for overriding binding that does not override" do
-      bindings.bind.override.name('an_int').to(42)
-      expect{injector(lbinder).lookup(scope, 'an_int') }.to raise_error(/Binding with unresolved 'override' detected/)
-    end
-
-    it "reports error for binding  without producer" do
-      bindings.bind.name('an_int')
-      expect{injector(lbinder).lookup(scope, 'an_int') }.to raise_error(/Binding without producer/)
-    end
-  end
-end