linux_admin 1.2.4 → 2.0.0

data/spec/network_interface/network_interface_rh_spec.rb

@@ -1,291 +0,0 @@
-describe LinuxAdmin::NetworkInterfaceRH do
-  let(:device_name) { "eth0" }
-  let(:ifcfg_file_dhcp) do
-    <<-EOF
-#A comment is here
-DEVICE=eth0
-BOOTPROTO=dhcp
-UUID=3a48a5b5-b80b-4712-82f7-e517e4088999
-ONBOOT=yes
-TYPE=Ethernet
-NAME="System eth0"
-EOF
-  end
-
-  let(:ifcfg_file_static) do
-    <<-EOF
-#A comment is here
-DEVICE=eth0
-BOOTPROTO=static
-UUID=3a48a5b5-b80b-4712-82f7-e517e4088999
-ONBOOT=yes
-TYPE=Ethernet
-NAME="System eth0"
-IPADDR=192.168.1.100
-NETMASK=255.255.255.0
-GATEWAY=192.168.1.1
-EOF
-  end
-
-  def stub_foreach_to_string(string)
-    allow(File).to receive(:foreach) do |&block|
-      string.each_line { |l| block.call(l) }
-    end
-  end
-
-  def result(output, exit_status)
-    AwesomeSpawn::CommandResult.new("", output, "", exit_status)
-  end
-
-  subject(:dhcp_interface) do
-    allow(File).to receive(:exist?).and_return(true)
-    stub_path = described_class.path_to_interface_config_file(device_name)
-    allow(Pathname).to receive(:new).and_return(stub_path)
-    allow(stub_path).to receive(:file?).and_return(true)
-    stub_foreach_to_string(ifcfg_file_dhcp)
-    allow(AwesomeSpawn).to receive(:run!).exactly(6).times.and_return(result("", 0))
-    described_class.new(device_name)
-  end
-
-  subject(:static_interface) do
-    allow(File).to receive(:exist?).and_return(true)
-    stub_foreach_to_string(ifcfg_file_static)
-    allow(AwesomeSpawn).to receive(:run!).exactly(4).times.and_return(result("", 0))
-    described_class.new(device_name)
-  end
-
-  describe ".new" do
-    it "loads the configuration" do
-      conf = dhcp_interface.interface_config
-      expect(conf["NM_CONTROLLED"]).to eq("no")
-      expect(conf["DEVICE"]).to        eq("eth0")
-      expect(conf["BOOTPROTO"]).to     eq("dhcp")
-      expect(conf["UUID"]).to          eq("3a48a5b5-b80b-4712-82f7-e517e4088999")
-      expect(conf["ONBOOT"]).to        eq("yes")
-      expect(conf["TYPE"]).to          eq("Ethernet")
-      expect(conf["NAME"]).to          eq('"System eth0"')
-    end
-  end
-
-  describe "#parse_conf" do
-    it "reloads the interface configuration" do
-      interface = dhcp_interface
-      stub_foreach_to_string(ifcfg_file_static)
-      interface.parse_conf
-
-      conf = interface.interface_config
-      expect(conf["NM_CONTROLLED"]).to eq("no")
-      expect(conf["DEVICE"]).to        eq("eth0")
-      expect(conf["BOOTPROTO"]).to     eq("static")
-      expect(conf["UUID"]).to          eq("3a48a5b5-b80b-4712-82f7-e517e4088999")
-      expect(conf["ONBOOT"]).to        eq("yes")
-      expect(conf["TYPE"]).to          eq("Ethernet")
-      expect(conf["NAME"]).to          eq('"System eth0"')
-      expect(conf["IPADDR"]).to        eq("192.168.1.100")
-      expect(conf["NETMASK"]).to       eq("255.255.255.0")
-      expect(conf["GATEWAY"]).to       eq("192.168.1.1")
-    end
-  end
-
-  describe "#address=" do
-    it "sets the address" do
-      address = "192.168.1.100"
-
-      dhcp_interface.address = address
-
-      conf = dhcp_interface.interface_config
-      expect(conf["IPADDR"]).to    eq(address)
-      expect(conf["BOOTPROTO"]).to eq("static")
-    end
-
-    it "raises argument error when given a bad address" do
-      expect { dhcp_interface.address = "garbage" }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#address6=' do
-    it 'sets the ipv6 address' do
-      address = 'fe80::1/64'
-      dhcp_interface.address6 = address
-      conf = dhcp_interface.interface_config
-      expect(conf['IPV6ADDR']).to eq(address)
-      expect(conf['IPV6INIT']).to eq('yes')
-      expect(conf['DHCPV6C']).to eq('no')
-    end
-
-    it 'raises error when given a bad address' do
-      expect { dhcp_interface.address6 = '1::1::1' }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#gateway=" do
-    it "sets the gateway address" do
-      address = "192.168.1.1"
-      dhcp_interface.gateway = address
-      expect(dhcp_interface.interface_config["GATEWAY"]).to eq(address)
-    end
-
-    it "raises argument error when given a bad address" do
-      expect { dhcp_interface.gateway = "garbage" }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#gateway6=' do
-    it 'sets the default gateway for IPv6' do
-      address = 'fe80::1/64'
-      dhcp_interface.gateway6 = address
-      expect(dhcp_interface.interface_config['IPV6_DEFAULTGW']).to eq(address)
-    end
-  end
-
-  describe "#netmask=" do
-    it "sets the sub-net mask" do
-      mask = "255.255.255.0"
-      dhcp_interface.netmask = mask
-      expect(dhcp_interface.interface_config["NETMASK"]).to eq(mask)
-    end
-
-    it "raises argument error when given a bad address" do
-      expect { dhcp_interface.netmask = "garbage" }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#dns=" do
-    it "sets the correct configuration" do
-      dns1 = "192.168.1.1"
-      dns2 = "192.168.1.10"
-
-      static_interface.dns = dns1, dns2
-
-      conf = static_interface.interface_config
-      expect(conf["DNS1"]).to eq(dns1)
-      expect(conf["DNS2"]).to eq(dns2)
-    end
-
-    it "sets the correct configuration when given an array" do
-      dns = %w(192.168.1.1 192.168.1.10)
-
-      static_interface.dns = dns
-
-      conf = static_interface.interface_config
-      expect(conf["DNS1"]).to eq(dns[0])
-      expect(conf["DNS2"]).to eq(dns[1])
-    end
-
-    it "sets only DNS1 if given one value" do
-      dns = "192.168.1.1"
-
-      static_interface.dns = dns
-
-      conf = static_interface.interface_config
-      expect(conf["DNS1"]).to eq(dns)
-      expect(conf["DNS2"]).to be_nil
-    end
-  end
-
-  describe "#search_order=" do
-    it "sets the search domain list" do
-      search1 = "localhost"
-      search2 = "test.example.com"
-      search3 = "example.com"
-      static_interface.search_order = search1, search2, search3
-      expect(static_interface.interface_config["DOMAIN"]).to eq("\"#{search1} #{search2} #{search3}\"")
-    end
-
-    it "sets the search domain list when given an array" do
-      search_list = %w(localhost test.example.com example.com)
-      static_interface.search_order = search_list
-      expect(static_interface.interface_config["DOMAIN"]).to eq("\"#{search_list.join(' ')}\"")
-    end
-  end
-
-  describe "#enable_dhcp" do
-    it "sets the correct configuration" do
-      static_interface.enable_dhcp
-      conf = static_interface.interface_config
-      expect(conf["BOOTPROTO"]).to eq("dhcp")
-      expect(conf["IPADDR"]).to    be_nil
-      expect(conf["NETMASK"]).to   be_nil
-      expect(conf["GATEWAY"]).to   be_nil
-      expect(conf["PREFIX"]).to    be_nil
-    end
-  end
-
-  describe '#enable_dhcp6' do
-    it 'sets the correct configuration' do
-      [static_interface, dhcp_interface].each do |interface|
-        interface.enable_dhcp6
-        conf = interface.interface_config
-        expect(conf).to include('IPV6INIT' => 'yes', 'DHCPV6C' => 'yes')
-        expect(conf.keys).not_to include('IPV6ADDR', 'IPV6_DEFAULTGW')
-      end
-    end
-  end
-
-  describe "#apply_static" do
-    it "sets the correct configuration" do
-      expect(dhcp_interface).to receive(:save)
-      dhcp_interface.apply_static("192.168.1.12", "255.255.255.0", "192.168.1.1", ["192.168.1.1", nil], ["localhost"])
-
-      conf = dhcp_interface.interface_config
-      expect(conf["BOOTPROTO"]).to eq("static")
-      expect(conf["IPADDR"]).to    eq("192.168.1.12")
-      expect(conf["NETMASK"]).to   eq("255.255.255.0")
-      expect(conf["GATEWAY"]).to   eq("192.168.1.1")
-      expect(conf["DNS1"]).to      eq("192.168.1.1")
-      expect(conf["DNS2"]).to      be_nil
-      expect(conf["DOMAIN"]).to    eq("\"localhost\"")
-    end
-  end
-
-  describe '#apply_static6' do
-    it 'sets the static IPv6 configuration' do
-      expect(dhcp_interface).to receive(:save)
-      dhcp_interface.apply_static6('d:e:a:d:b:e:e:f', 127, 'd:e:a:d::/64', ['d:e:a:d::'])
-      conf = dhcp_interface.interface_config
-      expect(conf).to include('IPV6INIT' => 'yes', 'DHCPV6C' => 'no', 'IPV6ADDR' => 'd:e:a:d:b:e:e:f/127', 'IPV6_DEFAULTGW' => 'd:e:a:d::/64')
-    end
-  end
-
-  describe "#save" do
-    let(:iface_file) { Pathname.new("/etc/sysconfig/network-scripts/ifcfg-#{device_name}") }
-
-    def expect_old_contents
-      expect(File).to receive(:write) do |file, contents|
-        expect(file).to eq(iface_file)
-        expect(contents).to include("DEVICE=eth0")
-        expect(contents).to include("BOOTPROTO=dhcp")
-        expect(contents).to include("UUID=3a48a5b5-b80b-4712-82f7-e517e4088999")
-        expect(contents).to include("ONBOOT=yes")
-        expect(contents).to include("TYPE=Ethernet")
-        expect(contents).to include('NAME="System eth0"')
-      end
-    end
-
-    it "writes the configuration" do
-      expect(File).to receive(:read).with(iface_file)
-      expect(dhcp_interface).to receive(:stop).and_return(true)
-      expect(dhcp_interface).to receive(:start).and_return(true)
-      expect_old_contents
-      expect(dhcp_interface.save).to be true
-    end
-
-    it "returns false when the interface cannot be brought down" do
-      expect(File).to receive(:read).with(iface_file)
-      expect(dhcp_interface).to receive(:stop).twice.and_return(false)
-      expect(File).not_to receive(:write)
-      expect(dhcp_interface.save).to be false
-    end
-
-    it "returns false and writes the old contents when the interface fails to come back up" do
-      dhcp_interface # evaluate the subject first so the expectations stub the right calls
-      expect(File).to receive(:read).with(iface_file).and_return("old stuff")
-      expect(dhcp_interface).to receive(:stop).and_return(true)
-      expect_old_contents
-      expect(dhcp_interface).to receive(:start).and_return(false)
-      expect(File).to receive(:write).with(iface_file, "old stuff")
-      expect(dhcp_interface).to receive(:start)
-      expect(dhcp_interface.save).to be false
-    end
-  end
-end

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