From b664fec30f8b7d8a4dd8621d8064df9b9789169b Mon Sep 17 00:00:00 2001 From: David Schmitt Date: Thu, 23 Apr 2015 16:37:01 -0700 Subject: specs: loosen certain error expectations to make tests pass on future parser --- spec/functions/validate_integer_spec.rb | 6 +++--- spec/functions/validate_ipv4_address_spec.rb | 4 +--- spec/functions/validate_ipv6_address_spec.rb | 4 +--- spec/functions/validate_numeric_spec.rb | 6 +++--- 4 files changed, 8 insertions(+), 12 deletions(-) (limited to 'spec/functions') diff --git a/spec/functions/validate_integer_spec.rb b/spec/functions/validate_integer_spec.rb index dff3415..3865c4f 100755 --- a/spec/functions/validate_integer_spec.rb +++ b/spec/functions/validate_integer_spec.rb @@ -43,7 +43,7 @@ describe Puppet::Parser::Functions.function(:validate_integer) do it "should not compile when #{the_number} is a bare word" do Puppet[:code] = "validate_integer(#{the_number})" - expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be an Integer/) + expect { scope.compiler.compile }.to raise_error end end @@ -117,7 +117,7 @@ describe Puppet::Parser::Functions.function(:validate_integer) do it "should not compile when a non-Integer maximum #{the_max} bare word is passed" do Puppet[:code] = "validate_integer(1,#{the_max})" - expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/) + expect { scope.compiler.compile }.to raise_error end end @@ -212,7 +212,7 @@ describe Puppet::Parser::Functions.function(:validate_integer) do it "should not compile when a non-Integer minimum #{the_min} bare word is passed" do Puppet[:code] = "validate_integer(1,#{max},#{the_min})" - expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or an Integer/) + expect { scope.compiler.compile }.to raise_error end end end diff --git a/spec/functions/validate_ipv4_address_spec.rb b/spec/functions/validate_ipv4_address_spec.rb index 45401a4..27ea4fe 100755 --- a/spec/functions/validate_ipv4_address_spec.rb +++ b/spec/functions/validate_ipv4_address_spec.rb @@ -39,9 +39,7 @@ describe Puppet::Parser::Functions.function(:validate_ipv4_address) do describe "when given numbers" do it "should not compile" do Puppet[:code] = "validate_ipv4_address(1, 2)" - expect { - scope.compiler.compile - }.to raise_error(Puppet::ParseError, /is not a valid IPv4 address/) + expect { scope.compiler.compile }.to raise_error end end diff --git a/spec/functions/validate_ipv6_address_spec.rb b/spec/functions/validate_ipv6_address_spec.rb index a839d90..e87b372 100755 --- a/spec/functions/validate_ipv6_address_spec.rb +++ b/spec/functions/validate_ipv6_address_spec.rb @@ -41,9 +41,7 @@ describe Puppet::Parser::Functions.function(:validate_ipv6_address) do describe "when given numbers" do it "should not compile" do Puppet[:code] = "validate_ipv6_address(1, 2)" - expect { - scope.compiler.compile - }.to raise_error(Puppet::ParseError, /not a valid IPv6 address/) + expect { scope.compiler.compile }.to raise_error end end end diff --git a/spec/functions/validate_numeric_spec.rb b/spec/functions/validate_numeric_spec.rb index c8b0e4d..1623a3d 100755 --- a/spec/functions/validate_numeric_spec.rb +++ b/spec/functions/validate_numeric_spec.rb @@ -43,7 +43,7 @@ describe Puppet::Parser::Functions.function(:validate_numeric) do it "should not compile when #{the_number} is a bare word" do Puppet[:code] = "validate_numeric(#{the_number})" - expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be a Numeric/) + expect { scope.compiler.compile }.to raise_error end end @@ -115,7 +115,7 @@ describe Puppet::Parser::Functions.function(:validate_numeric) do it "should not compile when a non-Numeric maximum #{the_max} bare word is passed" do Puppet[:code] = "validate_numeric(1,#{the_max})" - expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/) + expect { scope.compiler.compile }.to raise_error end end @@ -210,7 +210,7 @@ describe Puppet::Parser::Functions.function(:validate_numeric) do it "should not compile when a non-Numeric minimum #{the_min} bare word is passed" do Puppet[:code] = "validate_numeric(1,#{max},#{the_min})" - expect { scope.compiler.compile }.to raise_error(Puppet::ParseError, /to be unset or a Numeric/) + expect { scope.compiler.compile }.to raise_error end end end -- cgit v1.2.3 From a3016c45c5aaa979c9d148eb88bb3f7d1369a507 Mon Sep 17 00:00:00 2001 From: David Schmitt Date: Wed, 15 Apr 2015 16:55:28 -0700 Subject: specs: move function specs to where rspec-puppet expects them --- spec/functions/basename_spec.rb | 46 ++++++++++++++++++++++++++++++++++++++++ spec/functions/bool2str_spec.rb | 46 ++++++++++++++++++++++++++++++++++++++++ spec/functions/camelcase_spec.rb | 24 +++++++++++++++++++++ spec/functions/type_of_spec.rb | 33 ++++++++++++++++++++++++++++ 4 files changed, 149 insertions(+) create mode 100755 spec/functions/basename_spec.rb create mode 100755 spec/functions/bool2str_spec.rb create mode 100755 spec/functions/camelcase_spec.rb create mode 100644 spec/functions/type_of_spec.rb (limited to 'spec/functions') diff --git a/spec/functions/basename_spec.rb b/spec/functions/basename_spec.rb new file mode 100755 index 0000000..8a2d0dc --- /dev/null +++ b/spec/functions/basename_spec.rb @@ -0,0 +1,46 @@ +#! /usr/bin/env ruby -S rspec +require 'spec_helper' + +describe "the basename function" do + let(:scope) { PuppetlabsSpec::PuppetInternals.scope } + + it "should exist" do + Puppet::Parser::Functions.function("basename").should == "function_basename" + end + + it "should raise a ParseError if there is less than 1 argument" do + lambda { scope.function_basename([]) }.should( raise_error(Puppet::ParseError)) + end + + it "should raise a ParseError if there are more than 2 arguments" do + lambda { scope.function_basename(['a', 'b', 'c']) }.should( raise_error(Puppet::ParseError)) + end + + it "should return basename for an absolute path" do + result = scope.function_basename(['/path/to/a/file.ext']) + result.should(eq('file.ext')) + end + + it "should return basename for a relative path" do + result = scope.function_basename(['path/to/a/file.ext']) + result.should(eq('file.ext')) + end + + it "should strip extention when extension specified (absolute path)" do + result = scope.function_basename(['/path/to/a/file.ext', '.ext']) + result.should(eq('file')) + end + + it "should strip extention when extension specified (relative path)" do + result = scope.function_basename(['path/to/a/file.ext', '.ext']) + result.should(eq('file')) + end + + it "should complain about non-string first argument" do + lambda { scope.function_basename([[]]) }.should( raise_error(Puppet::ParseError)) + end + + it "should complain about non-string second argument" do + lambda { scope.function_basename(['/path/to/a/file.ext', []]) }.should( raise_error(Puppet::ParseError)) + end +end diff --git a/spec/functions/bool2str_spec.rb b/spec/functions/bool2str_spec.rb new file mode 100755 index 0000000..b878891 --- /dev/null +++ b/spec/functions/bool2str_spec.rb @@ -0,0 +1,46 @@ +#! /usr/bin/env ruby -S rspec +require 'spec_helper' + +describe "the bool2str function" do + let(:scope) { PuppetlabsSpec::PuppetInternals.scope } + + it "should exist" do + expect(Puppet::Parser::Functions.function("bool2str")).to eq("function_bool2str") + end + + it "should raise a ParseError if there is less than 1 arguments" do + expect { scope.function_bool2str([]) }.to( raise_error(Puppet::ParseError)) + end + + it "should convert true to 'true'" do + result = scope.function_bool2str([true]) + expect(result).to(eq('true')) + end + + it "should convert true to a string" do + result = scope.function_bool2str([true]) + expect(result.class).to(eq(String)) + end + + it "should convert false to 'false'" do + result = scope.function_bool2str([false]) + expect(result).to(eq('false')) + end + + it "should convert false to a string" do + result = scope.function_bool2str([false]) + expect(result.class).to(eq(String)) + end + + it "should not accept a string" do + expect { scope.function_bool2str(["false"]) }.to( raise_error(Puppet::ParseError)) + end + + it "should not accept a nil value" do + expect { scope.function_bool2str([nil]) }.to( raise_error(Puppet::ParseError)) + end + + it "should not accept an undef" do + expect { scope.function_bool2str([:undef]) }.to( raise_error(Puppet::ParseError)) + end +end diff --git a/spec/functions/camelcase_spec.rb b/spec/functions/camelcase_spec.rb new file mode 100755 index 0000000..70382ad --- /dev/null +++ b/spec/functions/camelcase_spec.rb @@ -0,0 +1,24 @@ +#! /usr/bin/env ruby -S rspec +require 'spec_helper' + +describe "the camelcase function" do + let(:scope) { PuppetlabsSpec::PuppetInternals.scope } + + it "should exist" do + expect(Puppet::Parser::Functions.function("camelcase")).to eq("function_camelcase") + end + + it "should raise a ParseError if there is less than 1 arguments" do + expect { scope.function_camelcase([]) }.to( raise_error(Puppet::ParseError)) + end + + it "should capitalize the beginning of a normal string" do + result = scope.function_camelcase(["abc"]) + expect(result).to(eq("Abc")) + end + + it "should camelcase an underscore-delimited string" do + result = scope.function_camelcase(["aa_bb_cc"]) + expect(result).to(eq("AaBbCc")) + end +end diff --git a/spec/functions/type_of_spec.rb b/spec/functions/type_of_spec.rb new file mode 100644 index 0000000..8afb624 --- /dev/null +++ b/spec/functions/type_of_spec.rb @@ -0,0 +1,33 @@ +#! /usr/bin/env ruby -S rspec + +require 'spec_helper' + +if ENV["FUTURE_PARSER"] == 'yes' or Puppet.version >= "4" + require 'puppet/pops' + require 'puppet/loaders' + + describe 'the type_of function' do + before(:all) do + loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [File.join(fixtures, "modules")])) + Puppet.push_context({:loaders => loaders}, "test-examples") + end + + after(:all) do + Puppet::Pops::Loaders.clear + Puppet::pop_context() + end + + let(:func) do + # Load the function from the environment modulepath's modules (ie, fixtures) + Puppet.lookup(:loaders).private_environment_loader.load(:function, 'type_of') + end + + it 'gives the type of a string' do + expect(func.call({}, 'hello world')).to be_kind_of(Puppet::Pops::Types::PStringType) + end + + it 'gives the type of an integer' do + expect(func.call({}, 5)).to be_kind_of(Puppet::Pops::Types::PIntegerType) + end + end +end -- cgit v1.2.3