linux_admin 1.2.2 → 2.0.2

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

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