puppet 4.7.1 → 4.8.0

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

@@ -178,6 +178,38 @@ end
       expect(s.string(f.iterator(f.integer))).to eq('Iterator[Integer]')
     end
 
+    it "should yield 'Timespan' for PTimespanType" do
+      expect(s.string(f.timespan())).to eq('Timespan')
+    end
+
+    it "should yield 'Timespan[{hours => 1}] for PTimespanType[Timespan]" do
+      expect(s.string(f.timespan({'hours' => 1}))).to eq("Timespan['0-01:00:00.0']")
+    end
+
+    it "should yield 'Timespan[default, {hours => 2}] for PTimespanType[nil, Timespan]" do
+      expect(s.string(f.timespan(nil, {'hours' => 2}))).to eq("Timespan[default, '0-02:00:00.0']")
+    end
+
+    it "should yield 'Timespan[{hours => 1}, {hours => 2}] for PTimespanType[Timespan, Timespan]" do
+      expect(s.string(f.timespan({'hours' => 1}, {'hours' => 2}))).to eq("Timespan['0-01:00:00.0', '0-02:00:00.0']")
+    end
+
+    it "should yield 'Timestamp' for PTimestampType" do
+      expect(s.string(f.timestamp())).to eq('Timestamp')
+    end
+
+    it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC'] for PTimestampType[Timestamp]" do
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC']")
+    end
+
+    it "should yield 'Timestamp[default, '2016-09-05T13:00:00.000 UTC'] for PTimestampType[nil, Timestamp]" do
+      expect(s.string(f.timestamp(nil, '2016-09-05T13:00:00.000 UTC'))).to eq("Timestamp[default, '2016-09-05T13:00:00.000 UTC']")
+    end
+
+    it "should yield 'Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'] for PTimestampType[Timestamp, Timestamp]" do
+      expect(s.string(f.timestamp('2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC'))).to eq("Timestamp['2016-09-05T13:00:00.000 UTC', '2016-12-01T00:00:00.000 UTC']")
+    end
+
     it "should yield 'Tuple[Integer]' for PTupleType[PIntegerType]" do
       expect(s.string(f.tuple([f.integer]))).to eq('Tuple[Integer]')
     end
@@ -269,10 +301,18 @@ end
       expect(s.string(f.callable)).to eql('Callable[0, 0]')
     end
 
+    it "should yield 'Callable[[0,0],rt]' for callable without params but with return type" do
+      expect(s.string(f.callable([], Float))).to eql('Callable[[0, 0], Float]')
+    end
+
     it "should yield 'Callable[t,t]' for callable with typed parameters" do
       expect(s.string(f.callable(String, Integer))).to eql('Callable[String, Integer]')
     end
 
+    it "should yield 'Callable[[t,t],rt]' for callable with typed parameters and return type" do
+      expect(s.string(f.callable([String, Integer], Float))).to eql('Callable[[String, Integer], Float]')
+    end
+
     it "should yield 'Callable[t,min,max]' for callable with size constraint (infinite max)" do
       expect(s.string(f.callable(String, 0))).to eql('Callable[String, 0, default]')
     end

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

@@ -112,84 +112,95 @@ describe 'the type mismatch describer' do
        /parameter 'evars' expects a match for EVariants = Enum\['a', 'b', 'c', 'd'\], got 'n'/))
   end
 
+  it "will not generalize a string that doesn't match an enum in a function call" do
+    code = <<-CODE
+      function check_enums(Enum[a,b] $arg) {}
+      check_enums('c')
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got 'c'/))
+  end
+
+  it "will not disclose a Sensitive that doesn't match an enum in a function call" do
+    code = <<-CODE
+      function check_enums(Enum[a,b] $arg) {}
+      check_enums(Sensitive('c'))
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
+  end
+
+  it "will not generalize a string that doesn't match an enum in a define call" do
+    code = <<-CODE
+      define check_enums(Enum[a,b] $arg) {}
+      check_enums { x: arg => 'c' }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got 'c'/))
+  end
+
+  it "will not disclose a Sensitive that doesn't match an enum in a define call" do
+    code = <<-CODE
+      define check_enums(Enum[a,b] $arg) {}
+      check_enums { x: arg => Sensitive('c') }
+    CODE
+    expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
+      /parameter 'arg' expects a match for Enum\['a', 'b'\], got Sensitive/))
+  end
+
   context 'when reporting a mismatch between' do
-    let(:parser) { TypeParser.new }
+    let(:parser) { TypeParser.singleton }
     let(:subject) { TypeMismatchDescriber.singleton }
 
     context 'hash and struct' do
       it 'reports a size mismatch when hash has unlimited size' do
         expected = parser.parse('Struct[{a=>Integer,b=>Integer}]')
         actual = parser.parse('Hash[String,Integer]')
-        expect(subject.describe_mismatch('', expected, actual)).to eq('expected size to be 2, got unlimited')
+        expect(subject.describe_mismatch('', expected, actual)).to eq('expects size to be 2, got unlimited')
       end
 
       it 'reports a size mismatch when hash has specified but incorrect size' do
         expected = parser.parse('Struct[{a=>Integer,b=>Integer}]')
         actual = parser.parse('Hash[String,Integer,1,1]')
-        expect(subject.describe_mismatch('', expected, actual)).to eq('expected size to be 2, got 1')
+        expect(subject.describe_mismatch('', expected, actual)).to eq('expects size to be 2, got 1')
       end
 
       it 'reports a full type mismatch when size is correct but hash value type is incorrect' do
         expected = parser.parse('Struct[{a=>Integer,b=>String}]')
         actual = parser.parse('Hash[String,Integer,2,2]')
-        expect(subject.describe_mismatch('', expected, actual)).to eq("expected a Struct[{'a' => Integer, 'b' => String}] value, got Hash[String, Integer]")
+        expect(subject.describe_mismatch('', expected, actual)).to eq("expects a Struct[{'a' => Integer, 'b' => String}] value, got Hash[String, Integer]")
       end
     end
-  end
 
-  context 'when using present tense' do
-    let(:parser) { TypeParser.singleton }
-    let(:subject) { TypeMismatchDescriber.singleton }
     it 'reports a missing parameter as "has no parameter"' do
       t = parser.parse('Struct[{a=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false, :present) }.to raise_error(Puppet::Error, "v: has no parameter named 'b'")
+      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false) }.to raise_error(Puppet::Error, "v: has no parameter named 'b'")
     end
 
     it 'reports a missing value as "expects a value"' do
       t = parser.parse('Struct[{a=>String,b=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false, :present) }.to raise_error(Puppet::Error, "v: expects a value for parameter 'b'")
+      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false) }.to raise_error(Puppet::Error, "v: expects a value for parameter 'b'")
     end
 
     it 'reports a missing block as "expects a block"' do
       callable = parser.parse('Callable[String,String,Callable]')
       args_tuple = parser.parse('Tuple[String,String]')
       dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], 'block', nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :present)).to eq("'function' expects a block")
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' expects a block")
     end
 
     it 'reports an unexpected block as "does not expect a block"' do
       callable = parser.parse('Callable[String,String]')
       args_tuple = parser.parse('Tuple[String,String,Callable]')
       dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], nil, nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :present)).to eq("'function' does not expect a block")
-    end
-  end
-
-  context 'when using past tense' do
-    let(:parser) { TypeParser.singleton }
-    let(:subject) { TypeMismatchDescriber.singleton }
-    it 'reports a missing parameter as "did not have a parameter"' do
-      t = parser.parse('Struct[{a=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a','b'=>'b'}, false, :past) }.to raise_error(Puppet::Error, "v: did not have a parameter named 'b'")
-    end
-
-    it 'reports a missing value as "expected a value"' do
-      t = parser.parse('Struct[{a=>String,b=>String}]')
-      expect { subject.validate_parameters('v', t, {'a'=>'a'}, false, :past) }.to raise_error(Puppet::Error, "v: expected a value for parameter 'b'")
-    end
-
-    it 'reports a missing block as "expected a block"' do
-      callable = parser.parse('Callable[String,String,Callable]')
-      args_tuple = parser.parse('Tuple[String,String]')
-      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], 'block', nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :past)).to eq("'function' expected a block")
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' does not expect a block")
     end
 
-    it 'reports an unexpected block as "did not expect a block"' do
-      callable = parser.parse('Callable[String,String]')
-      args_tuple = parser.parse('Tuple[String,String,Callable]')
-      dispatch = Functions::Dispatch.new(callable, 'foo', ['a','b'], nil, nil, nil, false)
-      expect(subject.describe_signatures('function', [dispatch], args_tuple, :past)).to eq("'function' did not expect a block")
+    it 'reports a block return type mismatch' do
+      callable = parser.parse('Callable[[0,0,Callable[ [0,0],String]],Undef]')
+      args_tuple = parser.parse('Tuple[Callable[[0,0],Integer]]')
+      dispatch = Functions::Dispatch.new(callable, 'foo', [], 'block', nil, nil, false)
+      expect(subject.describe_signatures('function', [dispatch], args_tuple)).to eq("'function' block return expects a String value, got Integer")
     end
   end
 end

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

@@ -111,6 +111,16 @@ describe TypeParser do
     expect(the_type_parsed_from(opt_t)).to be_the_type(opt_t)
   end
 
+  it "parses timespan type" do
+    timespan_t = types.timespan
+    expect(the_type_parsed_from(timespan_t)).to be_the_type(timespan_t)
+  end
+
+  it "parses timestamp type" do
+    timestamp_t = types.timestamp
+    expect(the_type_parsed_from(timestamp_t)).to be_the_type(timestamp_t)
+  end
+
   it "parses tuple type" do
     tuple_t = types.tuple([Integer, String])
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
@@ -248,6 +258,38 @@ describe TypeParser do
    expect(parser.parse("Collection[1,2]")).to be_the_type(types.collection(types.range(1,2)))
   end
 
+  it 'parses a timespan type' do
+    expect(parser.parse("Timespan")).to be_the_type(types.timespan)
+  end
+
+  it 'parses a timespan type with a lower bound' do
+    expect(parser.parse("Timespan[{hours => 3}]")).to be_the_type(types.timespan({'hours' => 3}))
+  end
+
+  it 'parses a timespan type with an upper bound' do
+    expect(parser.parse("Timespan[default, {hours => 9}]")).to be_the_type(types.timespan(nil, {'hours' => 9}))
+  end
+
+  it 'parses a timespan type with both lower and upper bounds' do
+    expect(parser.parse("Timespan[{hours => 3}, {hours => 9}]")).to be_the_type(types.timespan({'hours' => 3}, {'hours' => 9}))
+  end
+
+  it 'parses a timestamp type' do
+    expect(parser.parse("Timestamp")).to be_the_type(types.timestamp)
+  end
+
+  it 'parses a timestamp type with a lower bound' do
+    expect(parser.parse("Timestamp['2014-12-12T13:14:15 CET']")).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET'))
+  end
+
+  it 'parses a timestamp type with an upper bound' do
+    expect(parser.parse("Timestamp[default, '2014-12-12T13:14:15 CET']")).to be_the_type(types.timestamp(nil, '2014-12-12T13:14:15 CET'))
+  end
+
+  it 'parses a timestamp type with both lower and upper bounds' do
+    expect(parser.parse("Timestamp['2014-12-12T13:14:15 CET', '2016-08-23T17:50:00 CET']")).to be_the_type(types.timestamp('2014-12-12T13:14:15 CET', '2016-08-23T17:50:00 CET'))
+  end
+
   it 'parses a type type' do
     expect(parser.parse("Type[Integer]")).to be_the_type(types.type_type(types.integer))
   end
@@ -257,25 +299,57 @@ describe TypeParser do
   end
 
   it 'parses a callable type' do
-    expect(parser.parse("Callable")).to be_the_type(types.all_callables())
+    t = parser.parse("Callable")
+    expect(t).to be_the_type(types.all_callables())
+    expect(t.return_type).to be_nil
   end
 
   it 'parses a parameterized callable type' do
-    expect(parser.parse("Callable[String, Integer]")).to be_the_type(types.callable(String, Integer))
+    t = parser.parse("Callable[String, Integer]")
+    expect(t).to be_the_type(types.callable(String, Integer))
+    expect(t.return_type).to be_nil
   end
 
   it 'parses a parameterized callable type with min/max' do
-    expect(parser.parse("Callable[String, Integer, 1, default]")).to be_the_type(types.callable(String, Integer, 1, :default))
+    t = parser.parse("Callable[String, Integer, 1, default]")
+    expect(t).to be_the_type(types.callable(String, Integer, 1, :default))
+    expect(t.return_type).to be_nil
   end
 
   it 'parses a parameterized callable type with block' do
-    expect(parser.parse("Callable[String, Callable[Boolean]]")).to be_the_type(types.callable(String, types.callable(true)))
+    t = parser.parse("Callable[String, Callable[Boolean]]")
+    expect(t).to be_the_type(types.callable(String, types.callable(true)))
+    expect(t.return_type).to be_nil
+  end
+
+  it 'parses a callable with no parameters and return type' do
+    expect(parser.parse("Callable[[],Float]")).to be_the_type(types.callable([],Float))
+  end
+
+  it 'parses a parameterized callable type with return type' do
+    expect(parser.parse("Callable[[String, Integer],Float]")).to be_the_type(types.callable([String, Integer],Float))
+  end
+
+  it 'parses a parameterized callable type with min/max and return type' do
+    expect(parser.parse("Callable[[String, Integer, 1, default],Float]")).to be_the_type(types.callable([String, Integer, 1, :default], Float))
+  end
+
+  it 'parses a parameterized callable type with block and return type' do
+    expect(parser.parse("Callable[[String, Callable[Boolean]],Float]")).to be_the_type(types.callable([String, types.callable(true)], Float))
   end
 
   it 'parses a parameterized callable type with 0 min/max' do
     t = parser.parse("Callable[0,0]")
     expect(t).to be_the_type(types.callable(0,0))
     expect(t.param_types.types).to be_empty
+    expect(t.return_type).to be_nil
+  end
+
+  it 'parses a parameterized callable type with 0 min/max and return_type' do
+    t = parser.parse("Callable[[0,0],Float]")
+    expect(t).to be_the_type(types.callable([0,0],Float))
+    expect(t.param_types.types).to be_empty
+    expect(t.return_type).to be_the_type(types.float)
   end
 
   it 'parses a parameterized callable type with >0 min/max' do
@@ -283,6 +357,15 @@ describe TypeParser do
     expect(t).to be_the_type(types.callable(0,1))
     # Contains a Unit type to indicate "called with what you accept"
     expect(t.param_types.types[0]).to be_the_type(PUnitType.new())
+    expect(t.return_type).to be_nil
+  end
+
+  it 'parses a parameterized callable type with >0 min/max and a return type' do
+    t = parser.parse("Callable[[0,1],Float]")
+    expect(t).to be_the_type(types.callable([0,1], Float))
+    # Contains a Unit type to indicate "called with what you accept"
+    expect(t.param_types.types[0]).to be_the_type(PUnitType.new())
+    expect(t.return_type).to be_the_type(types.float)
   end
 
   it 'parses all known literals' do

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

@@ -440,7 +440,7 @@ describe 'Puppet Type System' do
       type Foo = Variant[Foo,String,Integer]
       assert_type(Foo, /x/)
       CODE
-      expect { eval_and_collect_notices(code) }.to raise_error(/expected a value of type String or Integer, got Regexp/)
+      expect { eval_and_collect_notices(code) }.to raise_error(/expects a value of type String or Integer, got Regexp/)
     end
 
     it 'will handle a scalar correctly in combinations of nested aliased variants' do

data/spec/unit/pops/validator/validator_spec.rb

@@ -440,6 +440,29 @@ describe "validating 4x" do
       end
     end
 
+    context 'that are functions' do
+      it 'accepts typed parameters' do
+        source = <<-CODE
+          function f(Integer $a) { $a }
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+
+      it 'accepts return types' do
+        source = <<-CODE
+          function f() >> Integer { 42 }
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+
+      it 'accepts block with return types' do
+        source = <<-CODE
+          map([1,2]) |Integer $x| >> Integer { $x + 3 }
+        CODE
+        expect(validate(parse(source))).not_to have_any_issues
+      end
+    end
+
     context 'that are type mappings' do
       it 'accepts a valid type mapping expression' do
         source = <<-CODE

data/spec/unit/provider/mount/parsed_spec.rb

@@ -115,6 +115,7 @@ FSTAB
   describe "mountinstances" do
     it "should get name from mountoutput found on Solaris" do
       Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+      Facter.stubs(:value).with(:kernel).returns 'SunOS'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('solaris.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
@@ -128,6 +129,7 @@ FSTAB
 
     it "should get name from mountoutput found on HP-UX" do
       Facter.stubs(:value).with(:osfamily).returns 'HP-UX'
+      Facter.stubs(:value).with(:kernel).returns 'HP-UX'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('hpux.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(17)
@@ -150,32 +152,35 @@ FSTAB
       expect(mounts[16]).to eq({ :name => '/ghost', :mounted => :yes })
     end
 
-    it "should get name from mountoutput found on Darwin" do
+    it "should get name and mount options from mountoutput found on Darwin" do
       Facter.stubs(:value).with(:osfamily).returns 'Darwin'
+      Facter.stubs(:value).with(:kernel).returns 'Darwin'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('darwin.mount')))
       mounts = described_class.mountinstances
       expect(mounts.size).to eq(6)
-      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
-      expect(mounts[1]).to eq({ :name => '/dev', :mounted => :yes })
-      expect(mounts[2]).to eq({ :name => '/net', :mounted => :yes })
-      expect(mounts[3]).to eq({ :name => '/home', :mounted => :yes })
-      expect(mounts[4]).to eq({ :name => '/usr', :mounted => :yes })
-      expect(mounts[5]).to eq({ :name => '/ghost', :mounted => :yes })
+      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes, :live_options=>"hfs, local, journaled"})
+      expect(mounts[1]).to eq({ :name => '/dev', :mounted => :yes, :live_options=>"devfs, local, nobrowse"})
+      expect(mounts[2]).to eq({ :name => '/net', :mounted => :yes, :live_options=>"autofs, nosuid, automounted, nobrowse"})
+      expect(mounts[3]).to eq({ :name => '/home', :mounted => :yes, :mounted=>:yes, :live_options=>"autofs, automounted, nobrowse"})
+      expect(mounts[4]).to eq({ :name => '/usr', :mounted => :yes, :mounted=>:yes, :live_options=>"hfs, local, journaled"})
+      expect(mounts[5]).to eq({ :name => '/ghost', :mounted => :yes, :live_options => "hfs, local, journaled"})
     end
 
-    it "should get name from mountoutput found on Linux" do
+    it "should get name and mount options from mountoutput found on Linux" do
       Facter.stubs(:value).with(:osfamily).returns 'Gentoo'
+      Facter.stubs(:value).with(:kernel).returns 'Linux'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('linux.mount')))
       mounts = described_class.mountinstances
-      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
-      expect(mounts[1]).to eq({ :name => '/lib64/rc/init.d', :mounted => :yes })
-      expect(mounts[2]).to eq({ :name => '/sys', :mounted => :yes })
-      expect(mounts[3]).to eq({ :name => '/usr/portage', :mounted => :yes })
-      expect(mounts[4]).to eq({ :name => '/ghost', :mounted => :yes })
+      expect(mounts[0]).to eq({ :name => '/', :mounted => :yes, :live_options=>"rw,noatime"})
+      expect(mounts[1]).to eq({ :name => '/lib64/rc/init.d', :mounted => :yes, :live_options => "rw,nosuid,nodev,noexec,relatime,size=1024k,mode=755" })
+      expect(mounts[2]).to eq({ :name => '/sys', :mounted => :yes, :live_options => "rw,nosuid,nodev,noexec,relatime"})
+      expect(mounts[3]).to eq({ :name => '/usr/portage', :mounted => :yes, :live_options => "rw" })
+      expect(mounts[4]).to eq({ :name => '/ghost', :mounted => :yes, :live_options => "rw" })
     end
 
     it "should get name from mountoutput found on AIX" do
       Facter.stubs(:value).with(:osfamily).returns 'AIX'
+      Facter.stubs(:value).with(:kernel).returns 'AIX'
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
       mounts = described_class.mountinstances
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
@@ -224,29 +229,42 @@ FSTAB
           platform != 'solaris' or
             skip "We need to stub the operatingsystem fact at load time, but can't"
         end
-
-        # Stub the mount output to our fixture.
-        begin
-          mount = my_fixture(platform + '.mount')
-          described_class.stubs(:mountcmd).returns File.read(mount)
-        rescue
-          skip "is #{platform}.mount missing at this point?"
-        end
-
-        # Note: we have to stub default_target before creating resources
-        # because it is used by Puppet::Type::Mount.new to populate the
-        # :target property.
-        described_class.stubs(:default_target).returns fstab
-        @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
       end
 
       # Following mountpoint are present in all fstabs/mountoutputs
       describe "on other platforms than Solaris", :if => Facter.value(:osfamily) != 'Solaris' do
-        it "should include unmounted resources" do
+        before :each do
+          # Stub the mount output to our fixture.
+          begin
+            mount = my_fixture(platform + '.mount')
+            described_class.stubs(:mountcmd).returns File.read(mount)
+          rescue
+            skip "is #{platform}.mount missing at this point?"
+          end
+
+          # Note: we have to stub default_target before creating resources
+          # because it is used by Puppet::Type::Mount.new to populate the
+          # :target property.
+          described_class.stubs(:default_target).returns fstab
+
+          platforms = {
+            'linux' => ['Gentoo', 'Linux'],
+            'freebsd' => ['BSD', 'BSD'],
+            'openbsd' => ['BSD', 'BSD'],
+            'netbsd' => ['BSd', 'BSD']
+          }
+          Facter.stubs(:value).with(:osfamily).returns(platforms[platform][0])
+          Facter.stubs(:value).with(:kernel).returns(platforms[platform][1])
+
+          @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
+        end
+        
+        it "should include mounted resources" do
           expect(@retrieve).to include(:name => '/', :ensure => :mounted)
         end
 
-        it "should include mounted resources" do
+        it "should include unmounted resources" do
+        @retrieve = described_class.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
           expect(@retrieve).to include(:name => '/boot', :ensure => :unmounted)
         end