puppet 4.7.1-x64-mingw32 → 4.8.0-x64-mingw32

data/spec/integration/parser/functions/require_spec.rb

@@ -1,43 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe "The require function" do
-  before :each do
-    @node = Puppet::Node.new("mynode")
-    @compiler = Puppet::Parser::Compiler.new(@node)
-
-    @compiler.send(:evaluate_main)
-    @compiler.catalog.client_version = "0.25"
-    @scope = @compiler.topscope
-    # preload our functions
-    Puppet::Parser::Functions.function(:include)
-    Puppet::Parser::Functions.function(:require)
-  end
-
-  it "should add a dependency between the 'required' class and our class" do
-    @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass")
-
-    @scope.function_require(["requiredclass"])
-    expect(@scope.resource["require"]).not_to be_nil
-    ref = @scope.resource["require"].shift
-    expect(ref.type).to eq("Class")
-    expect(ref.title).to eq("Requiredclass")
-  end
-
-  it "should queue relationships between the 'required' class and our classes" do
-    @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass1")
-    @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass2")
-
-    @scope.function_require(["requiredclass1"])
-    @scope.function_require(["requiredclass2"])
-
-    expect(@scope.resource["require"]).not_to be_nil
-
-    (ref1,ref2) = @scope.resource["require"]
-    expect(ref1.type).to eq("Class")
-    expect(ref1.title).to eq("Requiredclass1")
-    expect(ref2.type).to eq("Class")
-    expect(ref2.title).to eq("Requiredclass2")
-  end
-
-end

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

@@ -1,55 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'unit/parser/functions/shared'
-require 'puppet_spec/compiler'
-
-describe "the 'include' function" do
-  include PuppetSpec::Compiler
-
-  before :each do
-    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
-    @scope = Puppet::Parser::Scope.new(@compiler)
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("include")).to eq("function_include")
-  end
-
-  it "should include a single class" do
-    inc = "::foo"
-    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == [inc]}.returns([inc])
-    @scope.function_include(["foo"])
-  end
-
-  it "should include multiple classes" do
-    inc = ["::foo","::bar"]
-    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
-    @scope.function_include(["foo","bar"])
-  end
-
-  it "should include multiple classes passed in an array" do
-    inc = ["::foo","::bar"]
-    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
-    @scope.function_include([["foo","bar"]])
-  end
-
-  it "should flatten nested arrays" do
-    inc = ["::foo","::bar","::baz"]
-    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
-    @scope.function_include([["foo","bar"],"baz"])
-  end
-
-  it "should not lazily evaluate the included class" do
-    @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| lazy == false}.returns("foo")
-    @scope.function_include(["foo"])
-  end
-
-  it "should raise if the class is not found" do
-    @scope.stubs(:source).returns(true)
-    expect { @scope.function_include(["nosuchclass"]) }.to raise_error(Puppet::Error)
-  end
-
-  it_should_behave_like 'all functions transforming relative to absolute names', :function_include
-  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :include
-
-end

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

@@ -1,68 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'unit/parser/functions/shared'
-require 'puppet_spec/compiler'
-
-describe "the require function" do
-  include PuppetSpec::Compiler
-#  before :all do
-#    Puppet::Parser::Functions.autoloader.loadall
-#  end
-
-  before :each do
-    @catalog = stub 'catalog'
-
-    node      = Puppet::Node.new('localhost')
-    compiler  = Puppet::Parser::Compiler.new(node)
-    @scope = Puppet::Parser::Scope.new(compiler)
-
-    @scope.stubs(:findresource)
-    @klass = stub 'class', :name => "myclass"
-    @scope.environment.known_resource_types.stubs(:find_hostclass).returns(@klass)
-
-    @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
-    @scope.stubs(:resource).returns @resource
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("require")).to eq("function_require")
-  end
-
-  it "should delegate to the 'include' puppet function" do
-    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
-
-    @scope.function_require(["myclass"])
-  end
-
-  it "should set the 'require' parameter on the resource to a resource reference" do
-    @scope.compiler.stubs(:evaluate_classes)
-    @scope.function_require(["myclass"])
-
-    expect(@resource["require"]).to be_instance_of(Array)
-    expect(@resource["require"][0]).to be_instance_of(Puppet::Resource)
-  end
-
-  it "should lookup the absolute class path" do
-    @scope.compiler.stubs(:evaluate_classes)
-
-    @scope.environment.known_resource_types.expects(:find_hostclass).with("::myclass").returns(@klass)
-    @klass.expects(:name).returns("myclass")
-
-    @scope.function_require(["myclass"])
-  end
-
-  it "should append the required class to the require parameter" do
-    @scope.compiler.stubs(:evaluate_classes)
-
-    one = Puppet::Resource.new(:file, "/one")
-    @resource[:require] = one
-    @scope.function_require(["myclass"])
-
-    expect(@resource[:require]).to be_include(one)
-    expect(@resource[:require].detect { |r| r.to_s == "Class[Myclass]" }).to be_instance_of(Puppet::Resource)
-  end
-
-  it_should_behave_like 'all functions transforming relative to absolute names', :function_require
-  it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :require
-
-end