puppet 8.4.0-x64-mingw32 → 8.5.0-x64-mingw32

data/spec/unit/parser/files_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/parser/files'
-
-describe Puppet::Parser::Files do
-  include PuppetSpec::Files
-
-  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
-    FileUtils.mkdir_p(mymod_files)
-    File.open(mymod_a_file, 'w') do |f|
-      f.puts('something')
-    end
-    FileUtils.mkdir_p(mymod_templates)
-    File.open(mymod_a_template, 'w') do |f|
-      f.puts('<%= "something" %>')
-    end
-    FileUtils.mkdir_p(mymod_manifests)
-    File.open(mymod_init_manifest, 'w') do |f|
-      f.puts('class mymod { }')
-    end
-    File.open(mymod_another_manifest, 'w') do |f|
-      f.puts('class mymod::another { }')
-    end
-  end
-
-  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 "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 "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 "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
-
-  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 "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 "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
-
-    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
-    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
-      expect(Puppet::Parser::Files.find_manifests_in_modules("not_here_module/init.pp", environment)).to eq(no_manifests_found)
-    end
-
-    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
-
-    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, [])
-
-      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/create_resources_spec.rb

@@ -1,326 +0,0 @@
-require 'puppet'
-require 'spec_helper'
-require 'puppet_spec/compiler'
-require 'puppet_spec/files'
-
-describe 'function for dynamically creating resources' do
-  include PuppetSpec::Compiler
-  include PuppetSpec::Files
-
-  before :each do
-    node      = Puppet::Node.new("floppy", :environment => 'production')
-    @compiler = Puppet::Parser::Compiler.new(node)
-    @scope    = Puppet::Parser::Scope.new(@compiler)
-    @topscope = @scope.compiler.topscope
-    @scope.parent = @topscope
-    Puppet::Parser::Functions.function(:create_resources)
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function(:create_resources)).to eq("function_create_resources")
-  end
-
-  it 'should require two or three arguments' do
-    expect { @scope.function_create_resources(['foo']) }.to raise_error(ArgumentError, 'create_resources(): Wrong number of arguments given (1 for minimum 2)')
-    expect { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.to raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
-  end
-
-  it 'should require second argument to be a hash' do
-    expect { @scope.function_create_resources(['foo','bar']) }.to raise_error(ArgumentError, 'create_resources(): second argument must be a hash')
-  end
-
-  it 'should require optional third argument to be a hash' do
-    expect { @scope.function_create_resources(['foo',{},'foo']) }.to raise_error(ArgumentError, 'create_resources(): third argument, if provided, must be a hash')
-  end
-
-  context 'when being called from a manifest in a file' do
-    let(:dir) do
-      dir_containing('manifests', {
-              'site.pp' => <<-EOF
-                # comment here to make the call be on a particular
-                # source line (3)
-                create_resources('notify', {
-                  'a'  => { 'message'=>'message a'},
-                  'b'  => { 'message'=>'message b'},
-                  }
-                )
-              EOF
-          }
-      )
-    end
-
-    it 'file and line information where call originates is written to all resources created in one call' do
-      node = Puppet::Node.new('test')
-      file = File.join(dir, 'site.pp')
-      Puppet[:manifest] = file
-      catalog = Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
-
-      expect(catalog.resource(:notify, 'a').file).to eq(file)
-      expect(catalog.resource(:notify, 'a').line).to eq(3)
-      expect(catalog.resource(:notify, 'b').file).to eq(file)
-      expect(catalog.resource(:notify, 'b').line).to eq(3)
-    end
-
-  end
-  describe 'when creating native types' 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("")
-      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'}})")
-      expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
-    end
-
-    it 'should pick up and pass on file and line information' do
-      # mock location as the compile_to_catalog sets Puppet[:code} which does not
-      # have file/line support.
-      expect(Puppet::Pops::PuppetStack).to receive(:top_of_stack).once.and_return(['test.pp', 1234])
-      catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
-      r = catalog.resource(:file, "/etc/foo")
-      expect(r.file).to eq('test.pp')
-      expect(r.line).to eq(1234)
-    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'])")
-      expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
-    end
-
-    it 'unrealized exported resources should not be added' do
-      # a compiled catalog is normally filtered on virtual resources
-      # here the compilation is performed unfiltered to be able to find the exported resource
-      # it is then asserted that the exported resource is also virtual (and therefore filtered out by a real compilation).
-      catalog = compile_to_catalog_unfiltered("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
-      expect(catalog.resource(:file, "/etc/foo").exported).to eq(true)
-      expect(catalog.resource(:file, "/etc/foo").virtual).to eq(true)
-    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'])")
-      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 resources' do
-      catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'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 resource type' do
-      expect do
-        @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
-      end.to raise_error(/Unknown 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' }
-      expect(test).to be
-      expect(foo).to be
-      expect(rg.path_between(test,foo)).to be
-    end
-
-    it 'should filter out undefined edges as they cause errors' do
-      rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>undef}})")
-      test  = rg.vertices.find { |v| v.title == 'test' }
-      foo   = rg.vertices.find { |v| v.title == 'foo' }
-      expect(test).to be
-      expect(foo).to be
-      expect(rg.path_between(foo,nil)).to_not be
-    end
-
-    it 'should filter out undefined edges in an array as they cause errors' do
-      rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>[undef]}})")
-      test  = rg.vertices.find { |v| v.title == 'test' }
-      foo   = rg.vertices.find { |v| v.title == 'foo' }
-      expect(test).to be
-      expect(foo).to be
-      expect(rg.path_between(foo,nil)).to_not 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'})")
-      expect(catalog.resource(:file, "/etc/foo")['group']).to eq('bar')
-      expect(catalog.resource(:file, "/etc/baz")['group']).to eq('food')
-    end
-  end
-
-  describe 'when dynamically creating resource types' do
-    it 'should be able to create defined resource types' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        define foocreateresource($one) {
-          notify { $name: message => $one }
-        }
-
-        create_resources('foocreateresource', {'blah'=>{'one'=>'two'}})
-      MANIFEST
-      expect(catalog.resource(:notify, "blah")['message']).to eq('two')
-    end
-
-    it 'should fail if defines are missing params' do
-      expect {
-        compile_to_catalog(<<-MANIFEST)
-          define foocreateresource($one) {
-            notify { $name: message => $one }
-          }
-
-          create_resources('foocreateresource', {'blah'=>{}})
-        MANIFEST
-      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one'/)
-    end
-
-    it 'should accept undef as explicit value when parameter has no default value' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          define foocreateresource($one) {
-            notify { $name: message => "aaa${one}bbb" }
-          }
-
-          create_resources('foocreateresource', {'blah'=>{ one => undef}})
-        MANIFEST
-      expect(catalog.resource(:notify, "blah")['message']).to eq('aaabbb')
-    end
-
-    it 'should use default value expression if given value is undef' do
-        catalog = compile_to_catalog(<<-MANIFEST)
-          define foocreateresource($one = 'xx') {
-            notify { $name: message => "aaa${one}bbb" }
-          }
-
-          create_resources('foocreateresource', {'blah'=>{ one => undef}})
-        MANIFEST
-      expect(catalog.resource(:notify, "blah")['message']).to eq('aaaxxbbb')
-    end
-
-    it 'should be able to add multiple defines' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        define foocreateresource($one) {
-          notify { $name: message => $one }
-        }
-
-        create_resources('foocreateresource', {'blah'=>{'one'=>'two'}, 'blaz'=>{'one'=>'three'}})
-      MANIFEST
-
-      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
-      rg = compile_to_relationship_graph(<<-MANIFEST)
-        define foocreateresource($one) {
-          notify { $name: message => $one }
-        }
-
-        notify { test: }
-
-        create_resources('foocreateresource', {'blah'=>{'one'=>'two', 'require' => 'Notify[test]'}})
-      MANIFEST
-
-      test = rg.vertices.find { |v| v.title == 'test' }
-      blah = rg.vertices.find { |v| v.title == 'blah' }
-      expect(test).to be
-      expect(blah).to be
-      expect(rg.path_between(test,blah)).to be
-    end
-
-    it 'should account for default values' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        define foocreateresource($one) {
-          notify { $name: message => $one }
-        }
-
-        create_resources('foocreateresource', {'blah'=>{}}, {'one' => 'two'})
-      MANIFEST
-
-      expect(catalog.resource(:notify, "blah")['message']).to eq('two')
-    end
-  end
-
-  describe 'when creating classes' do
-    let(:logs) { [] }
-    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
-
-    it 'should be able to create classes' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        class bar($one) {
-          notify { test: message => $one }
-        }
-
-        create_resources('class', {'bar'=>{'one'=>'two'}})
-      MANIFEST
-
-      expect(catalog.resource(:notify, "test")['message']).to eq('two')
-      expect(catalog.resource(:class, "bar")).not_to be_nil
-    end
-
-    it 'should error if class is exported' do
-      expect{
-        compile_to_catalog('class test{} create_resources("@@class", {test => {}})')
-      }.to raise_error(/Classes are not virtualizable/)
-    end
-
-    it 'should error if class is virtual' do
-      expect{
-        compile_to_catalog('class test{} create_resources("@class", {test => {}})')
-      }.to raise_error(/Classes are not virtualizable/)
-    end
-
-    it 'should be able to add edges' do
-      rg = compile_to_relationship_graph(<<-MANIFEST)
-        class bar($one) {
-          notify { test: message => $one }
-        }
-
-        notify { tester: }
-
-        create_resources('class', {'bar'=>{'one'=>'two', 'require' => 'Notify[tester]'}})
-      MANIFEST
-
-      test   = rg.vertices.find { |v| v.title == 'test' }
-      tester = rg.vertices.find { |v| v.title == 'tester' }
-      expect(test).to be
-      expect(tester).to be
-      expect(rg.path_between(tester,test)).to be
-    end
-
-    it 'should account for default values' do
-      catalog = compile_to_catalog(<<-MANIFEST)
-        class bar($one) {
-          notify { test: message => $one }
-        }
-
-        create_resources('class', {'bar'=>{}}, {'one' => 'two'})
-      MANIFEST
-
-      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
-      expect{
-        Puppet[:modulepath] = my_fixture_dir
-        compile_to_catalog('include foo')
-      }.to raise_error(Puppet::Error, /Syntax error at.*/)
-    end
-
-    it 'is not available when --tasks is on' do
-      Puppet[:tasks] = true
-      expect do
-        compile_to_catalog(<<-MANIFEST)
-          create_resources('class', {'bar'=>{}}, {'one' => 'two'})
-        MANIFEST
-      end.to raise_error(Puppet::ParseError, /is only available when compiling a catalog/)
-    end
-  end
-
-  def collect_notices(code)
-    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-      compile_to_catalog(code)
-    end
-  end
-
-end

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

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe "the digest function", :uses_checksums => true do
-  before :each do
-    n = Puppet::Node.new('unnamed')
-    c = Puppet::Parser::Compiler.new(n)
-    @scope = Puppet::Parser::Scope.new(c)
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("digest")).to eq("function_digest")
-  end
-
-  with_digest_algorithms do
-    it "should use the proper digest function" do
-      result = @scope.function_digest([plaintext])
-      expect(result).to(eql( checksum ))
-    end
-
-    it "should only accept one parameter" do
-      expect do
-        @scope.function_digest(['foo', 'bar'])
-      end.to raise_error(ArgumentError)
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe "the 'fail' parser function" do
-  let :scope do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    scope    = Puppet::Parser::Scope.new(compiler)
-    allow(scope).to receive(:environment).and_return(nil)
-    scope
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function(:fail)).to eq("function_fail")
-  end
-
-  it "should raise a parse error if invoked" do
-    expect { scope.function_fail([]) }.to raise_error Puppet::ParseError
-  end
-
-  it "should join arguments into a string in the error" do
-    expect { scope.function_fail(["hello", "world"]) }.to raise_error(/hello world/)
-  end
-end

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

@@ -1,99 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-
-describe "the 'file' function" do
-  include PuppetSpec::Files
-
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
-
-  def with_file_content(content)
-    path = tmpfile('file-function')
-    file = File.new(path, 'wb')
-    file.sync = true
-    file.print content
-    yield path
-  end
-
-  it "should read a file" do
-    with_file_content('file content') do |name|
-      expect(scope.function_file([name])).to eq("file content")
-    end
-  end
-
-  it "should read a file keeping line endings intact" do
-    with_file_content("file content\r\n") do |name|
-      expect(scope.function_file([name])).to eq("file content\r\n")
-    end
-  end
-
-  it "should read a file from a module path" do
-    with_file_content('file content') do |name|
-      mod = double('module')
-      allow(mod).to receive(:file).with('myfile').and_return(name)
-      allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
-
-      expect(scope.function_file(['mymod/myfile'])).to eq('file content')
-    end
-  end
-
-  it "should return the first file if given two files with absolute paths" do
-    with_file_content('one') do |one|
-      with_file_content('two') do |two|
-        expect(scope.function_file([one, two])).to eq("one")
-      end
-    end
-  end
-
-  it "should return the first file if given two files with module paths" do
-    with_file_content('one') do |one|
-      with_file_content('two') do |two|
-        mod = double('module')
-        expect(compiler.environment).to receive(:module).with('mymod').and_return(mod)
-        expect(mod).to receive(:file).with('one').and_return(one)
-        allow(mod).to receive(:file).with('two').and_return(two)
-
-        expect(scope.function_file(['mymod/one','mymod/two'])).to eq('one')
-      end
-    end
-  end
-
-  it "should return the first file if given two files with mixed paths, absolute first" do
-    with_file_content('one') do |one|
-      with_file_content('two') do |two|
-        mod = double('module')
-        allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
-        allow(mod).to receive(:file).with('two').and_return(two)
-
-        expect(scope.function_file([one,'mymod/two'])).to eq('one')
-      end
-    end
-  end
-
-  it "should return the first file if given two files with mixed paths, module first" do
-    with_file_content('one') do |one|
-      with_file_content('two') do |two|
-        mod = double('module')
-        expect(compiler.environment).to receive(:module).with('mymod').and_return(mod)
-        allow(mod).to receive(:file).with('two').and_return(two)
-
-        expect(scope.function_file(['mymod/two',one])).to eq('two')
-      end
-    end
-  end
-
-  it "should not fail when some files are absent" do
-    expect {
-      with_file_content('one') do |one|
-        expect(scope.function_file([make_absolute("/should-not-exist"), one])).to eq('one')
-      end
-    }.to_not raise_error
-  end
-
-  it "should fail when all files are absent" do
-    expect {
-      scope.function_file([File.expand_path('one')])
-    }.to raise_error(Puppet::ParseError, /Could not find any files/)
-  end
-end

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

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/scope'
-
-describe "the fqdn_rand function" do
-  include PuppetSpec::Scope
-
-  it "returns an integer" do
-    expect(fqdn_rand(3)).to be_an(Integer)
-  end
-
-  it "provides a random number strictly less than the given max" do
-    expect(fqdn_rand(3)).to satisfy {|n| n < 3 }
-  end
-
-  it "provides the same 'random' value on subsequent calls for the same host" do
-    expect(fqdn_rand(3)).to eql(fqdn_rand(3))
-  end
-
-  it "considers the same host and same extra arguments to have the same random sequence" do
-    first_random = fqdn_rand(3, :extra_identifier => [1, "same", "host"])
-    second_random = fqdn_rand(3, :extra_identifier => [1, "same", "host"])
-
-    expect(first_random).to eql(second_random)
-  end
-
-  it "allows extra arguments to control the random value on a single host" do
-    first_random = fqdn_rand(10000, :extra_identifier => [1, "different", "host"])
-    second_different_random = fqdn_rand(10000, :extra_identifier => [2, "different", "host"])
-
-    expect(first_random).not_to eql(second_different_random)
-  end
-
-  it "should return different sequences of value for different hosts" do
-    val1 = fqdn_rand(1000000000, :host => "first.host.com")
-    val2 = fqdn_rand(1000000000, :host => "second.host.com")
-
-    expect(val1).not_to eql(val2)
-  end
-
-  it "should return a specific value with given set of inputs on non-fips enabled host" do
-    allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-
-    expect(fqdn_rand(3000, :host => 'dummy.fqdn.net')).to eql(338)
-  end
-
-  it "should return a specific value with given set of inputs on fips enabled host" do
-    allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
-
-    expect(fqdn_rand(3000, :host => 'dummy.fqdn.net')).to eql(278)
-  end
-
-  it "should return a specific value with given seed on a non-fips enabled host" do
-    allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(false)
-
-    expect(fqdn_rand(5000, :extra_identifier => ['expensive job 33'])).to eql(3374)
-  end
-
-  it "should return a specific value with given seed on a fips enabled host" do
-    allow(Puppet::Util::Platform).to receive(:fips_enabled?).and_return(true)
-
-    expect(fqdn_rand(5000, :extra_identifier => ['expensive job 33'])).to eql(2389)
-  end
-
-  it "returns the same value if only host differs by case" do
-    val1 = fqdn_rand(1000000000, :host => "host.example.com", :extra_identifier => [nil, true])
-    val2 = fqdn_rand(1000000000, :host => "HOST.example.com", :extra_identifier => [nil, true])
-
-    expect(val1).to eql(val2)
-  end
-
-  it "returns the same value if only host differs by case and an initial seed is given" do
-    val1 = fqdn_rand(1000000000, :host => "host.example.com", :extra_identifier => ['a seed', true])
-    val2 = fqdn_rand(1000000000, :host => "HOST.example.com", :extra_identifier => ['a seed', true])
-
-    expect(val1).to eql(val2)
-  end
-
-  def fqdn_rand(max, args = {})
-    host = args[:host] || '127.0.0.1'
-    extra = args[:extra_identifier] || []
-
-    scope = create_test_scope_for_node('localhost')
-    scope.set_facts({ 'networking' => { 'fqdn' => host }})
-
-    scope.function_fqdn_rand([max] + extra)
-  end
-end