linux_admin 1.2.4 → 2.0.0

data/spec/subscription_manager_spec.rb

@@ -1,228 +0,0 @@
-describe LinuxAdmin::SubscriptionManager do
-  context "#run!" do
-    it "raises a CredentialError if the error message contained a credential error" do
-      result = AwesomeSpawn::CommandResult.new("stuff", "things", "invalid username or password", 1)
-      err = AwesomeSpawn::CommandResultError.new("things", result)
-      expect(LinuxAdmin::Common).to receive(:run!).and_raise(err)
-
-      expect { subject.run!("stuff") }.to raise_error(LinuxAdmin::CredentialError)
-    end
-
-    it "raises a SubscriptionManagerError if the error message does not contain a credential error" do
-      result = AwesomeSpawn::CommandResult.new("stuff", "things", "not a credential error", 1)
-      err = AwesomeSpawn::CommandResultError.new("things", result)
-      expect(LinuxAdmin::Common).to receive(:run!).and_raise(err)
-
-      expect { subject.run!("stuff") }.to raise_error(LinuxAdmin::SubscriptionManagerError)
-    end
-  end
-
-  context "#registered?" do
-    it "system with subscription-manager commands" do
-      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(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(LinuxAdmin::Common).to receive(:run!).once.with("subscription-manager refresh", {})
-    described_class.new.refresh
-  end
-
-  context "#register" do
-    it "no username" do
-      expect { described_class.new.register }.to raise_error(ArgumentError)
-    end
-
-    context "with username and password" do
-      let(:base_options) { {:username       => "SomeUser@SomeDomain.org",
-                            :password       => "SomePass",
-                            :environment    => "Library",
-                            :org            => "IT",
-                            :proxy_address  => "1.2.3.4",
-                            :proxy_username => "ProxyUser",
-                            :proxy_password => "ProxyPass",
-                          }
-                        }
-      let(:run_params) { {:params=>{"--username="=>"SomeUser@SomeDomain.org", "--password="=>"SomePass", "--proxy="=>"1.2.3.4", "--proxyuser="=>"ProxyUser", "--proxypassword="=>"ProxyPass", "--environment="=>"Library"}} }
-
-      it "with server_url" do
-        run_params.store_path(:params, "--org=", "IT")
-        base_options.store_path(:server_url, "https://server.url")
-
-        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(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)
-      end
-    end
-  end
-
-  context "#subscribe" do
-    it "with pools" do
-      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(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(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(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(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",
-        :sku               => "SER0123",
-        :pool_id           => "82c042fca983889b10178893f29b06e3",
-        :quantity          => "1690",
-        :service_level     => "None",
-        :service_type      => "None",
-        :multi_entitlement => "No",
-        :ends              => Date.parse("2022-01-01"),
-        :system_type       => "Physical",
-      },
-      "4f738052ec866192c775c62f408ab868" => {
-        :subscription_name => "My Private Subscription",
-        :sku               => "SER9876",
-        :pool_id           => "4f738052ec866192c775c62f408ab868",
-        :quantity          => "Unlimited",
-        :service_level     => "None",
-        :service_type      => "None",
-        :multi_entitlement => "No",
-        :ends              => Date.parse("2013-06-04"),
-        :system_type       => "Virtual",
-      },
-      "3d81297f352305b9a3521981029d7d83" => {
-        :subscription_name => "Shared Subscription - With other characters, (2 sockets) (Up to 1 guest)",
-        :sku               => "RH0123456",
-        :pool_id           => "3d81297f352305b9a3521981029d7d83",
-        :quantity          => "1",
-        :service_level     => "Self-support",
-        :service_type      => "L1-L3",
-        :multi_entitlement => "No",
-        :ends              => Date.parse("2013-05-15"),
-        :system_type       => "Virtual",
-      },
-      "87cefe63b67984d5c7e401d833d2f87f" => {
-        :subscription_name => "Example Subscription, Premium (up to 2 sockets) 3 year",
-        :sku               => "MCT0123A9",
-        :pool_id           => "87cefe63b67984d5c7e401d833d2f87f",
-        :quantity          => "1",
-        :service_level     => "Premium",
-        :service_type      => "L1-L3",
-        :multi_entitlement => "No",
-        :ends              => Date.parse("2013-07-05"),
-        :system_type       => "Virtual",
-      },
-    })
-  end
-
-  context "#organizations" do
-    it "with valid credentials" 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(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
-
-    it "with invalid credentials" do
-      run_options = ["subscription-manager orgs", {:params=>{"--username="=>"BadUser", "--password="=>"BadPass"}}]
-      error = AwesomeSpawn::CommandResultError.new("",
-        double(
-          :error       => "Invalid username or password. To create a login, please visit https://www.redhat.com/wapps/ugc/register.html",
-          :exit_status => 255
-        )
-      )
-      expect(AwesomeSpawn).to receive(:run!).once.with(*run_options).and_raise(error)
-      expect { described_class.new.organizations({:username=>"BadUser", :password=>"BadPass"}) }.to raise_error(LinuxAdmin::CredentialError)
-    end
-  end
-
-  it "#enable_repo" do
-    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(LinuxAdmin::Common).to receive(:run!).once
-      .with("subscription-manager repos", :params => {"--disable=" => "abc"})
-
-    described_class.new.disable_repo("abc")
-  end
-
-  it "#all_repos" do
-    expected = [
-      {
-        :repo_id   => "some-repo-source-rpms",
-        :repo_name => "Some Repo (Source RPMs)",
-        :repo_url  => "https://my.host.example.com/repos/some-repo/source/rpms",
-        :enabled   => true
-      },
-      {
-        :repo_id   => "some-repo-rpms",
-        :repo_name => "Some Repo",
-        :repo_url  => "https://my.host.example.com/repos/some-repo/rpms",
-        :enabled   => true
-      },
-      {
-        :repo_id   => "some-repo-2-beta-rpms",
-        :repo_name => "Some Repo (Beta RPMs)",
-        :repo_url  => "https://my.host.example.com/repos/some-repo-2/beta/rpms",
-        :enabled   => false
-      }
-    ]
-
-    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
-
-  it "#enabled_repos" do
-    expected = ["some-repo-source-rpms", "some-repo-rpms"]
-
-    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
-end

data/spec/system_spec.rb

@@ -1,15 +0,0 @@
-describe LinuxAdmin::System do
-  describe "#reboot!" do
-    it "reboots the system" do
-      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::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:shutdown), :params => {'-h' => '0'})
-      LinuxAdmin::System.shutdown!
-    end
-  end
-end

data/spec/time_date_spec.rb

@@ -1,106 +0,0 @@
-describe LinuxAdmin::TimeDate do
-  RUN_COMMAND = LinuxAdmin::Common.cmd("timedatectl")
-
-  def timedatectl_result
-    output = File.read(Pathname.new(data_file_path("time_date/timedatectl_output")))
-    AwesomeSpawn::CommandResult.new("", output, "", 0)
-  end
-
-  describe ".system_timezone_detailed" do
-    it "returns the correct timezone" do
-      awesome_spawn_args = [
-        RUN_COMMAND,
-        :params => ["status"]
-      ]
-      expect(AwesomeSpawn).to receive(:run).with(*awesome_spawn_args).and_return(timedatectl_result)
-      tz = described_class.system_timezone_detailed
-      expect(tz).to eq("America/New_York (EDT, -0400)")
-    end
-  end
-
-  describe ".system_timezone" do
-    it "returns the correct timezone" do
-      awesome_spawn_args = [
-        RUN_COMMAND,
-        :params => ["status"]
-      ]
-      expect(AwesomeSpawn).to receive(:run).with(*awesome_spawn_args).and_return(timedatectl_result)
-      tz = described_class.system_timezone
-      expect(tz).to eq("America/New_York")
-    end
-  end
-
-  describe ".timezones" do
-    let(:timezones) do
-      <<-EOS
-Africa/Bangui
-Africa/Banjul
-Africa/Bissau
-Africa/Blantyre
-Africa/Brazzaville
-Africa/Bujumbura
-Africa/Cairo
-America/Havana
-America/Hermosillo
-America/Indiana/Indianapolis
-America/Indiana/Knox
-America/Argentina/San_Juan
-America/Argentina/San_Luis
-America/Argentina/Tucuman
-America/Argentina/Ushuaia
-      EOS
-    end
-
-    it "returns the correct list" do
-      awesome_spawn_args = [
-        RUN_COMMAND,
-        :params => ["list-timezones"]
-      ]
-      result = AwesomeSpawn::CommandResult.new("", timezones, "", 0)
-      expect(AwesomeSpawn).to receive(:run!).with(*awesome_spawn_args).and_return(result)
-      expect(described_class.timezones).to eq(timezones.split("\n"))
-    end
-  end
-
-  describe ".system_time=" do
-    it "sets the time" do
-      time = Time.new(2015, 1, 1, 1, 1, 1)
-      awesome_spawn_args = [
-        RUN_COMMAND,
-        :params => ["set-time", "2015-01-01 01:01:01", :adjust_system_clock]
-      ]
-      expect(AwesomeSpawn).to receive(:run!).with(*awesome_spawn_args)
-      described_class.system_time = time
-    end
-
-    it "raises when the command fails" do
-      time = Time.new(2015, 1, 1, 1, 1, 1)
-      err = AwesomeSpawn::CommandResultError.new("message", nil)
-      allow(AwesomeSpawn).to receive(:run!).and_raise(err)
-      expect do
-        described_class.send(:system_time=, time)
-      end.to raise_error(described_class::TimeCommandError, "message")
-    end
-  end
-
-  describe ".system_timezone=" do
-    it "sets the timezone" do
-      zone = "Location/City"
-      awesome_spawn_args = [
-        RUN_COMMAND,
-        :params => ["set-timezone", zone]
-      ]
-      expect(AwesomeSpawn).to receive(:run!).with(*awesome_spawn_args)
-      described_class.system_timezone = zone
-    end
-
-    it "raises when the command fails" do
-      zone = "Location/City"
-      err = AwesomeSpawn::CommandResultError.new("message", nil)
-      allow(AwesomeSpawn).to receive(:run!).and_raise(err)
-      expect do
-        described_class.send(:system_timezone=, zone)
-      end.to raise_error(described_class::TimeCommandError, "message")
-    end
-  end
-end

data/spec/volume_group_spec.rb

@@ -1,99 +0,0 @@
-describe LinuxAdmin::VolumeGroup do
-  before(:each) do
-    @groups = <<eos
-  vg_foobar:r/w:772:-1:0:2:2:-1:0:1:1:12058624:32768:368:368:0:tILZUF-IspH-H90I-pT5j-vVFl-b76L-zWx3CW
-eos
-  end
-
-  after(:each) do
-    # reset local copies of volumes / groups
-    LinuxAdmin::LogicalVolume.instance_variable_set(:@lvs, nil)
-    LinuxAdmin::PhysicalVolume.instance_variable_set(:@pvs, nil)
-    described_class.instance_variable_set(:@vgs, nil)
-  end
-
-  describe "#attach_to" do
-    it "uses lvextend" do
-      vg = described_class.new :name => 'vg'
-      lv = LinuxAdmin::LogicalVolume.new :name => 'lv', :volume_group => 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(LinuxAdmin::Common).to receive(:run!)
-      expect(vg.attach_to(lv)).to eq(vg)
-    end
-  end
-
-  describe "#extend_with" do
-    it "uses vgextend" do
-      vg = described_class.new :name => 'vg'
-      pv = LinuxAdmin::PhysicalVolume.new :device_name => '/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(LinuxAdmin::Common).to receive(:run!)
-      vg.extend_with(pv)
-      expect(pv.volume_group).to eq(vg)
-    end
-
-    it "returns self" do
-      vg = described_class.new :name => 'vg'
-      pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-      allow(LinuxAdmin::Common).to receive(:run!)
-      expect(vg.extend_with(pv)).to eq(vg)
-    end
-  end
-
-  describe "#create" do
-    before(:each) do
-      @pv = LinuxAdmin::PhysicalVolume.new :device_name => '/dev/hda'
-    end
-
-    it "uses vgcreate" do
-      described_class.instance_variable_set(:@vgs, [])
-      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(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(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-      vg = described_class.create 'vg', @pv
-      expect(described_class.scan).to include(vg)
-    end
-  end
-
-  describe "#scan" do
-    it "uses vgdisplay" do
-      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(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups))
-      vgs = described_class.scan
-
-      expect(vgs[0]).to be_an_instance_of(described_class)
-      expect(vgs[0].name).to eq('vg_foobar')
-    end
-  end
-end