puppet-retrospec 0.12.1 → 0.12.2

data/spec/fixtures/modules/stdlib/spec/functions/fqdn_rand_string_spec.rb

@@ -1,91 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the fqdn_rand_string function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("fqdn_rand_string")).to eq("function_fqdn_rand_string")
-  end
-
-  it "should raise an ArgumentError if there is less than 1 argument" do
-    expect { fqdn_rand_string() }.to( raise_error(ArgumentError, /wrong number of arguments/))
-  end
-
-  it "should raise an ArgumentError if argument 1 isn't a positive integer" do
-    expect { fqdn_rand_string(0) }.to( raise_error(ArgumentError, /first argument must be a positive integer/))
-    expect { fqdn_rand_string(-1) }.to( raise_error(ArgumentError, /first argument must be a positive integer/))
-    expect { fqdn_rand_string(0.5) }.to( raise_error(ArgumentError, /first argument must be a positive integer/))
-  end
-
-  it "provides a valid alphanumeric string when no character set is provided" do
-    length = 100
-    string = %r{\A[a-zA-Z0-9]{#{length}}\z}
-    expect(fqdn_rand_string(length).match(string)).not_to eq(nil)
-  end
-
-  it "provides a valid alphanumeric string when an undef character set is provided" do
-    length = 100
-    string = %r{\A[a-zA-Z0-9]{#{length}}\z}
-    expect(fqdn_rand_string(length, :charset => nil).match(string)).not_to eq(nil)
-  end
-
-  it "provides a valid alphanumeric string when an empty character set is provided" do
-    length = 100
-    string = %r{\A[a-zA-Z0-9]{#{length}}\z}
-    expect(fqdn_rand_string(length, :charset => '').match(string)).not_to eq(nil)
-  end
-
-  it "uses a provided character set" do
-    length = 100
-    charset = '!@#$%^&*()-_=+'
-    string = %r{\A[#{charset}]{#{length}}\z}
-    expect(fqdn_rand_string(length, :charset => charset).match(string)).not_to eq(nil)
-  end
-
-  it "provides a random string exactly as long as the given length" do
-    expect(fqdn_rand_string(10).size).to eql(10)
-  end
-
-  it "provides the same 'random' value on subsequent calls for the same host" do
-    expect(fqdn_rand_string(10)).to eql(fqdn_rand_string(10))
-  end
-
-  it "considers the same host and same extra arguments to have the same random sequence" do
-    first_random = fqdn_rand_string(10, :extra_identifier => [1, "same", "host"])
-    second_random = fqdn_rand_string(10, :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_string(10, :extra_identifier => [1, "different", "host"])
-    second_different_random = fqdn_rand_string(10, :extra_identifier => [2, "different", "host"])
-
-    expect(first_random).not_to eql(second_different_random)
-  end
-
-  it "should return different strings for different hosts" do
-    val1 = fqdn_rand_string(10, :host => "first.host.com")
-    val2 = fqdn_rand_string(10, :host => "second.host.com")
-
-    expect(val1).not_to eql(val2)
-  end
-
-  def fqdn_rand_string(max, args = {})
-    host = args[:host] || '127.0.0.1'
-    charset = args[:charset]
-    extra = args[:extra_identifier] || []
-
-    scope = PuppetlabsSpec::PuppetInternals.scope
-    scope.stubs(:[]).with("::fqdn").returns(host)
-    scope.stubs(:lookupvar).with("::fqdn").returns(host)
-
-    function_args = [max]
-    if args.has_key?(:charset) or !extra.empty?
-      function_args << charset
-    end
-    function_args += extra
-    scope.function_fqdn_rand_string(function_args)
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/fqdn_rotate_spec.rb

@@ -1,60 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the fqdn_rotate function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("fqdn_rotate")).to eq("function_fqdn_rotate")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_fqdn_rotate([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should rotate a string and the result should be the same size" do
-    scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
-    result = scope.function_fqdn_rotate(["asdf"])
-    expect(result.size).to(eq(4))
-  end
-
-  it "should rotate a string to give the same results for one host" do
-    scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1").twice
-    expect(scope.function_fqdn_rotate(["abcdefg"])).to eql(scope.function_fqdn_rotate(["abcdefg"]))
-  end
-
-  it "should rotate a string to give different values on different hosts" do
-     scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
-     val1 = scope.function_fqdn_rotate(["abcdefghijklmnopqrstuvwxyz01234567890987654321"])
-     scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.2")
-     val2 = scope.function_fqdn_rotate(["abcdefghijklmnopqrstuvwxyz01234567890987654321"])
-     expect(val1).not_to eql(val2)
-  end
-
-  it "should accept objects which extend String" do
-    class AlsoString < String
-    end
-
-    scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
-    value = AlsoString.new("asdf")
-    result = scope.function_fqdn_rotate([value])
-    result.size.should(eq(4))
-  end
-
-  it "should use the Puppet::Util.deterministic_rand function if available" do
-    scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
-    if Puppet::Util.respond_to?(:deterministic_rand)
-      Puppet::Util.expects(:deterministic_rand).with(113646079810780526294648115052177588845,4)
-    end
-    scope.function_fqdn_rotate(["asdf"])
-  end
-
-  it "should not leave the global seed in a deterministic state" do
-    scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1").twice
-    scope.function_fqdn_rotate(["asdf"])
-    rand1 = rand()
-    scope.function_fqdn_rotate(["asdf"])
-    rand2 = rand()
-    expect(rand1).not_to eql(rand2)
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/get_module_path_spec.rb

@@ -1,46 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:get_module_path) do
-  Internals = PuppetlabsSpec::PuppetInternals
-  class StubModule
-    attr_reader :path
-    def initialize(path)
-      @path = path
-    end
-  end
-
-  def scope(environment = "production")
-    Internals.scope(:compiler => Internals.compiler(:node => Internals.node(:environment => environment)))
-  end
-
-  it 'should only allow one argument' do
-    expect { scope.function_get_module_path([]) }.to raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
-    expect { scope.function_get_module_path(['1','2','3']) }.to raise_error(Puppet::ParseError, /Wrong number of arguments, expects one/)
-  end
-  it 'should raise an exception when the module cannot be found' do
-    expect { scope.function_get_module_path(['foo']) }.to raise_error(Puppet::ParseError, /Could not find module/)
-  end
-  describe 'when locating a module' do
-    let(:modulepath) { "/tmp/does_not_exist" }
-    let(:path_of_module_foo) { StubModule.new("/tmp/does_not_exist/foo") }
-
-    before(:each) { Puppet[:modulepath] = modulepath }
-
-    it 'should be able to find module paths from the modulepath setting' do
-      Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
-      expect(scope.function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
-    end
-    it 'should be able to find module paths when the modulepath is a list' do
-      Puppet[:modulepath] = modulepath + ":/tmp"
-      Puppet::Module.expects(:find).with('foo', 'production').returns(path_of_module_foo)
-      expect(scope.function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
-    end
-    it 'should respect the environment' do
-      skip("Disabled on Puppet 2.6.x") if Puppet.version =~ /^2\.6\b/
-      Puppet.settings[:environment] = 'danstestenv'
-      Puppet::Module.expects(:find).with('foo', 'danstestenv').returns(path_of_module_foo)
-      expect(scope('danstestenv').function_get_module_path(['foo'])).to eq(path_of_module_foo.path)
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/getparam_spec.rb

@@ -1,76 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'rspec-puppet'
-require 'puppet_spec/compiler'
-
-describe 'getparam' do
-  include PuppetSpec::Compiler
-
-  before :each do
-    Puppet::Parser::Functions.autoloader.loadall
-    Puppet::Parser::Functions.function(:getparam)
-  end
-
-  let :node     do Puppet::Node.new('localhost') end
-  let :compiler do Puppet::Parser::Compiler.new(node) end
-  if Puppet.version.to_f >= 3.0
-    let :scope    do Puppet::Parser::Scope.new(compiler) end
-  else
-    let :scope    do
-      newscope = Puppet::Parser::Scope.new
-      newscope.compiler = compiler
-      newscope.source   = Puppet::Resource::Type.new(:node, :localhost)
-      newscope
-    end
-  end
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("getparam")).to eq("function_getparam")
-  end
-
-  describe 'when a resource is not specified' do
-    it { expect { scope.function_getparam([]) }.to raise_error }
-    it { expect { scope.function_getparam(['User[dan]']) }.to raise_error }
-    it { expect { scope.function_getparam(['User[dan]']) }.to raise_error }
-    it { expect { scope.function_getparam(['User[dan]', {}]) }.to raise_error }
-    # This seems to be OK because we just check for a string.
-    it { expect { scope.function_getparam(['User[dan]', '']) }.to_not raise_error }
-  end
-
-  describe 'when compared against a resource with no params' do
-    let :catalog do
-      compile_to_catalog(<<-EOS
-        user { "dan": }
-      EOS
-      )
-    end
-
-    it do
-      expect(scope.function_getparam(['User[dan]', 'shell'])).to eq('')
-    end
-  end
-
-  describe 'when compared against a resource with params' do
-    let :catalog do
-      compile_to_catalog(<<-EOS
-        user { 'dan': ensure => present, shell => '/bin/sh', managehome => false}
-        $test = getparam(User[dan], 'shell')
-      EOS
-      )
-    end
-
-    it do
-      resource = Puppet::Parser::Resource.new(:user, 'dan', {:scope => scope})
-      resource.set_parameter('ensure', 'present')
-      resource.set_parameter('shell', '/bin/sh')
-      resource.set_parameter('managehome', false)
-      compiler.add_resource(scope, resource)
-
-      expect(scope.function_getparam(['User[dan]', 'shell'])).to eq('/bin/sh')
-      expect(scope.function_getparam(['User[dan]', ''])).to eq('')
-      expect(scope.function_getparam(['User[dan]', 'ensure'])).to eq('present')
-      # TODO: Expected this to be false, figure out why we're getting '' back.
-      expect(scope.function_getparam(['User[dan]', 'managehome'])).to eq('')
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/getvar_spec.rb

@@ -1,37 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:getvar) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-  describe 'when calling getvar from puppet' do
-
-    it "should not compile when no arguments are passed" do
-      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
-      Puppet[:code] = '$foo = getvar()'
-      expect {
-        scope.compiler.compile
-      }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
-    end
-
-    it "should not compile when too many arguments are passed" do
-      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
-      Puppet[:code] = '$foo = getvar("foo::bar", "baz")'
-      expect {
-        scope.compiler.compile
-      }.to raise_error(Puppet::ParseError, /wrong number of arguments/)
-    end
-
-    it "should lookup variables in other namespaces" do
-      skip("Fails on 2.6.x, see bug #15912") if Puppet.version =~ /^2\.6\./
-      Puppet[:code] = <<-'ENDofPUPPETcode'
-        class site::data { $foo = 'baz' }
-        include site::data
-        $foo = getvar("site::data::foo")
-        if $foo != 'baz' {
-          fail('getvar did not return what we expect')
-        }
-      ENDofPUPPETcode
-      scope.compiler.compile
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/grep_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the grep function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("grep")).to eq("function_grep")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_grep([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should grep contents from an array" do
-    result = scope.function_grep([["aaabbb","bbbccc","dddeee"], "bbb"])
-    expect(result).to(eq(["aaabbb","bbbccc"]))
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/has_interface_with_spec.rb

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:has_interface_with) do
-
-  let(:scope) do
-    PuppetlabsSpec::PuppetInternals.scope
-  end
-
-  # The subject of these examples is the method itself.
-  subject do
-    function_name = Puppet::Parser::Functions.function(:has_interface_with)
-    scope.method(function_name)
-  end
-
-  # We need to mock out the Facts so we can specify how we expect this function
-  # to behave on different platforms.
-  context "On Mac OS X Systems" do
-    before :each do
-      scope.stubs(:lookupvar).with("interfaces").returns('lo0,gif0,stf0,en1,p2p0,fw0,en0,vmnet1,vmnet8,utun0')
-    end
-    it 'should have loopback (lo0)' do
-      expect(subject.call(['lo0'])).to be_truthy
-    end
-    it 'should not have loopback (lo)' do
-      expect(subject.call(['lo'])).to be_falsey
-    end
-  end
-  context "On Linux Systems" do
-    before :each do
-      scope.stubs(:lookupvar).with("interfaces").returns('eth0,lo')
-      scope.stubs(:lookupvar).with("ipaddress").returns('10.0.0.1')
-      scope.stubs(:lookupvar).with("ipaddress_lo").returns('127.0.0.1')
-      scope.stubs(:lookupvar).with("ipaddress_eth0").returns('10.0.0.1')
-      scope.stubs(:lookupvar).with('muppet').returns('kermit')
-      scope.stubs(:lookupvar).with('muppet_lo').returns('mspiggy')
-      scope.stubs(:lookupvar).with('muppet_eth0').returns('kermit')
-    end
-    it 'should have loopback (lo)' do
-      expect(subject.call(['lo'])).to be_truthy
-    end
-    it 'should not have loopback (lo0)' do
-      expect(subject.call(['lo0'])).to be_falsey
-    end
-    it 'should have ipaddress with 127.0.0.1' do
-      expect(subject.call(['ipaddress', '127.0.0.1'])).to be_truthy
-    end
-    it 'should have ipaddress with 10.0.0.1' do
-      expect(subject.call(['ipaddress', '10.0.0.1'])).to be_truthy
-    end
-    it 'should not have ipaddress with 10.0.0.2' do
-      expect(subject.call(['ipaddress', '10.0.0.2'])).to be_falsey
-    end
-    it 'should have muppet named kermit' do
-      expect(subject.call(['muppet', 'kermit'])).to be_truthy
-    end
-    it 'should have muppet named mspiggy' do
-      expect(subject.call(['muppet', 'mspiggy'])).to be_truthy
-    end
-    it 'should not have muppet named bigbird' do
-      expect(subject.call(['muppet', 'bigbird'])).to be_falsey
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/has_ip_address_spec.rb

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:has_ip_address) do
-
-  let(:scope) do
-    PuppetlabsSpec::PuppetInternals.scope
-  end
-
-  subject do
-    function_name = Puppet::Parser::Functions.function(:has_ip_address)
-    scope.method(function_name)
-  end
-
-  context "On Linux Systems" do
-    before :each do
-      scope.stubs(:lookupvar).with('interfaces').returns('eth0,lo')
-      scope.stubs(:lookupvar).with('ipaddress').returns('10.0.2.15')
-      scope.stubs(:lookupvar).with('ipaddress_eth0').returns('10.0.2.15')
-      scope.stubs(:lookupvar).with('ipaddress_lo').returns('127.0.0.1')
-    end
-
-    it 'should have primary address (10.0.2.15)' do
-      expect(subject.call(['10.0.2.15'])).to be_truthy
-    end
-
-    it 'should have lookupback address (127.0.0.1)' do
-      expect(subject.call(['127.0.0.1'])).to be_truthy
-    end
-
-    it 'should not have other address' do
-      expect(subject.call(['192.1681.1.1'])).to be_falsey
-    end
-
-    it 'should not have "mspiggy" on an interface' do
-      expect(subject.call(['mspiggy'])).to be_falsey
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/functions/has_ip_network_spec.rb

@@ -1,36 +0,0 @@
-#!/usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:has_ip_network) do
-
-  let(:scope) do
-    PuppetlabsSpec::PuppetInternals.scope
-  end
-
-  subject do
-    function_name = Puppet::Parser::Functions.function(:has_ip_network)
-    scope.method(function_name)
-  end
-
-  context "On Linux Systems" do
-    before :each do
-      scope.stubs(:lookupvar).with('interfaces').returns('eth0,lo')
-      scope.stubs(:lookupvar).with('network').returns(:undefined)
-      scope.stubs(:lookupvar).with('network_eth0').returns('10.0.2.0')
-      scope.stubs(:lookupvar).with('network_lo').returns('127.0.0.1')
-    end
-
-    it 'should have primary network (10.0.2.0)' do
-      expect(subject.call(['10.0.2.0'])).to be_truthy
-    end
-
-    it 'should have loopback network (127.0.0.0)' do
-      expect(subject.call(['127.0.0.1'])).to be_truthy
-    end
-
-    it 'should not have other network' do
-      expect(subject.call(['192.168.1.0'])).to be_falsey
-    end
-  end
-end
-