puppet 4.4.0 → 4.5.0

data/spec/unit/provider/package/rpm_spec.rb

@@ -12,6 +12,7 @@ describe provider_class do
     chkconfig 0 1.3.30.2 2.el5 x86_64
     myresource 0 1.2.3.4 5.el4 noarch
     mysummaryless 0 1.2.3.4 5.el4 noarch
+    tomcat 1 1.2.3.4 5.el4 x86_64
     RPM_OUTPUT
   end
 
@@ -116,7 +117,18 @@ describe provider_class do
           :ensure => "1.3.30.2-2.el5",
         }
       )
-      expect(installed_packages.last.properties).to eq(
+      expect(installed_packages[3].properties).to eq(
+        {
+          :provider => :rpm,
+          :name => "myresource",
+          :epoch => "0",
+          :version => "1.2.3.4",
+          :release => "5.el4",
+          :arch => "noarch",
+          :ensure => "1.2.3.4-5.el4",
+        }
+      )
+      expect(installed_packages[4].properties).to eq(
         {
           :provider    => :rpm,
           :name        => "mysummaryless",
@@ -127,6 +139,17 @@ describe provider_class do
           :ensure      => "1.2.3.4-5.el4",
         }
       )
+      expect(installed_packages[5].properties).to eq(
+        {
+          :provider    => :rpm,
+          :name        => "tomcat",
+          :epoch       => "1",
+          :version     => "1.2.3.4",
+          :release     => "5.el4",
+          :arch        => "x86_64",
+          :ensure      => "1:1.2.3.4-5.el4",
+        }
+      )
     end
   end
 
@@ -257,7 +280,7 @@ describe provider_class do
         :release => 'release',
         :arch => 'arch',
         :provider => :rpm,
-        :ensure => 'version-release',
+        :ensure => 'epoch:version-release',
       }
     end
     let(:line) { 'name epoch version release arch' }
@@ -269,7 +292,7 @@ describe provider_class do
           line.gsub(field, delimiter),
           package_hash.merge(
             field.to_sym => delimiter,
-            :ensure => 'version-release'.gsub(field, delimiter)
+            :ensure => 'epoch:version-release'.gsub(field, delimiter)
           )
         )
       end
@@ -481,4 +504,138 @@ describe provider_class do
     it { expect(provider.rpmvercmp("1", "0")).to eq(1) }
   end
 
+  describe 'package evr parsing' do
+
+    it 'should parse full simple evr' do
+      v = provider.rpm_parse_evr('0:1.2.3-4.el5')
+      expect(v[:epoch]).to eq('0')
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.el5')
+    end
+
+    it 'should parse version only' do
+      v = provider.rpm_parse_evr('1.2.3')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq(nil)
+    end
+
+    it 'should parse version-release' do
+      v = provider.rpm_parse_evr('1.2.3-4.5.el6')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.5.el6')
+    end
+
+    it 'should parse release with git hash' do
+      v = provider.rpm_parse_evr('1.2.3-4.1234aefd')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4.1234aefd')
+    end
+
+    it 'should parse single integer versions' do
+      v = provider.rpm_parse_evr('12345')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('12345')
+      expect(v[:release]).to eq(nil)
+    end
+
+    it 'should parse text in the epoch to 0' do
+      v = provider.rpm_parse_evr('foo0:1.2.3-4')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('4')
+    end
+
+    it 'should parse revisions with text' do
+      v = provider.rpm_parse_evr('1.2.3-SNAPSHOT20140107')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('1.2.3')
+      expect(v[:release]).to eq('SNAPSHOT20140107')
+    end
+
+    # test cases for PUP-682
+    it 'should parse revisions with text and numbers' do
+      v = provider.rpm_parse_evr('2.2-SNAPSHOT20121119105647')
+      expect(v[:epoch]).to eq(nil)
+      expect(v[:version]).to eq('2.2')
+      expect(v[:release]).to eq('SNAPSHOT20121119105647')
+    end
+
+  end
+
+  describe 'rpm evr comparison' do
+
+    # currently passing tests
+    it 'should evaluate identical version-release as equal' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '1.el5'})
+      expect(v).to eq(0)
+    end
+
+    it 'should evaluate identical version as equal' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
+                                  {:epoch => '0', :version => '1.2.3', :release => nil})
+      expect(v).to eq(0)
+    end
+
+    it 'should evaluate identical version but older release as less' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(-1)
+    end
+
+    it 'should evaluate identical version but newer release as greater' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => '3.el5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(1)
+    end
+
+    it 'should evaluate a newer epoch as greater' do
+      v = provider.rpm_compareEVR({:epoch => '1', :version => '1.2.3', :release => '4.5'},
+                                  {:epoch => '0', :version => '1.2.3', :release => '4.5'})
+      expect(v).to eq(1)
+    end
+
+    # these tests describe PUP-1244 logic yet to be implemented
+    it 'should evaluate any version as equal to the same version followed by release' do
+      v = provider.rpm_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
+                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
+      expect(v).to eq(0)
+    end
+
+    # test cases for PUP-682
+    it 'should evaluate same-length numeric revisions numerically' do
+      expect(provider.rpm_compareEVR({:epoch => '0', :version => '2.2', :release => '405'},
+                               {:epoch => '0', :version => '2.2', :release => '406'})).to eq(-1)
+    end
+
+  end
+
+  describe 'version segment comparison' do
+
+    it 'should treat two nil values as equal' do
+      v = provider.compare_values(nil, nil)
+      expect(v).to eq(0)
+    end
+
+    it 'should treat a nil value as less than a non-nil value' do
+      v = provider.compare_values(nil, '0')
+      expect(v).to eq(-1)
+    end
+
+    it 'should treat a non-nil value as greater than a nil value' do
+      v = provider.compare_values('0', nil)
+      expect(v).to eq(1)
+    end
+
+    it 'should pass two non-nil values on to rpmvercmp' do
+      provider.stubs(:rpmvercmp) { 0 }
+      provider.expects(:rpmvercmp).with('s1', 's2')
+      provider.compare_values('s1', 's2')
+    end
+
+  end
+
 end

data/spec/unit/provider/package/yum_spec.rb

@@ -21,6 +21,21 @@ describe provider_class do
     provider
   end
 
+  let(:arch) { 'x86_64' }
+  let(:arch_resource) do
+    Puppet::Type.type(:package).new(
+      :name     => "#{name}.#{arch}",
+      :ensure   => :installed,
+      :provider => 'yum'
+    )
+  end
+
+  let(:arch_provider) do
+    provider = provider_class.new
+    provider.resource = arch_resource
+    provider
+  end
+
   before do
     provider_class.stubs(:command).with(:cmd).returns('/usr/bin/yum')
     provider.stubs(:rpm).returns 'rpm'
@@ -42,140 +57,6 @@ describe provider_class do
     end
   end
 
-  describe 'package evr parsing' do
-
-    it 'should parse full simple evr' do
-      v = provider.yum_parse_evr('0:1.2.3-4.el5')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq('4.el5')
-    end
-
-    it 'should parse version only' do
-      v = provider.yum_parse_evr('1.2.3')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq(nil)
-    end
-
-    it 'should parse version-release' do
-      v = provider.yum_parse_evr('1.2.3-4.5.el6')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq('4.5.el6')
-    end
-
-    it 'should parse release with git hash' do
-      v = provider.yum_parse_evr('1.2.3-4.1234aefd')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq('4.1234aefd')
-    end
-
-    it 'should parse single integer versions' do
-      v = provider.yum_parse_evr('12345')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('12345')
-      expect(v[:release]).to eq(nil)
-    end
-
-    it 'should parse text in the epoch to 0' do
-      v = provider.yum_parse_evr('foo0:1.2.3-4')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq('4')
-    end
-
-    it 'should parse revisions with text' do
-      v = provider.yum_parse_evr('1.2.3-SNAPSHOT20140107')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('1.2.3')
-      expect(v[:release]).to eq('SNAPSHOT20140107')
-    end
-
-    # test cases for PUP-682
-    it 'should parse revisions with text and numbers' do
-      v = provider.yum_parse_evr('2.2-SNAPSHOT20121119105647')
-      expect(v[:epoch]).to eq('0')
-      expect(v[:version]).to eq('2.2')
-      expect(v[:release]).to eq('SNAPSHOT20121119105647')
-    end
-
-  end
-
-  describe 'yum evr comparison' do
-
-    # currently passing tests
-    it 'should evaluate identical version-release as equal' do
-      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
-                                  {:epoch => '0', :version => '1.2.3', :release => '1.el5'})
-      expect(v).to eq(0)
-    end
-
-    it 'should evaluate identical version as equal' do
-      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
-                                  {:epoch => '0', :version => '1.2.3', :release => nil})
-      expect(v).to eq(0)
-    end
-
-    it 'should evaluate identical version but older release as less' do
-      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => '1.el5'},
-                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
-      expect(v).to eq(-1)
-    end
-
-    it 'should evaluate identical version but newer release as greater' do
-      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => '3.el5'},
-                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
-      expect(v).to eq(1)
-    end
-
-    it 'should evaluate a newer epoch as greater' do
-      v = provider.yum_compareEVR({:epoch => '1', :version => '1.2.3', :release => '4.5'},
-                                  {:epoch => '0', :version => '1.2.3', :release => '4.5'})
-      expect(v).to eq(1)
-    end
-
-    # these tests describe PUP-1244 logic yet to be implemented
-    it 'should evaluate any version as equal to the same version followed by release' do
-      v = provider.yum_compareEVR({:epoch => '0', :version => '1.2.3', :release => nil},
-                                  {:epoch => '0', :version => '1.2.3', :release => '2.el5'})
-      expect(v).to eq(0)
-    end
-
-    # test cases for PUP-682
-    it 'should evaluate same-length numeric revisions numerically' do
-      expect(provider.yum_compareEVR({:epoch => '0', :version => '2.2', :release => '405'},
-                               {:epoch => '0', :version => '2.2', :release => '406'})).to eq(-1)
-    end
-
-  end
-
-  describe 'yum version segment comparison' do
-
-    it 'should treat two nil values as equal' do
-      v = provider.compare_values(nil, nil)
-      expect(v).to eq(0)
-    end
-
-    it 'should treat a nil value as less than a non-nil value' do
-      v = provider.compare_values(nil, '0')
-      expect(v).to eq(-1)
-    end
-
-    it 'should treat a non-nil value as greater than a nil value' do
-      v = provider.compare_values('0', nil)
-      expect(v).to eq(1)
-    end
-
-    it 'should pass two non-nil values on to rpmvercmp' do
-      provider.stubs(:rpmvercmp) { 0 }
-      provider.expects(:rpmvercmp).with('s1', 's2')
-      provider.compare_values('s1', 's2')
-    end
-
-  end
-
   describe 'when installing' do
     before(:each) do
       Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
@@ -249,6 +130,14 @@ describe provider_class do
       Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, name])
       provider.install
     end
+
+    it 'moves architecture to end of version' do
+      version = '1.2.3'
+      arch_resource[:ensure] = version
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/yum', '-d', '0', '-e', '0', '-y', :install, "#{name}-#{version}.#{arch}"])
+      arch_provider.stubs(:query).returns :ensure => version
+      arch_provider.install
+    end
   end
 
   describe 'when uninstalling' do

data/spec/unit/provider/service/smf_spec.rb

@@ -28,12 +28,13 @@ describe provider_class, :if => Puppet.features.posix? do
     end
 
     it "should get a list of services (excluding legacy)" do
-      provider_class.expects(:svcs).with('-H').returns File.read(my_fixture('svcs.out'))
+      provider_class.expects(:svcs).with('-H', '-o', 'state,fmri').returns File.read(my_fixture('svcs.out'))
       instances = provider_class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
       # we dont manage legacy
-      expect(instances.size).to eq(2)
+      expect(instances.size).to eq(3)
       expect(instances[0]).to eq({:name => 'svc:/system/svc/restarter:default', :ensure => :running })
       expect(instances[1]).to eq({:name => 'svc:/network/cswrsyncd:default', :ensure => :maintenance })
+      expect(instances[2]).to eq({:name => 'svc:/network/dns/client:default', :ensure => :degraded })
     end
   end
 
@@ -86,6 +87,10 @@ describe provider_class, :if => Puppet.features.posix? do
       @provider.stubs(:svcs).returns("maintenance\t-")
       expect(@provider.status).to eq(:maintenance)
     end
+    it "should return degraded if in degraded in svcs output" do
+      @provider.stubs(:svcs).returns("degraded\t-")
+      expect(@provider.status).to eq(:degraded)
+    end
     it "should return target state if transitioning in svcs output" do
       @provider.stubs(:svcs).returns("online\tdisabled")
       expect(@provider.status).to eq(:stopped)
@@ -118,6 +123,13 @@ describe provider_class, :if => Puppet.features.posix? do
       @provider.start
     end
 
+    it "should execute external command 'svcadm clear /system/myservice' if in degraded" do
+      @provider.stubs(:status).returns :degraded
+      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :clear, "/system/myservice"], true)
+      @provider.expects(:wait).with('online')
+      @provider.start
+    end
+
     it "should error if timeout occurs while starting the service" do
       @provider.expects(:status).returns :stopped
       @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)

data/spec/unit/provider/service/systemd_spec.rb

@@ -42,7 +42,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
   end
 
-  [ 17, 18, 19, 20, 21 ].each do |ver|
+  [ 17, 18, 19, 20, 21, 22, 23 ].each do |ver|
     it "should be the default provider on fedora#{ver}" do
       Facter.stubs(:value).with(:osfamily).returns(:redhat)
       Facter.stubs(:value).with(:operatingsystem).returns(:fedora)
@@ -151,7 +151,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
 
     it "should start the service with systemctl start otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('unmask', 'sshd.service')
+      provider.expects(:systemctl).with(:unmask, 'sshd.service')
       provider.expects(:execute).with(['/bin/systemctl','start','sshd.service'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
@@ -174,49 +174,31 @@ describe Puppet::Type.type(:service).provider(:systemd) do
   describe "#enabled?" do
     it "should return :true if the service is enabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with(
-        'show',
-        'sshd.service',
-        '--property', 'LoadState',
-        '--property', 'UnitFileState',
-        '--no-pager'
-      ).returns "LoadState=loaded\nUnitFileState=enabled\n"
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "enabled\n"
+      expect(provider.enabled?).to eq(:true)
+    end
+
+    it "should return :true if the service is static" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "static\n"
       expect(provider.enabled?).to eq(:true)
     end
 
     it "should return :false if the service is disabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with(
-        'show',
-        'sshd.service',
-        '--property', 'LoadState',
-        '--property', 'UnitFileState',
-        '--no-pager'
-      ).returns "LoadState=loaded\nUnitFileState=disabled\n"
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "disabled\n"
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :false if the service is masked and the resource is attempting to be disabled" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => false))
-      provider.expects(:systemctl).with(
-        'show',
-        'sshd.service',
-        '--property', 'LoadState',
-        '--property', 'UnitFileState',
-        '--no-pager'
-      ).returns "LoadState=masked\nUnitFileState=\n"
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return :mask if the service is masked and the resource is attempting to be masked" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :enable => 'mask'))
-      provider.expects(:systemctl).with(
-        'show',
-        'sshd.service',
-        '--property', 'LoadState',
-        '--property', 'UnitFileState',
-        '--no-pager'
-      ).returns "LoadState=masked\nUnitFileState=\n"
+      provider.expects(:execute).with(['/bin/systemctl','is-enabled','sshd.service'], :failonfail => false).returns "masked\n"
       expect(provider.enabled?).to eq(:mask)
     end
   end
@@ -224,8 +206,8 @@ describe Puppet::Type.type(:service).provider(:systemd) do
   describe "#enable" do
     it "should run systemctl enable to enable a service" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('unmask', 'sshd.service')
-      provider.expects(:systemctl).with('enable', 'sshd.service')
+      provider.expects(:systemctl).with(:unmask, 'sshd.service')
+      provider.expects(:systemctl).with(:enable, 'sshd.service')
       provider.enable
     end
   end
@@ -245,7 +227,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
       # a string.
       # This should be made consistent in the future and all tests updated.
       provider.expects(:systemctl).with(:disable, 'sshd.service')
-      provider.expects(:systemctl).with('mask', 'sshd.service')
+      provider.expects(:systemctl).with(:mask, 'sshd.service')
       provider.mask
     end
   end
@@ -253,16 +235,26 @@ describe Puppet::Type.type(:service).provider(:systemd) do
   # Note: systemd provider does not care about hasstatus or a custom status
   # command. I just assume that it does not make sense for systemd.
   describe "#status" do
-    it "should return running if active" do
+    it "should return running if if the command returns 0" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('is-active', 'sshd.service').returns 'active'
+      provider.expects(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).returns "active\n"
+      $CHILD_STATUS.stubs(:exitstatus).returns(0)
       expect(provider.status).to eq(:running)
     end
 
-    it "should return stopped if inactive" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
-      provider.expects(:systemctl).with('is-active', 'sshd.service').raises Puppet::ExecutionFailure, "Execution of '/bin/systemctl is-active sshd.service' returned 3: inactive"
-      expect(provider.status).to eq(:stopped)
+    [-10,-1,3,10].each { |ec|
+      it "should return stopped if the command returns something non-0" do
+        provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
+        provider.expects(:execute).with(['/bin/systemctl','is-active','sshd.service'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).returns "inactive\n"
+        $CHILD_STATUS.stubs(:exitstatus).returns(ec)
+        expect(provider.status).to eq(:stopped)
+      end
+    }
+
+    it "should use the supplied status command if specified" do
+      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service', :status => '/bin/foo'))
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
+      provider.status
     end
   end
 
@@ -289,7 +281,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd.service'))
         provider.stubs(:system)
         $CHILD_STATUS.expects(:exitstatus).returns(status)
-        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:true)
+        expect(provider.debian_enabled?).to eq(:true)
       end
     end
 
@@ -299,7 +291,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
         provider.stubs(:system)
         provider.expects(:get_start_link_count).returns(4)
         $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
-        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:true)
+        expect(provider.debian_enabled?).to eq(:true)
       end
 
       it "should return false when status is #{status} and there are less than 4 start links" do
@@ -307,7 +299,7 @@ describe Puppet::Type.type(:service).provider(:systemd) do
         provider.stubs(:system)
         provider.expects(:get_start_link_count).returns(1)
         $CHILD_STATUS.expects(:exitstatus).twice.returns(status)
-        expect(provider.debian_enabled?({:LoadState => "loaded", :UnitFileState => "UnitFileState"})).to eq(:false)
+        expect(provider.debian_enabled?).to eq(:false)
       end
     end
   end