linux_admin 0.9.1 → 0.9.2

data/spec/distro_spec.rb

@@ -1,10 +1,8 @@
-require 'spec_helper'
-
 describe LinuxAdmin::Distros::Distro do
   let(:subject) { LinuxAdmin::Distros.local }
   describe "#local" do
     before do
-      LinuxAdmin::Distros.unstub(:local)
+      allow(LinuxAdmin::Distros).to receive(:local).and_call_original
     end
 
     [['ubuntu',  :ubuntu],
@@ -74,6 +72,6 @@ describe LinuxAdmin::Distros::Distro do
   private
 
   def exists(files)
-    files.each_pair { |file, value| allow(File).to receive(:exists?).with(file).and_return(value) }
+    files.each_pair { |file, value| allow(File).to receive(:exist?).with(file).and_return(value) }
   end
 end

data/spec/etc_issue_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'stringio'
 
 describe LinuxAdmin::EtcIssue do
@@ -9,7 +8,7 @@ describe LinuxAdmin::EtcIssue do
   end
 
   it "should not find the phrase when the file is missing" do
-    expect(File).to receive(:exists?).with('/etc/issue').at_least(:once).and_return(false)
+    expect(File).to receive(:exist?).with('/etc/issue').at_least(:once).and_return(false)
     expect(subject).not_to include("phrase")
   end
 

data/spec/fstab_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'stringio'
 
 describe LinuxAdmin::FSTab do
@@ -13,9 +12,9 @@ describe LinuxAdmin::FSTab do
   
 	
 eos
-    File.should_receive(:read).with('/etc/fstab').and_return(fstab)
-    LinuxAdmin::FSTab.instance.entries.size.should == 3
-    LinuxAdmin::FSTab.instance.entries.any? { |e| e.has_content? }.should be_false
+    expect(File).to receive(:read).with('/etc/fstab').and_return(fstab)
+    expect(LinuxAdmin::FSTab.instance.entries.size).to eq(3)
+    expect(LinuxAdmin::FSTab.instance.entries.any? { |e| e.has_content? }).to be_falsey
   end
 
   it "creates FSTabEntry for each line in fstab" do
@@ -27,27 +26,27 @@ eos
 /dev/sda1 / ext4  defaults  1 1
 /dev/sda2 swap  swap  defaults  0 0
 eos
-    File.should_receive(:read).with('/etc/fstab').and_return(fstab)
+    expect(File).to receive(:read).with('/etc/fstab').and_return(fstab)
     entries = LinuxAdmin::FSTab.instance.entries
-    entries.size.should == 6
+    expect(entries.size).to eq(6)
 
-    entries[0].comment.should == "# Comment, indented comment, comment with device information\n"
-    entries[1].comment.should == "# /dev/sda1 / ext4  defaults  1 1\n"
-    entries[2].comment.should == "# /dev/sda1 / ext4  defaults  1 1\n"
-    entries[3].comment.should == nil
-    entries[4].device.should == '/dev/sda1'
-    entries[4].mount_point.should == '/'
-    entries[4].fs_type.should == 'ext4'
-    entries[4].mount_options.should == 'defaults'
-    entries[4].dumpable.should == 1
-    entries[4].fsck_order.should == 1
+    expect(entries[0].comment).to eq("# Comment, indented comment, comment with device information\n")
+    expect(entries[1].comment).to eq("# /dev/sda1 / ext4  defaults  1 1\n")
+    expect(entries[2].comment).to eq("# /dev/sda1 / ext4  defaults  1 1\n")
+    expect(entries[3].comment).to eq(nil)
+    expect(entries[4].device).to eq('/dev/sda1')
+    expect(entries[4].mount_point).to eq('/')
+    expect(entries[4].fs_type).to eq('ext4')
+    expect(entries[4].mount_options).to eq('defaults')
+    expect(entries[4].dumpable).to eq(1)
+    expect(entries[4].fsck_order).to eq(1)
 
-    entries[5].device.should == '/dev/sda2'
-    entries[5].mount_point.should == 'swap'
-    entries[5].fs_type.should == 'swap'
-    entries[5].mount_options.should == 'defaults'
-    entries[5].dumpable.should == 0
-    entries[5].fsck_order.should == 0
+    expect(entries[5].device).to eq('/dev/sda2')
+    expect(entries[5].mount_point).to eq('swap')
+    expect(entries[5].fs_type).to eq('swap')
+    expect(entries[5].mount_options).to eq('defaults')
+    expect(entries[5].dumpable).to eq(0)
+    expect(entries[5].fsck_order).to eq(0)
   end
 
   describe "#write!" do
@@ -61,11 +60,11 @@ eos
       entry.dumpable      = 1
       entry.fsck_order    = 1
       entry.comment = "# more"
-      LinuxAdmin::FSTab.any_instance.stub(:refresh) # don't read /etc/fstab
+      allow_any_instance_of(LinuxAdmin::FSTab).to receive(:refresh) # don't read /etc/fstab
       LinuxAdmin::FSTab.instance.maximum_column_lengths = [9, 1, 4, 8, 1, 1, 1]
       LinuxAdmin::FSTab.instance.entries  = [entry]
 
-      File.should_receive(:write).with('/etc/fstab', "/dev/sda1 / ext4 defaults 1 1 # more\n")
+      expect(File).to receive(:write).with('/etc/fstab', "/dev/sda1 / ext4 defaults 1 1 # more\n")
       LinuxAdmin::FSTab.instance.write!
     end
   end

data/spec/hosts_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
-
 describe LinuxAdmin::Hosts do
   etc_hosts = "\n #Some Comment\n127.0.0.1\tlocalhost localhost.localdomain # with a comment\n127.0.1.1  my.domain.local"
   before do
-    File.stub(:read).and_return(etc_hosts)
+    allow(File).to receive(:read).and_return(etc_hosts)
     @instance = LinuxAdmin::Hosts.new
   end
 
@@ -35,7 +33,7 @@ describe LinuxAdmin::Hosts do
 
   describe "#save" do
     before do
-      File.stub(:write)
+      allow(File).to receive(:write)
     end
 
     it "properly generates file with new content" do
@@ -52,4 +50,4 @@ describe LinuxAdmin::Hosts do
       expect(@instance.raw_lines).to eq(expected_array)
     end
   end
-end
+end

data/spec/logical_volume_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe LinuxAdmin::LogicalVolume do
   before(:each) do
     @logical_volumes = <<eos
@@ -23,7 +21,7 @@ eos
     it "uses lvextend" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       lv = described_class.new :name => 'lv', :volume_group => vg
-      lv.should_receive(:run!).
+      expect(lv).to receive(:run!).
          with(vg.cmd(:lvextend),
               :params => ['lv', 'vg'])
       lv.extend_with(vg)
@@ -32,8 +30,8 @@ eos
     it "returns self" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       lv = described_class.new :name => 'lv', :volume_group => vg
-      lv.stub(:run!)
-      lv.extend_with(vg).should == lv
+      allow(lv).to receive(:run!)
+      expect(lv.extend_with(vg)).to eq(lv)
     end
   end
 
@@ -41,7 +39,7 @@ eos
     it "returns /dev/vgname/lvname" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       lv = described_class.new :name => 'lv', :volume_group => vg
-      lv.path.should == '/dev/vg/lv'
+      expect(lv.path).to eq('/dev/vg/lv')
     end
   end
 
@@ -52,7 +50,7 @@ eos
 
     it "uses lvcreate" do
       described_class.instance_variable_set(:@lvs, [])
-      described_class.should_receive(:run!).
+      expect(described_class).to receive(:run!).
                                 with(LinuxAdmin.cmd(:lvcreate),
                                      :params => { '-n' => 'lv',
                                                    nil => 'vg',
@@ -63,7 +61,7 @@ eos
     context "size is specified" do
       it "passes -L option to lvcreate" do
         described_class.instance_variable_set(:@lvs, [])
-        described_class.should_receive(:run!).
+        expect(described_class).to receive(:run!).
                                   with(LinuxAdmin.cmd(:lvcreate),
                                        :params => { '-n' => 'lv',
                                                      nil => 'vg',
@@ -75,7 +73,7 @@ eos
     context "extents is specified" do
       it "passes -l option to lvcreate" do
         described_class.instance_variable_set(:@lvs, [])
-        described_class.should_receive(:run!).
+        expect(described_class).to receive(:run!).
                                   with(LinuxAdmin.cmd(:lvcreate),
                                        :params => { '-n' => 'lv',
                                                      nil => 'vg',
@@ -85,84 +83,84 @@ eos
     end
 
     it "returns new logical volume" do
-      LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
-      described_class.stub(:run! => double(:output => ""))
+      allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
+      allow(described_class).to receive_messages(:run! => double(:output => ""))
       lv = described_class.create 'lv', @vg, 256.gigabytes
-      lv.should be_an_instance_of(described_class)
-      lv.name.should == 'lv'
+      expect(lv).to be_an_instance_of(described_class)
+      expect(lv.name).to eq('lv')
     end
 
     context "name is specified" do
       it "sets path under volume group" do
-        LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
-        described_class.stub(:run! => double(:output => ""))
+        allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
+        allow(described_class).to receive_messages(:run! => double(:output => ""))
         lv = described_class.create 'lv', @vg, 256.gigabytes
-        lv.path.to_s.should == "#{described_class::DEVICE_PATH}#{@vg.name}/lv"
+        expect(lv.path.to_s).to eq("#{described_class::DEVICE_PATH}#{@vg.name}/lv")
       end
     end
 
     context "path is specified" do
       it "sets name" do
-        LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
-        described_class.stub(:run! => double(:output => ""))
+        allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
+        allow(described_class).to receive_messages(:run! => double(:output => ""))
         lv = described_class.create '/dev/lv', @vg, 256.gigabytes
-        lv.name.should == "lv"
+        expect(lv.name).to eq("lv")
       end
     end
 
     context "path is specified as Pathname" do
       it "sets name" do
         require 'pathname'
-        LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
-        described_class.stub(:run! => double(:output => ""))
+        allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
+        allow(described_class).to receive_messages(:run! => double(:output => ""))
         lv = described_class.create Pathname.new("/dev/#{@vg.name}/lv"), @vg, 256.gigabytes
-        lv.name.should == "lv"
-        lv.path.should == "/dev/vg/lv"
+        expect(lv.name).to eq("lv")
+        expect(lv.path).to eq("/dev/vg/lv")
       end
     end
 
     it "adds logical volume to local registry" do
-      LinuxAdmin::VolumeGroup.stub(:run! => double(:output => ""))
-      described_class.stub(:run! => double(:output => ""))
+      allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
+      allow(described_class).to receive_messages(:run! => double(:output => ""))
       lv = described_class.create 'lv', @vg, 256.gigabytes
-      described_class.scan.should include(lv)
+      expect(described_class.scan).to include(lv)
     end
   end
 
   describe "#scan" do
     it "uses lvdisplay" do
-      described_class.should_receive(:run!).
+      expect(described_class).to receive(:run!).
                                 with(LinuxAdmin.cmd(:lvdisplay),
                                      :params => { '-c' => nil}).
                                 and_return(double(:output => @logical_volumes))
-      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
+      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
       described_class.scan
     end
 
     it "returns local logical volumes" do
-      described_class.should_receive(:run!).and_return(double(:output => @logical_volumes))
-      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
+      expect(described_class).to receive(:run!).and_return(double(:output => @logical_volumes))
+      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
       lvs = described_class.scan
 
-      lvs[0].should be_an_instance_of(described_class)
-      lvs[0].path.should == '/dev/vg_foobar/lv_swap'
-      lvs[0].name.should == 'lv_swap'
-      lvs[0].sectors.should == 4128768
+      expect(lvs[0]).to be_an_instance_of(described_class)
+      expect(lvs[0].path).to eq('/dev/vg_foobar/lv_swap')
+      expect(lvs[0].name).to eq('lv_swap')
+      expect(lvs[0].sectors).to eq(4128768)
 
-      lvs[1].should be_an_instance_of(described_class)
-      lvs[1].path.should == '/dev/vg_foobar/lv_root'
-      lvs[1].name.should == 'lv_root'
-      lvs[1].sectors.should == 19988480
+      expect(lvs[1]).to be_an_instance_of(described_class)
+      expect(lvs[1].path).to eq('/dev/vg_foobar/lv_root')
+      expect(lvs[1].name).to eq('lv_root')
+      expect(lvs[1].sectors).to eq(19988480)
     end
 
     it "resolves volume group references" do
-      described_class.should_receive(:run!).and_return(double(:output => @logical_volumes))
-      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
+      expect(described_class).to receive(:run!).and_return(double(:output => @logical_volumes))
+      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
       lvs = described_class.scan
-      lvs[0].volume_group.should be_an_instance_of(LinuxAdmin::VolumeGroup)
-      lvs[0].volume_group.name.should == 'vg_foobar'
-      lvs[1].volume_group.should be_an_instance_of(LinuxAdmin::VolumeGroup)
-      lvs[1].volume_group.name.should == 'vg_foobar'
+      expect(lvs[0].volume_group).to be_an_instance_of(LinuxAdmin::VolumeGroup)
+      expect(lvs[0].volume_group.name).to eq('vg_foobar')
+      expect(lvs[1].volume_group).to be_an_instance_of(LinuxAdmin::VolumeGroup)
+      expect(lvs[1].volume_group.name).to eq('vg_foobar')
     end
   end
 end

data/spec/mountable_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class TestMountable < LinuxAdmin
   include LinuxAdmin::Mountable
 
@@ -13,8 +11,8 @@ describe LinuxAdmin::Mountable do
     @mountable = TestMountable.new
 
     # stub out calls that modify system
-    FileUtils.stub(:mkdir)
-    @mountable.stub(:run!)
+    allow(FileUtils).to receive(:mkdir)
+    allow(@mountable).to receive(:run!)
 
     @mount_out1 = <<eos
 /dev/sda on /mnt/usb type vfat (rw)
@@ -27,92 +25,92 @@ eos
 
   describe "#mount_point_exists?" do
     it "uses mount" do
-      TestMountable.should_receive(:run!).with(TestMountable.cmd(:mount)).and_return(double(:output => ""))
+      expect(TestMountable).to receive(:run!).with(TestMountable.cmd(:mount)).and_return(double(:output => ""))
       TestMountable.mount_point_exists?('/mnt/usb')
     end
 
     context "disk mounted at specified location" do
       it "returns true" do
-        TestMountable.should_receive(:run!).and_return(double(:output => @mount_out1))
-        TestMountable.mount_point_exists?('/mnt/usb').should be_true
+        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out1))
+        expect(TestMountable.mount_point_exists?('/mnt/usb')).to be_truthy
       end
     end
 
     context "no disk mounted at specified location" do
       it "returns false" do
-        TestMountable.should_receive(:run!).and_return(double(:output => @mount_out2))
-        TestMountable.mount_point_exists?('/mnt/usb').should be_false
+        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out2))
+        expect(TestMountable.mount_point_exists?('/mnt/usb')).to be_falsey
       end
     end
   end
 
   describe "#mount_point_available?" do
     it "uses mount" do
-      TestMountable.should_receive(:run!).with(TestMountable.cmd(:mount)).and_return(double(:output => ""))
+      expect(TestMountable).to receive(:run!).with(TestMountable.cmd(:mount)).and_return(double(:output => ""))
       TestMountable.mount_point_available?('/mnt/usb')
     end
 
     context "disk mounted at specified location" do
       it "returns false" do
-        TestMountable.should_receive(:run!).and_return(double(:output => @mount_out1))
-        TestMountable.mount_point_available?('/mnt/usb').should be_false
+        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out1))
+        expect(TestMountable.mount_point_available?('/mnt/usb')).to be_falsey
       end
     end
 
     context "no disk mounted at specified location" do
       it "returns true" do
-        TestMountable.should_receive(:run!).and_return(double(:output => @mount_out2))
-        TestMountable.mount_point_available?('/mnt/usb').should be_true
+        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out2))
+        expect(TestMountable.mount_point_available?('/mnt/usb')).to be_truthy
       end
     end
   end
 
   describe "#format_to" do
     it "uses mke2fs" do
-      @mountable.should_receive(:run!).
+      expect(@mountable).to receive(:run!).
          with(@mountable.cmd(:mke2fs),
               :params => { '-t' => 'ext4', nil => '/dev/foo'})
       @mountable.format_to('ext4')
     end
 
     it "sets fs type" do
-      @mountable.should_receive(:run!) # ignore actual formatting cmd
+      expect(@mountable).to receive(:run!) # ignore actual formatting cmd
       @mountable.format_to('ext4')
-      @mountable.fs_type.should == 'ext4'
+      expect(@mountable.fs_type).to eq('ext4')
     end
   end
 
   describe "#mount" do
     it "sets mount point" do
       # ignore actual mount cmds
-      @mountable.should_receive(:run!).and_return(double(:output => ""))
-      TestMountable.should_receive(:run!).and_return(double(:output => ""))
+      expect(@mountable).to receive(:run!).and_return(double(:output => ""))
+      expect(TestMountable).to receive(:run!).and_return(double(:output => ""))
 
-      @mountable.mount('/mnt/sda2').should == '/mnt/sda2'
-      @mountable.mount_point.should == '/mnt/sda2'
+      expect(@mountable.mount('/mnt/sda2')).to eq('/mnt/sda2')
+      expect(@mountable.mount_point).to eq('/mnt/sda2')
     end
     
     context "mountpoint does not exist" do
       it "creates mountpoint" do
-        TestMountable.should_receive(:mount_point_exists?).and_return(false)
-        File.should_receive(:directory?).with('/mnt/sda2').and_return(false)
-        FileUtils.should_receive(:mkdir).with('/mnt/sda2')
-        @mountable.should_receive(:run!) # ignore actual mount cmd
+        expect(TestMountable).to receive(:mount_point_exists?).and_return(false)
+        expect(File).to receive(:directory?).with('/mnt/sda2').and_return(false)
+        expect(FileUtils).to receive(:mkdir).with('/mnt/sda2')
+        expect(@mountable).to receive(:run!) # ignore actual mount cmd
         @mountable.mount '/mnt/sda2'
       end
     end
 
     context "disk mounted at mountpoint" do
       it "raises argument error" do
-        TestMountable.should_receive(:mount_point_exists?).and_return(true)
-        File.should_receive(:directory?).with('/mnt/sda2').and_return(true)
+        expect(TestMountable).to receive(:mount_point_exists?).and_return(true)
+        expect(File).to receive(:directory?).with('/mnt/sda2').and_return(true)
         expect { @mountable.mount '/mnt/sda2' }.to raise_error(ArgumentError, "disk already mounted at /mnt/sda2")
       end
     end
 
     it "mounts partition" do
-      TestMountable.should_receive(:mount_point_exists?).and_return(false)
-      @mountable.should_receive(:run!).
+      expect(TestMountable).to receive(:mount_point_exists?).and_return(false)
+      expect(@mountable).to receive(:run!).
          with(@mountable.cmd(:mount),
               :params => { nil => ['/dev/foo', '/mnt/sda2']})
       @mountable.mount '/mnt/sda2'
@@ -122,7 +120,7 @@ eos
   describe "#umount" do
     it "unmounts partition" do
       @mountable.mount_point = '/mnt/sda2'
-      @mountable.should_receive(:run!).with(@mountable.cmd(:umount), :params => { nil => ['/mnt/sda2']})
+      expect(@mountable).to receive(:run!).with(@mountable.cmd(:umount), :params => { nil => ['/mnt/sda2']})
       @mountable.umount
     end
   end