Update stdlib

[mirror/dsa-puppet.git] / 3rdparty / modules / stdlib / spec / functions / fqdn_rotate_spec.rb

diff --git a/3rdparty/modules/stdlib/spec/functions/fqdn_rotate_spec.rb b/3rdparty/modules/stdlib/spec/functions/fqdn_rotate_spec.rb
index 673a8a3..7c1038a 100755 (executable)
--- a/3rdparty/modules/stdlib/spec/functions/fqdn_rotate_spec.rb
+++ b/3rdparty/modules/stdlib/spec/functions/fqdn_rotate_spec.rb
@@ -1,60 +1,76 @@
-#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
-describe "the fqdn_rotate function" do
-  let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
+describe 'fqdn_rotate' do
+  it { is_expected.not_to eq(nil) }
+  it { is_expected.to run.with_params().and_raise_error(Puppet::ParseError, /wrong number of arguments/i) }
+  it { is_expected.to run.with_params(0).and_raise_error(Puppet::ParseError, /Requires either array or string to work with/) }
+  it { is_expected.to run.with_params({}).and_raise_error(Puppet::ParseError, /Requires either array or string to work with/) }
+  it { is_expected.to run.with_params('').and_return('') }
+  it { is_expected.to run.with_params('a').and_return('a') }
+  it { is_expected.to run.with_params('ã').and_return('ã') }
 
-  it "should exist" do
-    expect(Puppet::Parser::Functions.function("fqdn_rotate")).to eq("function_fqdn_rotate")
+  it { is_expected.to run.with_params([]).and_return([]) }
+  it { is_expected.to run.with_params(['a']).and_return(['a']) }
+
+  it "should rotate a string and the result should be the same size" do
+    expect(fqdn_rotate("asdf").size).to eq(4)
   end
 
-  it "should raise a ParseError if there is less than 1 arguments" do
-    expect { scope.function_fqdn_rotate([]) }.to( raise_error(Puppet::ParseError))
+  it "should rotate a string to give the same results for one host" do
+    val1 = fqdn_rotate("abcdefg", :host => 'one')
+    val2 = fqdn_rotate("abcdefg", :host => 'one')
+    expect(val1).to eq(val2)
   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))
+  it "allows extra arguments to control the random rotation on a single host" do
+    val1 = fqdn_rotate("abcdefg", :extra_identifier => [1, "different", "host"])
+    val2 = fqdn_rotate("abcdefg", :extra_identifier => [2, "different", "host"])
+    expect(val1).not_to eq(val2)
   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"]))
+  it "considers the same host and same extra arguments to have the same random rotation" do
+    val1 = fqdn_rotate("abcdefg", :extra_identifier => [1, "same", "host"])
+    val2 = fqdn_rotate("abcdefg", :extra_identifier => [1, "same", "host"])
+    expect(val1).to eq(val2)
   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)
+    val1 = fqdn_rotate("abcdefg", :host => 'one')
+    val2 = fqdn_rotate("abcdefg", :host => 'two')
+    expect(val1).not_to eq(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))
+    result = fqdn_rotate(AlsoString.new('asdf'))
+    expect(result).to eq('dfas')
   end
 
-  it "should use the Puppet::Util.deterministic_rand function if available" do
-    scope.expects(:lookupvar).with("::fqdn").returns("127.0.0.1")
+  it "should use the Puppet::Util.deterministic_rand function" do
     if Puppet::Util.respond_to?(:deterministic_rand)
-      Puppet::Util.expects(:deterministic_rand).with(113646079810780526294648115052177588845,4)
+      Puppet::Util.expects(:deterministic_rand).with(44489829212339698569024999901561968770,4)
+      fqdn_rotate("asdf")
+    else
+      skip 'Puppet::Util#deterministic_rand not available'
     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"])
+    fqdn_rotate("asdf")
     rand1 = rand()
-    scope.function_fqdn_rotate(["asdf"])
+    fqdn_rotate("asdf")
     rand2 = rand()
     expect(rand1).not_to eql(rand2)
   end
+
+  def fqdn_rotate(value, args = {})
+    host = args[:host] || '127.0.0.1'
+    extra = args[:extra_identifier] || []
+
+    # workaround not being able to use let(:facts) because some tests need
+    # multiple different hostnames in one context
+    scope.stubs(:lookupvar).with("::fqdn").returns(host)
+
+    function_args = [value] + extra
+    scope.function_fqdn_rotate(function_args)
+  end
 end