linux_admin 1.2.2 → 2.0.2

data/spec/network_interface_spec.rb

@@ -1,284 +0,0 @@
-describe LinuxAdmin::NetworkInterface do
-  let(:device_name) { "eth0" }
-  let(:config_file_path) { LinuxAdmin::NetworkInterfaceRH.path_to_interface_config_file(device_name) }
-  context "on redhat systems" do
-    describe ".dist_class" do
-      it "returns NetworkInterfaceRH" do
-        allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.rhel)
-        expect(described_class.dist_class(true)).to eq(LinuxAdmin::NetworkInterfaceRH)
-      end
-    end
-
-    describe ".new" do
-      before do
-        allow_any_instance_of(described_class).to receive(:ip_show).and_raise(LinuxAdmin::NetworkInterfaceError.new(nil, nil))
-        allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.rhel)
-        described_class.dist_class(true)
-        allow(Pathname).to receive(:new).and_return(config_file_path)
-      end
-
-      it "creates a NetworkInterfaceRH instance if the config file does exist" do
-        expect(config_file_path).to receive(:file?).and_return(true)
-        expect(File).to receive(:foreach).and_return("")
-
-        expect(described_class.new(device_name)).to be_an_instance_of(LinuxAdmin::NetworkInterfaceRH)
-      end
-
-      it "creates a NetworkInterfaceRH instance if the config file does not exist" do
-        expect(config_file_path).to receive(:file?).and_return(false)
-
-        expect(described_class.new(device_name)).to be_an_instance_of(LinuxAdmin::NetworkInterfaceRH)
-      end
-    end
-  end
-
-  context "on other linux systems" do
-    describe ".dist_class" do
-      it "returns NetworkInterfaceGeneric" do
-        allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.generic)
-        expect(described_class.dist_class(true)).to eq(LinuxAdmin::NetworkInterfaceGeneric)
-      end
-    end
-
-    describe ".new" do
-      subject do
-        allow_any_instance_of(described_class).to receive(:ip_show).and_raise(LinuxAdmin::NetworkInterfaceError.new(nil, nil))
-        allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.generic)
-        described_class.dist_class(true)
-        described_class.new(device_name)
-      end
-
-      it "creates a NetworkInterfaceGeneric instance" do
-        expect(subject).to be_an_instance_of(LinuxAdmin::NetworkInterfaceGeneric)
-      end
-    end
-  end
-
-  context "on all systems" do
-    IP_SHOW_ARGS = [
-      LinuxAdmin::Common.cmd("ip"),
-      :params => %w(addr show eth0)
-    ]
-
-    IP_ROUTE_ARGS = [
-      LinuxAdmin::Common.cmd("ip"),
-      :params => ['-4', 'route']
-    ]
-
-    IP6_ROUTE_ARGS = [
-      LinuxAdmin::Common.cmd("ip"),
-      :params => ['-6', 'route']
-    ]
-
-    IFUP_ARGS = [
-      LinuxAdmin::Common.cmd("ifup"),
-      :params => ["eth0"]
-    ]
-
-    IFDOWN_ARGS = [
-      LinuxAdmin::Common.cmd("ifdown"),
-      :params => ["eth0"]
-    ]
-
-    IP_ADDR_OUT = <<-IP_OUT
-2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
-    link/ether 00:0c:29:ed:0e:8b brd ff:ff:ff:ff:ff:ff
-    inet 192.168.1.9/24 brd 192.168.1.255 scope global dynamic eth0
-       valid_lft 1297sec preferred_lft 1297sec
-    inet6 fe80::20c:29ff:feed:e8b/64 scope link
-       valid_lft forever preferred_lft forever
-    inet6 fd12:3456:789a:1::1/96 scope global
-       valid_lft forever preferred_lft forever
-IP_OUT
-
-    IP6_ADDR_OUT = <<-IP_OUT
-2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
-    link/ether 00:0c:29:ed:0e:8b brd ff:ff:ff:ff:ff:ff
-    inet6 fe80::20c:29ff:feed:e8b/64 scope link
-       valid_lft forever preferred_lft forever
-    inet6 fd12:3456:789a:1::1/96 scope global
-       valid_lft forever preferred_lft forever
-IP_OUT
-
-    IP_ROUTE_OUT = <<-IP_OUT
-default via 192.168.1.1 dev eth0  proto static  metric 100
-192.168.1.0/24 dev eth0  proto kernel  scope link  src 192.168.1.9  metric 100
-IP_OUT
-    IP6_ROUTE_OUT = <<-IP_OUT
-default via d:e:a:d:b:e:e:f dev eth0  proto static  metric 100
-fc00:dead:beef:a::/64 dev virbr1  proto kernel  metric 256 linkdown  pref medium
-fe80::/64 dev eth0  proto kernel  scope link metric 100
-IP_OUT
-
-    IP_NONE_ADDR_OUT = <<-IP_OUT.freeze
-2: eth0: <BROADCAST,MULTICAST> mtu 1500 qdisc fq_codel master virbr1 state DOWN group default qlen 1000
-    link/ether 52:54:00:ce:b4:f4 brd ff:ff:ff:ff:ff:ff
-IP_OUT
-
-    subject(:subj) do
-      allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.generic)
-      described_class.dist_class(true)
-
-      allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP_ADDR_OUT, 0))
-      allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
-      allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
-      described_class.new(device_name)
-    end
-
-    subject(:subj6) do
-      allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.generic)
-      described_class.dist_class(true)
-
-      allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP6_ADDR_OUT, 0))
-      allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
-      allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
-      described_class.new(device_name)
-    end
-
-    subject(:subj_no_net) do
-      allow(LinuxAdmin::Distros).to receive(:local).and_return(LinuxAdmin::Distros.generic)
-      described_class.dist_class(true)
-
-      allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP_NONE_ADDR_OUT, 0))
-      allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
-      allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
-      described_class.new(device_name)
-    end
-
-    def result(output, exit_status)
-      AwesomeSpawn::CommandResult.new("", output, "", exit_status)
-    end
-
-    describe "#reload" do
-      it "returns false when ip addr show fails" do
-        subj
-        awesome_error = AwesomeSpawn::CommandResultError.new("", nil)
-        allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_raise(awesome_error)
-        expect(subj.reload).to eq(false)
-      end
-
-      it "raises when ip route fails" do
-        subj
-        awesome_error = AwesomeSpawn::CommandResultError.new("", nil)
-        allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP_ADDR_OUT, 0))
-        allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_raise(awesome_error)
-        allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_raise(awesome_error)
-        expect { subj.reload }.to raise_error(LinuxAdmin::NetworkInterfaceError)
-      end
-
-      it "doesn't blow up when given only ipv6 addresses" do
-        subj6
-        allow(AwesomeSpawn).to receive(:run!).with(*IP_SHOW_ARGS).and_return(result(IP6_ADDR_OUT, 0))
-        allow(AwesomeSpawn).to receive(:run!).with(*IP_ROUTE_ARGS).and_return(result(IP_ROUTE_OUT, 0))
-        allow(AwesomeSpawn).to receive(:run!).with(*IP6_ROUTE_ARGS).and_return(result(IP6_ROUTE_OUT, 0))
-        expect { subj.reload }.to_not raise_error
-      end
-    end
-
-    describe "#address" do
-      it "returns an address" do
-        expect(subj.address).to eq("192.168.1.9")
-      end
-    end
-
-    describe "#address6" do
-      it "returns the global address by default" do
-        expect(subj.address6).to eq("fd12:3456:789a:1::1")
-      end
-
-      it "returns the link local address" do
-        expect(subj.address6(:link)).to eq("fe80::20c:29ff:feed:e8b")
-      end
-
-      it "raises ArgumentError when given a bad scope" do
-        expect { subj.address6(:garbage) }.to raise_error(ArgumentError)
-      end
-    end
-
-    describe "#mac_address" do
-      it "returns the correct MAC address" do
-        expect(subj.mac_address).to eq("00:0c:29:ed:0e:8b")
-      end
-    end
-
-    describe "#netmask" do
-      it "returns the correct netmask" do
-        expect(subj.netmask).to eq("255.255.255.0")
-      end
-
-      it 'does not blow-up, when no ip assigned' do
-        expect(subj_no_net.netmask).to eq(nil)
-      end
-    end
-
-    describe "#netmask6" do
-      it "returns the correct global netmask" do
-        expect(subj.netmask6).to eq("ffff:ffff:ffff:ffff:ffff:ffff::")
-      end
-
-      it "returns the correct link local netmask" do
-        expect(subj.netmask6(:link)).to eq("ffff:ffff:ffff:ffff::")
-      end
-
-      it "raises ArgumentError when given a bad scope" do
-        expect { subj.netmask6(:garbage) }.to raise_error(ArgumentError)
-      end
-    end
-
-    describe '#prefix' do
-      it 'returns the correct prefix' do
-        expect(subj.prefix).to eq(24)
-      end
-    end
-
-    describe '#prefix6' do
-      it 'returns the correct global prefix length' do
-        expect(subj.prefix6).to eq(96)
-      end
-
-      it 'returns the correct link local prefix length' do
-        expect(subj.prefix6(:link)).to eq(64)
-      end
-
-      it 'raises ArgumentError when given a bad scope' do
-        expect { subj.prefix6(:garbage) }.to raise_error(ArgumentError)
-      end
-    end
-
-    describe "#gateway" do
-      it "returns the correct gateway address" do
-        expect(subj.gateway).to eq("192.168.1.1")
-      end
-    end
-
-    describe '#gateway6' do
-      it 'returns the correct default gateway for IPv6 routing' do
-        expect(subj.gateway6).to eq('d:e:a:d:b:e:e:f')
-      end
-    end
-
-    describe "#start" do
-      it "returns true on success" do
-        expect(AwesomeSpawn).to receive(:run).with(*IFUP_ARGS).and_return(result("", 0))
-        expect(subj.start).to be true
-      end
-
-      it "returns false on failure" do
-        expect(AwesomeSpawn).to receive(:run).with(*IFUP_ARGS).and_return(result("", 1))
-        expect(subj.start).to be false
-      end
-    end
-
-    describe "#stop" do
-      it "returns true on success" do
-        expect(AwesomeSpawn).to receive(:run).with(*IFDOWN_ARGS).and_return(result("", 0))
-        expect(subj.stop).to be true
-      end
-
-      it "returns false on failure" do
-        expect(AwesomeSpawn).to receive(:run).with(*IFDOWN_ARGS).and_return(result("", 1))
-        expect(subj.stop).to be false
-      end
-    end
-  end
-end

data/spec/partition_spec.rb

@@ -1,24 +0,0 @@
-describe LinuxAdmin::Partition do
-  before(:each) do
-    @disk = LinuxAdmin::Disk.new :path => '/dev/sda'
-    @partition = LinuxAdmin::Partition.new :disk => @disk, :id => 2
-  end
-
-  describe "#path" do
-    it "returns partition path" do
-      expect(@partition.path).to eq('/dev/sda2')
-    end
-  end
-
-  describe "#mount" do
-    context "mount_point not specified" 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(LinuxAdmin::Common).to receive(:run!)
-        @partition.mount
-        expect(@partition.mount_point).to eq('/mnt/sda2')
-      end
-    end
-  end
-end

data/spec/physical_volume_spec.rb

@@ -1,101 +0,0 @@
-describe LinuxAdmin::PhysicalVolume do
-  before(:each) do
-    @physical_volumes = <<eos
-  /dev/vda2:vg_foobar:24139776:-1:8:8:-1:32768:368:0:368:pxR32D-YkC2-PfHe-zOwb-eaGD-9Ar0-mAOl9u
-eos
-
-    @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)
-    described_class.instance_variable_set(:@pvs, nil)
-    LinuxAdmin::VolumeGroup.instance_variable_set(:@vgs, nil)
-  end
-
-  describe "#attach_to" do
-    it "uses vgextend" do
-      vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-      pv = described_class.new :device_name => '/dev/hda'
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:vgextend),
-              :params => ['vg', '/dev/hda'])
-      pv.attach_to(vg)
-    end
-
-    it "assigns volume group to physical volume" do
-      vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-      pv = described_class.new :device_name => '/dev/hda'
-      allow(LinuxAdmin::Common).to receive(:run!)
-      pv.attach_to(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'
-      allow(LinuxAdmin::Common).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'
-      allow(@disk).to receive(:size)
-    end
-
-    let(:disk) {@disk}
-
-    it "uses pvcreate" do
-      described_class.instance_variable_set(:@pvs, [])
-      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::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::Common).to receive_messages(:run! => double(:output => ""))
-      pv = described_class.create disk
-      expect(described_class.scan).to include(pv)
-    end
-  end
-
-  describe "#scan" do
-    it "uses pvdisplay" do
-      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(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)
-      expect(pvs[0].device_name).to eq('/dev/vda2')
-      expect(pvs[0].size).to eq(24139776)
-    end
-
-    it "resolves volume group references" do
-      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')
-    end
-  end
-end

data/spec/registration_system_spec.rb

@@ -1,85 +0,0 @@
-describe LinuxAdmin::RegistrationSystem do
-  context ".registration_type" do
-    it "when registered Subscription Manager" do
-      stub_registered_to_system(:sm)
-      expect(described_class.registration_type).to eq(LinuxAdmin::SubscriptionManager)
-    end
-
-    it "when registered RHN" do
-      stub_registered_to_system(:sm, :rhn)
-      expect(described_class.registration_type).to eq(LinuxAdmin::Rhn)
-    end
-
-    it "when unregistered" do
-      stub_registered_to_system(nil)
-      expect(described_class.registration_type).to eq(described_class)
-    end
-
-    it "should memoize results" do
-      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
-      expect(described_class).to receive(:registration_type_uncached).twice.and_return("anything_non_nil")
-      described_class.registration_type
-      described_class.registration_type(true)
-    end
-  end
-
-  context "#registered?" do
-    it "when unregistered" do
-      stub_registered_to_system(nil)
-      expect(described_class.registered?).to be_falsey
-    end
-
-    context "SubscriptionManager" do
-      it "with no args" do
-        expect(LinuxAdmin::Common).to receive(:run).with("subscription-manager identity").and_return(double(:exit_status => 0))
-
-        LinuxAdmin::SubscriptionManager.new.registered?
-      end
-
-      it "with a proxy" do
-        expect(LinuxAdmin::Common).to receive(:run).with(
-          "subscription-manager identity",
-          :params => {
-            "--proxy="         => "https://example.com",
-            "--proxyuser="     => "user",
-            "--proxypassword=" => "pass"
-          }
-        ).and_return(double(:exit_status => 0))
-
-        LinuxAdmin::SubscriptionManager.new.registered?(
-          :proxy_address  => "https://example.com",
-          :proxy_username => "user",
-          :proxy_password => "pass"
-        )
-      end
-    end
-  end
-
-  context ".method_missing" do
-    before do
-      stub_registered_to_system(:rhn)
-    end
-
-    it "exists on the subclass" do
-      expect(LinuxAdmin::RegistrationSystem.registered?).to be_truthy
-    end
-
-    it "does not exist on the subclass" do
-      expect { LinuxAdmin::RegistrationSystem.organizations }.to raise_error(NotImplementedError)
-    end
-
-    it "is an unknown method" do
-      expect { LinuxAdmin::RegistrationSystem.method_does_not_exist }.to raise_error(NoMethodError)
-    end
-  end
-
-  def stub_registered_to_system(*system)
-    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