puppet-retrospec 0.12.1 → 0.12.2

data/spec/fixtures/modules/stdlib/spec/acceptance/validate_string_spec.rb

@@ -1,36 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper_acceptance'
-
-describe 'validate_string function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  describe 'success' do
-    it 'validates a single argument' do
-      pp = <<-EOS
-      $one = 'string'
-      validate_string($one)
-      EOS
-
-      apply_manifest(pp, :catch_failures => true)
-    end
-    it 'validates an multiple arguments' do
-      pp = <<-EOS
-      $one = 'string'
-      $two = 'also string'
-      validate_string($one,$two)
-      EOS
-
-      apply_manifest(pp, :catch_failures => true)
-    end
-    it 'validates a non-string' do
-      {
-        %{validate_string({ 'a' => 'hash' })} => "Hash",
-        %{validate_string(['array'])}         => "Array",
-        %{validate_string(false)}             => "FalseClass",
-      }.each do |pp,type|
-        expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/a #{type}/)
-      end
-    end
-  end
-  describe 'failure' do
-    it 'handles improper number of arguments'
-  end
-end

data/spec/fixtures/modules/stdlib/spec/acceptance/values_at_spec.rb

@@ -1,73 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper_acceptance'
-
-describe 'values_at function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  describe 'success' do
-    it 'returns a specific value' do
-      pp = <<-EOS
-      $one = ['a','b','c','d','e']
-      $two = 1
-      $output = values_at($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["b"\]/)
-    end
-    it 'returns a specific negative index value' do
-      pending("negative numbers don't work")
-      pp = <<-EOS
-      $one = ['a','b','c','d','e']
-      $two = -1
-      $output = values_at($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["e"\]/)
-    end
-    it 'returns a range of values' do
-      pp = <<-EOS
-      $one = ['a','b','c','d','e']
-      $two = "1-3"
-      $output = values_at($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["b", "c", "d"\]/)
-    end
-    it 'returns a negative specific value and range of values' do
-      pp = <<-EOS
-      $one = ['a','b','c','d','e']
-      $two = ["1-3",0]
-      $output = values_at($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["b", "c", "d", "a"\]/)
-    end
-  end
-  describe 'failure' do
-    it 'handles improper number of arguments' do
-      pp = <<-EOS
-      $one = ['a','b','c','d','e']
-      $output = values_at($one)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Wrong number of arguments/)
-    end
-    it 'handles non-indicies arguments' do
-      pp = <<-EOS
-      $one = ['a','b','c','d','e']
-      $two = []
-      $output = values_at($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/at least one positive index/)
-    end
-
-    it 'detects index ranges smaller than the start range'
-    it 'handles index ranges larger than array'
-    it 'handles non-integer indicies'
-  end
-end

data/spec/fixtures/modules/stdlib/spec/acceptance/values_spec.rb

@@ -1,35 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper_acceptance'
-
-describe 'values function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  describe 'success' do
-    it 'returns an array of values' do
-      pp = <<-EOS
-      $arg = {
-        'a' => 1,
-        'b' => 2,
-        'c' => 3,
-      }
-      $output = values($arg)
-      notice(inline_template('<%= @output.sort.inspect %>'))
-      EOS
-      if is_future_parser_enabled?
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[1, 2, 3\]/)
-      else
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["1", "2", "3"\]/)
-      end
-
-    end
-  end
-  describe 'failure' do
-    it 'handles non-hash arguments' do
-      pp = <<-EOS
-      $arg = "foo"
-      $output = values($arg)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Requires hash/)
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/acceptance/zip_spec.rb

@@ -1,86 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper_acceptance'
-require 'puppet'
-
-describe 'zip function', :unless => UNSUPPORTED_PLATFORMS.include?(fact('operatingsystem')) do
-  describe 'success' do
-    it 'zips two arrays of numbers together' do
-      pp = <<-EOS
-      $one = [1,2,3,4]
-      $two = [5,6,7,8]
-      $output = zip($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-      if is_future_parser_enabled?
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\[1, 5\], \[2, 6\], \[3, 7\], \[4, 8\]\]/)
-      else
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\["1", "5"\], \["2", "6"\], \["3", "7"\], \["4", "8"\]\]/)
-      end
-    end
-    it 'zips two arrays of numbers & bools together' do
-      pp = <<-EOS
-      $one = [1,2,"three",4]
-      $two = [true,true,false,false]
-      $output = zip($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-      if is_future_parser_enabled?
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\[1, true\], \[2, true\], \["three", false\], \[4, false\]\]/)
-      else
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\["1", true\], \["2", true\], \["three", false\], \["4", false\]\]/)
-      end
-    end
-    it 'zips two arrays of numbers together and flattens them' do
-      # XXX This only tests the argument `true`, even though the following are valid:
-      # 1 t y true yes
-      # 0 f n false no
-      # undef undefined
-      pp = <<-EOS
-      $one = [1,2,3,4]
-      $two = [5,6,7,8]
-      $output = zip($one,$two,true)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-      if is_future_parser_enabled?
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[1, 5, 2, 6, 3, 7, 4, 8\]/)
-      else
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\["1", "5", "2", "6", "3", "7", "4", "8"\]/)
-      end
-    end
-    it 'handles unmatched length' do
-      # XXX Is this expected behavior?
-      pp = <<-EOS
-      $one = [1,2]
-      $two = [5,6,7,8]
-      $output = zip($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-      if is_future_parser_enabled?
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\[1, 5\], \[2, 6\]\]/)
-      else
-        expect(apply_manifest(pp, :catch_failures => true).stdout).to match(/\[\["1", "5"\], \["2", "6"\]\]/)
-      end
-    end
-  end
-  describe 'failure' do
-    it 'handles improper number of arguments' do
-      pp = <<-EOS
-      $one = [1,2]
-      $output = zip($one)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Wrong number of arguments/)
-    end
-    it 'handles improper argument types' do
-      pp = <<-EOS
-      $one = "a string"
-      $two = [5,6,7,8]
-      $output = zip($one,$two)
-      notice(inline_template('<%= @output.inspect %>'))
-      EOS
-
-      expect(apply_manifest(pp, :expect_failures => true).stderr).to match(/Requires array/)
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/spec/classes/anchor_spec.rb

@@ -1,30 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe "anchorrefresh" do
-  include PuppetSpec::Compiler
-
-  let :transaction do
-    apply_compiled_manifest(<<-ANCHORCLASS)
-      class anchored {
-        anchor { 'anchored::begin': }
-        ~> anchor { 'anchored::end': }
-      }
-
-      class anchorrefresh {
-        notify { 'first': }
-        ~> class { 'anchored': }
-        ~> anchor { 'final': }
-      }
-
-      include anchorrefresh
-    ANCHORCLASS
-  end
-
-  it 'propagates events through the anchored class' do
-    resource = transaction.resource_status('Anchor[final]')
-
-    expect(resource.restarted).to eq(true)
-  end
-end

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

@@ -1,25 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the abs function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("abs")).to eq("function_abs")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_abs([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should convert a negative number into a positive" do
-    result = scope.function_abs(["-34"])
-    expect(result).to(eq(34))
-  end
-
-  it "should do nothing with a positive number" do
-    result = scope.function_abs(["5678"])
-    expect(result).to(eq(5678))
-  end
-end

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

@@ -1,55 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the any2array function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("any2array")).to eq("function_any2array")
-  end
-
-  it "should return an empty array if there is less than 1 argument" do
-    result = scope.function_any2array([])
-    expect(result).to(eq([]))
-  end
-
-  it "should convert boolean true to [ true ] " do
-    result = scope.function_any2array([true])
-    expect(result).to(eq([true]))
-  end
-
-  it "should convert one object to [object]" do
-    result = scope.function_any2array(['one'])
-    expect(result).to(eq(['one']))
-  end
-
-  it "should convert multiple objects to [objects]" do
-    result = scope.function_any2array(['one', 'two'])
-    expect(result).to(eq(['one', 'two']))
-  end
-
-  it "should return empty array it was called with" do
-    result = scope.function_any2array([[]])
-    expect(result).to(eq([]))
-  end
-
-  it "should return one-member array it was called with" do
-    result = scope.function_any2array([['string']])
-    expect(result).to(eq(['string']))
-  end
-
-  it "should return multi-member array it was called with" do
-    result = scope.function_any2array([['one', 'two']])
-    expect(result).to(eq(['one', 'two']))
-  end
-
-  it "should return members of a hash it was called with" do
-    result = scope.function_any2array([{ 'key' => 'value' }])
-    expect(result).to(eq(['key', 'value']))
-  end
-
-  it "should return an empty array if it was called with an empty hash" do
-    result = scope.function_any2array([{ }])
-    expect(result).to(eq([]))
-  end
-end

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

@@ -1,55 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe Puppet::Parser::Functions.function(:assert_private) do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  subject do
-    function_name = Puppet::Parser::Functions.function(:assert_private)
-    scope.method(function_name)
-  end
-
-  context "when called from inside module" do
-    it "should not fail" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('foo')
-      expect {
-        subject.call []
-      }.not_to raise_error
-    end
-  end
-
-  context "with an explicit failure message" do
-    it "prints the failure message on error" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('bar')
-      expect {
-        subject.call ['failure message!']
-      }.to raise_error Puppet::ParseError, /failure message!/
-    end
-  end
-
-  context "when called from private class" do
-    it "should fail with a class error message" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('bar')
-      scope.source.expects(:name).returns('foo::baz')
-      scope.source.expects(:type).returns('hostclass')
-      expect {
-        subject.call []
-      }.to raise_error Puppet::ParseError, /Class foo::baz is private/
-    end
-  end
-
-  context "when called from private definition" do
-    it "should fail with a class error message" do
-      scope.expects(:lookupvar).with('module_name').returns('foo')
-      scope.expects(:lookupvar).with('caller_module_name').returns('bar')
-      scope.source.expects(:name).returns('foo::baz')
-      scope.source.expects(:type).returns('definition')
-      expect {
-        subject.call []
-      }.to raise_error Puppet::ParseError, /Definition foo::baz is private/
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-
-require 'spec_helper'
-
-describe "the base64 function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("base64")).to eq("function_base64")
-  end
-
-  it "should raise a ParseError if there are other than 2 arguments" do
-    expect { scope.function_base64([]) }.to(raise_error(Puppet::ParseError))
-    expect { scope.function_base64(["asdf"]) }.to(raise_error(Puppet::ParseError))
-    expect { scope.function_base64(["asdf","moo","cow"]) }.to(raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError if argument 1 isn't 'encode' or 'decode'" do
-    expect { scope.function_base64(["bees","astring"]) }.to(raise_error(Puppet::ParseError, /first argument must be one of/))
-  end
-
-  it "should raise a ParseError if argument 2 isn't a string" do
-    expect { scope.function_base64(["encode",["2"]]) }.to(raise_error(Puppet::ParseError, /second argument must be a string/))
-  end
-
-  it "should encode a encoded string" do
-    result = scope.function_base64(["encode",'thestring'])
-    expect(result).to match(/\AdGhlc3RyaW5n\n\Z/)
-  end
-  it "should decode a base64 encoded string" do
-    result = scope.function_base64(["decode",'dGhlc3RyaW5n'])
-    expect(result).to eq('thestring')
-  end
-end

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

@@ -1,38 +0,0 @@
-#! /usr/bin/env ruby -S rspec
-require 'spec_helper'
-
-describe "the bool2num function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
-
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("bool2num")).to eq("function_bool2num")
-  end
-
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_bool2num([]) }.to( raise_error(Puppet::ParseError))
-  end
-
-  it "should convert true to 1" do
-    result = scope.function_bool2num([true])
-    expect(result).to(eq(1))
-  end
-
-  it "should convert 'true' to 1" do
-    result = scope.function_bool2num(['true'])
-    result.should(eq(1))
-  end
-
-  it "should convert 'false' to 0" do
-    result = scope.function_bool2num(['false'])
-    expect(result).to(eq(0))
-  end
-
-  it "should accept objects which extend String" do
-    class AlsoString < String
-    end
-
-    value = AlsoString.new('true')
-    result = scope.function_bool2num([value])
-    result.should(eq(1))
-  end
-end