linux_admin 0.14.0 → 0.15.0

data/spec/hosts_spec.rb

@@ -81,20 +81,20 @@ describe LinuxAdmin::Hosts do
   describe "#hostname=" do
     it "sets the hostname using hostnamectl when the command exists" do
       spawn_args = [
-        @instance.cmd('hostnamectl'),
+        LinuxAdmin::Common.cmd('hostnamectl'),
         :params => ['set-hostname', TEST_HOSTNAME]
       ]
-      expect(@instance).to receive(:cmd?).with("hostnamectl").and_return(true)
+      expect(LinuxAdmin::Common).to receive(:cmd?).with("hostnamectl").and_return(true)
       expect(AwesomeSpawn).to receive(:run!).with(*spawn_args)
       @instance.hostname = TEST_HOSTNAME
     end
 
     it "sets the hostname with hostname when hostnamectl does not exist" do
       spawn_args = [
-        @instance.cmd('hostname'),
+        LinuxAdmin::Common.cmd('hostname'),
         :params => {:file => "/etc/hostname"}
       ]
-      expect(@instance).to receive(:cmd?).with("hostnamectl").and_return(false)
+      expect(LinuxAdmin::Common).to receive(:cmd?).with("hostnamectl").and_return(false)
       expect(File).to receive(:write).with("/etc/hostname", TEST_HOSTNAME)
       expect(AwesomeSpawn).to receive(:run!).with(*spawn_args)
       @instance.hostname = TEST_HOSTNAME
@@ -103,7 +103,7 @@ describe LinuxAdmin::Hosts do
 
   describe "#hostname" do
     let(:spawn_args) do
-      [@instance.cmd('hostname'), {}]
+      [LinuxAdmin::Common.cmd('hostname'), {}]
     end
 
     it "returns the hostname" do

data/spec/ip_address_spec.rb

@@ -2,22 +2,22 @@ describe LinuxAdmin::IpAddress do
   let(:ip) { described_class.new }
 
   ADDR_SPAWN_ARGS = [
-    described_class.new.cmd("hostname"),
+    LinuxAdmin::Common.cmd("hostname"),
     :params => ["-I"]
   ]
 
   MAC_SPAWN_ARGS = [
-    described_class.new.cmd("ip"),
+    LinuxAdmin::Common.cmd("ip"),
     :params => %w(addr show eth0)
   ]
 
   MASK_SPAWN_ARGS = [
-    described_class.new.cmd("ifconfig"),
+    LinuxAdmin::Common.cmd("ifconfig"),
     :params => %w(eth0)
   ]
 
   GW_SPAWN_ARGS = [
-    described_class.new.cmd("ip"),
+    LinuxAdmin::Common.cmd("ip"),
     :params => %w(route)
   ]
 

data/spec/logical_volume_spec.rb

@@ -21,16 +21,16 @@ eos
     it "uses lvextend" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       lv = described_class.new :name => 'lv', :volume_group => vg
-      expect(lv).to receive(:run!).
-         with(vg.cmd(:lvextend),
-              :params => ['lv', 'vg'])
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:lvextend),
+              :params => %w(lv vg))
       lv.extend_with(vg)
     end
 
     it "returns self" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       lv = described_class.new :name => 'lv', :volume_group => vg
-      allow(lv).to receive(:run!)
+      allow(LinuxAdmin::Common).to receive(:run!)
       expect(lv.extend_with(vg)).to eq(lv)
     end
   end
@@ -50,22 +50,22 @@ eos
 
     it "uses lvcreate" do
       described_class.instance_variable_set(:@lvs, [])
-      expect(described_class).to receive(:run!).
-                                with(LinuxAdmin.cmd(:lvcreate),
-                                     :params => { '-n' => 'lv',
-                                                   nil => 'vg',
-                                                  '-L' => '256G' })
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:lvcreate),
+              :params => {'-n' => 'lv',
+                          nil  => 'vg',
+                          '-L' => '256G'})
       described_class.create 'lv', @vg, 256.gigabytes
     end
 
     context "size is specified" do
       it "passes -L option to lvcreate" do
         described_class.instance_variable_set(:@lvs, [])
-        expect(described_class).to receive(:run!).
-                                  with(LinuxAdmin.cmd(:lvcreate),
-                                       :params => { '-n' => 'lv',
-                                                     nil => 'vg',
-                                                    '-L' => '256G' })
+        expect(LinuxAdmin::Common).to receive(:run!)
+          .with(LinuxAdmin::Common.cmd(:lvcreate),
+                :params => {'-n' => 'lv',
+                            nil  => 'vg',
+                            '-L' => '256G'})
         described_class.create 'lv', @vg, 256.gigabytes
       end
     end
@@ -73,18 +73,18 @@ eos
     context "extents is specified" do
       it "passes -l option to lvcreate" do
         described_class.instance_variable_set(:@lvs, [])
-        expect(described_class).to receive(:run!).
-                                  with(LinuxAdmin.cmd(:lvcreate),
-                                       :params => { '-n' => 'lv',
-                                                     nil => 'vg',
-                                                    '-l' => '100%FREE' })
+        expect(LinuxAdmin::Common).to receive(:run!)
+          .with(LinuxAdmin::Common.cmd(:lvcreate),
+                :params => {'-n' => 'lv',
+                            nil  => 'vg',
+                            '-l' => '100%FREE'})
         described_class.create 'lv', @vg, 100
       end
     end
 
     it "returns new logical volume" do
-      allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
-      allow(described_class).to receive_messages(:run! => double(:output => ""))
+      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
+      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
       lv = described_class.create 'lv', @vg, 256.gigabytes
       expect(lv).to be_an_instance_of(described_class)
       expect(lv.name).to eq('lv')
@@ -92,8 +92,8 @@ eos
 
     context "name is specified" do
       it "sets path under volume group" do
-        allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
-        allow(described_class).to receive_messages(:run! => double(:output => ""))
+        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
+        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
         lv = described_class.create 'lv', @vg, 256.gigabytes
         expect(lv.path.to_s).to eq("#{described_class::DEVICE_PATH}#{@vg.name}/lv")
       end
@@ -101,8 +101,8 @@ eos
 
     context "path is specified" do
       it "sets name" do
-        allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
-        allow(described_class).to receive_messages(:run! => double(:output => ""))
+        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
+        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
         lv = described_class.create '/dev/lv', @vg, 256.gigabytes
         expect(lv.name).to eq("lv")
       end
@@ -111,8 +111,8 @@ eos
     context "path is specified as Pathname" do
       it "sets name" do
         require 'pathname'
-        allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
-        allow(described_class).to receive_messages(:run! => double(:output => ""))
+        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
+        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
         lv = described_class.create Pathname.new("/dev/#{@vg.name}/lv"), @vg, 256.gigabytes
         expect(lv.name).to eq("lv")
         expect(lv.path).to eq("/dev/vg/lv")
@@ -120,8 +120,8 @@ eos
     end
 
     it "adds logical volume to local registry" do
-      allow(LinuxAdmin::VolumeGroup).to receive_messages(:run! => double(:output => ""))
-      allow(described_class).to receive_messages(:run! => double(:output => ""))
+      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
+      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
       lv = described_class.create 'lv', @vg, 256.gigabytes
       expect(described_class.scan).to include(lv)
     end
@@ -129,17 +129,17 @@ eos
 
   describe "#scan" do
     it "uses lvdisplay" do
-      expect(described_class).to receive(:run!).
-                                with(LinuxAdmin.cmd(:lvdisplay),
-                                     :params => { '-c' => nil}).
-                                and_return(double(:output => @logical_volumes))
-      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:lvdisplay),
+              :params => {'-c' => nil})
+        .and_return(double(:output => @logical_volumes))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
       described_class.scan
     end
 
     it "returns local logical volumes" do
-      expect(described_class).to receive(:run!).and_return(double(:output => @logical_volumes))
-      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @logical_volumes))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups))
       lvs = described_class.scan
 
       expect(lvs[0]).to be_an_instance_of(described_class)
@@ -154,8 +154,8 @@ eos
     end
 
     it "resolves volume group references" do
-      expect(described_class).to receive(:run!).and_return(double(:output => @logical_volumes))
-      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @logical_volumes))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups))
       lvs = described_class.scan
       expect(lvs[0].volume_group).to be_an_instance_of(LinuxAdmin::VolumeGroup)
       expect(lvs[0].volume_group.name).to eq('vg_foobar')

data/spec/mountable_spec.rb

@@ -12,7 +12,7 @@ describe LinuxAdmin::Mountable do
 
     # stub out calls that modify system
     allow(FileUtils).to receive(:mkdir)
-    allow(@mountable).to receive(:run!)
+    allow(LinuxAdmin::Common).to receive(:run!)
 
     @mount_out1 = <<eos
 /dev/sda on /mnt/usb type vfat (rw)
@@ -25,20 +25,21 @@ eos
 
   describe "#mount_point_exists?" do
     it "uses mount" do
-      expect(TestMountable).to receive(:run!).with(TestMountable.cmd(:mount)).and_return(double(:output => ""))
+      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:mount))
+        .and_return(double(:output => ""))
       TestMountable.mount_point_exists?('/mnt/usb')
     end
 
     context "disk mounted at specified location" do
       it "returns true" do
-        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out1))
+        expect(LinuxAdmin::Common).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
-        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out2))
+        expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out2))
         expect(TestMountable.mount_point_exists?('/mnt/usb')).to be_falsey
       end
     end
@@ -46,20 +47,21 @@ eos
 
   describe "#mount_point_available?" do
     it "uses mount" do
-      expect(TestMountable).to receive(:run!).with(TestMountable.cmd(:mount)).and_return(double(:output => ""))
+      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:mount))
+        .and_return(double(:output => ""))
       TestMountable.mount_point_available?('/mnt/usb')
     end
 
     context "disk mounted at specified location" do
       it "returns false" do
-        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out1))
+        expect(LinuxAdmin::Common).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
-        expect(TestMountable).to receive(:run!).and_return(double(:output => @mount_out2))
+        expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out2))
         expect(TestMountable.mount_point_available?('/mnt/usb')).to be_truthy
       end
     end
@@ -67,14 +69,14 @@ eos
 
   describe "#format_to" do
     it "uses mke2fs" do
-      expect(@mountable).to receive(:run!).
-         with(@mountable.cmd(:mke2fs),
-              :params => { '-t' => 'ext4', nil => '/dev/foo'})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:mke2fs),
+              :params => {'-t' => 'ext4', nil => '/dev/foo'})
       @mountable.format_to('ext4')
     end
 
     it "sets fs type" do
-      expect(@mountable).to receive(:run!) # ignore actual formatting cmd
+      expect(LinuxAdmin::Common).to receive(:run!) # ignore actual formatting cmd
       @mountable.format_to('ext4')
       expect(@mountable.fs_type).to eq('ext4')
     end
@@ -83,19 +85,19 @@ eos
   describe "#mount" do
     it "sets mount point" do
       # ignore actual mount cmds
-      expect(@mountable).to receive(:run!).and_return(double(:output => ""))
-      expect(TestMountable).to receive(:run!).and_return(double(:output => ""))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => ""))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => ""))
 
       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
         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
+        expect(LinuxAdmin::Common).to receive(:run!) # ignore actual mount cmd
         @mountable.mount '/mnt/sda2'
       end
     end
@@ -110,9 +112,9 @@ eos
 
     it "mounts partition" do
       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']})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:mount),
+              :params => {nil => ['/dev/foo', '/mnt/sda2']})
       @mountable.mount '/mnt/sda2'
     end
   end
@@ -120,9 +122,9 @@ eos
   describe "#umount" do
     it "unmounts partition" do
       @mountable.mount_point = '/mnt/sda2'
-      expect(@mountable).to receive(:run!).with(@mountable.cmd(:umount), :params => { nil => ['/mnt/sda2']})
+      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:umount),
+                                                        :params => {nil => ['/mnt/sda2']})
       @mountable.umount
     end
   end
-
 end

data/spec/network_interface/network_interface_rh_spec.rb

@@ -1,6 +1,7 @@
 describe LinuxAdmin::NetworkInterfaceRH do
-  DEVICE_NAME = "eth0"
-  IFCFG_FILE_DHCP = <<-EOF
+  let(:device_name) { "eth0" }
+  let(:ifcfg_file_dhcp) do
+    <<-EOF
 #A comment is here
 DEVICE=eth0
 BOOTPROTO=dhcp
@@ -9,8 +10,10 @@ ONBOOT=yes
 TYPE=Ethernet
 NAME="System eth0"
 EOF
+  end
 
-  IFCFG_FILE_STATIC = <<-EOF
+  let(:ifcfg_file_static) do
+    <<-EOF
 #A comment is here
 DEVICE=eth0
 BOOTPROTO=static
@@ -22,6 +25,7 @@ IPADDR=192.168.1.100
 NETMASK=255.255.255.0
 GATEWAY=192.168.1.1
 EOF
+  end
 
   def stub_foreach_to_string(string)
     allow(File).to receive(:foreach) do |&block|
@@ -35,16 +39,16 @@ EOF
 
   subject(:dhcp_interface) do
     allow(File).to receive(:exist?).and_return(true)
-    stub_foreach_to_string(IFCFG_FILE_DHCP)
+    stub_foreach_to_string(ifcfg_file_dhcp)
     allow(AwesomeSpawn).to receive(:run!).twice.and_return(result("", 0))
-    described_class.new(DEVICE_NAME)
+    described_class.new(device_name)
   end
 
   subject(:static_interface) do
     allow(File).to receive(:exist?).and_return(true)
-    stub_foreach_to_string(IFCFG_FILE_STATIC)
+    stub_foreach_to_string(ifcfg_file_static)
     allow(AwesomeSpawn).to receive(:run!).twice.and_return(result("", 0))
-    described_class.new(DEVICE_NAME)
+    described_class.new(device_name)
   end
 
   describe ".new" do
@@ -63,7 +67,7 @@ EOF
   describe "#parse_conf" do
     it "reloads the interface configuration" do
       interface = dhcp_interface
-      stub_foreach_to_string(IFCFG_FILE_STATIC)
+      stub_foreach_to_string(ifcfg_file_static)
       interface.parse_conf
 
       conf = interface.interface_config
@@ -198,7 +202,7 @@ EOF
   end
 
   describe "#save" do
-    let(:iface_file) { Pathname.new("/etc/sysconfig/network-scripts/ifcfg-#{DEVICE_NAME}") }
+    let(:iface_file) { Pathname.new("/etc/sysconfig/network-scripts/ifcfg-#{device_name}") }
 
     def expect_old_contents
       expect(File).to receive(:write) do |file, contents|

data/spec/network_interface_spec.rb

@@ -58,25 +58,23 @@ describe LinuxAdmin::NetworkInterface do
   end
 
   context "on all systems" do
-    common_inst = Class.new { include LinuxAdmin::Common }.new
-
     IP_SHOW_ARGS = [
-      common_inst.cmd("ip"),
+      LinuxAdmin::Common.cmd("ip"),
       :params => %w(addr show eth0)
     ]
 
     IP_ROUTE_ARGS = [
-      common_inst.cmd("ip"),
+      LinuxAdmin::Common.cmd("ip"),
       :params => %w(route)
     ]
 
     IFUP_ARGS = [
-      common_inst.cmd("ifup"),
+      LinuxAdmin::Common.cmd("ifup"),
       :params => ["eth0"]
     ]
 
     IFDOWN_ARGS = [
-      common_inst.cmd("ifdown"),
+      LinuxAdmin::Common.cmd("ifdown"),
       :params => ["eth0"]
     ]
 

data/spec/partition_spec.rb

@@ -15,7 +15,7 @@ describe LinuxAdmin::Partition do
       it "sets default mount_point" do
         expect(described_class).to receive(:mount_point_exists?).and_return(false)
         expect(File).to receive(:directory?).with('/mnt/sda2').and_return(true)
-        expect(@partition).to receive(:run!)
+        expect(LinuxAdmin::Common).to receive(:run!)
         @partition.mount
         expect(@partition.mount_point).to eq('/mnt/sda2')
       end