linux_admin 0.9.1 → 0.9.2

data/spec/partition_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe LinuxAdmin::Partition do
   before(:each) do
     @disk = LinuxAdmin::Disk.new :path => '/dev/sda'
@@ -8,18 +6,18 @@ describe LinuxAdmin::Partition do
 
   describe "#path" do
     it "returns partition path" do
-      @partition.path.should == '/dev/sda2'
+      expect(@partition.path).to eq('/dev/sda2')
     end
   end
 
   describe "#mount" do
     context "mount_point not specified" do
       it "sets default mount_point" do
-        described_class.should_receive(:mount_point_exists?).and_return(false)
-        File.should_receive(:directory?).with('/mnt/sda2').and_return(true)
-        @partition.should_receive(:run!)
+        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!)
         @partition.mount
-        @partition.mount_point.should == '/mnt/sda2'
+        expect(@partition.mount_point).to eq('/mnt/sda2')
       end
     end
   end

data/spec/physical_volume_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe LinuxAdmin::PhysicalVolume do
   before(:each) do
     @physical_volumes = <<eos
@@ -22,7 +20,7 @@ eos
     it "uses vgextend" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      pv.should_receive(:run!).
+      expect(pv).to receive(:run!).
          with(pv.cmd(:vgextend),
               :params => ['vg', '/dev/hda'])
       pv.attach_to(vg)
@@ -31,77 +29,77 @@ eos
     it "assigns volume group to physical volume" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      pv.stub(:run!)
+      allow(pv).to receive(:run!)
       pv.attach_to(vg)
-      pv.volume_group.should == vg
+      expect(pv.volume_group).to eq(vg)
     end
 
     it "returns self" do
       vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
       pv = described_class.new :device_name => '/dev/hda'
-      pv.stub(:run!)
-      pv.attach_to(vg).should == pv
+      allow(pv).to receive(:run!)
+      expect(pv.attach_to(vg)).to eq(pv)
     end
   end
 
   describe "#create" do
     before do
       @disk = LinuxAdmin::Disk.new :path => '/dev/hda'
-      @disk.stub(:size)
+      allow(@disk).to receive(:size)
     end
 
     let(:disk) {@disk}
 
     it "uses pvcreate" do
       described_class.instance_variable_set(:@pvs, [])
-      described_class.should_receive(:run!).
+      expect(described_class).to receive(:run!).
                                  with(LinuxAdmin.cmd(:pvcreate),
                                       :params => { nil => '/dev/hda'})
       described_class.create disk
     end
 
     it "returns new physical 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 => ""))
       pv = described_class.create disk
-      pv.should be_an_instance_of(described_class)
-      pv.device_name.should == '/dev/hda'
+      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
-      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 => ""))
       pv = described_class.create disk
-      described_class.scan.should include(pv)
+      expect(described_class.scan).to include(pv)
     end
   end
 
   describe "#scan" do
     it "uses pvdisplay" do
-      described_class.should_receive(:run!).
+      expect(described_class).to receive(:run!).
                                  with(LinuxAdmin.cmd(:pvdisplay),
                                      :params => { '-c' => nil}).
                                  and_return(double(:output => @physical_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 physical volumes" do
-      described_class.should_receive(:run!).and_return(double(:output => @physical_volumes))
-      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
+      expect(described_class).to receive(:run!).and_return(double(:output => @physical_volumes))
+      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
       pvs = described_class.scan
 
-      pvs[0].should be_an_instance_of(described_class)
-      pvs[0].device_name.should == '/dev/vda2'
-      pvs[0].size.should == 24139776
+      expect(pvs[0]).to be_an_instance_of(described_class)
+      expect(pvs[0].device_name).to eq('/dev/vda2')
+      expect(pvs[0].size).to eq(24139776)
     end
 
     it "resolves volume group references" do
-      described_class.should_receive(:run!).and_return(double(:output => @physical_volumes))
-      LinuxAdmin::VolumeGroup.should_receive(:run!).and_return(double(:output => @groups))
+      expect(described_class).to receive(:run!).and_return(double(:output => @physical_volumes))
+      expect(LinuxAdmin::VolumeGroup).to receive(:run!).and_return(double(:output => @groups))
       pvs = described_class.scan
-      pvs[0].volume_group.should be_an_instance_of(LinuxAdmin::VolumeGroup)
-      pvs[0].volume_group.name.should == 'vg_foobar'
+      expect(pvs[0].volume_group).to be_an_instance_of(LinuxAdmin::VolumeGroup)
+      expect(pvs[0].volume_group.name).to eq('vg_foobar')
     end
   end
 end

data/spec/registration_system_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe LinuxAdmin::RegistrationSystem do
   context ".registration_type" do
     it "when registered Subscription Manager" do
@@ -18,13 +16,13 @@ describe LinuxAdmin::RegistrationSystem do
     end
 
     it "should memoize results" do
-      described_class.should_receive(:registration_type_uncached).once.and_return("anything_non_nil")
+      expect(described_class).to receive(:registration_type_uncached).once.and_return("anything_non_nil")
       described_class.registration_type
       described_class.registration_type
     end
 
     it "with reload should refresh results" do
-      described_class.should_receive(:registration_type_uncached).twice.and_return("anything_non_nil")
+      expect(described_class).to receive(:registration_type_uncached).twice.and_return("anything_non_nil")
       described_class.registration_type
       described_class.registration_type(true)
     end
@@ -32,7 +30,7 @@ describe LinuxAdmin::RegistrationSystem do
 
   it "#registered? when unregistered" do
     stub_registered_to_system(nil)
-    expect(described_class.registered?).to be_false
+    expect(described_class.registered?).to be_falsey
   end
 
   context ".method_missing" do
@@ -41,7 +39,7 @@ describe LinuxAdmin::RegistrationSystem do
     end
 
     it "exists on the subclass" do
-      expect(LinuxAdmin::RegistrationSystem.registered?).to be_true
+      expect(LinuxAdmin::RegistrationSystem.registered?).to be_truthy
     end
 
     it "does not exist on the subclass" do
@@ -49,12 +47,12 @@ describe LinuxAdmin::RegistrationSystem do
     end
 
     it "is an unknown method" do
-      expect { LinuxAdmin::RegistrationSystem.method_does_not_exist }.to be_true
+      expect { LinuxAdmin::RegistrationSystem.method_does_not_exist }.to raise_error(NoMethodError)
     end
   end
 
   def stub_registered_to_system(*system)
-    LinuxAdmin::SubscriptionManager.any_instance.stub(:registered? => (system.include?(:sm)))
-    LinuxAdmin::Rhn.any_instance.stub(:registered? => (system.include?(:rhn)))
+    allow_any_instance_of(LinuxAdmin::SubscriptionManager).to receive_messages(:registered? => (system.include?(:sm)))
+    allow_any_instance_of(LinuxAdmin::Rhn).to receive_messages(:registered? => (system.include?(:rhn)))
   end
-end
+end

data/spec/rhn_spec.rb

@@ -1,19 +1,17 @@
-require 'spec_helper'
-
 describe LinuxAdmin::Rhn do
   context "#registered?" do
     it "with registered system_id" do
-      described_class.any_instance.stub(:systemid_file => data_file_path("rhn/systemid"))
+      allow_any_instance_of(described_class).to receive_messages(:systemid_file => data_file_path("rhn/systemid"))
       expect(described_class.new).to be_registered
     end
 
     it "with unregistered system_id" do
-      described_class.any_instance.stub(:systemid_file => data_file_path("rhn/systemid.missing_system_id"))
+      allow_any_instance_of(described_class).to receive_messages(:systemid_file => data_file_path("rhn/systemid.missing_system_id"))
       expect(described_class.new).to_not be_registered
     end
 
     it "with missing systemid file" do
-      described_class.any_instance.stub(:systemid_file => data_file_path("rhn/systemid.missing_file"))
+      allow_any_instance_of(described_class).to receive_messages(:systemid_file => data_file_path("rhn/systemid.missing_file"))
       expect(described_class.new).to_not be_registered
     end
   end
@@ -41,25 +39,25 @@ 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")
 
-        described_class.any_instance.should_receive(:run!).once.with("rhnreg_ks", run_params)
-        LinuxAdmin::Rpm.should_receive(:upgrade).with("http://server.url/pub/rhn-org-trusted-ssl-cert-1.0-1.noarch.rpm")
-        LinuxAdmin::Rpm.should_receive(:list_installed).and_return({"rhn-org-trusted-ssl-cert" => "1.0"})
+        expect_any_instance_of(described_class).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"})
 
         described_class.new.register(base_options)
       end
 
       it "without server_url" do
-        described_class.any_instance.should_receive(:run!).once.with("rhnreg_ks", run_params)
-        described_class.any_instance.should_not_receive(:install_server_certificate)
-        LinuxAdmin::Rpm.should_receive(:list_installed).and_return({"rhn-org-trusted-ssl-cert" => nil})
+        expect_any_instance_of(described_class).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})
 
         described_class.new.register(base_options)
       end
     end
 
     it "with activation key" do
-      described_class.any_instance.should_receive(:run!).once.with("rhnreg_ks", {:params=>{"--activationkey="=>"123abc", "--proxy="=>"1.2.3.4", "--proxyUser="=>"ProxyUser", "--proxyPassword="=>"ProxyPass"}})
-      LinuxAdmin::Rpm.should_receive(:list_installed).and_return({"rhn-org-trusted-ssl-cert" => nil})
+      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::Rpm).to receive(:list_installed).and_return({"rhn-org-trusted-ssl-cert" => nil})
 
       described_class.new.register(
         :activationkey  => "123abc",
@@ -71,19 +69,19 @@ describe LinuxAdmin::Rhn do
   end
 
   it "#enable_channel" do
-    described_class.any_instance.should_receive(:run!).once.with("rhn-channel -a", {:params=>{"--user="=>"SomeUser", "--password="=>"SomePass", "--channel="=>123}})
+    expect_any_instance_of(described_class).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
-    described_class.any_instance.should_receive(:run!).once.with("rhn-channel -l").and_return(double(:output => sample_output("rhn/output_rhn-channel_list")))
+    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(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
-    described_class.any_instance.should_receive(:run!).once.with("rhn-channel -r", {:params=>{"--user="=>"SomeUser", "--password="=>"SomePass", "--channel="=>123}})
+    expect_any_instance_of(described_class).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
@@ -107,7 +105,7 @@ describe LinuxAdmin::Rhn do
       }
     }
 
-    described_class.any_instance.should_receive(:run!).once.with(cmd, params).and_return(double(:output => sample_output("rhn/output_rhn-channel_list_available")))
+    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(described_class.new.available_channels(credentials)).to eq(expected)
   end
@@ -125,8 +123,8 @@ describe LinuxAdmin::Rhn do
       {:repo_id => "rhel-x86_64-server-6",              :enabled => true}
     ]
 
-    described_class.any_instance.should_receive(:run!).once.and_return(double(:output => sample_output("rhn/output_rhn-channel_list_available")))
-    described_class.any_instance.should_receive(:run!).once.with("rhn-channel -l").and_return(double(:output => sample_output("rhn/output_rhn-channel_list")))
+    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(described_class.new.all_repos(credentials)).to eq(expected)
   end

data/spec/rpm_spec.rb

@@ -1,8 +1,6 @@
-require 'spec_helper'
-
 describe LinuxAdmin::Rpm do
   it ".list_installed" do
-    described_class.stub(:run! => double(:output => sample_output("rpm/cmd_output_for_list_installed")))
+    allow(described_class).to receive_messages(:run! => 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",
@@ -28,7 +26,7 @@ describe LinuxAdmin::Rpm do
   end
 
   it ".import_key" do
-    described_class.should_receive(:run!).with("rpm", {:params => {"--import" => "abc"}})
+    expect(described_class).to receive(:run!).with("rpm", {:params => {"--import" => "abc"}})
     expect { described_class.import_key("abc") }.to_not raise_error
   end
 
@@ -61,25 +59,25 @@ straight-forward, and extensible.
 EOS
       arguments = [described_class.rpm_cmd, :params => {"-qi" => "ruby"}]
       result = AwesomeSpawn::CommandResult.new("", data, "", 0)
-      described_class.should_receive(:run!).with(*arguments).and_return(result)
+      expect(described_class).to receive(:run!).with(*arguments).and_return(result)
       metadata = described_class.info("ruby")
-      metadata['name'].should == 'ruby'
-      metadata['version'].should == '2.0.0.247'
-      metadata['release'].should == '15.fc19'
-      metadata['architecture'].should == 'x86_64'
-      metadata['group'].should == 'Development/Languages'
-      metadata['size'].should == '64473'
-      metadata['license'].should == '(Ruby or BSD) and Public Domain'
-      metadata['source_rpm'].should == 'ruby-2.0.0.247-15.fc19.src.rpm'
-      metadata['build_host'].should == 'buildvm-16.phx2.fedoraproject.org'
-      metadata['packager'].should == 'Fedora Project'
-      metadata['vendor'].should == 'Fedora Project'
-      metadata['summary'].should == 'An interpreter of object-oriented scripting language'
+      expect(metadata['name']).to eq('ruby')
+      expect(metadata['version']).to eq('2.0.0.247')
+      expect(metadata['release']).to eq('15.fc19')
+      expect(metadata['architecture']).to eq('x86_64')
+      expect(metadata['group']).to eq('Development/Languages')
+      expect(metadata['size']).to eq('64473')
+      expect(metadata['license']).to eq('(Ruby or BSD) and Public Domain')
+      expect(metadata['source_rpm']).to eq('ruby-2.0.0.247-15.fc19.src.rpm')
+      expect(metadata['build_host']).to eq('buildvm-16.phx2.fedoraproject.org')
+      expect(metadata['packager']).to eq('Fedora Project')
+      expect(metadata['vendor']).to eq('Fedora Project')
+      expect(metadata['summary']).to eq('An interpreter of object-oriented scripting language')
     end
   end
 
   it ".upgrade" do
-    described_class.should_receive(:run).with("rpm -U", {:params=>{nil=>"abc"}}).and_return(double(:exit_status => 0))
-    expect(described_class.upgrade("abc")).to be_true
+    expect(described_class).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_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe LinuxAdmin::Service do
   before(:each) do
     @service = LinuxAdmin::Service.new 'foo'
@@ -7,7 +5,7 @@ describe LinuxAdmin::Service do
 
   describe "#running?" do
     it "checks service" do
-      @service.should_receive(:run).
+      expect(@service).to receive(:run).
          with(@service.cmd(:service),
               :params => { nil => ['foo', 'status']}).and_return(double(:exit_status => 0))
       @service.running?
@@ -16,79 +14,79 @@ describe LinuxAdmin::Service do
     context "service is running" do
       it "returns true" do
         @service = LinuxAdmin::Service.new :id => :foo
-        @service.should_receive(:run).and_return(double(:exit_status => 0))
-        @service.should be_running
+        expect(@service).to receive(:run).and_return(double(:exit_status => 0))
+        expect(@service).to be_running
      end
     end
 
     context "service is not running" do
       it "returns false" do
         @service = LinuxAdmin::Service.new :id => :foo
-        @service.should_receive(:run).and_return(double(:exit_status => 1))
-        @service.should_not be_running
+        expect(@service).to receive(:run).and_return(double(:exit_status => 1))
+        expect(@service).not_to be_running
       end
     end
   end
 
   describe "#enable" do
     it "enables service" do
-      @service.should_receive(:run!).
+      expect(@service).to receive(:run!).
          with(@service.cmd(:chkconfig),
               :params => { nil => [ 'foo', 'on']})
       @service.enable
     end
 
     it "returns self" do
-      @service.should_receive(:run!) # stub out cmd invocation
-      @service.enable.should == @service
+      expect(@service).to receive(:run!) # stub out cmd invocation
+      expect(@service.enable).to eq(@service)
     end
   end
 
   describe "#disable" do
     it "disable service" do
-      @service.should_receive(:run!).
+      expect(@service).to receive(:run!).
          with(@service.cmd(:chkconfig),
               :params => { nil => [ 'foo', 'off']})
       @service.disable
     end
 
     it "returns self" do
-      @service.should_receive(:run!)
-      @service.disable.should == @service
+      expect(@service).to receive(:run!)
+      expect(@service.disable).to eq(@service)
     end
   end
 
   describe "#start" do
     it "starts service" do
-      @service.should_receive(:run!).
+      expect(@service).to receive(:run!).
          with(@service.cmd(:service),
               :params => { nil => [ 'foo', 'start']})
       @service.start
     end
 
     it "returns self" do
-      @service.should_receive(:run!)
-      @service.start.should == @service
+      expect(@service).to receive(:run!)
+      expect(@service.start).to eq(@service)
     end
   end
 
   describe "#stop" do
     it "stops service" do
-      @service.should_receive(:run!).
+      expect(@service).to receive(:run!).
          with(@service.cmd(:service),
               :params => { nil => [ 'foo', 'stop']})
       @service.stop
     end
 
     it "returns self" do
-      @service.should_receive(:run!)
-      @service.stop.should == @service
+      expect(@service).to receive(:run!)
+      expect(@service.stop).to eq(@service)
     end
   end
 
   describe "#restart" do
     it "stops service" do
-      @service.should_receive(:run).
+      expect(@service).to receive(:run).
          with(@service.cmd(:service),
               :params => { nil => [ 'foo', 'restart']}).and_return(double(:exit_status => 0))
       @service.restart
@@ -96,16 +94,16 @@ describe LinuxAdmin::Service do
 
     context "service restart fails" do
       it "manually stops/starts service" do
-        @service.should_receive(:run).and_return(double(:exit_status => 1))
-        @service.should_receive(:stop)
-        @service.should_receive(:start)
+        expect(@service).to receive(:run).and_return(double(:exit_status => 1))
+        expect(@service).to receive(:stop)
+        expect(@service).to receive(:start)
         @service.restart
       end
     end
 
     it "returns self" do
-      @service.should_receive(:run).and_return(double(:exit_status => 0))
-      @service.restart.should == @service
+      expect(@service).to receive(:run).and_return(double(:exit_status => 0))
+      expect(@service.restart).to eq(@service)
     end
   end