linux_admin 0.14.0 → 0.15.0

data/spec/physical_volume_spec.rb

@@ -20,8 +20,8 @@ eos
     it "uses vgextend" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      expect(pv).to receive(:run!).
-         with(pv.cmd(:vgextend),
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:vgextend),
               :params => ['vg', '/dev/hda'])
       pv.attach_to(vg)
     end
@@ -29,7 +29,7 @@ eos
     it "assigns volume group to physical volume" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      allow(pv).to receive(:run!)
+      allow(LinuxAdmin::Common).to receive(:run!)
       pv.attach_to(vg)
       expect(pv.volume_group).to eq(vg)
     end
@@ -37,7 +37,7 @@ eos
     it "returns self" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      allow(pv).to receive(:run!)
+      allow(LinuxAdmin::Common).to receive(:run!)
       expect(pv.attach_to(vg)).to eq(pv)
     end
   end
@@ -52,23 +52,21 @@ eos
 
     it "uses pvcreate" do
       described_class.instance_variable_set(:@pvs, [])
-      expect(described_class).to receive(:run!).
-                                 with(LinuxAdmin.cmd(:pvcreate),
-                                      :params => { nil => '/dev/hda'})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:pvcreate),
+              :params => {nil => '/dev/hda'})
       described_class.create disk
     end
 
     it "returns new physical 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 => ""))
       pv = described_class.create disk
       expect(pv).to be_an_instance_of(described_class)
       expect(pv.device_name).to eq('/dev/hda')
     end
 
     it "adds physical 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 => ""))
       pv = described_class.create disk
       expect(described_class.scan).to include(pv)
     end
@@ -76,17 +74,16 @@ eos
 
   describe "#scan" do
     it "uses pvdisplay" do
-      expect(described_class).to receive(:run!).
-                                 with(LinuxAdmin.cmd(:pvdisplay),
-                                     :params => { '-c' => nil}).
-                                 and_return(double(:output => @physical_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(:pvdisplay),
+              :params => {'-c' => nil})
+        .and_return(double(:output => @physical_volumes))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
       described_class.scan
     end
 
     it "returns local physical volumes" do
-      expect(described_class).to receive(:run!).and_return(double(:output => @physical_volumes))
-      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @physical_volumes), double(:output => @groups))
       pvs = described_class.scan
 
       expect(pvs[0]).to be_an_instance_of(described_class)
@@ -95,8 +92,7 @@ eos
     end
 
     it "resolves volume group references" do
-      expect(described_class).to receive(:run!).and_return(double(:output => @physical_volumes))
-      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @physical_volumes), double(:output => @groups))
       pvs = described_class.scan
       expect(pvs[0].volume_group).to be_an_instance_of(LinuxAdmin::VolumeGroup)
       expect(pvs[0].volume_group.name).to eq('vg_foobar')

data/spec/rhn_spec.rb

@@ -39,7 +39,7 @@ describe LinuxAdmin::Rhn do
         run_params.store_path(:params, "--sslCACert=", "/usr/share/rhn/RHN-ORG-TRUSTED-SSL-CERT")
         base_options.store_path(:server_url, "https://server.url")
 
-        expect_any_instance_of(described_class).to receive(:run!).once.with("rhnreg_ks", run_params)
+        expect(LinuxAdmin::Common).to receive(:run!).once.with("rhnreg_ks", run_params)
         expect(LinuxAdmin::Rpm).to receive(:upgrade).with("http://server.url/pub/rhn-org-trusted-ssl-cert-1.0-1.noarch.rpm")
         expect(LinuxAdmin::Rpm).to receive(:list_installed).and_return({"rhn-org-trusted-ssl-cert" => "1.0"})
 
@@ -47,7 +47,7 @@ describe LinuxAdmin::Rhn do
       end
 
       it "without server_url" do
-        expect_any_instance_of(described_class).to receive(:run!).once.with("rhnreg_ks", run_params)
+        expect(LinuxAdmin::Common).to receive(:run!).once.with("rhnreg_ks", run_params)
         expect_any_instance_of(described_class).not_to receive(:install_server_certificate)
         expect(LinuxAdmin::Rpm).to receive(:list_installed).and_return({"rhn-org-trusted-ssl-cert" => nil})
 
@@ -56,7 +56,11 @@ describe LinuxAdmin::Rhn do
     end
 
     it "with activation key" do
-      expect_any_instance_of(described_class).to receive(:run!).once.with("rhnreg_ks", {:params=>{"--activationkey="=>"123abc", "--proxy="=>"1.2.3.4", "--proxyUser="=>"ProxyUser", "--proxyPassword="=>"ProxyPass"}})
+      expect(LinuxAdmin::Common).to receive(:run!).once.with("rhnreg_ks",
+                                                             :params => {"--activationkey=" => "123abc",
+                                                                         "--proxy="         => "1.2.3.4",
+                                                                         "--proxyUser="     => "ProxyUser",
+                                                                         "--proxyPassword=" => "ProxyPass"})
       expect(LinuxAdmin::Rpm).to receive(:list_installed).and_return({"rhn-org-trusted-ssl-cert" => nil})
 
       described_class.new.register(
@@ -69,19 +73,25 @@ describe LinuxAdmin::Rhn do
   end
 
   it "#enable_channel" do
-    expect_any_instance_of(described_class).to receive(:run!).once.with("rhn-channel -a", {:params=>{"--user="=>"SomeUser", "--password="=>"SomePass", "--channel="=>123}})
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("rhn-channel -a",
+                                                           :params => {"--user="     => "SomeUser",
+                                                                       "--password=" => "SomePass",
+                                                                       "--channel="  => 123})
 
     described_class.new.enable_channel(123, :username => "SomeUser", :password => "SomePass")
   end
 
   it "#enabled_channels" do
-    expect_any_instance_of(described_class).to receive(:run!).once.with("rhn-channel -l").and_return(double(:output => sample_output("rhn/output_rhn-channel_list")))
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("rhn-channel -l")
+      .and_return(double(:output => sample_output("rhn/output_rhn-channel_list")))
 
     expect(described_class.new.enabled_channels).to eq(["rhel-x86_64-server-6", "rhel-x86_64-server-6-cf-me-2"])
   end
 
   it "#disable_channel" do
-    expect_any_instance_of(described_class).to receive(:run!).once.with("rhn-channel -r", {:params=>{"--user="=>"SomeUser", "--password="=>"SomePass", "--channel="=>123}})
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("rhn-channel -r", :params => {"--user="     => "SomeUser",
+                                                                                         "--password=" => "SomePass",
+                                                                                         "--channel="  => 123})
 
     described_class.new.disable_channel(123, :username => "SomeUser", :password => "SomePass")
   end
@@ -105,7 +115,8 @@ describe LinuxAdmin::Rhn do
       }
     }
 
-    expect_any_instance_of(described_class).to receive(:run!).once.with(cmd, params).and_return(double(:output => sample_output("rhn/output_rhn-channel_list_available")))
+    expect(LinuxAdmin::Common).to receive(:run!).once.with(cmd, params)
+      .and_return(double(:output => sample_output("rhn/output_rhn-channel_list_available")))
 
     expect(described_class.new.available_channels(credentials)).to eq(expected)
   end
@@ -123,8 +134,10 @@ describe LinuxAdmin::Rhn do
       {:repo_id => "rhel-x86_64-server-6",              :enabled => true}
     ]
 
-    expect_any_instance_of(described_class).to receive(:run!).once.and_return(double(:output => sample_output("rhn/output_rhn-channel_list_available")))
-    expect_any_instance_of(described_class).to receive(:run!).once.with("rhn-channel -l").and_return(double(:output => sample_output("rhn/output_rhn-channel_list")))
+    expect(LinuxAdmin::Common).to receive(:run!).once
+      .and_return(double(:output => sample_output("rhn/output_rhn-channel_list_available")))
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("rhn-channel -l")
+      .and_return(double(:output => sample_output("rhn/output_rhn-channel_list")))
 
     expect(described_class.new.all_repos(credentials)).to eq(expected)
   end

data/spec/rpm_spec.rb

@@ -1,6 +1,7 @@
 describe LinuxAdmin::Rpm do
   it ".list_installed" do
-    allow(described_class).to receive_messages(:run! => double(:output => sample_output("rpm/cmd_output_for_list_installed")))
+    allow(LinuxAdmin::Common).to receive(:run!)
+      .and_return(double(:output => sample_output("rpm/cmd_output_for_list_installed")))
     expect(described_class.list_installed).to eq({
       "ruby193-rubygem-some_really_long_name" =>"1.0.7-1.el6",
       "fipscheck-lib"                         =>"1.2.0-7.el6",
@@ -26,7 +27,7 @@ describe LinuxAdmin::Rpm do
   end
 
   it ".import_key" do
-    expect(described_class).to receive(:run!).with("rpm", {:params => {"--import" => "abc"}})
+    expect(LinuxAdmin::Common).to receive(:run!).with("rpm", :params => {"--import" => "abc"})
     expect { described_class.import_key("abc") }.to_not raise_error
   end
 
@@ -59,7 +60,7 @@ straight-forward, and extensible.
 EOS
       arguments = [described_class.rpm_cmd, :params => {"-qi" => "ruby"}]
       result = AwesomeSpawn::CommandResult.new("", data, "", 0)
-      expect(described_class).to receive(:run!).with(*arguments).and_return(result)
+      expect(LinuxAdmin::Common).to receive(:run!).with(*arguments).and_return(result)
       metadata = described_class.info("ruby")
       expect(metadata['name']).to eq('ruby')
       expect(metadata['version']).to eq('2.0.0.247')
@@ -77,7 +78,8 @@ EOS
   end
 
   it ".upgrade" do
-    expect(described_class).to receive(:run).with("rpm -U", {:params=>{nil=>"abc"}}).and_return(double(:exit_status => 0))
+    expect(LinuxAdmin::Common).to receive(:run).with("rpm -U", :params => {nil => "abc"})
+      .and_return(double(:exit_status => 0))
     expect(described_class.upgrade("abc")).to be_truthy
   end
 end

data/spec/service/sys_v_init_service_spec.rb

@@ -5,24 +5,24 @@ describe LinuxAdmin::SysVInitService do
 
   describe "#running?" do
     it "checks service" do
-      expect(@service).to receive(:run).
-         with(@service.cmd(:service),
-              :params => { nil => ['foo', 'status']}).and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run)
+        .with(LinuxAdmin::Common.cmd(:service),
+              :params => {nil => %w(foo status)}).and_return(double(:exit_status => 0))
       @service.running?
     end
 
     context "service is running" do
       it "returns true" do
         @service = described_class.new :id => :foo
-        expect(@service).to receive(:run).and_return(double(:exit_status => 0))
+        expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
         expect(@service).to be_running
-     end
+      end
     end
 
     context "service is not running" do
       it "returns false" do
         @service = described_class.new :id => :foo
-        expect(@service).to receive(:run).and_return(double(:exit_status => 1))
+        expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
         expect(@service).not_to be_running
       end
     end
@@ -30,71 +30,71 @@ describe LinuxAdmin::SysVInitService do
 
   describe "#enable" do
     it "enables service" do
-      expect(@service).to receive(:run!).
-         with(@service.cmd(:chkconfig),
-              :params => { nil => [ 'foo', 'on']})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:chkconfig),
+              :params => {nil => %w(foo on)})
       @service.enable
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!) # stub out cmd invocation
+      expect(LinuxAdmin::Common).to receive(:run!) # stub out cmd invocation
       expect(@service.enable).to eq(@service)
     end
   end
 
   describe "#disable" do
     it "disable service" do
-      expect(@service).to receive(:run!).
-         with(@service.cmd(:chkconfig),
-              :params => { nil => [ 'foo', 'off']})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:chkconfig),
+              :params => {nil => %w(foo off)})
       @service.disable
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       expect(@service.disable).to eq(@service)
     end
   end
 
   describe "#start" do
     it "starts service" do
-      expect(@service).to receive(:run!).
-         with(@service.cmd(:service),
-              :params => { nil => [ 'foo', 'start']})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:service),
+              :params => {nil => %w(foo start)})
       @service.start
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       expect(@service.start).to eq(@service)
     end
   end
 
   describe "#stop" do
     it "stops service" do
-      expect(@service).to receive(:run!).
-         with(@service.cmd(:service),
-              :params => { nil => [ 'foo', 'stop']})
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:service),
+              :params => {nil => %w(foo stop)})
       @service.stop
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       expect(@service.stop).to eq(@service)
     end
   end
 
   describe "#restart" do
     it "stops service" do
-      expect(@service).to receive(:run).
-         with(@service.cmd(:service),
-              :params => { nil => [ 'foo', 'restart']}).and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run)
+        .with(LinuxAdmin::Common.cmd(:service),
+              :params => {nil => %w(foo restart)}).and_return(double(:exit_status => 0))
       @service.restart
     end
 
     context "service restart fails" do
       it "manually stops/starts service" do
-        expect(@service).to receive(:run).and_return(double(:exit_status => 1))
+        expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
         expect(@service).to receive(:stop)
         expect(@service).to receive(:start)
         @service.restart
@@ -102,9 +102,8 @@ describe LinuxAdmin::SysVInitService do
     end
 
     it "returns self" do
-      expect(@service).to receive(:run).and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
       expect(@service.restart).to eq(@service)
     end
   end
-
 end

data/spec/service/systemd_service_spec.rb

@@ -5,96 +5,96 @@ describe LinuxAdmin::SystemdService do
 
   describe "#running?" do
     it "checks service" do
-      expect(@service).to receive(:run)
-        .with(@service.cmd(:systemctl),
+      expect(LinuxAdmin::Common).to receive(:run)
+        .with(LinuxAdmin::Common.cmd(:systemctl),
               :params => {nil => %w(status foo)}).and_return(double(:exit_status => 0))
       @service.running?
     end
 
     it "returns true when service is running" do
-      expect(@service).to receive(:run).and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
       expect(@service).to be_running
     end
 
     it "returns false when service is not running" do
-      expect(@service).to receive(:run).and_return(double(:exit_status => 1))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
       expect(@service).not_to be_running
     end
   end
 
   describe "#enable" do
     it "enables service" do
-      expect(@service).to receive(:run!)
-        .with(@service.cmd(:systemctl),
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:systemctl),
               :params => {nil => %w(enable foo)})
       @service.enable
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!) # stub out cmd invocation
+      expect(LinuxAdmin::Common).to receive(:run!) # stub out cmd invocation
       expect(@service.enable).to eq(@service)
     end
   end
 
   describe "#disable" do
     it "disables service" do
-      expect(@service).to receive(:run!)
-        .with(@service.cmd(:systemctl),
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:systemctl),
               :params => {nil => %w(disable foo)})
       @service.disable
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       expect(@service.disable).to eq(@service)
     end
   end
 
   describe "#start" do
     it "starts service" do
-      expect(@service).to receive(:run!)
-        .with(@service.cmd(:systemctl),
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:systemctl),
               :params => {nil => %w(start foo)})
       @service.start
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       expect(@service.start).to eq(@service)
     end
   end
 
   describe "#stop" do
     it "stops service" do
-      expect(@service).to receive(:run!)
-        .with(@service.cmd(:systemctl),
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:systemctl),
               :params => {nil => %w(stop foo)})
       @service.stop
     end
 
     it "returns self" do
-      expect(@service).to receive(:run!)
+      expect(LinuxAdmin::Common).to receive(:run!)
       expect(@service.stop).to eq(@service)
     end
   end
 
   describe "#restart" do
     it "restarts service" do
-      expect(@service).to receive(:run)
-        .with(@service.cmd(:systemctl),
+      expect(LinuxAdmin::Common).to receive(:run)
+        .with(LinuxAdmin::Common.cmd(:systemctl),
               :params => {nil => %w(restart foo)}).and_return(double(:exit_status => 0))
       @service.restart
     end
 
     it "manually stops then starts service when restart fails" do
-      expect(@service).to receive(:run).and_return(double(:exit_status => 1))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
       expect(@service).to receive(:stop)
       expect(@service).to receive(:start)
       @service.restart
     end
 
     it "returns self" do
-      expect(@service).to receive(:run).and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
       expect(@service.restart).to eq(@service)
     end
   end