linux_admin 0.14.0 → 0.15.0

data/spec/service_spec.rb

@@ -49,6 +49,6 @@ describe LinuxAdmin::Service do
   end
 
   def stub_to_service_type(system)
-    allow(LinuxAdmin::Service).to receive(:cmd?).with(:systemctl).and_return(system == :systemd_service)
+    allow(LinuxAdmin::Common).to receive(:cmd?).with(:systemctl).and_return(system == :systemd_service)
   end
 end

data/spec/subscription_manager_spec.rb

@@ -1,18 +1,20 @@
 describe LinuxAdmin::SubscriptionManager do
   context "#registered?" do
     it "system with subscription-manager commands" do
-      expect_any_instance_of(described_class).to receive(:run).once.with("subscription-manager identity").and_return(double(:exit_status => 0))
+      expect(LinuxAdmin::Common).to receive(:run).once.with("subscription-manager identity")
+        .and_return(double(:exit_status => 0))
       expect(described_class.new.registered?).to be_truthy
     end
 
     it "system without subscription-manager commands" do
-      expect_any_instance_of(described_class).to receive(:run).once.with("subscription-manager identity").and_return(double(:exit_status => 255))
+      expect(LinuxAdmin::Common).to receive(:run).once.with("subscription-manager identity")
+        .and_return(double(:exit_status => 255))
       expect(described_class.new.registered?).to be_falsey
     end
   end
 
   it "#refresh" do
-    expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager refresh")
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager refresh", {})
     described_class.new.refresh
   end
 
@@ -37,14 +39,14 @@ describe LinuxAdmin::SubscriptionManager do
         run_params.store_path(:params, "--org=", "IT")
         base_options.store_path(:server_url, "https://server.url")
 
-        expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager register", run_params)
+        expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager register", run_params)
         expect(LinuxAdmin::Rpm).to receive(:upgrade).with("http://server.url/pub/katello-ca-consumer-latest.noarch.rpm")
 
         described_class.new.register(base_options)
       end
 
       it "without server_url" do
-        expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager register", run_params)
+        expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager register", run_params)
         expect_any_instance_of(described_class).not_to receive(:install_server_certificate)
 
         described_class.new.register(base_options)
@@ -54,30 +56,35 @@ describe LinuxAdmin::SubscriptionManager do
 
   context "#subscribe" do
     it "with pools" do
-      expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager attach", {:params=>[["--pool", 123], ["--pool", 456]]})
+      expect(LinuxAdmin::Common).to receive(:run!).once
+        .with("subscription-manager attach", :params => [["--pool", 123], ["--pool", 456]])
       described_class.new.subscribe({:pools => [123, 456]})
     end
 
     it "without pools" do
-      expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager attach", {:params=>{"--auto"=>nil}})
+      expect(LinuxAdmin::Common).to receive(:run!).once
+        .with("subscription-manager attach", :params => {"--auto" => nil})
       described_class.new.subscribe({})
     end
   end
 
   context "#subscribed_products" do
     it "subscribed" do
-      expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager list --installed").and_return(double(:output => sample_output("subscription_manager/output_list_installed_subscribed")))
+      expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager list --installed", {})
+        .and_return(double(:output => sample_output("subscription_manager/output_list_installed_subscribed")))
       expect(described_class.new.subscribed_products).to eq(["69", "167"])
     end
 
     it "not subscribed" do
-      expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager list --installed").and_return(double(:output => sample_output("subscription_manager/output_list_installed_not_subscribed")))
+      expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager list --installed", {})
+        .and_return(double(:output => sample_output("subscription_manager/output_list_installed_not_subscribed")))
       expect(described_class.new.subscribed_products).to eq(["167"])
     end
   end
 
   it "#available_subscriptions" do
-    expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager list --all --available").and_return(double(:output => sample_output("subscription_manager/output_list_all_available")))
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager list --all --available", {})
+      .and_return(double(:output => sample_output("subscription_manager/output_list_all_available")))
     expect(described_class.new.available_subscriptions).to eq({
       "82c042fca983889b10178893f29b06e3" => {
         :subscription_name => "Example Subscription",
@@ -131,7 +138,8 @@ describe LinuxAdmin::SubscriptionManager do
       run_options = ["subscription-manager orgs", {:params=>{"--username="=>"SomeUser", "--password="=>"SomePass", "--proxy="=>"1.2.3.4", "--proxyuser="=>"ProxyUser", "--proxypassword="=>"ProxyPass"}}]
 
       expect(LinuxAdmin::Rpm).to receive(:upgrade).with("http://192.168.1.1/pub/katello-ca-consumer-latest.noarch.rpm")
-      expect_any_instance_of(described_class).to receive(:run!).once.with(*run_options).and_return(double(:output => sample_output("subscription_manager/output_orgs")))
+      expect(LinuxAdmin::Common).to receive(:run!).once.with(*run_options)
+        .and_return(double(:output => sample_output("subscription_manager/output_orgs")))
 
       expect(described_class.new.organizations({:username=>"SomeUser", :password=>"SomePass", :proxy_address=>"1.2.3.4", :proxy_username=>"ProxyUser", :proxy_password=>"ProxyPass", :server_url=>"192.168.1.1"})).to eq({"SomeOrg"=>{:name=>"SomeOrg", :key=>"1234567"}})
     end
@@ -150,13 +158,15 @@ describe LinuxAdmin::SubscriptionManager do
   end
 
   it "#enable_repo" do
-    expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager repos", {:params=>{"--enable="=>"abc"}})
+    expect(LinuxAdmin::Common).to receive(:run!).once
+      .with("subscription-manager repos", :params => {"--enable=" => "abc"})
 
     described_class.new.enable_repo("abc")
   end
 
   it "#disable_repo" do
-    expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager repos", {:params=>{"--disable="=>"abc"}})
+    expect(LinuxAdmin::Common).to receive(:run!).once
+      .with("subscription-manager repos", :params => {"--disable=" => "abc"})
 
     described_class.new.disable_repo("abc")
   end
@@ -183,7 +193,8 @@ describe LinuxAdmin::SubscriptionManager do
       }
     ]
 
-    expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager repos").and_return(double(:output => sample_output("subscription_manager/output_repos")))
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager repos", {})
+      .and_return(double(:output => sample_output("subscription_manager/output_repos")))
 
     expect(described_class.new.all_repos).to eq(expected)
   end
@@ -191,7 +202,8 @@ describe LinuxAdmin::SubscriptionManager do
   it "#enabled_repos" do
     expected = ["some-repo-source-rpms", "some-repo-rpms"]
 
-    expect_any_instance_of(described_class).to receive(:run!).once.with("subscription-manager repos").and_return(double(:output => sample_output("subscription_manager/output_repos")))
+    expect(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager repos", {})
+      .and_return(double(:output => sample_output("subscription_manager/output_repos")))
 
     expect(described_class.new.enabled_repos).to eq(expected)
   end

data/spec/system_spec.rb

@@ -1,18 +1,14 @@
 describe LinuxAdmin::System do
   describe "#reboot!" do
     it "reboots the system" do
-      expect(LinuxAdmin::System).to receive(:run!).
-         with(LinuxAdmin::System.cmd(:shutdown),
-              :params => { '-r' => 'now'})
+      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:shutdown), :params => {'-r' => 'now'})
       LinuxAdmin::System.reboot!
     end
   end
 
   describe "#shutdown!" do
     it "shuts down the system" do
-      expect(LinuxAdmin::System).to receive(:run!).
-         with(LinuxAdmin::System.cmd(:shutdown),
-              :params => { '-h' => '0'})
+      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:shutdown), :params => {'-h' => '0'})
       LinuxAdmin::System.shutdown!
     end
   end

data/spec/time_date_spec.rb

@@ -1,5 +1,5 @@
 describe LinuxAdmin::TimeDate do
-  RUN_COMMAND = described_class.cmd("timedatectl")
+  RUN_COMMAND = LinuxAdmin::Common.cmd("timedatectl")
 
   def timedatectl_result
     output = File.read(Pathname.new(data_file_path("time_date/timedatectl_output")))

data/spec/volume_group_spec.rb

@@ -16,16 +16,15 @@ eos
     it "uses lvextend" do
       vg = described_class.new :name => 'vg'
       lv = LinuxAdmin::LogicalVolume.new :name => 'lv', :volume_group => vg
-      expect(vg).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))
       vg.attach_to(lv)
     end
 
     it "returns self" do
       vg = described_class.new :name => 'vg'
       lv = LinuxAdmin::LogicalVolume.new :name => 'lv', :volume_group => vg
-      allow(vg).to receive(:run!)
+      allow(LinuxAdmin::Common).to receive(:run!)
       expect(vg.attach_to(lv)).to eq(vg)
     end
   end
@@ -34,16 +33,15 @@ eos
     it "uses vgextend" do
       vg = described_class.new :name => 'vg'
       pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-      expect(vg).to receive(:run!).
-         with(vg.cmd(:vgextend),
-              :params => ['vg', '/dev/hda'])
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:vgextend), :params => ['vg', '/dev/hda'])
       vg.extend_with(pv)
     end
 
     it "assigns volume group to physical volume" do
       vg = described_class.new :name => 'vg'
       pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-      allow(vg).to receive(:run!)
+      allow(LinuxAdmin::Common).to receive(:run!)
       vg.extend_with(pv)
       expect(pv.volume_group).to eq(vg)
     end
@@ -51,7 +49,7 @@ eos
     it "returns self" do
       vg = described_class.new :name => 'vg'
       pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-      allow(vg).to receive(:run!)
+      allow(LinuxAdmin::Common).to receive(:run!)
       expect(vg.extend_with(pv)).to eq(vg)
     end
   end
@@ -63,21 +61,20 @@ eos
 
     it "uses vgcreate" do
       described_class.instance_variable_set(:@vgs, [])
-      expect(described_class).to receive(:run!).
-                              with(LinuxAdmin.cmd(:vgcreate),
-                                   :params => ['vg', '/dev/hda'])
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:vgcreate), :params => ['vg', '/dev/hda'])
       described_class.create 'vg', @pv
     end
 
     it "returns new volume group" do
-      allow(described_class).to receive_messages(:run! => double(:output => ""))
+      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
       vg = described_class.create 'vg', @pv
       expect(vg).to be_an_instance_of(described_class)
       expect(vg.name).to eq('vg')
     end
 
     it "adds volume group to local registry" do
-      allow(described_class).to receive_messages(:run! => double(:output => ""))
+      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
       vg = described_class.create 'vg', @pv
       expect(described_class.scan).to include(vg)
     end
@@ -85,15 +82,14 @@ eos
 
   describe "#scan" do
     it "uses vgdisplay" do
-      expect(described_class).to receive(:run!).
-                              with(LinuxAdmin.cmd(:vgdisplay),
-                                   :params => { '-c' => nil}).
-                                 and_return(double(:output => @groups))
+      expect(LinuxAdmin::Common).to receive(:run!)
+        .with(LinuxAdmin::Common.cmd(:vgdisplay), :params => {'-c' => nil})
+        .and_return(double(:output => @groups))
       described_class.scan
     end
 
     it "returns local volume groups" do
-      expect(described_class).to receive(:run!).and_return(double(:output => @groups))
+      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups))
       vgs = described_class.scan
 
       expect(vgs[0]).to be_an_instance_of(described_class)

data/spec/yum_spec.rb

@@ -5,19 +5,21 @@ describe LinuxAdmin::Yum do
 
   context ".create_repo" do
     it "default arguments" do
-      expect(described_class).to receive(:run!).once.with("createrepo", {:params=>{nil=>"some/path", "--database"=>nil, "--unique-md-filenames"=>nil}})
+      expect(LinuxAdmin::Common).to receive(:run!).once
+        .with("createrepo", :params => {nil => "some/path", "--database" => nil, "--unique-md-filenames" => nil})
       described_class.create_repo("some/path")
     end
 
     it "bare create" do
-      expect(described_class).to receive(:run!).once.with("createrepo", {:params=>{nil=>"some/path"}})
+      expect(LinuxAdmin::Common).to receive(:run!).once.with("createrepo", :params => {nil => "some/path"})
       described_class.create_repo("some/path", :database => false, :unique_file_names => false)
     end
   end
 
   context ".download_packages" do
     it "with valid input" do
-      expect(described_class).to receive(:run!).once.with("repotrack", {:params=>{"-p"=>"some/path", nil=>"pkg_a pkg_b"}})
+      expect(LinuxAdmin::Common).to receive(:run!).once
+        .with("repotrack", :params => {"-p" => "some/path", nil => "pkg_a pkg_b"})
       described_class.download_packages("some/path", "pkg_a pkg_b")
     end
 
@@ -66,45 +68,49 @@ describe LinuxAdmin::Yum do
 
   context ".updates_available?" do
     it "check updates for a specific package" do
-      expect(described_class).to receive(:run).once.with("yum check-update", {:params=>{nil=>["abc"]}}).and_return(double(:exit_status => 100))
+      expect(LinuxAdmin::Common).to receive(:run).once.with("yum check-update", :params => {nil => ["abc"]})
+        .and_return(double(:exit_status => 100))
       expect(described_class.updates_available?("abc")).to be_truthy
     end
 
     it "updates are available" do
-      allow(described_class).to receive_messages(:run => double(:exit_status => 100))
+      allow(LinuxAdmin::Common).to receive_messages(:run => double(:exit_status => 100))
       expect(described_class.updates_available?).to be_truthy
     end
 
     it "updates not available" do
-      allow(described_class).to receive_messages(:run => double(:exit_status => 0))
+      allow(LinuxAdmin::Common).to receive_messages(:run => double(:exit_status => 0))
       expect(described_class.updates_available?).to be_falsey
     end
 
     it "other exit code" do
-      allow(described_class).to receive_messages(:run => double(:exit_status => 255))
+      allow(LinuxAdmin::Common).to receive_messages(:run => double(:exit_status => 255))
       expect { described_class.updates_available? }.to raise_error(RuntimeError)
     end
 
     it "other error" do
-      allow(described_class).to receive(:run).and_raise(RuntimeError)
+      allow(LinuxAdmin::Common).to receive(:run).and_raise(RuntimeError)
       expect { described_class.updates_available? }.to raise_error(RuntimeError)
     end
   end
 
   context ".update" do
     it "no arguments" do
-      expect(described_class).to receive(:run!).once.with("yum -y update", :params => nil).and_return(AwesomeSpawn::CommandResult.new("", "", "", 0))
+      expect(LinuxAdmin::Common).to receive(:run!).once.with("yum -y update", :params => nil)
+        .and_return(AwesomeSpawn::CommandResult.new("", "", "", 0))
       described_class.update
     end
 
     it "with arguments" do
-      expect(described_class).to receive(:run!).once.with("yum -y update", :params => {nil => ["1 2", "3"]}).and_return(AwesomeSpawn::CommandResult.new("", "", "", 0))
+      expect(LinuxAdmin::Common).to receive(:run!).once.with("yum -y update", :params => {nil => ["1 2", "3"]})
+        .and_return(AwesomeSpawn::CommandResult.new("", "", "", 0))
       described_class.update("1 2", "3")
     end
 
     it "with bad arguments" do
       error = AwesomeSpawn::CommandResult.new("", "Loaded plugins: product-id\nNo Packages marked for Update\n", "Blah blah ...\nNo Match for argument: \n", 0)
-      expect(described_class).to receive(:run!).once.with("yum -y update", :params => {nil => [""]}).and_return(error)
+      expect(LinuxAdmin::Common).to receive(:run!).once
+        .with("yum -y update", :params => {nil => [""]}).and_return(error)
       expect { described_class.update("") }.to raise_error(AwesomeSpawn::CommandResultError)
     end
   end
@@ -115,12 +121,16 @@ describe LinuxAdmin::Yum do
     end
 
     it "with one package" do
-      expect(described_class).to receive(:run!).once.with("repoquery --qf=\"%{name} %{version}\"", {:params=>{nil=>["subscription-manager"]}}).and_return(double(:output => sample_output("yum/output_repoquery_single")))
+      expect(LinuxAdmin::Common).to receive(:run!).once
+        .with("repoquery --qf=\"%{name} %{version}\"", :params => {nil => ["subscription-manager"]})
+        .and_return(double(:output => sample_output("yum/output_repoquery_single")))
       expect(described_class.version_available("subscription-manager")).to eq({"subscription-manager" => "1.1.23.1"})
     end
 
     it "with multiple packages" do
-      expect(described_class).to receive(:run!).once.with("repoquery --qf=\"%{name} %{version}\"", {:params=>{nil=>["curl", "subscription-manager", "wget"]}}).and_return(double(:output => sample_output("yum/output_repoquery_multiple")))
+      expect(LinuxAdmin::Common).to receive(:run!).once
+        .with("repoquery --qf=\"%{name} %{version}\"", :params => {nil => ["curl", "subscription-manager", "wget"]})
+        .and_return(double(:output => sample_output("yum/output_repoquery_multiple")))
       expect(described_class.version_available("curl", "subscription-manager", "wget")).to eq({
         "curl"                  => "7.19.7",
         "subscription-manager"  => "1.1.23.1",
@@ -131,12 +141,14 @@ describe LinuxAdmin::Yum do
 
   context ".repo_list" do
     it "with no arguments" do
-      expect(described_class).to receive(:run!).with("yum repolist", {:params=>{nil=>"enabled"}}).and_return(double(:output => sample_output("yum/output_repo_list")))
+      expect(LinuxAdmin::Common).to receive(:run!).with("yum repolist", :params => {nil => "enabled"})
+        .and_return(double(:output => sample_output("yum/output_repo_list")))
       expect(described_class.repo_list).to eq(["rhel-6-server-rpms", "rhel-ha-for-rhel-6-server-rpms", "rhel-lb-for-rhel-6-server-rpms"])
     end
 
     it "with argument" do
-      expect(described_class).to receive(:run!).with("yum repolist", {:params=>{nil=>"enabled"}}).and_return(double(:output => sample_output("yum/output_repo_list")))
+      expect(LinuxAdmin::Common).to receive(:run!).with("yum repolist", :params => {nil => "enabled"})
+        .and_return(double(:output => sample_output("yum/output_repo_list")))
       expect(described_class.repo_list("enabled")).to eq(["rhel-6-server-rpms", "rhel-ha-for-rhel-6-server-rpms", "rhel-lb-for-rhel-6-server-rpms"])
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: linux_admin
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Brandon Dunne
@@ -11,10 +11,11 @@ authors:
 - Keenan Brock
 - Thomas Wiest
 - Nick Carboni
+- Martin Hradil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-15 00:00:00.000000000 Z
+date: 2016-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,14 +107,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: awesome_spawn
   requirement: !ruby/object:Gem::Requirement
@@ -166,9 +167,10 @@ email:
 - fryguy9@gmail.com
 - mmorsi@redhat.com
 - jrafanie@redhat.com
-- kbrock@redhat.com
+- keenan@thebrocks.net
 - twiest@redhat.com
 - ncarboni@redhat.com
+- mhradil@redhat.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -282,7 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: LinuxAdmin is a module to simplify management of linux systems.