puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/parser/files_spec.rb

@@ -6,163 +6,97 @@ require 'puppet/parser/files'
 describe Puppet::Parser::Files do
   include PuppetSpec::Files
 
-  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:modulepath) { tmpdir("modulepath") }
+  let(:environment) { Puppet::Node::Environment.create(:testing, [modulepath]) }
+  let(:mymod) { File.join(modulepath, "mymod") }
+  let(:mymod_files) { File.join(mymod, "files") }
+  let(:mymod_a_file) { File.join(mymod_files, "some.txt") }
+  let(:mymod_templates) { File.join(mymod, "templates") }
+  let(:mymod_a_template) { File.join(mymod_templates, "some.erb") }
+  let(:mymod_manifests) { File.join(mymod, "manifests") }
+  let(:mymod_init_manifest) { File.join(mymod_manifests, "init.pp") }
+  let(:mymod_another_manifest) { File.join(mymod_manifests, "another.pp") }
+  let(:an_absolute_file_path_outside_of_module) { make_absolute("afilenamesomewhere") }
 
   before do
-    @basepath = make_absolute("/somepath")
-  end
-
-  describe "when searching for files" do
-    it "should return fully-qualified files directly" do
-      Puppet::Parser::Files.expects(:modulepath).never
-      Puppet::Parser::Files.find_file(@basepath + "/my/file", environment).should == @basepath + "/my/file"
-    end
-
-    it "should return the first found file" do
-      mod = mock 'module'
-      mod.expects(:file).returns("/one/mymod/files/myfile")
-      environment.expects(:module).with("mymod").returns mod
-
-      Puppet::Parser::Files.find_file("mymod/myfile", environment).should == "/one/mymod/files/myfile"
-    end
-
-    it "should return nil if template is not found" do
-      Puppet::Parser::Files.find_file("foomod/myfile", environment).should be_nil
-    end
-  end
-
-  describe "when searching for templates" do
-    it "should return fully-qualified templates directly" do
-      Puppet::Parser::Files.expects(:modulepath).never
-      Puppet::Parser::Files.find_template(@basepath + "/my/template", environment).should == @basepath + "/my/template"
-    end
-
-    it "should return the template from the first found module" do
-      mod = mock 'module'
-      mod.expects(:template).returns("/one/mymod/templates/mytemplate")
-      environment.expects(:module).with("mymod").returns mod
-
-      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == "/one/mymod/templates/mytemplate"
-    end
-
-    it "should return the file in the templatedir if it exists" do
-      Puppet[:templatedir] = "/my/templates"
-      Puppet[:modulepath] = "/one:/two"
-      File.stubs(:directory?).returns(true)
-      Puppet::FileSystem.stubs(:exist?).returns(true)
-      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == File.join(Puppet[:templatedir], "mymod/mytemplate")
+    FileUtils.mkdir_p(mymod_files)
+    File.open(mymod_a_file, 'w') do |f|
+      f.puts('something')
     end
-
-    it "should not raise an error if no valid templatedir exists and the template exists in a module" do
-      mod = mock 'module'
-      mod.expects(:template).returns("/one/mymod/templates/mytemplate")
-      environment.expects(:module).with("mymod").returns mod
-      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(nil)
-
-      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == "/one/mymod/templates/mytemplate"
+    FileUtils.mkdir_p(mymod_templates)
+    File.open(mymod_a_template, 'w') do |f|
+      f.puts('<%= "something" %>')
     end
-
-    it "should return unqualified templates if they exist in the template dir" do
-      Puppet::FileSystem.stubs(:exist?).returns true
-      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/my/templates"])
-
-      Puppet::Parser::Files.find_template("mytemplate", environment).should == "/my/templates/mytemplate"
+    FileUtils.mkdir_p(mymod_manifests)
+    File.open(mymod_init_manifest, 'w') do |f|
+      f.puts('class mymod { }')
     end
-
-    it "should only return templates if they actually exist" do
-      Puppet::FileSystem.expects(:exist?).with("/my/templates/mytemplate").returns true
-      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/my/templates"])
-      Puppet::Parser::Files.find_template("mytemplate", environment).should == "/my/templates/mytemplate"
-    end
-
-    it "should return nil when asked for a template that doesn't exist" do
-      Puppet::FileSystem.expects(:exist?).with("/my/templates/mytemplate").returns false
-      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/my/templates"])
-      Puppet::Parser::Files.find_template("mytemplate", environment).should be_nil
+    File.open(mymod_another_manifest, 'w') do |f|
+      f.puts('class mymod::another { }')
     end
+  end
 
-    it "should accept relative templatedirs" do
-      Puppet::FileSystem.stubs(:exist?).returns true
-      Puppet[:templatedir] = "my/templates"
-      File.expects(:directory?).with(File.expand_path("my/templates")).returns(true)
-      Puppet::Parser::Files.find_template("mytemplate", environment).should == File.expand_path("my/templates/mytemplate")
+  describe "when searching for files" do
+    it "returns fully-qualified file names directly" do
+      expect(Puppet::Parser::Files.find_file(an_absolute_file_path_outside_of_module, environment)).to eq(an_absolute_file_path_outside_of_module)
     end
 
-    it "should use the environment templatedir if no module is found and an environment is specified" do
-      Puppet::FileSystem.stubs(:exist?).returns true
-      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/myenv/templates"])
-      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == "/myenv/templates/mymod/mytemplate"
+    it "returns the full path to the file if given a modulename/relative_filepath selector " do
+      expect(Puppet::Parser::Files.find_file("mymod/some.txt", environment)).to eq(mymod_a_file)
     end
 
-    it "should use first dir from environment templatedir if no module is found and an environment is specified" do
-      Puppet::FileSystem.stubs(:exist?).returns true
-      Puppet::Parser::Files.stubs(:templatepath).with(environment).returns(["/myenv/templates", "/two/templates"])
-      Puppet::Parser::Files.find_template("mymod/mytemplate", environment).should == "/myenv/templates/mymod/mytemplate"
+    it "returns nil if the module is not found" do
+      expect(Puppet::Parser::Files.find_file("mod_does_not_exist/myfile", environment)).to be_nil
     end
 
-    it "should use a valid dir when templatedir is a path for unqualified templates and the first dir contains template" do
-      Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
-      Puppet::FileSystem.expects(:exist?).with("/one/templates/mytemplate").returns(true)
-      Puppet::Parser::Files.find_template("mytemplate", environment).should == "/one/templates/mytemplate"
+    it "also returns nil if the module is found, but the file is not" do
+      expect(Puppet::Parser::Files.find_file("mymod/file_does_not_exist", environment)).to be_nil
     end
+  end
 
-    it "should use a valid dir when templatedir is a path for unqualified templates and only second dir contains template" do
-      Puppet::Parser::Files.stubs(:templatepath).returns(["/one/templates", "/two/templates"])
-      Puppet::FileSystem.expects(:exist?).with("/one/templates/mytemplate").returns(false)
-      Puppet::FileSystem.expects(:exist?).with("/two/templates/mytemplate").returns(true)
-      Puppet::Parser::Files.find_template("mytemplate", environment).should == "/two/templates/mytemplate"
+  describe "when searching for templates" do
+    it "returns fully-qualified templates directly" do
+      expect(Puppet::Parser::Files.find_template(an_absolute_file_path_outside_of_module, environment)).to eq(an_absolute_file_path_outside_of_module)
     end
 
-    it "should use the node environment if specified" do
-      mod = mock 'module'
-      environment.expects(:module).with("mymod").returns mod
-
-      mod.expects(:template).returns("/my/modules/mymod/templates/envtemplate")
-
-      Puppet::Parser::Files.find_template("mymod/envtemplate", environment).should == "/my/modules/mymod/templates/envtemplate"
+    it "returns the full path to the template if given a modulename/relative_templatepath selector" do
+      expect(Puppet::Parser::Files.find_template("mymod/some.erb", environment)).to eq(mymod_a_template)
     end
 
-    it "should return nil if no template can be found" do
-      Puppet::Parser::Files.find_template("foomod/envtemplate", environment).should be_nil
+    it "returns nil if the module is not found" do
+      expect(Puppet::Parser::Files.find_template("module_does_not_exist/mytemplate", environment)).to be_nil
     end
-  end
-
-  describe "when searching for manifests" do
-    it "should ignore invalid modules" do
-      mod = mock 'module'
-      environment.expects(:module).with("mymod").raises(Puppet::Module::InvalidName, "name is invalid")
-      Puppet.expects(:value).with(:modulepath).never
-      Dir.stubs(:glob).returns %w{foo}
 
-      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", environment)
+    it "returns nil if the module is found, but the template is not " do
+      expect(Puppet::Parser::Files.find_template("mymod/template_does_not_exist", environment)).to be_nil
     end
   end
 
   describe "when searching for manifests in a module" do
-    def a_module_in_environment(env, name)
-      mod = Puppet::Module.new(name, "/one/#{name}", env)
-      env.stubs(:module).with(name).returns mod
-      mod.stubs(:match_manifests).with("init.pp").returns(["/one/#{name}/manifests/init.pp"])
+    let(:no_manifests_found) { [nil, []] }
+
+    it "ignores invalid module names" do
+      expect(Puppet::Parser::Files.find_manifests_in_modules("mod.has.invalid.name/init.pp", environment)).to eq(no_manifests_found)
     end
 
     it "returns no files when no module is found" do
-      module_name, files = Puppet::Parser::Files.find_manifests_in_modules("not_here_module/foo", environment)
-      expect(files).to be_empty
-      expect(module_name).to be_nil
+      expect(Puppet::Parser::Files.find_manifests_in_modules("not_here_module/init.pp", environment)).to eq(no_manifests_found)
     end
 
-    it "should return the name of the module and the manifests from the first found module" do
-      a_module_in_environment(environment, "mymod")
+    it "returns the name of the module and the manifests from the first found module" do
+      expect(Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", environment)
+            ).to eq(["mymod", [mymod_init_manifest]])
+    end
 
-      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", environment).should ==
-        ["mymod", ["/one/mymod/manifests/init.pp"]]
+    it "always includes init.pp if present" do
+      expect(Puppet::Parser::Files.find_manifests_in_modules("mymod/another.pp", environment)
+            ).to eq(["mymod", [mymod_init_manifest, mymod_another_manifest]])
     end
 
     it "does not find the module when it is a different environment" do
       different_env = Puppet::Node::Environment.create(:different, [])
-      a_module_in_environment(environment, "mymod")
 
-      Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", different_env).should_not include("mymod")
+      expect(Puppet::Parser::Files.find_manifests_in_modules("mymod/init.pp", different_env)).to eq(no_manifests_found)
     end
   end
 end

data/spec/unit/parser/functions/contain_spec.rb

@@ -13,6 +13,11 @@ describe 'The "contain" function' do
   include ContainmentMatchers
   include Matchers::Resource
 
+  before(:each) do
+    compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+    @scope = Puppet::Parser::Scope.new(compiler)
+  end
+
   it "includes the class" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class contained {
@@ -49,7 +54,7 @@ describe 'The "contain" function' do
     catalog = compile_to_catalog(<<-MANIFEST)
       class outer {
         class named { }
-        contain named
+        contain outer::named
       }
 
       class named { }
@@ -222,15 +227,7 @@ describe 'The "contain" function' do
     end
   end
 
-  describe "When the future parser is in use" do
-    require 'puppet/pops'
-    before(:each) do
-      Puppet[:parser] = 'future'
-      compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-      @scope = Puppet::Parser::Scope.new(compiler)
-    end
+  it_should_behave_like 'all functions transforming relative to absolute names', :function_contain
+  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :contain
 
-    it_should_behave_like 'all functions transforming relative to absolute names', :function_contain
-    it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :contain
-  end
 end

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -15,7 +15,7 @@ describe 'function for dynamically creating resources' do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function(:create_resources).should == "function_create_resources"
+    expect(Puppet::Parser::Functions.function(:create_resources)).to eq("function_create_resources")
   end
 
   it 'should require two or three arguments' do
@@ -35,50 +35,50 @@ describe 'function for dynamically creating resources' do
     it 'empty hash should not cause resources to be added' do
       noop_catalog = compile_to_catalog("create_resources('file', {})")
       empty_catalog = compile_to_catalog("")
-      noop_catalog.resources.size.should == empty_catalog.resources.size
+      expect(noop_catalog.resources.size).to eq(empty_catalog.resources.size)
     end
 
     it 'should be able to add' do
       catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
-      catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
     end
 
     it 'should be able to add virtual resources' do
       catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
-      catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
     end
 
     it 'should be able to add exported resources' do
       catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}}) realize(File['/etc/foo'])")
-      catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
-      catalog.resource(:file, "/etc/foo").exported.should == true
+      expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/etc/foo").exported).to eq(true)
     end
 
     it 'should accept multiple types' do
       catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
-      catalog.resource(:notify, "foo")['message'].should == 'one'
-      catalog.resource(:notify, "bar")['message'].should == 'two'
+      expect(catalog.resource(:notify, "foo")['message']).to eq('one')
+      expect(catalog.resource(:notify, "bar")['message']).to eq('two')
     end
 
     it 'should fail to add non-existing type' do
       expect do
         @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
-      end.to raise_error(/Invalid resource type create-resource-foo/)
+      end.to raise_error(ArgumentError, /Invalid resource type create-resource-foo/)
     end
 
     it 'should be able to add edges' do
       rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>'Notify[test]'}})")
       test  = rg.vertices.find { |v| v.title == 'test' }
       foo   = rg.vertices.find { |v| v.title == 'foo' }
-      test.must be
-      foo.must be
-      rg.path_between(test,foo).should be
+      expect(test).to be
+      expect(foo).to be
+      expect(rg.path_between(test,foo)).to be
     end
 
     it 'should account for default values' do
       catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'})")
-      catalog.resource(:file, "/etc/foo")['group'].should == 'bar'
-      catalog.resource(:file, "/etc/baz")['group'].should == 'food'
+      expect(catalog.resource(:file, "/etc/foo")['group']).to eq('bar')
+      expect(catalog.resource(:file, "/etc/baz")['group']).to eq('food')
     end
   end
 
@@ -91,7 +91,7 @@ describe 'function for dynamically creating resources' do
 
         create_resources('foocreateresource', {'blah'=>{'one'=>'two'}})
       MANIFEST
-      catalog.resource(:notify, "blah")['message'].should == 'two'
+      expect(catalog.resource(:notify, "blah")['message']).to eq('two')
     end
 
     it 'should fail if defines are missing params' do
@@ -115,8 +115,8 @@ describe 'function for dynamically creating resources' do
         create_resources('foocreateresource', {'blah'=>{'one'=>'two'}, 'blaz'=>{'one'=>'three'}})
       MANIFEST
 
-      catalog.resource(:notify, "blah")['message'].should == 'two'
-      catalog.resource(:notify, "blaz")['message'].should == 'three'
+      expect(catalog.resource(:notify, "blah")['message']).to eq('two')
+      expect(catalog.resource(:notify, "blaz")['message']).to eq('three')
     end
 
     it 'should be able to add edges' do
@@ -132,9 +132,9 @@ describe 'function for dynamically creating resources' do
 
       test = rg.vertices.find { |v| v.title == 'test' }
       blah = rg.vertices.find { |v| v.title == 'blah' }
-      test.must be
-      blah.must be
-      rg.path_between(test,blah).should be
+      expect(test).to be
+      expect(blah).to be
+      expect(rg.path_between(test,blah)).to be
     end
 
     it 'should account for default values' do
@@ -146,7 +146,7 @@ describe 'function for dynamically creating resources' do
         create_resources('foocreateresource', {'blah'=>{}}, {'one' => 'two'})
       MANIFEST
 
-      catalog.resource(:notify, "blah")['message'].should == 'two'
+      expect(catalog.resource(:notify, "blah")['message']).to eq('two')
     end
   end
 
@@ -160,8 +160,8 @@ describe 'function for dynamically creating resources' do
         create_resources('class', {'bar'=>{'one'=>'two'}})
       MANIFEST
 
-      catalog.resource(:notify, "test")['message'].should == 'two'
-      catalog.resource(:class, "bar").should_not be_nil
+      expect(catalog.resource(:notify, "test")['message']).to eq('two')
+      expect(catalog.resource(:class, "bar")).not_to be_nil
     end
 
     it 'should fail to create non-existing classes' do
@@ -169,7 +169,7 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'blah'=>{'one'=>'two'}})
         MANIFEST
-      end.to raise_error(/Could not find declared class blah at line 1 on node foonode/)
+      end.to raise_error(/Could not find declared class blah at line 1:11 on node foonode/)
     end
 
     it 'should be able to add edges' do
@@ -185,9 +185,9 @@ describe 'function for dynamically creating resources' do
 
       test   = rg.vertices.find { |v| v.title == 'test' }
       tester = rg.vertices.find { |v| v.title == 'tester' }
-      test.must be
-      tester.must be
-      rg.path_between(tester,test).should be
+      expect(test).to be
+      expect(tester).to be
+      expect(rg.path_between(tester,test)).to be
     end
 
     it 'should account for default values' do
@@ -199,8 +199,8 @@ describe 'function for dynamically creating resources' do
         create_resources('class', {'bar'=>{}}, {'one' => 'two'})
       MANIFEST
 
-      catalog.resource(:notify, "test")['message'].should == 'two'
-      catalog.resource(:class, "bar").should_not be_nil
+      expect(catalog.resource(:notify, "test")['message']).to eq('two')
+      expect(catalog.resource(:class, "bar")).not_to be_nil
     end
 
     it 'should fail with a correct error message if the syntax of an imported file is incorrect' do

data/spec/unit/parser/functions/defined_spec.rb

@@ -3,9 +3,6 @@ require 'spec_helper'
 require 'puppet/pops'
 
 describe "the 'defined' function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
 
   before :each do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
@@ -18,102 +15,106 @@ describe "the 'defined' function" do
 
   it "is true when the name is defined as a class" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "yayness")
-    expect(@scope.function_defined(["yayness"])).to be_true
+    expect(@scope.function_defined(["yayness"])).to be_truthy
   end
 
   it "is true when the name is defined as a definition" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
-    expect(@scope.function_defined(["yayness"])).to be_true
+    expect(@scope.function_defined(["yayness"])).to be_truthy
   end
 
   it "is true when the name is defined as a builtin type" do
-    expect(@scope.function_defined(["file"])).to be_true
+    expect(@scope.function_defined(["file"])).to be_truthy
   end
 
   it "is true when any of the provided names are defined" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
-    expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_true
+    expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_truthy
   end
 
   it "is false when a single given name is not defined" do
-    expect(@scope.function_defined(["meh"])).to be_false
+    expect(@scope.function_defined(["meh"])).to be_falsey
   end
 
   it "is false when none of the names are defined" do
-    expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_false
+    expect(@scope.function_defined(["meh", "yayness", "booness"])).to be_falsey
   end
 
   it "is true when a resource reference is provided and the resource is in the catalog" do
     resource = Puppet::Resource.new("file", "/my/file")
     @compiler.add_resource(@scope, resource)
-    expect(@scope.function_defined([resource])).to be_true
+    expect(@scope.function_defined([resource])).to be_truthy
   end
 
   context "with string variable references" do
     it "is true when variable exists in scope" do
       @scope['x'] = 'something'
-      expect(@scope.function_defined(['$x'])).to be_true
+      expect(@scope.function_defined(['$x'])).to be_truthy
+    end
+
+    it "is true when absolute referenced variable exists in scope" do
+      @compiler.topscope['x'] = 'something'
+      # Without this magic linking, scope cannot find the global scope via the name ''
+      # which is the name of "topscope". (This is one of many problems with the scope impl)
+      # When running real code, scopes are always linked up this way.
+      @scope.class_set('', @compiler.topscope)
+      expect(@scope.function_defined(['$::x'])).to be_truthy
     end
 
     it "is true when ::variable exists in scope" do
       @compiler.topscope['x'] = 'something'
-      expect(@scope.function_defined(['$::x'])).to be_true
+      expect(@scope.function_defined(['$::x'])).to be_truthy
     end
 
     it "is true when at least one variable exists in scope" do
       @scope['x'] = 'something'
-      expect(@scope.function_defined(['$y', '$x', '$z'])).to be_true
+      expect(@scope.function_defined(['$y', '$x', '$z'])).to be_truthy
     end
 
     it "is false when variable does not exist in scope" do
-      expect(@scope.function_defined(['$x'])).to be_false
+      expect(@scope.function_defined(['$x'])).to be_falsey
     end
   end
 
-  context "with future parser" do
-    before(:each) do
-      Puppet[:parser] = 'future'
-    end
-
-    it "is true when a future resource type reference is provided, and the resource is in the catalog" do
-      resource = Puppet::Resource.new("file", "/my/file")
-      @compiler.add_resource(@scope, resource)
+  it "is true when a resource type reference is provided, and the resource is in the catalog" do
+    resource = Puppet::Resource.new("file", "/my/file")
+    @compiler.add_resource(@scope, resource)
 
-      resource_type = Puppet::Pops::Types::TypeFactory.resource('file', '/my/file')
-      expect(@scope.function_defined([resource_type])).to be_true
-    end
+    resource_type = Puppet::Pops::Types::TypeFactory.resource('file', '/my/file')
+    expect(@scope.function_defined([resource_type])).to be_truthy
+  end
 
-    it "raises an argument error if you ask if Resource is defined" do
-      resource_type = Puppet::Pops::Types::TypeFactory.resource
-      expect { @scope.function_defined([resource_type]) }.to raise_error(ArgumentError, /reference to all.*type/)
-    end
+  it "raises an argument error if you ask if Resource is defined" do
+    resource_type = Puppet::Pops::Types::TypeFactory.resource
+    expect { @scope.function_defined([resource_type]) }.to raise_error(ArgumentError, /reference to all.*type/)
+  end
 
-    it "is true if referencing a built in type" do
-      resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
-      expect(@scope.function_defined([resource_type])).to be_true
-    end
+  it "is true if referencing a built in type" do
+    resource_type = Puppet::Pops::Types::TypeFactory.resource('file')
+    expect(@scope.function_defined([resource_type])).to be_truthy
+  end
 
-    it "is true if referencing a defined type" do
-      @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
-      resource_type = Puppet::Pops::Types::TypeFactory.resource('yayness')
-      expect(@scope.function_defined([resource_type])).to be_true
-    end
+  it "is true if referencing a defined type" do
+    @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
+    resource_type = Puppet::Pops::Types::TypeFactory.resource('yayness')
+    expect(@scope.function_defined([resource_type])).to be_truthy
+  end
 
-    it "is false if referencing an undefined type" do
-      resource_type = Puppet::Pops::Types::TypeFactory.resource('barbershops')
-      expect(@scope.function_defined([resource_type])).to be_false
-    end
+  it "is false if referencing an undefined type" do
+    resource_type = Puppet::Pops::Types::TypeFactory.resource('barbershops')
+    expect(@scope.function_defined([resource_type])).to be_falsey
+  end
 
-    it "is true when a future class reference type is provided" do
-      @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "cowabunga")
+  it "is true when a class type is provided" do
+    @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "cowabunga")
 
-      class_type = Puppet::Pops::Types::TypeFactory.host_class("cowabunga")
-      expect(@scope.function_defined([class_type])).to be_true
-    end
+    class_type = Puppet::Pops::Types::TypeFactory.host_class("cowabunga")
+    expect(@scope.function_defined([class_type])).to be_truthy
+  end
 
-    it "raises an argument error if you ask if Class is defined" do
-      class_type = Puppet::Pops::Types::TypeFactory.host_class
-      expect { @scope.function_defined([class_type]) }.to raise_error(ArgumentError, /reference to all.*class/)
-    end
+  it "raises an argument error if you ask if Class is defined" do
+    class_type = Puppet::Pops::Types::TypeFactory.host_class
+    expect { @scope.function_defined([class_type]) }.to raise_error(ArgumentError, /reference to all.*class/)
   end
+
 end