chef 18.8.11 → 18.8.54

data/spec/unit/provider/log_spec.rb

@@ -1,94 +0,0 @@
-#
-# Author:: Cary Penniman (<cary@rightscale.com>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-describe Chef::Resource::Log do
-
-  let(:log_str) { "this is my test string to log" }
-
-  let(:node) { Chef::Node.new }
-
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
-
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
-
-  let(:new_resource) { Chef::Resource::Log.new(log_str, run_context) }
-
-  let(:provider) { new_resource.provider_for_action(:run) }
-
-  let(:logger) { double("Mixlib::Log::Child").as_null_object }
-  before do
-    allow(run_context).to receive(:logger).and_return(logger)
-  end
-
-  it "should write the string to the logger object at default level (info)" do
-    expect(logger).to receive(:info).with(log_str).and_return(true)
-    provider.run_action(:write)
-  end
-
-  it "should write the string to the logger object at debug level" do
-    new_resource.level :debug
-    expect(logger).to receive(:debug).with(log_str).and_return(true)
-    provider.run_action(:write)
-  end
-
-  it "should write the string to the logger object at info level" do
-    new_resource.level :info
-    expect(logger).to receive(:info).with(log_str).and_return(true)
-    provider.run_action(:write)
-  end
-
-  it "should write the string to the logger object at warn level" do
-    new_resource.level :warn
-    expect(logger).to receive(:warn).with(log_str).and_return(true)
-    provider.run_action(:write)
-  end
-
-  it "should write the string to the logger object at error level" do
-    new_resource.level :error
-    expect(logger).to receive(:error).with(log_str).and_return(true)
-    provider.run_action(:write)
-  end
-
-  it "should write the string to the logger object at fatal level" do
-    new_resource.level :fatal
-    expect(logger).to receive(:fatal).with(log_str).and_return(true)
-    provider.run_action(:write)
-  end
-
-  it "should print the string in why-run mode" do
-    Chef::Config[:why_run] = true
-    expect(logger).to receive(:info).with(log_str).and_return(true)
-    provider.run_action(:write)
-  end
-
-  context "when count_log_resource_updates is passed in knife.rb" do
-    it "updates the resource count if count_log_resource_updates=true" do
-      Chef::Config[:count_log_resource_updates] = true
-      expect(new_resource).to receive(:updated_by_last_action)
-      provider.run_action(:write)
-    end
-
-    it "doesn't update the resource count if count_log_resource_updates=false" do
-      Chef::Config[:count_log_resource_updates] = false
-      expect(new_resource).not_to receive(:updated_by_last_action)
-      provider.run_action(:write)
-    end
-  end
-end

data/spec/unit/provider/mdadm_spec.rb

@@ -1,138 +0,0 @@
-#
-# Author:: Joe Williams (<joe@joetify.com>)
-# Copyright:: Copyright 2009-2016, Joe Williams
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "ostruct"
-
-describe Chef::Resource::Mdadm do
-
-  before(:each) do
-    run_context = Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
-    @new_resource = Chef::Resource::Mdadm.new("/dev/md1", run_context)
-    @new_resource.devices ["/dev/sdz1", "/dev/sdz2", "/dev/sdz3"]
-    @provider = @new_resource.provider_for_action(:create)
-  end
-
-  describe "when determining the current metadevice status" do
-    it "should set the current resources mount point to the new resources mount point" do
-      allow(@provider).to receive(:shell_out!).and_return(OpenStruct.new(status: 0))
-      @provider.load_current_resource
-      expect(@provider.current_resource.name).to eq("/dev/md1")
-      expect(@provider.current_resource.raid_device).to eq("/dev/md1")
-    end
-
-    it "determines that the metadevice exists when mdadm exit code is zero" do
-      allow(@provider).to receive(:shell_out_compacted!).with("mdadm", "--detail", "--test", "/dev/md1", returns: [0, 4]).and_return(OpenStruct.new(status: 0))
-      @provider.load_current_resource
-      expect(@provider.current_resource.exists).to be_truthy
-    end
-
-    it "determines that the metadevice does not exist when mdadm exit code is 4" do
-      allow(@provider).to receive(:shell_out_compacted!).with("mdadm", "--detail", "--test", "/dev/md1", returns: [0, 4]).and_return(OpenStruct.new(status: 4))
-      @provider.load_current_resource
-      expect(@provider.current_resource.exists).to be_falsey
-    end
-  end
-
-  describe "after the metadevice status is known" do
-    before(:each) do
-      @current_resource = Chef::Resource::Mdadm.new("/dev/md1")
-      @new_resource.level 5
-      allow(@provider).to receive(:load_current_resource).and_return(true)
-      @provider.current_resource = @current_resource
-    end
-
-    describe "when creating the metadevice" do
-      it "should create the raid device if it doesnt exist" do
-        @current_resource.exists(false)
-        expected_command = "yes | mdadm --create /dev/md1 --level 5 --chunk=16 --metadata=0.90 --raid-devices 3 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        expect(@provider).to receive(:shell_out!).with(expected_command)
-        @provider.run_action(:create)
-      end
-
-      it "should specify a bitmap only if set" do
-        @current_resource.exists(false)
-        @new_resource.bitmap("grow")
-        expected_command = "yes | mdadm --create /dev/md1 --level 5 --chunk=16 --metadata=0.90 --bitmap=grow --raid-devices 3 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        expect(@provider).to receive(:shell_out!).with(expected_command)
-        @provider.run_action(:create)
-        expect(@new_resource).to be_updated_by_last_action
-      end
-
-      it "should specify a layout only if set" do
-        @current_resource.exists(false)
-        @new_resource.layout("rs")
-        expected_command = "yes | mdadm --create /dev/md1 --level 5 --chunk=16 --metadata=0.90 --layout=rs --raid-devices 3 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        expect(@provider).to receive(:shell_out!).with(expected_command)
-        @provider.run_action(:create)
-        expect(@new_resource).to be_updated_by_last_action
-      end
-
-      it "should not specify a chunksize if raid level 1" do
-        @current_resource.exists(false)
-        @new_resource.level 1
-        expected_command = "yes | mdadm --create /dev/md1 --level 1 --metadata=0.90 --raid-devices 3 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        expect(@provider).to receive(:shell_out!).with(expected_command)
-        @provider.run_action(:create)
-        expect(@new_resource).to be_updated_by_last_action
-      end
-
-      it "should not create the raid device if it does exist" do
-        @current_resource.exists(true)
-        expect(@provider).not_to receive(:shell_out!)
-        @provider.run_action(:create)
-        expect(@new_resource).not_to be_updated_by_last_action
-      end
-    end
-
-    describe "when asembling the metadevice" do
-      it "should assemble the raid device if it doesnt exist" do
-        @current_resource.exists(false)
-        expected_mdadm_cmd = "yes | mdadm --assemble /dev/md1 /dev/sdz1 /dev/sdz2 /dev/sdz3"
-        expect(@provider).to receive(:shell_out!).with(expected_mdadm_cmd)
-        @provider.run_action(:assemble)
-        expect(@new_resource).to be_updated_by_last_action
-      end
-
-      it "should not assemble the raid device if it doesnt exist" do
-        @current_resource.exists(true)
-        expect(@provider).not_to receive(:shell_out!)
-        @provider.run_action(:assemble)
-        expect(@new_resource).not_to be_updated_by_last_action
-      end
-    end
-
-    describe "when stopping the metadevice" do
-
-      it "should stop the raid device if it exists" do
-        @current_resource.exists(true)
-        expected_mdadm_cmd = "yes | mdadm --stop /dev/md1"
-        expect(@provider).to receive(:shell_out!).with(expected_mdadm_cmd)
-        @provider.run_action(:stop)
-        expect(@new_resource).to be_updated_by_last_action
-      end
-
-      it "should not attempt to stop the raid device if it does not exist" do
-        @current_resource.exists(false)
-        expect(@provider).not_to receive(:shell_out!)
-        @provider.run_action(:stop)
-        expect(@new_resource).not_to be_updated_by_last_action
-      end
-    end
-  end
-end

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

@@ -1,277 +0,0 @@
-#
-# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "ostruct"
-
-describe Chef::Provider::Mount::Aix do
-
-  before(:all) do
-    @mounted_output = <<~MOUNT
-        node       mounted        mounted over    vfs       date        options
-      -------- ---------------  ---------------  ------ ------------ ---------------
-               /dev/sdz1         /tmp/foo         jfs2   Jul 17 13:22 rw,log=/dev/hd8
-    MOUNT
-
-    @unmounted_output = <<~UNMOUNTED
-        node       mounted        mounted over    vfs       date        options
-      -------- ---------------  ---------------  ------ ------------ ---------------
-               /dev/sdz2         /                jfs2   Jul 17 13:22 rw,log=/dev/hd8
-    UNMOUNTED
-
-    @conflict_mounted_output = <<~MOUNT
-        node       mounted        mounted over    vfs       date        options
-      -------- ---------------  ---------------  ------ ------------ ---------------
-               /dev/sdz3         /tmp/foo         jfs2   Jul 17 13:22 rw,log=/dev/hd8
-    MOUNT
-
-    @enabled_output = <<~ENABLED
-      #MountPoint:Device:Vfs:Nodename:Type:Size:Options:AutoMount:Acct
-      /tmp/foo:/dev/sdz1:jfs2::bootfs:10485760:rw:yes:no
-    ENABLED
-
-    @test_wrong_output = <<~WRONG
-      #MountPoint:Device:Vfs:Nodename:Type:Size:Options:AutoMount:Acct
-      /tmp/foo::/dev/sdz1:jfs2:bootfs:10485760:rw:yes:no
-    WRONG
-  end
-
-  before(:each) do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-
-    @new_resource = Chef::Resource::Mount.new("/tmp/foo")
-    @new_resource.device      "/dev/sdz1"
-    @new_resource.device_type :device
-    @new_resource.fstype      "jfs2"
-
-    @new_resource.supports remount: false
-
-    @provider = Chef::Provider::Mount::Aix.new(@new_resource, @run_context)
-
-    allow(::File).to receive(:exist?).with("/dev/sdz1").and_return true
-    allow(::File).to receive(:exist?).with("/tmp/foo").and_return true
-  end
-
-  def stub_mounted(provider, mounted_output)
-    response = double("Mixlib::ShellOut command", exitstatus: 0, stdout: mounted_output, stderr: "")
-    expect(provider).to receive(:shell_out_compacted!).with("mount").and_return(response)
-  end
-
-  def stub_enabled(provider, enabled_output)
-    response = double("Mixlib::ShellOut command", exitstatus: 0, stdout: enabled_output, stderr: "")
-    expect(provider).to receive(:shell_out_compacted).with("lsfs", "-c", @new_resource.mount_point).and_return(response)
-  end
-
-  def stub_mounted_enabled(provider, mounted_output, enabled_output)
-    stub_mounted(provider, mounted_output)
-    stub_enabled(provider, enabled_output)
-  end
-
-  describe "when discovering the current fs state" do
-    it "should set current_resource.mounted to true if device is already mounted" do
-      stub_mounted_enabled(@provider, @mounted_output, "")
-      @provider.load_current_resource
-
-      expect(@provider.current_resource.mounted).to be_truthy
-    end
-
-    it "should set current_resource.mounted to false if device is not mounted" do
-      stub_mounted_enabled(@provider, @unmounted_output, "")
-
-      @provider.load_current_resource
-
-      expect(@provider.current_resource.mounted).to be_falsey
-    end
-
-    it "should set current_resource.mounted to false if the mount point is used for another device" do
-      stub_mounted_enabled(@provider, @conflict_mounted_output, "")
-
-      @provider.load_current_resource
-
-      expect(@provider.current_resource.mounted).to be_falsey
-    end
-
-    context "mount_options_unchanged?" do
-      it "should return true if mounted device is the same" do
-        stub_mounted_enabled(@provider, @mounted_output, @enabled_output)
-        @provider.load_current_resource
-
-        allow(@provider.current_resource).to receive(:fstype).and_return("jfs2")
-        expect(@provider.send :mount_options_unchanged?).to be true
-      end
-
-      it "should return false if mounted device has changed" do
-        stub_mounted_enabled(@provider, @mounted_output, @enabled_output)
-        @provider.load_current_resource
-
-        allow(@provider.current_resource).to receive(:fstype).and_return("XXXX")
-        expect(@provider.send :mount_options_unchanged?).to be false
-      end
-    end
-
-  end
-
-  # tests for #enabled?
-  it "should load current_resource with properties if device is already mounted and enabled" do
-    stub_mounted_enabled(@provider, @mounted_output, @enabled_output)
-
-    @provider.load_current_resource
-
-    expect(@provider.current_resource.enabled).to be_truthy
-    expect(@provider.current_resource.mounted).to be_truthy
-    expect(@provider.current_resource.mount_point).to eql(@new_resource.mount_point)
-    expect(@provider.current_resource.fstype).to eql("jfs2")
-    expect(@provider.current_resource.options).to eql(["rw"])
-  end
-
-  describe "mount_fs" do
-    it "should mount resource if it is not mounted" do
-      stub_mounted_enabled(@provider, @unmounted_output, "")
-
-      expect(@provider).to receive(:shell_out_compacted!).with("mount", "-v", @new_resource.fstype, @new_resource.device, @new_resource.mount_point)
-
-      @provider.run_action(:mount)
-    end
-
-    it "should not mount resource if it is already mounted" do
-      stub_mounted_enabled(@provider, @mounted_output, "")
-
-      expect(@provider).not_to receive(:mount_fs)
-
-      @provider.run_action(:mount)
-    end
-  end
-
-  describe "umount_fs" do
-    it "should umount resource if it is already mounted" do
-      stub_mounted_enabled(@provider, @mounted_output, "")
-
-      expect(@provider).to receive(:shell_out_compacted!).with("umount", @new_resource.mount_point)
-
-      @provider.run_action(:umount)
-    end
-
-    it "should not umount resource if it is not mounted" do
-      stub_mounted_enabled(@provider, @unmounted_output, "")
-
-      expect(@provider).not_to receive(:umount_fs)
-
-      @provider.run_action(:umount)
-    end
-  end
-
-  describe "remount_fs" do
-    it "should remount resource if it is already mounted and it supports remounting" do
-      @new_resource.supports({ remount: true })
-      stub_mounted_enabled(@provider, @mounted_output, "")
-
-      expect(@provider).to receive(:shell_out_compacted!).with("mount", "-o", "remount", @new_resource.device, @new_resource.mount_point)
-
-      @provider.run_action(:remount)
-    end
-
-    it "should remount with new mount options if it is already mounted and it supports remounting" do
-      @new_resource.supports({ remount: true })
-      @new_resource.options("nodev,rw")
-      stub_mounted_enabled(@provider, @mounted_output, "")
-
-      expect(@provider).to receive(:shell_out_compacted!).with("mount", "-o", "remount,nodev,rw", @new_resource.device, @new_resource.mount_point)
-
-      @provider.run_action(:remount)
-    end
-  end
-
-  describe "enable_fs" do
-    it "should enable mount if it is mounted and not enabled" do
-      @new_resource.options("nodev,rw")
-      stub_mounted_enabled(@provider, @mounted_output, "")
-      # Add existing mount to test enable action appends additional mount with separating blank line
-      filesystems = StringIO.new
-      filesystems.puts <<~ETCFILESYSTEMS
-        /tmp/abc:
-          dev   = /dev/sdz2
-          vfs   = jfs2
-          mount   = true
-          options   = rw
-      ETCFILESYSTEMS
-      allow(::File).to receive(:open).with("/etc/filesystems", "a").and_yield(filesystems)
-
-      @provider.run_action(:enable)
-
-      expect(filesystems.string).to match(%r{^\n\n/tmp/foo:\n\tdev\t\t= /dev/sdz1\n\tvfs\t\t= jfs2\n\tmount\t\t= false\n\toptions\t\t= nodev,rw\n$})
-    end
-
-    it "should not enable mount if it is mounted and already enabled and mount options are unchanged" do
-      stub_mounted_enabled(@provider, @mounted_output, @enabled_output)
-
-      expect(@provider).not_to receive(:enable_fs)
-
-      @provider.run_action(:enable)
-    end
-
-    it "should return false if enabled_output is given in wrong syntax" do
-      stub_mounted_enabled(@provider, @mounted_output, @test_wrong_output)
-
-      expect(@provider).to receive(:enable_fs)
-
-      @provider.run_action(:enable)
-    end
-
-  end
-
-  describe "disable_fs" do
-    it "should disable mount if it is mounted and enabled" do
-      stub_mounted_enabled(@provider, @mounted_output, @enabled_output)
-
-      allow(::File).to receive(:open).with("/etc/filesystems", "r").and_return(<<~ETCFILESYSTEMS)
-        /tmp/foo:
-          dev   = /dev/sdz1
-          vfs   = jfs2
-          log   = /dev/hd8
-          mount   = true
-          check   = true
-          vol   = /opt
-          free    = false
-          quota   = no
-
-        /tmp/abc:
-          dev   = /dev/sdz2
-          vfs   = jfs2
-          mount   = true
-          options   = rw
-      ETCFILESYSTEMS
-
-      filesystems = StringIO.new
-      allow(::File).to receive(:open).with("/etc/filesystems", "w").and_yield(filesystems)
-
-      @provider.run_action(:disable)
-
-      expect(filesystems.string).to match(%r{^/tmp/abc:\s+dev\s+= /dev/sdz2\s+vfs\s+= jfs2\s+mount\s+= true\s+options\s+= rw\n$})
-    end
-
-    it "should not disable mount if it is not mounted" do
-      stub_mounted_enabled(@provider, @unmounted_output, "")
-
-      expect(@provider).not_to receive(:disable_fs)
-
-      @provider.run_action(:disable)
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-require "spec_helper"
-
-describe Chef::Provider::Mount::Linux do
-
-  let(:run_context) do
-    node = Chef::Node.new
-    events = Chef::EventDispatch::Dispatcher.new
-    run_context = Chef::RunContext.new(node, {}, events)
-  end
-
-  let(:new_resource) do
-    new_resource = Chef::Resource::Mount.new("/tmp/foo")
-    new_resource.device "/dev/sdz1"
-    new_resource.device_type :device
-    new_resource.fstype "ext3"
-    new_resource.supports remount: false
-    new_resource
-  end
-
-  let(:provider) do
-    Chef::Provider::Mount::Linux.new(new_resource, run_context)
-  end
-
-  before(:each) do
-    allow(::File).to receive(:exist?).with("/etc/fstab").and_call_original
-    allow(::File).to receive(:exist?).with("/dev/sdz1").and_return true
-    allow(::File).to receive(:exist?).with("/tmp/foo").and_return true
-    allow(::File).to receive(:exist?).with("//192.168.11.102/Share/backup").and_return true
-    allow(::File).to receive(:exist?).with("//192.168.11.102/Share/backup folder").and_return true
-    allow(::File).to receive(:realpath).with("/dev/sdz1").and_return "/dev/sdz1"
-    allow(::File).to receive(:realpath).with("/tmp/foo").and_return "/tmp/foo"
-  end
-
-  context "to see if the volume is mounted" do
-
-    it "should set mounted true if the mount point is found in the mounts list" do
-      allow(provider).to receive(:shell_out!).with("losetup --list").and_return(double(stdout: "/tmp/foo"))
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: "/tmp/foo /dev/sdz1 type ext3 (rw)\n"))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_truthy
-    end
-
-    it "should set mounted false if another mount point beginning with the same path is found in the mounts list" do
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: "/tmp/foobar /dev/sdz1 type ext3 (rw)\n"))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_falsey
-    end
-
-    it "should set mounted true if the symlink target of the device is found in the mounts list" do
-      # expand the target path to correct specs on Windows
-      target = ::File.expand_path("/dev/mapper/target")
-
-      allow(::File).to receive(:symlink?).with((new_resource.device).to_s).and_return(true)
-      allow(::File).to receive(:readlink).with((new_resource.device).to_s).and_return(target)
-
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: "/tmp/foo #{target} type ext3 (rw)\n"))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_truthy
-    end
-
-    it "should set mounted true if the symlink target of the device is relative and is found in the mounts list - CHEF-4957" do
-      target = "xsdz1"
-
-      # expand the target path to correct specs on Windows
-      absolute_target = ::File.expand_path("/dev/xsdz1")
-
-      allow(::File).to receive(:symlink?).with((new_resource.device).to_s).and_return(true)
-      allow(::File).to receive(:readlink).with((new_resource.device).to_s).and_return(target)
-
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: "/tmp/foo #{absolute_target} type ext3 (rw)\n"))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_truthy
-    end
-
-    it "should set mounted true if the mount point is found last in the mounts list" do
-      mount = "#{new_resource.mount_point} /dev/sdy1 type ext3 (rw)\n"
-      mount << "#{new_resource.mount_point} #{new_resource.device} type ext3 (rw)\n"
-
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: mount))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_truthy
-    end
-
-    it "should set mounted false if the mount point is not last in the mounts list" do
-      mount = "#{new_resource.device} on #{new_resource.mount_point} type ext3 (rw)\n"
-      mount << "/dev/sdy1 on #{new_resource.mount_point} type ext3 (rw)\n"
-
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: mount))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_falsey
-    end
-
-    it "mounted should be false if the mount point is not found in the mounts list" do
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: "/dev/sdy1 on /tmp/foo type ext3 (rw)\n"))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_falsey
-    end
-
-    it "should set mounted true if network_device? is true and the mount point is found in the mounts list" do
-      new_resource.device "//192.168.11.102/Share/backup"
-      new_resource.fstype "cifs"
-      mount = "/tmp/foo //192.168.11.102/Share/backup[/backup] cifs rw\n"
-      mount << "#{new_resource.mount_point} #{new_resource.device} type #{new_resource.fstype}\n"
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: mount))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_truthy
-    end
-
-    it "should set mounted true if device name has a space and the mount point is found in the mounts list" do
-      new_resource.device "//192.168.11.102/Share/backup folder"
-      new_resource.fstype "cifs"
-      mount = "/tmp/foo //192.168.11.102/Share/backup\x20folder cifs rw\n"
-      allow(provider).to receive(:shell_out!).and_return(double(stdout: mount))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_truthy
-    end
-  end
-
-  context "to check if loop resource is mounted" do
-    it "should set mounted true in case of loop resource" do
-      new_resource.options "loop"
-      mount = "/tmp/foo /dev/loop16 iso660 cifs ro\n"
-      losetup = "/dev/loop16 0 0 1 1 /dev/sdz1 \n"
-      allow(provider).to receive(:shell_out!).with("findmnt -rn").and_return(double(stdout: mount))
-      allow(provider).to receive(:shell_out!).with("losetup -a").and_return(double(stdout: losetup))
-      provider.load_current_resource
-      expect(provider.current_resource.mounted).to be_truthy
-    end
-  end
-
-end