puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/provider/aix_object_spec.rb

@@ -1,821 +0,0 @@
-require 'spec_helper'
-require 'puppet/provider/aix_object'
-
-describe 'Puppet::Provider::AixObject' do
-  let(:resource) do
-    Puppet::Type.type(:user).new(
-      :name   => 'test_aix_user',
-      :ensure => :present
-    )
-  end
-  let(:klass) { Puppet::Provider::AixObject }
-  let(:provider) do
-    Puppet::Provider::AixObject.new(resource)
-  end
-
-  # Clear out the class-level + instance-level mappings
-  def clear_attributes
-    klass.instance_variable_set(:@mappings, nil)
-  end
-
-  before(:each) do
-    clear_attributes
-  end
-
-  describe '.mapping' do
-    let(:puppet_property) { :uid }
-    let(:aix_attribute) { :id }
-    let(:info) do
-      {
-        :puppet_property => puppet_property,
-        :aix_attribute   => aix_attribute
-      }
-    end
-
-    shared_examples 'a mapping' do |from, to|
-      context "<#{from}> => <#{to}>" do
-        let(:from_suffix) { from.to_s.split("_")[-1] }
-        let(:to_suffix)   { to.to_s.split("_")[-1] }
-        let(:conversion_fn) do
-          "convert_#{from_suffix}_value".to_sym
-        end
-
-        it 'creates the mapping for a pure conversion function and defines it' do
-          conversion_fn_lambda = "#{from_suffix}_to_#{to_suffix}".to_sym
-          info[conversion_fn_lambda] = lambda { |x| x.to_s }
-          provider.class.mapping(info)
-    
-          mappings = provider.class.mappings[to]
-          expect(mappings).to include(info[from])
-
-          mapping = mappings[info[from]]
-          expect(mapping.public_methods).to include(conversion_fn)
-
-          expect(mapping.send(conversion_fn, 3)).to eql('3')
-        end
-
-        it 'creates the mapping for an impure conversion function without defining it' do
-          conversion_fn_lambda = "#{from_suffix}_to_#{to_suffix}".to_sym
-          info[conversion_fn_lambda] = lambda { |provider, x| x.to_s }
-          provider.class.mapping(info)
-    
-          mappings = provider.class.mappings[to]
-          expect(mappings).to include(info[from])
-
-          mapping = mappings[info[from]]
-          expect(mapping.public_methods).not_to include(conversion_fn)
-        end
-  
-        it 'uses the identity function as the conversion function if none is provided' do
-          provider.class.mapping(info)
-
-    
-          mappings = provider.class.mappings[to]
-          expect(mappings).to include(info[from])
-
-          mapping = mappings[info[from]]
-          expect(mapping.public_methods).to include(conversion_fn)
-
-          expect(mapping.send(conversion_fn, 3)).to eql(3)
-        end
-      end
-    end
-
-    include_examples 'a mapping',
-                     :puppet_property,
-                     :aix_attribute
-
-    include_examples 'a mapping',
-                     :aix_attribute,
-                     :puppet_property
-
-    it 'sets the AIX attribute to the Puppet property if it is not provided' do
-      info[:aix_attribute] = nil
-      provider.class.mapping(info)
-
-      mappings = provider.class.mappings[:puppet_property]
-      expect(mappings).to include(info[:puppet_property])
-    end
-  end
-
-  describe '.numeric_mapping' do
-    let(:info) do
-      info_hash = {
-        :puppet_property => :uid,
-        :aix_attribute   => :id
-      }
-      provider.class.numeric_mapping(info_hash)
-
-      info_hash
-    end
-    let(:aix_attribute) do
-      provider.class.mappings[:aix_attribute][info[:puppet_property]]
-    end
-    let(:puppet_property) do
-      provider.class.mappings[:puppet_property][info[:aix_attribute]]
-    end
-
-    it 'raises an ArgumentError for a non-numeric Puppet property value' do
-      value = 'foo'
-      expect do
-        aix_attribute.convert_property_value(value) 
-      end.to raise_error do |error|
-        expect(error).to be_a(ArgumentError)
-
-        expect(error.message).to match(value)
-        expect(error.message).to match(info[:puppet_property].to_s)
-      end
-    end
-
-    it 'converts the numeric Puppet property to a numeric AIX attribute' do
-      expect(aix_attribute.convert_property_value(10)).to eql('10')
-    end
-
-    it 'converts the numeric AIX attribute to a numeric Puppet property' do
-      expect(puppet_property.convert_attribute_value('10')).to eql(10)
-    end
-  end
-
-  describe '.mk_resource_methods' do
-    before(:each) do
-      # Add some Puppet properties
-      provider.class.mapping(
-        puppet_property: :foo,
-        aix_attribute: :foo
-      )
-      provider.class.mapping(
-        puppet_property: :bar,
-        aix_attribute: :bar
-      )
-
-      provider.class.mk_resource_methods
-    end
-
-    it 'defines the property getters' do
-      provider = Puppet::Provider::AixObject.new(resource)
-      provider.instance_variable_set(:@object_info, { :foo => 'foo', :baz => 'baz' })
-
-      (provider.class.mappings[:aix_attribute].keys + [:attributes]).each do |property|
-        expect(provider).to receive(:get).with(property).and_return('value')
-
-        expect(provider.send(property)).to eql('value')
-      end
-    end
-
-    it 'defines the property setters' do
-      provider = Puppet::Provider::AixObject.new(resource)
-
-      value = '15'
-      provider.class.mappings[:aix_attribute].keys.each do |property|
-        expect(provider).to receive(:set).with(property, value)
-
-        provider.send("#{property}=".to_sym, value)
-      end
-    end
-  end
-
-  describe '.parse_colon_separated_list' do
-    it 'parses a single empty item' do
-      input = ''
-      output = ['']
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it 'parses a single nonempty item' do
-      input = 'item'
-      output = ['item']
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it "parses an escaped ':'" do
-      input = '#!:'
-      output = [':']
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it "parses a single item with an escaped ':'" do
-      input = 'fd8c#!:215d#!:178#!:'
-      output = ['fd8c:215d:178:']
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it "parses multiple items that do not have an escaped ':'" do
-      input = "foo:bar baz:buu:1234"
-      output = ["foo", "bar baz", "buu", "1234"]
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it "parses multiple items some of which have escaped ':'" do
-      input = "1234#!:567:foo bar#!:baz:buu#!bob:sally:fd8c#!:215d#!:178"
-      output = ["1234:567", "foo bar:baz", "buu#!bob", "sally", 'fd8c:215d:178']
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it "parses a list with several empty items" do
-      input = "foo:::bar:baz:boo:"
-      output = ["foo", "", "", "bar", "baz", "boo", ""]
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it "parses a list with an escaped ':' and empty item at the end" do
-      input = "foo:bar#!::"
-      output = ["foo", "bar:", ""]
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-
-    it 'parses a real world example' do
-      input = File.read(my_fixture('aix_colon_list_real_world_input.out')).chomp
-      output = Object.instance_eval(File.read(my_fixture('aix_colon_list_real_world_output.out')))
-
-      expect(provider.class.parse_colon_separated_list(input)).to eql(output)
-    end
-  end
-
-  describe '.parse_aix_objects' do
-    # parse_colon_separated_list is well tested, so we don't need to be
-    # as strict on the formatting of the output here. Main point of these
-    # tests is to capture the 'wholemeal' parsing that's going on, i.e.
-    # that we can parse a bunch of objects together.
-    let(:output) do
-      <<-AIX_OBJECTS
-#name:id:pgrp:groups
-root:0:system:system,bin,sys,security,cron,audit,lp
-#name:id:pgrp:groups:home:gecos
-user:10000:staff:staff:/home/user3:Some User
-AIX_OBJECTS
-    end
-
-    let(:expected_aix_attributes) do
-      [
-        {
-          :name => 'root',
-          :attributes => {
-            :id     => '0',
-            :pgrp   => 'system',
-            :groups => 'system,bin,sys,security,cron,audit,lp',
-          }
-        },
-        {
-          :name => 'user',
-          :attributes => {
-            :id     => '10000',
-            :pgrp   => 'staff',
-            :groups => 'staff',
-            :home   => '/home/user3',
-            :gecos  => 'Some User'
-          }
-        }
-      ]
-    end
-
-    it 'parses the AIX attributes from the command output' do
-      expect(provider.class.parse_aix_objects(output)).to eql(expected_aix_attributes)
-    end
-  end
-
-  describe 'list_all' do
-    let(:output) do
-      <<-OUTPUT
-#name:id
-system:0
-#name:id
-staff:1
-#name:id
-bin:2
-      OUTPUT
-    end
-
-    it 'lists all of the objects' do
-      lscmd = 'lsgroups'
-      allow(provider.class).to receive(:command).with(:list).and_return(lscmd)
-      allow(provider.class).to receive(:execute).with([lscmd, '-c', '-a', 'id', 'ALL']).and_return(output)
-
-      expected_objects = [
-        { :name => 'system', :id => '0' },
-        { :name => 'staff', :id => '1' },
-        { :name => 'bin', :id => '2' }
-      ]
-      expect(provider.class.list_all).to eql(expected_objects)
-    end
-  end
-
-  describe '.instances' do
-    let(:objects) do
-      [
-        { :name => 'group1', :id => '1' },
-        { :name => 'group2', :id => '2' }
-      ]
-    end
-
-    it 'returns all of the available instances' do
-      allow(provider.class).to receive(:list_all).and_return(objects)
-
-      expect(provider.class.instances.map(&:name)).to eql(['group1', 'group2'])
-    end
-  end
-
-  describe '#mappings' do
-    # Returns a pair [ instance_level_mapped_object, class_level_mapped_object ]
-    def mapped_objects(type, input)
-      [
-        provider.mappings[type][input],
-        provider.class.mappings[type][input]
-      ]
-    end
-
-    before(:each) do
-      # Create a pure mapping
-      provider.class.numeric_mapping(
-        puppet_property: :pure_puppet_property,
-        aix_attribute: :pure_aix_attribute
-      )
-
-      # Create an impure mapping
-      impure_conversion_fn = lambda do |provider, value|
-        "Provider instance's name is #{provider.name}"
-      end
-      provider.class.mapping(
-        puppet_property: :impure_puppet_property,
-        aix_attribute: :impure_aix_attribute,
-        property_to_attribute: impure_conversion_fn,
-        attribute_to_property: impure_conversion_fn
-      )
-    end
-
-    it 'memoizes the result' do
-      provider.instance_variable_set(:@mappings, 'memoized')
-      expect(provider.mappings).to eql('memoized')
-    end
-
-    it 'creates the instance-level mappings with the same structure as the class-level one' do
-      expect(provider.mappings.keys).to eql(provider.class.mappings.keys)
-      provider.mappings.keys.each do |type|
-        expect(provider.mappings[type].keys).to eql(provider.class.mappings[type].keys)
-      end
-    end
-    
-    shared_examples 'uses the right mapped object for a given mapping' do |from_type, to_type|
-      context "<#{from_type}> => <#{to_type}>" do
-        it 'shares the class-level mapped object for pure mappings' do
-          input = "pure_#{from_type}".to_sym
-
-          instance_level_mapped_object, class_level_mapped_object = mapped_objects(to_type, input)
-          expect(instance_level_mapped_object.object_id).to eql(class_level_mapped_object.object_id)
-        end
-
-        it 'dups the class-level mapped object for impure mappings' do
-          input = "impure_#{from_type}".to_sym
-
-          instance_level_mapped_object, class_level_mapped_object = mapped_objects(to_type, input)
-          expect(instance_level_mapped_object.object_id).to_not eql(
-            class_level_mapped_object.object_id
-          )
-        end
-
-        it 'defines the conversion function for impure mappings' do
-          from_type_suffix = from_type.to_s.split("_")[-1]
-          conversion_fn = "convert_#{from_type_suffix}_value".to_sym
-
-          input = "impure_#{from_type}".to_sym
-          mapped_object, _ = mapped_objects(to_type, input)
-
-          expect(mapped_object.public_methods).to include(conversion_fn)
-          expect(mapped_object.send(conversion_fn, 3)).to match(provider.name)
-        end
-      end
-    end
-
-    include_examples 'uses the right mapped object for a given mapping',
-                     :puppet_property,
-                     :aix_attribute
-
-    include_examples 'uses the right mapped object for a given mapping',
-                     :aix_attribute,
-                     :puppet_property
-  end
-
-  describe '#attributes_to_args' do
-    let(:attributes) do
-      {
-        :attribute1 => 'value1',
-        :attribute2 => 'value2'
-      }
-    end
-
-    it 'converts the attributes hash to CLI arguments' do
-      expect(provider.attributes_to_args(attributes)).to eql(
-        ["attribute1=value1", "attribute2=value2"]
-      )
-    end
-  end
-
-  describe '#ia_module_args' do
-    it 'returns no arguments if ia_load_module parameter or forcelocal parameter are not specified' do
-      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return(nil)
-      allow(provider.resource).to receive(:[]).with(:forcelocal).and_return(nil)
-      expect(provider.ia_module_args).to eql([])
-    end
-
-    it 'returns the ia_load_module as a CLI argument when ia_load_module is specified' do
-      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return('module')
-      allow(provider.resource).to receive(:[]).with(:forcelocal).and_return(nil)
-      expect(provider.ia_module_args).to eql(['-R', 'module'])
-    end
-
-    it 'returns "files" as a CLI argument when forcelocal is specified' do
-      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return(nil)
-      allow(provider.resource).to receive(:[]).with(:forcelocal).and_return(true)
-      expect(provider.ia_module_args).to eql(['-R', 'files'])
-    end
-
-    it 'raises argument error when both ia_load_module and forcelocal parameters are set' do
-      allow(provider.resource).to receive(:[]).with(:ia_load_module).and_return('files')
-      allow(provider.resource).to receive(:[]).with(:forcelocal).and_return(true)
-      expect { provider.ia_module_args }.to raise_error(ArgumentError, "Cannot have both 'forcelocal' and 'ia_load_module' at the same time!")
-    end
-  end
-
-  describe '#lscmd' do
-    it 'returns the lscmd' do
-      allow(provider.class).to receive(:command).with(:list).and_return('list')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
-
-      expect(provider.lscmd).to eql(
-        ['list', '-c', 'ia_module_args', provider.resource.name]
-      )
-    end
-  end
-
-  describe '#addcmd' do
-    let(:attributes) do
-      {
-        :attribute1 => 'value1',
-        :attribute2 => 'value2'
-      }
-    end
-
-    it 'returns the addcmd passing in the attributes as CLI arguments' do
-      allow(provider.class).to receive(:command).with(:add).and_return('add')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
-
-      expect(provider.addcmd(attributes)).to eql(
-        ['add', 'ia_module_args', 'attribute1=value1', 'attribute2=value2', provider.resource.name]
-      )
-    end
-  end
-
-  describe '#deletecmd' do
-    it 'returns the lscmd' do
-      allow(provider.class).to receive(:command).with(:delete).and_return('delete')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
-
-      expect(provider.deletecmd).to eql(
-        ['delete', 'ia_module_args', provider.resource.name]
-      )
-    end
-  end
-
-  describe '#modifycmd' do
-    let(:attributes) do
-      {
-        :attribute1 => 'value1',
-        :attribute2 => 'value2'
-      }
-    end
-
-    it 'returns the addcmd passing in the attributes as CLI arguments' do
-      allow(provider.class).to receive(:command).with(:modify).and_return('modify')
-      allow(provider).to receive(:ia_module_args).and_return(['ia_module_args'])
-
-      expect(provider.modifycmd(attributes)).to eql(
-        ['modify', 'ia_module_args', 'attribute1=value1', 'attribute2=value2', provider.resource.name]
-      )
-    end
-  end
-
-  describe '#modify_object' do
-    let(:new_attributes) do
-      {
-        :nofiles => 10000,
-        :fsize   => 30000
-      }
-    end
-
-    it 'modifies the AIX object with the new attributes' do
-      allow(provider).to receive(:modifycmd).with(new_attributes).and_return('modify_cmd')
-      expect(provider).to receive(:execute).with('modify_cmd')
-      expect(provider).to receive(:object_info).with(true)
-
-      provider.modify_object(new_attributes)
-    end
-  end
-
-  describe '#get' do
-    # Input
-    let(:property) { :uid }
-    
-    let!(:object_info) do
-      hash = {}
-
-      provider.instance_variable_set(:@object_info, hash)
-      hash
-    end
-
-    it 'returns :absent if the AIX object does not exist' do
-      allow(provider).to receive(:exists?).and_return(false)
-      object_info[property] = 15
-      
-      expect(provider.get(property)).to eql(:absent)
-    end
-
-    it 'returns :absent if the property is not present on the system' do
-      allow(provider).to receive(:exists?).and_return(true)
-
-      expect(provider.get(property)).to eql(:absent)
-    end
-
-    it "returns the property's value" do
-      allow(provider).to receive(:exists?).and_return(true)
-      object_info[property] = 15
-
-      expect(provider.get(property)).to eql(15)
-    end
-  end
-
-  describe '#set' do
-    # Input
-    let(:property) { :uid }
-    let(:value) { 10 }
-
-    # AIX attribute params
-    let(:aix_attribute) { :id }
-    let(:property_to_attribute) do
-      lambda { |x| x.to_s }
-    end
-
-    before(:each) do
-      # Add an attribute
-      provider.class.mapping(
-        puppet_property: property,
-        aix_attribute: aix_attribute,
-        property_to_attribute: property_to_attribute
-      )
-    end
-
-    it "raises a Puppet::Error if it fails to set the property's value" do
-      allow(provider).to receive(:modify_object)
-        .with({ :id => value.to_s })
-        .and_raise(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
-
-      expect { provider.set(property, value) }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-      end
-    end
-
-    it "sets the given property's value to the passed-in value" do
-      expect(provider).to receive(:modify_object).with({ :id => value.to_s })
-
-      provider.set(property, value)
-    end
-  end
-
-  describe '#validate_new_attributes' do
-    let(:new_attributes) do
-      {
-        :nofiles => 10000,
-        :fsize   => 100000
-      }
-    end
-
-    it 'raises a Puppet::Error if a specified attributes corresponds to a Puppet property, reporting all of the attribute-property conflicts' do
-      provider.class.mapping(puppet_property: :uid, aix_attribute: :id)
-      provider.class.mapping(puppet_property: :groups, aix_attribute: :groups)
-
-      new_attributes[:id] = '25'
-      new_attributes[:groups] = 'groups'
-
-      expect { provider.validate_new_attributes(new_attributes) }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-
-        expect(error.message).to match("'uid', 'groups'")
-        expect(error.message).to match("'id', 'groups'")
-      end
-    end
-  end
-
-  describe '#attributes=' do
-    let(:new_attributes) do
-      {
-        :nofiles => 10000,
-        :fsize   => 100000
-      }
-    end
-
-    it 'raises a Puppet::Error if one of the specified attributes corresponds to a Puppet property' do
-      provider.class.mapping(puppet_property: :uid, aix_attribute: :id)
-      new_attributes[:id] = '25'
-
-      expect { provider.attributes = new_attributes }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-
-        expect(error.message).to match('uid')
-        expect(error.message).to match('id')
-      end
-    end
-
-    it 'raises a Puppet::Error if it fails to set the new AIX attributes' do
-      allow(provider).to receive(:modify_object)
-        .with(new_attributes)
-        .and_raise(Puppet::ExecutionFailure, 'failed to modify the AIX object!')
-      
-      expect { provider.attributes = new_attributes }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-
-        expect(error.message).to match('failed to modify the AIX object!')
-      end
-    end
-
-    it 'sets the new AIX attributes' do
-      expect(provider).to receive(:modify_object).with(new_attributes)
-
-      provider.attributes = new_attributes
-    end
-  end
-
-  describe '#object_info' do
-    before(:each) do
-      # Add some Puppet properties
-      provider.class.mapping(
-        puppet_property: :uid,
-        aix_attribute: :id,
-        attribute_to_property: lambda { |x| x.to_i },
-      )
-      provider.class.mapping(
-        puppet_property: :groups,
-        aix_attribute: :groups
-      )
-
-      # Mock out our lscmd
-      allow(provider).to receive(:lscmd).and_return("lsuser #{resource[:name]}")
-    end
-
-    it 'memoizes the result' do
-      provider.instance_variable_set(:@object_info, {})
-      expect(provider.object_info).to eql({})
-    end
-
-    it 'returns nil if the AIX object does not exist' do
-      allow(provider).to receive(:execute).with(provider.lscmd).and_raise(
-        Puppet::ExecutionFailure, 'lscmd failed!'
-      )
-
-      expect(provider.object_info).to be_nil
-    end
-
-    it 'collects the Puppet properties' do
-      output = 'mock_output'
-      allow(provider).to receive(:execute).with(provider.lscmd).and_return(output)
-
-      # Mock the AIX attributes on the system
-      mock_attributes = {
-        :id         => '1',
-        :groups     => 'foo,bar,baz',
-        :attribute1 => 'value1',
-        :attribute2 => 'value2'
-      }
-      allow(provider.class).to receive(:parse_aix_objects)
-        .with(output)
-        .and_return([{ :name => resource.name, :attributes => mock_attributes }])
-
-      expected_property_values = {
-        :uid        => 1,
-        :groups     => 'foo,bar,baz',
-        :attributes => {
-          :attribute1 => 'value1',
-          :attribute2 => 'value2'
-        }
-      }
-      provider.object_info
-      expect(provider.instance_variable_get(:@object_info)).to eql(expected_property_values)
-    end
-  end
-
-  describe '#exists?' do
-    it 'should return true if the AIX object exists' do
-      allow(provider).to receive(:object_info).and_return({})
-      expect(provider.exists?).to be(true)
-    end
-
-    it 'should return false if the AIX object does not exist' do
-      allow(provider).to receive(:object_info).and_return(nil)
-      expect(provider.exists?).to be(false)
-    end
-  end
-
-  describe "#create" do
-    let(:property_attributes) do
-      {}
-    end
-
-    def stub_attributes_property(attributes)
-      allow(provider.resource).to receive(:should).with(:attributes).and_return(attributes)
-    end
-
-    def set_property(puppet_property, aix_attribute, property_to_attribute, should_value = nil)
-      property_to_attribute ||= lambda { |x| x }
-
-      provider.class.mapping(
-        puppet_property: puppet_property,
-        aix_attribute: aix_attribute,
-        property_to_attribute: property_to_attribute
-      )
-      allow(provider.resource).to receive(:should).with(puppet_property).and_return(should_value)
-
-      if should_value
-        property_attributes[aix_attribute] = property_to_attribute.call(should_value)
-      end
-    end
-
-    before(:each) do
-      clear_attributes
-      
-      # Clear out the :attributes property. We will be setting this later.
-      stub_attributes_property(nil)
-
-      # Add some properties
-      set_property(:uid, :id, lambda { |x| x.to_s }, 10)
-      set_property(:groups, :groups, nil, 'group1,group2,group3')
-      set_property(:shell, :shell, nil)
-    end
-
-    it 'raises a Puppet::Error if one of the specified attributes corresponds to a Puppet property' do
-      stub_attributes_property({ :id => 15 })
-      provider.class.mapping(puppet_property: :uid, aix_attribute: :id)
-
-      expect { provider.create }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-
-        expect(error.message).to match('uid')
-        expect(error.message).to match('id')
-      end
-    end
-
-    it "raises a Puppet::Error if it fails to create the AIX object" do
-      allow(provider).to receive(:addcmd)
-      allow(provider).to receive(:execute).and_raise(
-        Puppet::ExecutionFailure, "addcmd failed!"
-      )
-
-      expect { provider.create }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-
-        expect(error.message).to match("not create")
-      end
-    end
-
-    it "creates the AIX object with the given AIX attributes + Puppet properties" do
-      attributes = { :fsize => 1000 }
-      stub_attributes_property(attributes)
-
-      expect(provider).to receive(:addcmd)
-        .with(attributes.merge(property_attributes))
-        .and_return('addcmd')
-      expect(provider).to receive(:execute).with('addcmd')
-
-      provider.create
-    end
-  end
- 
-  describe "#delete" do
-    before(:each) do
-      allow(provider).to receive(:deletecmd).and_return('deletecmd')
-    end
-
-    it "raises a Puppet::Error if it fails to delete the AIX object" do
-      allow(provider).to receive(:execute).with(provider.deletecmd).and_raise(
-        Puppet::ExecutionFailure, "deletecmd failed!"
-      )
-
-      expect { provider.delete }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Error)
-
-        expect(error.message).to match("not delete")
-      end
-    end
-
-    it "deletes the AIX object" do
-      expect(provider).to receive(:execute).with(provider.deletecmd)
-      expect(provider).to receive(:object_info).with(true)
-
-      provider.delete
-    end
-  end
-end