puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/pops/types/type_factory_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe 'The type factory' do
+  context 'when creating' do
+    it 'integer() returns PIntegerType' do
+      Puppet::Pops::Types::TypeFactory.integer().class().should == Puppet::Pops::Types::PIntegerType
+    end
+
+    it 'float() returns PFloatType' do
+      Puppet::Pops::Types::TypeFactory.float().class().should == Puppet::Pops::Types::PFloatType
+    end
+
+    it 'string() returns PStringType' do
+      Puppet::Pops::Types::TypeFactory.string().class().should == Puppet::Pops::Types::PStringType
+    end
+
+    it 'boolean() returns PBooleanType' do
+      Puppet::Pops::Types::TypeFactory.boolean().class().should == Puppet::Pops::Types::PBooleanType
+    end
+
+    it 'pattern() returns PPatternType' do
+      Puppet::Pops::Types::TypeFactory.pattern().class().should == Puppet::Pops::Types::PPatternType
+    end
+
+    it 'literal() returns PLiteralType' do
+      Puppet::Pops::Types::TypeFactory.literal().class().should == Puppet::Pops::Types::PLiteralType
+    end
+
+    it 'data() returns PDataType' do
+      Puppet::Pops::Types::TypeFactory.data().class().should == Puppet::Pops::Types::PDataType
+    end
+
+    it 'array_of(fixnum) returns PArrayType[PIntegerType]' do
+      at = Puppet::Pops::Types::TypeFactory.array_of(1)
+      at.class().should == Puppet::Pops::Types::PArrayType
+      at.element_type.class.should == Puppet::Pops::Types::PIntegerType
+    end
+
+    it 'array_of(PIntegerType) returns PArrayType[PIntegerType]' do
+      at = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::PIntegerType.new())
+      at.class().should == Puppet::Pops::Types::PArrayType
+      at.element_type.class.should == Puppet::Pops::Types::PIntegerType
+    end
+
+    it 'array_of_data returns PArrayType[PDataType]' do
+      at = Puppet::Pops::Types::TypeFactory.array_of_data
+      at.class().should == Puppet::Pops::Types::PArrayType
+      at.element_type.class.should == Puppet::Pops::Types::PDataType
+    end
+
+    it 'hash_of_data returns PHashType[PLiteralType,PDataType]' do
+      ht = Puppet::Pops::Types::TypeFactory.hash_of_data
+      ht.class().should == Puppet::Pops::Types::PHashType
+      ht.key_type.class.should == Puppet::Pops::Types::PLiteralType
+      ht.element_type.class.should == Puppet::Pops::Types::PDataType
+    end
+
+    it 'ruby(1) returns PRubyType[\'Fixnum\']' do
+      ht = Puppet::Pops::Types::TypeFactory.ruby(1)
+      ht.class().should == Puppet::Pops::Types::PRubyType
+      ht.ruby_class.should == 'Fixnum'
+    end
+  end
+end

data/spec/unit/pops/types/type_parser_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe Puppet::Pops::Types::TypeParser do
+  extend RSpec::Matchers::DSL
+
+  let(:parser) { Puppet::Pops::Types::TypeParser.new }
+  let(:types) { Puppet::Pops::Types::TypeFactory }
+
+  it "rejects a puppet expression" do
+    expect { parser.parse("1 + 1") }.to raise_error(Puppet::ParseError, /The expression <1 \+ 1> is not a valid type specification/)
+  end
+
+  it "rejects a empty type specification" do
+    expect { parser.parse("") }.to raise_error(Puppet::ParseError, /The expression <> is not a valid type specification/)
+  end
+
+  it "rejects an invalid type simple type" do
+    expect { parser.parse("NotAType") }.to raise_type_error_for("NotAType")
+  end
+
+  it "rejects an unknown parameterized type" do
+    expect { parser.parse("NotAType[Integer]") }.to raise_type_error_for("NotAType")
+  end
+
+  it "does not support types that do not make sense in the puppet language" do
+    expect { parser.parse("Object") }.to raise_type_error_for("Object")
+    expect { parser.parse("Collection[Integer]") }.to raise_type_error_for("Collection")
+  end
+
+  it "parses a simple, unparameterized type into the type object" do
+    expect(the_type_parsed_from(types.integer)).to be_the_type(types.integer)
+    expect(the_type_parsed_from(types.float)).to be_the_type(types.float)
+    expect(the_type_parsed_from(types.string)).to be_the_type(types.string)
+    expect(the_type_parsed_from(types.boolean)).to be_the_type(types.boolean)
+    expect(the_type_parsed_from(types.pattern)).to be_the_type(types.pattern)
+    expect(the_type_parsed_from(types.data)).to be_the_type(types.data)
+  end
+
+  it "interprets an unparameterized Array as an Array of Data" do
+    expect(parser.parse("Array")).to be_the_type(types.array_of_data)
+  end
+
+  it "interprets an unparameterized Hash as a Hash of Literal to Data" do
+    expect(parser.parse("Hash")).to be_the_type(types.hash_of_data)
+  end
+
+  it "interprets a parameterized Hash[t] as a Hash of Literal to t" do
+    expect(parser.parse("Hash[Integer]")).to be_the_type(types.hash_of(types.integer))
+  end
+
+  it "parses a parameterized type into the type object" do
+    parameterized_array = types.array_of(types.integer)
+    parameterized_hash = types.hash_of(types.integer, types.boolean)
+
+    expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
+    expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
+  end
+
+  it "rejects an array spec with the wrong number of parameters" do
+    expect { parser.parse("Array[Integer, Integer]") }.to raise_the_parameter_error("Array", 1, 2)
+    expect { parser.parse("Hash[Integer, Integer, Integer]") }.to raise_the_parameter_error("Hash", "1 or 2", 3)
+  end
+
+  matcher :be_the_type do |type|
+    calc = Puppet::Pops::Types::TypeCalculator.new
+
+    match do |actual|
+      calc.assignable?(actual, type) && calc.assignable?(type, actual)
+    end
+
+    failure_message_for_should do |actual|
+      "expected #{calc.string(type)}, but was #{calc.string(actual)}"
+    end
+  end
+
+  def raise_the_parameter_error(type, required, given)
+    raise_error(Puppet::ParseError, /#{type} requires #{required}, #{given} provided/)
+  end
+
+  def raise_type_error_for(type_name)
+    raise_error(Puppet::ParseError, /Unknown type <#{type_name}>/)
+  end
+
+  def the_type_parsed_from(type)
+    parser.parse(the_type_spec_for(type))
+  end
+
+  def the_type_spec_for(type)
+    calc = Puppet::Pops::Types::TypeCalculator.new
+    calc.string(type)
+  end
+end

data/spec/unit/property/list_spec.rb

@@ -44,7 +44,7 @@ describe list_class do
         @property.add_should_with_current(["foo"], ["bar"]).should == ["foo", "bar"]
       end
 
-      it "should return should if current is not a array" do
+      it "should return should if current is not an array" do
         @property.add_should_with_current(["foo"], :absent).should == ["foo"]
       end
 

data/spec/unit/property/ordered_list_spec.rb

@@ -24,7 +24,7 @@ describe ordered_list_class do
         @property.add_should_with_current(["should"], ["current"]).should == ["should", "current"]
       end
 
-      it "should return 'should' if current is not a array" do
+      it "should return 'should' if current is not an array" do
         @property.add_should_with_current(["should"], :absent).should == ["should"]
       end
 

data/spec/unit/provider/aixobject_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'puppet/provider/aixobject'
+
+describe Puppet::Provider::AixObject do
+  let(:resource) do
+    Puppet::Type.type(:user).new(
+      :name   => 'test_aix_user',
+      :ensure => :present
+    )
+  end
+
+  let(:provider) do
+    provider = Puppet::Provider::AixObject.new resource
+  end
+
+  describe "base provider methods" do
+    [ :lscmd,
+      :addcmd,
+      :modifycmd,
+      :deletecmd
+    ].each do |method|
+      it "should raise an error when unimplemented method #{method} called" do
+        lambda do
+          provider.send(method)
+        end.should raise_error(Puppet::Error, /not defined/)
+      end
+    end
+  end
+
+  describe "attribute mapping methods" do
+    let(:mapping) do
+      [
+        { :aix_attr => :test_aix_property,
+          :puppet_prop => :test_puppet_property,
+          :to => :test_convert_to_aix_method,
+          :from => :test_convert_to_puppet_method
+        }
+      ]
+    end
+
+    before(:each) do
+      provider.class.attribute_mapping = mapping
+    end
+
+    describe ".attribute_mapping_to" do
+      before(:each) do
+         if provider.class.instance_variable_defined? :@attribute_mapping_to
+           provider.class.send(:remove_instance_variable, :@attribute_mapping_to)
+         end
+      end
+
+      it "should create a hash where the key is the puppet property and the value is a hash with the aix property and the conversion method" do
+        hash = provider.class.attribute_mapping_to
+        hash.should have_key :test_puppet_property
+        sub_hash = hash[:test_puppet_property]
+        sub_hash.should have_key :key
+        sub_hash.should have_key :method
+        sub_hash[:key].should == :test_aix_property
+        sub_hash[:method].should == :test_convert_to_aix_method
+      end
+
+      it "should cache results between calls" do
+        provider.class.expects(:attribute_mapping).returns(mapping).once
+        provider.class.attribute_mapping_to
+        provider.class.attribute_mapping_to
+      end
+    end
+
+    describe ".attribute_mapping_from" do
+      before(:each) do
+        if provider.class.instance_variable_defined? :@attribute_mapping_from
+          provider.class.send(:remove_instance_variable, :@attribute_mapping_from)
+        end
+      end
+
+      it "should create a hash where the key is the aix property and the value is a hash with the puppet property and the conversion method" do
+        hash = provider.class.attribute_mapping_from
+        hash.should have_key :test_aix_property
+        sub_hash = hash[:test_aix_property]
+        sub_hash.should have_key :key
+        sub_hash.should have_key :method
+        sub_hash[:key].should == :test_puppet_property
+        sub_hash[:method].should == :test_convert_to_puppet_method
+      end
+
+      it "should cache results between calls" do
+        provider.class.expects(:attribute_mapping).returns(mapping).once
+        provider.class.attribute_mapping_from
+        provider.class.attribute_mapping_from
+      end
+    end
+  end
+
+  describe "#getinfo" do
+    it "should only execute the system command once" do
+      provider.stubs(:lscmd).returns "ls"
+      provider.expects(:execute).returns("bob=frank").once
+      provider.getinfo(true)
+    end
+  end
+end

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -650,28 +650,39 @@ describe provider_class do
       before do
         @augeas.expects(:match).with("/augeas//error").returns(["/augeas/files/foo/error"])
         @augeas.expects(:match).with("/augeas/files/foo/error/*").returns(["/augeas/files/foo/error/path", "/augeas/files/foo/error/message"])
+        @augeas.expects(:get).with("/augeas/files/foo/error").returns("some_failure")
         @augeas.expects(:get).with("/augeas/files/foo/error/path").returns("/foo")
         @augeas.expects(:get).with("/augeas/files/foo/error/message").returns("Failed to...")
       end
 
       it "and output to debug" do
-        @provider.expects(:debug).times(4)
+        @provider.expects(:debug).times(5)
         @provider.print_load_errors
       end
 
       it "and output a warning and to debug" do
         @provider.expects(:warning).once()
-        @provider.expects(:debug).times(3)
+        @provider.expects(:debug).times(4)
         @provider.print_load_errors(:warning => true)
       end
     end
 
+    it "should find load errors from lenses" do
+      @augeas.expects(:match).with("/augeas//error").returns(["/augeas/load/Xfm/error"])
+      @augeas.expects(:match).with("/augeas/load/Xfm/error/*").returns([])
+      @augeas.expects(:get).with("/augeas/load/Xfm/error").returns(["Could not find lens php.aug"])
+      @provider.expects(:warning).once()
+      @provider.expects(:debug).twice()
+      @provider.print_load_errors(:warning => true)
+    end
+
     it "should find save errors and output to debug" do
       @augeas.expects(:match).with("/augeas//error[. = 'put_failed']").returns(["/augeas/files/foo/error"])
       @augeas.expects(:match).with("/augeas/files/foo/error/*").returns(["/augeas/files/foo/error/path", "/augeas/files/foo/error/message"])
+      @augeas.expects(:get).with("/augeas/files/foo/error").returns("some_failure")
       @augeas.expects(:get).with("/augeas/files/foo/error/path").returns("/foo")
       @augeas.expects(:get).with("/augeas/files/foo/error/message").returns("Failed to...")
-      @provider.expects(:debug).times(4)
+      @provider.expects(:debug).times(5)
       @provider.print_put_errors
     end
   end

data/spec/unit/provider/mcx/mcxcontent_spec.rb

@@ -43,101 +43,136 @@ describe provider_class do
     @provider.should respond_to(:exists?)
   end
 
-  it "should have an content method." do
+  it "should have a content method." do
     @provider.should respond_to(:content)
   end
 
-  it "should have an content= method." do
+  it "should have a content= method." do
     @provider.should respond_to(:content=)
   end
 
   describe "when managing the resource" do
     it "should execute external command dscl from :create" do
+      @provider.stubs(:has_mcx?).returns(false)
       @provider.class.expects(:dscl).returns('').once
       @provider.create
     end
+
+    it "deletes existing mcx prior to import from :create" do
+      @provider.stubs(:has_mcx?).returns(true)
+      @provider.class.expects(:dscl).with('localhost', '-mcxdelete', @ds_path, anything()).once
+      @provider.class.expects(:dscl).with('localhost', '-mcximport', @ds_path, anything()).once
+      @provider.create
+    end
+
     it "should execute external command dscl from :destroy" do
       @provider.class.expects(:dscl).with('localhost', '-mcxdelete', @ds_path).returns('').once
       @provider.destroy
     end
+
     it "should execute external command dscl from :exists?" do
       @provider.class.expects(:dscl).with('localhost', '-mcxexport', @ds_path).returns('').once
       @provider.exists?
     end
+
     it "should execute external command dscl from :content" do
       @provider.class.expects(:dscl).with('localhost', '-mcxexport', @ds_path).returns('')
       @provider.content
     end
+
     it "should execute external command dscl from :content=" do
-      @provider.class.expects(:dscl).returns('')
+      @provider.stubs(:has_mcx?).returns(false)
+      @provider.class.expects(:dscl).returns('').once
+      @provider.content=''
+    end
+
+    it "deletes existing mcx prior to import from :content=" do
+      @provider.stubs(:has_mcx?).returns(true)
+      @provider.class.expects(:dscl).with('localhost', '-mcxdelete', @ds_path, anything()).once
+      @provider.class.expects(:dscl).with('localhost', '-mcximport', @ds_path, anything()).once
       @provider.content=''
     end
   end
 
   describe "when creating and parsing the name for ds_type" do
     before :each do
+      @provider.class.stubs(:dscl).returns('')
       @resource.stubs(:[]).with(:name).returns "/Foo/bar"
     end
+
     it "should not accept /Foo/bar" do
-      lambda { @provider.create }.should raise_error(MCXContentProviderException)
+      expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
+
     it "should accept /Foo/bar with ds_type => user" do
       @resource.stubs(:[]).with(:ds_type).returns "user"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
+
     it "should accept /Foo/bar with ds_type => group" do
       @resource.stubs(:[]).with(:ds_type).returns "group"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
+
     it "should accept /Foo/bar with ds_type => computer" do
       @resource.stubs(:[]).with(:ds_type).returns "computer"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
+
     it "should accept :name => /Foo/bar with ds_type => computerlist" do
       @resource.stubs(:[]).with(:ds_type).returns "computerlist"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
   end
 
   describe "when creating and :name => foobar" do
     before :each do
+      @provider.class.stubs(:dscl).returns('')
       @resource.stubs(:[]).with(:name).returns "foobar"
     end
+
     it "should not accept unspecified :ds_type and :ds_name" do
-      lambda { @provider.create }.should raise_error(MCXContentProviderException)
+      expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
+
     it "should not accept unspecified :ds_type" do
       @resource.stubs(:[]).with(:ds_type).returns "user"
-      lambda { @provider.create }.should raise_error(MCXContentProviderException)
+      expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
+
     it "should not accept unspecified :ds_name" do
       @resource.stubs(:[]).with(:ds_name).returns "foo"
-      lambda { @provider.create }.should raise_error(MCXContentProviderException)
+      expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
+
     it "should accept :ds_type => user, ds_name => foo" do
       @resource.stubs(:[]).with(:ds_type).returns "user"
       @resource.stubs(:[]).with(:ds_name).returns "foo"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
+
     it "should accept :ds_type => group, ds_name => foo" do
       @resource.stubs(:[]).with(:ds_type).returns "group"
       @resource.stubs(:[]).with(:ds_name).returns "foo"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
+
     it "should accept :ds_type => computer, ds_name => foo" do
       @resource.stubs(:[]).with(:ds_type).returns "computer"
       @resource.stubs(:[]).with(:ds_name).returns "foo"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
+
     it "should accept :ds_type => computerlist, ds_name => foo" do
       @resource.stubs(:[]).with(:ds_type).returns "computerlist"
       @resource.stubs(:[]).with(:ds_name).returns "foo"
-      lambda { @provider.create }.should_not raise_error(MCXContentProviderException)
+      expect { @provider.create }.to_not raise_error
     end
+
     it "should not accept :ds_type => bogustype, ds_name => foo" do
       @resource.stubs(:[]).with(:ds_type).returns "bogustype"
       @resource.stubs(:[]).with(:ds_name).returns "foo"
-      lambda { @provider.create }.should raise_error(MCXContentProviderException)
+      expect { @provider.create }.to raise_error(MCXContentProviderException)
     end
   end
 
@@ -145,6 +180,7 @@ describe provider_class do
     it "should define an instances class method." do
       @provider.class.should respond_to(:instances)
     end
+
     it "should call external command dscl -list /Local/Default/<ds_type> on each known ds_type" do
       @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Users").returns('')
       @provider.class.expects(:dscl).with('localhost', '-list', "/Local/Default/Groups").returns('')