linux_admin 1.2.4 → 2.0.0

data/spec/ip_address_spec.rb

@@ -1,148 +0,0 @@
-describe LinuxAdmin::IpAddress do
-  let(:ip) { described_class.new }
-
-  ADDR_SPAWN_ARGS = [
-    LinuxAdmin::Common.cmd("hostname"),
-    :params => ["-I"]
-  ]
-
-  MAC_SPAWN_ARGS = [
-    LinuxAdmin::Common.cmd("ip"),
-    :params => %w(addr show eth0)
-  ]
-
-  MASK_SPAWN_ARGS = [
-    LinuxAdmin::Common.cmd("ifconfig"),
-    :params => %w(eth0)
-  ]
-
-  GW_SPAWN_ARGS = [
-    LinuxAdmin::Common.cmd("ip"),
-    :params => %w(route)
-  ]
-
-  IP_ADDR_SHOW_ETH0 = <<-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
-
-IP_OUT
-
-  IFCFG = <<-IP_OUT
-eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
-        inet 192.168.1.9  netmask 255.255.255.0  broadcast 192.168.1.255
-        inet6 fe80::20c:29ff:feed:e8b  prefixlen 64  scopeid 0x20<link>
-        ether 00:0c:29:ed:0e:8b  txqueuelen 1000  (Ethernet)
-        RX packets 10171  bytes 8163955 (7.7 MiB)
-        RX errors 0  dropped 0  overruns 0  frame 0
-        TX packets 2871  bytes 321915 (314.3 KiB)
-        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
-
-IP_OUT
-
-  IP_ROUTE = <<-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
-
-  def result(output, exit_status)
-    AwesomeSpawn::CommandResult.new("", output, "", exit_status)
-  end
-
-  describe "#address" do
-    it "returns an address" do
-      ip_addr = "192.168.1.2"
-      expect(AwesomeSpawn).to receive(:run).with(*ADDR_SPAWN_ARGS).and_return(result(ip_addr, 0))
-      expect(ip.address).to eq(ip_addr)
-    end
-
-    it "returns nil when no address is found" do
-      ip_addr = ""
-      expect(AwesomeSpawn).to receive(:run).at_least(5).times.with(*ADDR_SPAWN_ARGS).and_return(result(ip_addr, 1))
-      expect(ip.address).to be_nil
-    end
-
-    it "returns only IPv4 addresses" do
-      ip_addr = "fd12:3456:789a:1::1 192.168.1.2"
-      expect(AwesomeSpawn).to receive(:run).with(*ADDR_SPAWN_ARGS).and_return(result(ip_addr, 0))
-      expect(ip.address).to eq("192.168.1.2")
-    end
-  end
-
-  describe "#address6" do
-    it "returns an address" do
-      ip_addr = "fd12:3456:789a:1::1"
-      expect(AwesomeSpawn).to receive(:run).with(*ADDR_SPAWN_ARGS).and_return(result(ip_addr, 0))
-      expect(ip.address6).to eq(ip_addr)
-    end
-
-    it "returns nil when no address is found" do
-      ip_addr = ""
-      expect(AwesomeSpawn).to receive(:run).at_least(5).times.with(*ADDR_SPAWN_ARGS).and_return(result(ip_addr, 1))
-      expect(ip.address6).to be_nil
-    end
-
-    it "returns only IPv6 addresses" do
-      ip_addr = "192.168.1.2 fd12:3456:789a:1::1"
-      expect(AwesomeSpawn).to receive(:run).with(*ADDR_SPAWN_ARGS).and_return(result(ip_addr, 0))
-      expect(ip.address6).to eq("fd12:3456:789a:1::1")
-    end
-  end
-
-  describe "#mac_address" do
-    it "returns the correct MAC address" do
-      expect(AwesomeSpawn).to receive(:run).with(*MAC_SPAWN_ARGS).and_return(result(IP_ADDR_SHOW_ETH0, 0))
-      expect(ip.mac_address("eth0")).to eq("00:0c:29:ed:0e:8b")
-    end
-
-    it "returns nil when the command fails" do
-      expect(AwesomeSpawn).to receive(:run).with(*MAC_SPAWN_ARGS).and_return(result("", 1))
-      expect(ip.mac_address("eth0")).to be_nil
-    end
-
-    it "returns nil if the link/ether line is not present" do
-      bad_output = IP_ADDR_SHOW_ETH0.gsub(%r{link/ether}, "")
-      expect(AwesomeSpawn).to receive(:run).with(*MAC_SPAWN_ARGS).and_return(result(bad_output, 0))
-      expect(ip.mac_address("eth0")).to be_nil
-    end
-  end
-
-  describe "#netmask" do
-    it "returns the correct netmask" do
-      expect(AwesomeSpawn).to receive(:run).with(*MASK_SPAWN_ARGS).and_return(result(IFCFG, 0))
-      expect(ip.netmask("eth0")).to eq("255.255.255.0")
-    end
-
-    it "returns nil when the command fails" do
-      expect(AwesomeSpawn).to receive(:run).with(*MASK_SPAWN_ARGS).and_return(result("", 1))
-      expect(ip.netmask("eth0")).to be_nil
-    end
-
-    it "returns nil if the netmask line is not present" do
-      bad_output = IFCFG.gsub(/netmask/, "")
-      expect(AwesomeSpawn).to receive(:run).with(*MASK_SPAWN_ARGS).and_return(result(bad_output, 0))
-      expect(ip.netmask("eth0")).to be_nil
-    end
-  end
-
-  describe "#gateway" do
-    it "returns the correct gateway address" do
-      expect(AwesomeSpawn).to receive(:run).with(*GW_SPAWN_ARGS).and_return(result(IP_ROUTE, 0))
-      expect(ip.gateway).to eq("192.168.1.1")
-    end
-
-    it "returns nil when the command fails" do
-      expect(AwesomeSpawn).to receive(:run).with(*GW_SPAWN_ARGS).and_return(result("", 1))
-      expect(ip.gateway).to be_nil
-    end
-
-    it "returns nil if the default line is not present" do
-      bad_output = IP_ROUTE.gsub(/default/, "")
-      expect(AwesomeSpawn).to receive(:run).with(*GW_SPAWN_ARGS).and_return(result(bad_output, 0))
-      expect(ip.gateway).to be_nil
-    end
-  end
-end

data/spec/logical_volume_spec.rb

@@ -1,166 +0,0 @@
-describe LinuxAdmin::LogicalVolume do
-  before(:each) do
-    @logical_volumes = <<eos
-  /dev/vg_foobar/lv_swap:vg_foobar:3:1:-1:2:4128768:63:-1:0:-1:253:0
-  /dev/vg_foobar/lv_root:vg_foobar:3:1:-1:1:19988480:305:-1:0:-1:253:1
-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
-    described_class.instance_variable_set(:@lvs, nil)
-    LinuxAdmin::PhysicalVolume.instance_variable_set(:@pvs, nil)
-    LinuxAdmin::VolumeGroup.instance_variable_set(:@vgs, nil)
-  end
-
-  describe "#extend_with" do
-    it "uses lvextend" do
-      vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-      lv = described_class.new :name => 'lv', :volume_group => vg
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:lvextend),
-              :params => %w(lv vg))
-      lv.extend_with(vg)
-    end
-
-    it "returns self" do
-      vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-      lv = described_class.new :name => 'lv', :volume_group => vg
-      allow(LinuxAdmin::Common).to receive(:run!)
-      expect(lv.extend_with(vg)).to eq(lv)
-    end
-  end
-
-  describe "#path" do
-    it "returns /dev/vgname/lvname" do
-      vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-      lv = described_class.new :name => 'lv', :volume_group => vg
-      expect(lv.path).to eq('/dev/vg/lv')
-    end
-  end
-
-  describe "#create" do
-    before(:each) do
-      @vg = LinuxAdmin::VolumeGroup.new :name => 'vg'
-    end
-
-    it "uses lvcreate" do
-      described_class.instance_variable_set(:@lvs, [])
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:lvcreate),
-              :params => {'-n' => 'lv',
-                          nil  => 'vg',
-                          '-L' => '256G'})
-      described_class.create 'lv', @vg, 274_877_906_944 # 256.gigabytes
-    end
-
-    context "size is specified" do
-      it "passes -L option to lvcreate" do
-        described_class.instance_variable_set(:@lvs, [])
-        expect(LinuxAdmin::Common).to receive(:run!)
-          .with(LinuxAdmin::Common.cmd(:lvcreate),
-                :params => {'-n' => 'lv',
-                            nil  => 'vg',
-                            '-L' => '256G'})
-        described_class.create 'lv', @vg, 274_877_906_944 # 256.gigabytes
-      end
-    end
-
-    context "extents is specified" do
-      it "passes -l option to lvcreate" do
-        described_class.instance_variable_set(:@lvs, [])
-        expect(LinuxAdmin::Common).to receive(:run!)
-          .with(LinuxAdmin::Common.cmd(:lvcreate),
-                :params => {'-n' => 'lv',
-                            nil  => 'vg',
-                            '-l' => '100%FREE'})
-        described_class.create 'lv', @vg, 100
-      end
-    end
-
-    it "returns new logical volume" do
-      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-      lv = described_class.create 'lv', @vg, 274_877_906_944 # 256.gigabytes
-      expect(lv).to be_an_instance_of(described_class)
-      expect(lv.name).to eq('lv')
-    end
-
-    context "name is specified" do
-      it "sets path under volume group" do
-        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-        lv = described_class.create 'lv', @vg, 274_877_906_944 # 256.gigabytes
-        expect(lv.path.to_s).to eq("#{described_class::DEVICE_PATH}#{@vg.name}/lv")
-      end
-    end
-
-    context "path is specified" do
-      it "sets name" do
-        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-        lv = described_class.create '/dev/lv', @vg, 274_877_906_944 # 256.gigabytes
-        expect(lv.name).to eq("lv")
-      end
-    end
-
-    context "path is specified as Pathname" do
-      it "sets name" do
-        require 'pathname'
-        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-        allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-        lv = described_class.create Pathname.new("/dev/#{@vg.name}/lv"), @vg, 274_877_906_944 # 256.gigabytes
-        expect(lv.name).to eq("lv")
-        expect(lv.path).to eq("/dev/vg/lv")
-      end
-    end
-
-    it "adds logical volume to local registry" do
-      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-      allow(LinuxAdmin::Common).to receive_messages(:run! => double(:output => ""))
-      lv = described_class.create 'lv', @vg, 274_877_906_944 # 256.gigabytes
-      expect(described_class.scan).to include(lv)
-    end
-  end
-
-  describe "#scan" do
-    it "uses lvdisplay" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:lvdisplay),
-              :params => {'-c' => nil})
-        .and_return(double(:output => @logical_volumes))
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups)) # stub out call to vgdisplay
-      described_class.scan
-    end
-
-    it "returns local logical volumes" do
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @logical_volumes))
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups))
-      lvs = described_class.scan
-
-      expect(lvs[0]).to be_an_instance_of(described_class)
-      expect(lvs[0].path).to eq('/dev/vg_foobar/lv_swap')
-      expect(lvs[0].name).to eq('lv_swap')
-      expect(lvs[0].sectors).to eq(4128768)
-
-      expect(lvs[1]).to be_an_instance_of(described_class)
-      expect(lvs[1].path).to eq('/dev/vg_foobar/lv_root')
-      expect(lvs[1].name).to eq('lv_root')
-      expect(lvs[1].sectors).to eq(19988480)
-    end
-
-    it "resolves volume group references" do
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @logical_volumes))
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @groups))
-      lvs = described_class.scan
-      expect(lvs[0].volume_group).to be_an_instance_of(LinuxAdmin::VolumeGroup)
-      expect(lvs[0].volume_group.name).to eq('vg_foobar')
-      expect(lvs[1].volume_group).to be_an_instance_of(LinuxAdmin::VolumeGroup)
-      expect(lvs[1].volume_group.name).to eq('vg_foobar')
-    end
-  end
-end

data/spec/mountable_spec.rb

@@ -1,182 +0,0 @@
-class TestMountable
-  include LinuxAdmin::Mountable
-
-  def path
-    "/dev/foo"
-  end
-end
-
-describe LinuxAdmin::Mountable do
-  before(:each) do
-    @mountable = TestMountable.new
-
-    # stub out calls that modify system
-    allow(FileUtils).to receive(:mkdir)
-    allow(LinuxAdmin::Common).to receive(:run!)
-
-    @mount_out1 = <<eos
-/dev/sda on /mnt/usb type vfat (rw)
-eos
-    @mount_out2 = <<eos
-cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
-systemd-1 on /proc/sys/fs/binfmt_misc type autofs (rw,relatime,fd=26,pgrp=1,timeout=300,minproto=5,maxproto=5,direct)
-eos
-
-    @mount_out3 = <<eos
-/dev/mapper/vg_data-lv_pg on /var/opt/rh/rh-postgresql95/lib/pgsql type xfs (rw,relatime,seclabel,attr2,inode64,noquota)
-/dev/foo on /tmp type xfs (rw,relatime,seclabel,attr2,inode64,noquota)
-/dev/foo on /home type xfs (rw,relatime,seclabel,attr2,inode64,noquota)
-eos
-  end
-
-  describe "#mount_point_exists?" do
-    it "uses mount" do
-      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:mount))
-        .and_return(double(:output => ""))
-      TestMountable.mount_point_exists?('/mnt/usb')
-    end
-
-    context "disk mounted at specified location" do
-      before do
-        expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out1))
-      end
-
-      it "returns true" do
-        expect(TestMountable.mount_point_exists?('/mnt/usb')).to be_truthy
-      end
-
-      it "returns true when using a pathname" do
-        path = Pathname.new("/mnt/usb")
-        expect(TestMountable.mount_point_exists?(path)).to be_truthy
-      end
-    end
-
-    context "no disk mounted at specified location" do
-      before do
-        expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out2))
-      end
-
-      it "returns false" do
-        expect(TestMountable.mount_point_exists?('/mnt/usb')).to be_falsey
-      end
-
-      it "returns false when using a pathname" do
-        path = Pathname.new("/mnt/usb")
-        expect(TestMountable.mount_point_exists?(path)).to be_falsey
-      end
-    end
-  end
-
-  describe "#mount_point_available?" do
-    it "uses mount" do
-      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:mount))
-        .and_return(double(:output => ""))
-      TestMountable.mount_point_available?('/mnt/usb')
-    end
-
-    context "disk mounted at specified location" do
-      before do
-        expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out1))
-      end
-
-      it "returns false" do
-        expect(TestMountable.mount_point_available?('/mnt/usb')).to be_falsey
-      end
-
-      it "returns false when using a pathname" do
-        path = Pathname.new("/mnt/usb")
-        expect(TestMountable.mount_point_available?(path)).to be_falsey
-      end
-    end
-
-    context "no disk mounted at specified location" do
-      before do
-        expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out2))
-      end
-
-      it "returns true" do
-        expect(TestMountable.mount_point_available?('/mnt/usb')).to be_truthy
-      end
-
-      it "returns true when using a pathname" do
-        path = Pathname.new("/mnt/usb")
-        expect(TestMountable.mount_point_available?(path)).to be_truthy
-      end
-    end
-  end
-
-  describe "#discover_mount_point" do
-    it "sets the correct mountpoint when the path is mounted" do
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out3))
-      @mountable.discover_mount_point
-      expect(@mountable.mount_point).to eq("/tmp")
-    end
-
-    it "sets mount_point to nil when the path is not mounted" do
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => @mount_out1))
-      @mountable.discover_mount_point
-      expect(@mountable.mount_point).to be_nil
-    end
-  end
-
-  describe "#format_to" do
-    it "uses mke2fs" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:mke2fs),
-              :params => {'-t' => 'ext4', nil => '/dev/foo'})
-      @mountable.format_to('ext4')
-    end
-
-    it "sets fs type" do
-      expect(LinuxAdmin::Common).to receive(:run!) # ignore actual formatting cmd
-      @mountable.format_to('ext4')
-      expect(@mountable.fs_type).to eq('ext4')
-    end
-  end
-
-  describe "#mount" do
-    it "sets mount point" do
-      # ignore actual mount cmds
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => ""))
-      expect(LinuxAdmin::Common).to receive(:run!).and_return(double(:output => ""))
-
-      expect(@mountable.mount('/mnt/sda2')).to eq('/mnt/sda2')
-      expect(@mountable.mount_point).to eq('/mnt/sda2')
-    end
-
-    context "mountpoint does not exist" do
-      it "creates mountpoint" do
-        expect(TestMountable).to receive(:mount_point_exists?).and_return(false)
-        expect(File).to receive(:directory?).with('/mnt/sda2').and_return(false)
-        expect(FileUtils).to receive(:mkdir).with('/mnt/sda2')
-        expect(LinuxAdmin::Common).to receive(:run!) # ignore actual mount cmd
-        @mountable.mount '/mnt/sda2'
-      end
-    end
-
-    context "disk mounted at mountpoint" do
-      it "raises argument error" do
-        expect(TestMountable).to receive(:mount_point_exists?).and_return(true)
-        expect(File).to receive(:directory?).with('/mnt/sda2').and_return(true)
-        expect { @mountable.mount '/mnt/sda2' }.to raise_error(ArgumentError, "disk already mounted at /mnt/sda2")
-      end
-    end
-
-    it "mounts partition" do
-      expect(TestMountable).to receive(:mount_point_exists?).and_return(false)
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:mount),
-              :params => {nil => ['/dev/foo', '/mnt/sda2']})
-      @mountable.mount '/mnt/sda2'
-    end
-  end
-
-  describe "#umount" do
-    it "unmounts partition" do
-      @mountable.mount_point = '/mnt/sda2'
-      expect(LinuxAdmin::Common).to receive(:run!).with(LinuxAdmin::Common.cmd(:umount),
-                                                        :params => {nil => ['/mnt/sda2']})
-      @mountable.umount
-    end
-  end
-end