puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/spec/unit/pops/evaluator/variables_spec.rb

@@ -46,7 +46,7 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
       end
 
       it "can not change a variable value in same scope" do
-        expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable '\$a'/)
+        expect { evaluate_l(block(var('a').set(literal(10)), var('a').set(literal(20)))) }.to raise_error(/Cannot reassign variable '\$a'/)
       end
 
       context "access to numeric variables" do

data/spec/unit/pops/factory_rspec_helper.rb

@@ -21,10 +21,6 @@ module FactoryRspecHelper
     Puppet::Pops::Model::Factory.string(*args)
   end
 
-  def text(x)
-    Puppet::Pops::Model::Factory.text(x)
-  end
-
   def minus(x)
     Puppet::Pops::Model::Factory.minus(x)
   end

data/spec/unit/pops/factory_spec.rb

@@ -11,55 +11,55 @@ describe Puppet::Pops::Model::Factory do
 
   context "When factory methods are invoked they should produce expected results" do
     it "tests #var should create a VariableExpression" do
-      expect(var('a').current.class).to eq(Puppet::Pops::Model::VariableExpression)
+      expect(var('a').model.class).to eq(Puppet::Pops::Model::VariableExpression)
     end
 
     it "tests #fqn should create a QualifiedName" do
-      expect(fqn('a').current.class).to eq(Puppet::Pops::Model::QualifiedName)
+      expect(fqn('a').model.class).to eq(Puppet::Pops::Model::QualifiedName)
     end
 
     it "tests #QNAME should create a QualifiedName" do
-      expect(QNAME('a').current.class).to eq(Puppet::Pops::Model::QualifiedName)
+      expect(QNAME('a').model.class).to eq(Puppet::Pops::Model::QualifiedName)
     end
 
     it "tests #QREF should create a QualifiedReference" do
-      expect(QREF('a').current.class).to eq(Puppet::Pops::Model::QualifiedReference)
+      expect(QREF('a').model.class).to eq(Puppet::Pops::Model::QualifiedReference)
     end
 
     it "tests #block should create a BlockExpression" do
-      expect(block().current.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
+      expect(block().model.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
     end
 
     it "should create a literal undef on :undef" do
-      expect(literal(:undef).current.class).to eq(Puppet::Pops::Model::LiteralUndef)
+      expect(literal(:undef).model.class).to eq(Puppet::Pops::Model::LiteralUndef)
     end
 
     it "should create a literal default on :default" do
-      expect(literal(:default).current.class).to eq(Puppet::Pops::Model::LiteralDefault)
+      expect(literal(:default).model.class).to eq(Puppet::Pops::Model::LiteralDefault)
     end
   end
 
   context "When calling block_or_expression" do
     it "A single expression should produce identical output" do
-      expect(block_or_expression(literal(1) + literal(2)).current.is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
+      expect(block_or_expression([literal(1) + literal(2)]).model.is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
     end
 
     it "Multiple expressions should produce a block expression" do
-      built = block_or_expression(literal(1) + literal(2), literal(2) + literal(3)).current
-      expect(built.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
-      expect(built.statements.size).to eq(2)
+      model = block_or_expression([literal(1) + literal(2), literal(2) + literal(3)]).model
+      expect(model.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
+      expect(model.statements.size).to eq(2)
     end
   end
 
   context "When processing calls with CALL_NAMED" do
     it "Should be possible to state that r-value is required" do
-      built = CALL_NAMED("foo", true, []).current
+      built = call_named('foo', true).model
       expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
       expect(built.rval_required).to eq(true)
     end
 
     it "Should produce a call expression without arguments" do
-      built = CALL_NAMED("foo", false, []).current
+      built = call_named('foo', false).model
       expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
       expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
       expect(built.functor_expr.value).to eq("foo")
@@ -68,7 +68,7 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "Should produce a call expression with one argument" do
-      built = CALL_NAMED("foo", false, [literal(1) + literal(2)]).current
+      built = call_named('foo', false, literal(1) + literal(2)).model
       expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
       expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
       expect(built.functor_expr.value).to eq("foo")
@@ -78,7 +78,7 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "Should produce a call expression with two arguments" do
-      built = CALL_NAMED("foo", false, [literal(1) + literal(2), literal(1) + literal(2)]).current
+      built = call_named('foo', false, literal(1) + literal(2), literal(1) + literal(2)).model
       expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
       expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
       expect(built.functor_expr.value).to eq("foo")
@@ -91,17 +91,17 @@ describe Puppet::Pops::Model::Factory do
 
   context "When creating attribute operations" do
     it "Should produce an attribute operation for =>" do
-      built = ATTRIBUTE_OP("aname", :'=>', 'x').current
+      built = ATTRIBUTE_OP('aname', '=>', literal('x')).model
       built.is_a?(Puppet::Pops::Model::AttributeOperation)
-      expect(built.operator).to eq(:'=>')
+      expect(built.operator).to eq('=>')
       expect(built.attribute_name).to eq("aname")
       expect(built.value_expr.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
     end
 
     it "Should produce an attribute operation for +>" do
-      built = ATTRIBUTE_OP("aname", :'+>', 'x').current
+      built = ATTRIBUTE_OP('aname', '+>', literal('x')).model
       built.is_a?(Puppet::Pops::Model::AttributeOperation)
-      expect(built.operator).to eq(:'+>')
+      expect(built.operator).to eq('+>')
       expect(built.attribute_name).to eq("aname")
       expect(built.value_expr.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
     end
@@ -109,7 +109,7 @@ describe Puppet::Pops::Model::Factory do
 
   context "When processing RESOURCE" do
     it "Should create a Resource body" do
-      built = RESOURCE_BODY("title", [ATTRIBUTE_OP('aname', :'=>', 'x')]).current
+      built = RESOURCE_BODY(literal('title'), [ATTRIBUTE_OP('aname', '=>', literal('x'))]).model
       expect(built.is_a?(Puppet::Pops::Model::ResourceBody)).to eq(true)
       expect(built.title.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
       expect(built.operations.size).to eq(1)
@@ -119,22 +119,22 @@ describe Puppet::Pops::Model::Factory do
 
     it "Should create a RESOURCE without a resource body" do
       bodies = []
-      built = RESOURCE("rtype", bodies).current
+      built = RESOURCE(literal('rtype'), bodies).model
       expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
       expect(built.bodies.size).to eq(0)
     end
 
     it "Should create a RESOURCE with 1 resource body" do
-      bodies = [] << RESOURCE_BODY('title', [])
-      built = RESOURCE("rtype", bodies).current
+      bodies = [] << RESOURCE_BODY(literal('title'), [])
+      built = RESOURCE(literal('rtype'), bodies).model
       expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
       expect(built.bodies.size).to eq(1)
       expect(built.bodies[0].title.value).to eq('title')
     end
 
     it "Should create a RESOURCE with 2 resource bodies" do
-      bodies = [] << RESOURCE_BODY('title', []) << RESOURCE_BODY('title2', [])
-      built = RESOURCE("rtype", bodies).current
+      bodies = [] << RESOURCE_BODY(literal('title'), []) << RESOURCE_BODY(literal('title2'), [])
+      built = RESOURCE(literal('rtype'), bodies).model
       expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
       expect(built.bodies.size).to eq(2)
       expect(built.bodies[0].title.value).to eq('title')
@@ -144,40 +144,40 @@ describe Puppet::Pops::Model::Factory do
 
   context "When processing simple literals" do
     it "Should produce a literal boolean from a boolean" do
-      built = literal(true).current
-      expect(built.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(built.value).to eq(true)
-      built = literal(false).current
-      expect(built.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(built.value).to eq(false)
+      model = literal(true).model
+      expect(model.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(model.value).to eq(true)
+      model = literal(false).model
+      expect(model.class).to eq(Puppet::Pops::Model::LiteralBoolean)
+      expect(model.value).to eq(false)
     end
   end
 
   context "When processing COLLECT" do
     it "should produce a virtual query" do
-      built = VIRTUAL_QUERY(fqn('a') == literal(1)).current
-      expect(built.class).to eq(Puppet::Pops::Model::VirtualQuery)
-      expect(built.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
-      expect(built.expr.operator).to eq(:'==')
+      model = VIRTUAL_QUERY(fqn('a').eq(literal(1))).model
+      expect(model.class).to eq(Puppet::Pops::Model::VirtualQuery)
+      expect(model.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
+      expect(model.expr.operator).to eq('==')
     end
 
     it "should produce an export query" do
-      built = EXPORTED_QUERY(fqn('a') == literal(1)).current
-      expect(built.class).to eq(Puppet::Pops::Model::ExportedQuery)
-      expect(built.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
-      expect(built.expr.operator).to eq(:'==')
+      model = EXPORTED_QUERY(fqn('a').eq(literal(1))).model
+      expect(model.class).to eq(Puppet::Pops::Model::ExportedQuery)
+      expect(model.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
+      expect(model.expr.operator).to eq('==')
     end
 
     it "should produce a collect expression" do
-      q = VIRTUAL_QUERY(fqn('a') == literal(1))
-      built = COLLECT(literal('t'), q, [ATTRIBUTE_OP('name', :'=>', 3)]).current
+      q = VIRTUAL_QUERY(fqn('a').eq(literal(1)))
+      built = COLLECT(literal('t'), q, [ATTRIBUTE_OP('name', '=>', literal(3))]).model
       expect(built.class).to eq(Puppet::Pops::Model::CollectExpression)
       expect(built.operations.size).to eq(1)
     end
 
     it "should produce a collect expression without attribute operations" do
-      q = VIRTUAL_QUERY(fqn('a') == literal(1))
-      built = COLLECT(literal('t'), q, []).current
+      q = VIRTUAL_QUERY(fqn('a').eq(literal(1)))
+      built = COLLECT(literal('t'), q, []).model
       expect(built.class).to eq(Puppet::Pops::Model::CollectExpression)
       expect(built.operations.size).to eq(0)
     end
@@ -185,63 +185,63 @@ describe Puppet::Pops::Model::Factory do
 
   context "When processing concatenated string(iterpolation)" do
     it "should handle 'just a string'" do
-      built = string('blah blah').current
-      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      built.segments.size == 1
-      expect(built.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(built.segments[0].value).to eq("blah blah")
+      model = string('blah blah').model
+      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
+      model.segments.size == 1
+      expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(model.segments[0].value).to eq("blah blah")
     end
 
     it "should handle one expression in the middle" do
-      built = string('blah blah', TEXT(literal(1)+literal(2)), 'blah blah').current
-      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      built.segments.size == 3
-      expect(built.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(built.segments[0].value).to eq("blah blah")
-      expect(built.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(built.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
-      expect(built.segments[2].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(built.segments[2].value).to eq("blah blah")
+      model = string('blah blah', TEXT(literal(1)+literal(2)), 'blah blah').model
+      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
+      model.segments.size == 3
+      expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(model.segments[0].value).to eq("blah blah")
+      expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(model.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
+      expect(model.segments[2].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(model.segments[2].value).to eq("blah blah")
     end
 
     it "should handle one expression at the end" do
-      built = string('blah blah', TEXT(literal(1)+literal(2))).current
-      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      built.segments.size == 2
-      expect(built.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(built.segments[0].value).to eq("blah blah")
-      expect(built.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(built.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
+      model = string('blah blah', TEXT(literal(1)+literal(2))).model
+      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
+      model.segments.size == 2
+      expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
+      expect(model.segments[0].value).to eq("blah blah")
+      expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(model.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
 
     it "should handle only one expression" do
-      built = string(TEXT(literal(1)+literal(2))).current
-      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      built.segments.size == 1
-      expect(built.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(built.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
+      model = string(TEXT(literal(1)+literal(2))).model
+      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
+      model.segments.size == 1
+      expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
 
     it "should handle several expressions" do
-      built = string(TEXT(literal(1)+literal(2)), TEXT(literal(1)+literal(2))).current
-      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      built.segments.size == 2
-      expect(built.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(built.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
-      expect(built.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(built.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
+      model = string(TEXT(literal(1)+literal(2)), TEXT(literal(1)+literal(2))).model
+      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
+      model.segments.size == 2
+      expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
+      expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
+      expect(model.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
 
     it "should handle no expression" do
-      built = string().current
-      expect(built.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      built.segments.size == 0
+      model = string().model
+      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
+      model.segments.size == 0
     end
   end
 
   context "When processing UNLESS" do
     it "should create an UNLESS expression with then part" do
-      built = UNLESS(true, literal(1), nil).current
+      built = UNLESS(literal(true), literal(1), literal(nil)).model
       expect(built.class).to eq(Puppet::Pops::Model::UnlessExpression)
       expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
       expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
@@ -249,7 +249,7 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "should create an UNLESS expression with then and else parts" do
-      built = UNLESS(true, literal(1), literal(2)).current
+      built = UNLESS(literal(true), literal(1), literal(2)).model
       expect(built.class).to eq(Puppet::Pops::Model::UnlessExpression)
       expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
       expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
@@ -259,7 +259,7 @@ describe Puppet::Pops::Model::Factory do
 
   context "When processing IF" do
     it "should create an IF expression with then part" do
-      built = IF(true, literal(1), nil).current
+      built = IF(literal(true), literal(1), literal(nil)).model
       expect(built.class).to eq(Puppet::Pops::Model::IfExpression)
       expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
       expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
@@ -267,7 +267,7 @@ describe Puppet::Pops::Model::Factory do
     end
 
     it "should create an IF expression with then and else parts" do
-      built = IF(true, literal(1), literal(2)).current
+      built = IF(literal(true), literal(1), literal(2)).model
       expect(built.class).to eq(Puppet::Pops::Model::IfExpression)
       expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
       expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -476,6 +476,9 @@ describe 'loaders' do
 
       let(:env_dir_files) do
         {
+          'types' => {
+            'c.pp' => 'type C = Integer'
+          },
           'modules' => {
             'a' => {
               'manifests' => {
@@ -496,7 +499,27 @@ describe 'loaders' do
             },
             'c' => {
               'types' => {
-                'c.pp' => 'type C::C = Integer'
+                'init_typeset.pp' => <<-PUPPET.unindent,
+                  type C = TypeSet[{
+                    pcore_version => '1.0.0',
+                    types => {
+                      C => Integer,
+                      D => Float
+                    }
+                  }]
+                  PUPPET
+                'd.pp' => <<-PUPPET.unindent,
+                  type C::D = TypeSet[{
+                    pcore_version => '1.0.0',
+                    types => {
+                      X => String,
+                      Y => Float
+                    }
+                  }]
+                  PUPPET
+                'd' => {
+                  'y.pp' => 'type C::D::Y = Integer'
+                }
               },
               'metadata.json' => sprintf(metadata_json, 'c', '')
             },
@@ -545,6 +568,51 @@ describe 'loaders' do
         expect(type).to be_a(Puppet::Pops::Types::PTypeReferenceType)
         expect(type.type_string).to eql('A::A')
       end
+
+      it 'does not resolve init_typeset when more qualified type is found in typeset' do
+        type = Puppet::Pops::Types::TypeParser.singleton.parse('C::D::X', Puppet::Pops::Loaders.find_loader('c'))
+        expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+        expect(type.resolved_type).to be_a(Puppet::Pops::Types::PStringType)
+      end
+
+      it 'defined TypeSet type shadows type defined inside of TypeSet' do
+        type = Puppet::Pops::Types::TypeParser.singleton.parse('C::D', Puppet::Pops::Loaders.find_loader('c'))
+        expect(type).to be_a(Puppet::Pops::Types::PTypeSetType)
+      end
+
+      it 'parent name search does not traverse parent loaders' do
+        type = Puppet::Pops::Types::TypeParser.singleton.parse('C::C', Puppet::Pops::Loaders.find_loader('c'))
+        expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+        expect(type.resolved_type).to be_a(Puppet::Pops::Types::PIntegerType)
+      end
+
+      it 'global type defined in environment trumps modules init_typeset type' do
+        type = Puppet::Pops::Types::TypeParser.singleton.parse('C', Puppet::Pops::Loaders.find_loader('c'))
+        expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+        expect(type.resolved_type).to be_a(Puppet::Pops::Types::PIntegerType)
+      end
+
+      it 'hit on qualified name trumps hit on typeset using parent name + traversal' do
+        type = Puppet::Pops::Types::TypeParser.singleton.parse('C::D::Y', Puppet::Pops::Loaders.find_loader('c'))
+        expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+        expect(type.resolved_type).to be_a(Puppet::Pops::Types::PIntegerType)
+      end
+
+      it 'hit on qualified name and subsequent hit in typeset when searching for other name causes collision' do
+        l = Puppet::Pops::Loaders.find_loader('c')
+        p = Puppet::Pops::Types::TypeParser.singleton
+        p.parse('C::D::Y', l)
+        expect { p.parse('C::D::X', l) }.to raise_error(/Attempt to redefine entity 'http:\/\/puppet.com\/2016.1\/runtime\/type\/c::d::y'/)
+      end
+
+      it 'hit in typeset using parent name and subsequent search that would cause hit on fqn does not cause collision (fqn already loaded from typeset)' do
+        l = Puppet::Pops::Loaders.find_loader('c')
+        p = Puppet::Pops::Types::TypeParser.singleton
+        p.parse('C::D::X', l)
+        type = p.parse('C::D::Y', l)
+        expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+        expect(type.resolved_type).to be_a(Puppet::Pops::Types::PFloatType)
+      end
     end
   end
 

data/spec/unit/pops/loaders/static_loader_spec.rb

@@ -24,7 +24,7 @@ describe 'the static loader' do
     let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
 
     %w{
-      Augeas
+      Auegas
       Component
       Computer
       Cron
@@ -82,15 +82,11 @@ describe 'the static loader' do
   end
 
   context 'provides access to app-management specific resource types built into puppet' do
-    before(:each) { Puppet[:app_management] = true }
-    after(:each) { Puppet[:app_management] = false }
 
     let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
 
-    %w{Node}.each do |name|
-      it "such that #{name} is avaiable" do
-        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
-      end
+    it "such that Node is available" do
+      expect(loader.load(:type, 'node')).to be_the_type(resource_type('Node'))
     end
   end