bosh-stemcell 1.5.0.pre.1226 → 1.5.0.pre.1244

data/spec/bosh/stemcell/disk_image_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-require 'bosh/stemcell/disk_image'
-
-module Bosh::Stemcell
-  describe DiskImage do
-    let(:shell) { instance_double('Bosh::Core::Shell', run: nil) }
-
-    let(:kpartx_map_output) { 'add map FAKE_LOOP1p1 (252:3): 0 3997984 linear /dev/loop1 63' }
-    let(:options) do
-      {
-        image_file_path: '/path/to/FAKE_IMAGE',
-        image_mount_point: '/fake/mnt'
-      }
-    end
-
-    subject(:disk_image) { DiskImage.new(options) }
-
-    before do
-      Bosh::Core::Shell.stub(:new).and_return(shell)
-    end
-
-    describe '#initialize' do
-      it 'requires an image_file_path' do
-        options.delete(:image_file_path)
-        expect { DiskImage.new(options) }.to raise_error /key not found: :image_file_path/
-      end
-
-      it 'requires an mount_point' do
-        options.delete(:image_mount_point)
-
-        dir_mock = class_double('Dir').as_stubbed_const
-        dir_mock.should_receive(:mktmpdir).and_return('/fake/tmpdir')
-
-        expect(DiskImage.new(options).image_mount_point).to eq('/fake/tmpdir')
-      end
-    end
-
-    describe '#mount' do
-      it 'maps the file to a loop device' do
-        losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
-        shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
-        shell.should_receive(:run).with('sudo kpartx -av /dev/loop0',
-                                        output_command: false).and_return(kpartx_map_output)
-
-        disk_image.mount
-      end
-
-      it 'mounts the loop device' do
-        losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
-        shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
-        shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
-
-        shell.should_receive(:run).with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false)
-
-        disk_image.mount
-      end
-
-      context 'when the device does not exist' do
-        let(:mount_command) do
-          'sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt'
-        end
-
-        let(:mount_error) do
-          "Failed: '#{mount_command}' from /fake/mnt/blah/blah/bosh-stemcell, with exit status 8192\n\n"
-        end
-
-        before do
-          disk_image.stub(:sleep)
-        end
-
-        it 'runs mount a second time after sleeping long enough for the device node to be created' do
-          losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
-          shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
-          shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
-          shell.should_receive(:run).with(mount_command, output_command: false).ordered.and_raise(mount_error)
-          disk_image.should_receive(:sleep).with(0.5)
-          shell.should_receive(:run).with(mount_command, output_command: false).ordered
-
-          disk_image.mount
-        end
-
-        context 'when the second mount command fails' do
-          it 'raises an error' do
-            losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
-            shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
-            shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
-            shell.should_receive(:run).with(mount_command, output_command: false).ordered.twice.and_raise(mount_error)
-
-            expect { disk_image.mount }.to raise_error(mount_error)
-          end
-        end
-      end
-
-      context 'when the mount command fails' do
-        it 'runs mount a second time' do
-          losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
-          shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
-          shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
-          shell.should_receive(:run).
-            with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false).ordered.
-            and_raise(RuntimeError, 'UNEXEPECTED')
-
-          expect { disk_image.mount }.to raise_error(RuntimeError, 'UNEXEPECTED')
-        end
-      end
-    end
-
-    describe '#unmount' do
-      before do
-        disk_image.stub(device: '/dev/loop0') # pretend we've mounted
-      end
-
-      it 'unmounts the loop device and then unmaps the file' do
-        shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).ordered
-        shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
-        shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
-
-        disk_image.unmount
-      end
-
-      it 'unmaps the file even if unmounting the device fails' do
-        shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).and_raise
-        shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
-        shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
-
-        expect { disk_image.unmount }.to raise_error
-      end
-    end
-
-    describe '#while_mounted' do
-      it 'mounts the disk, calls the provided block, and unmounts' do
-        fake_thing = double('FakeThing')
-        losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
-        shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
-        shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
-        shell.should_receive(:run).with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false)
-        fake_thing.should_receive(:fake_call).with(disk_image).ordered
-        shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).ordered
-        shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
-        shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
-
-        disk_image.while_mounted do |image|
-          fake_thing.fake_call(image)
-        end
-      end
-
-      context 'when the block raises and error' do
-        it 'mounts the disk, calls the provided block, and unmounts' do
-          losetup_commad = 'sudo losetup --show --find /path/to/FAKE_IMAGE'
-          shell.stub(:run).with(losetup_commad, output_command: false).and_return('/dev/loop0')
-          shell.stub(:run).with('sudo kpartx -av /dev/loop0', output_command: false).and_return(kpartx_map_output)
-          shell.should_receive(:run).with('sudo mount /dev/mapper/FAKE_LOOP1p1 /fake/mnt', output_command: false)
-
-          shell.should_receive(:run).with('sudo umount /fake/mnt', output_command: false).ordered
-          shell.should_receive(:run).with('sudo kpartx -dv /dev/loop0', output_command: false).ordered
-          shell.should_receive(:run).with('sudo losetup -dv /dev/loop0', output_command: false).ordered
-
-          expect { disk_image.while_mounted { |_| raise } }.to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/bosh/stemcell/infrastructure_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'bosh/stemcell/infrastructure'
-
-module Bosh::Stemcell
-  describe Infrastructure do
-    describe '.for' do
-      it 'returns the correct infrastrcture' do
-        expect(Infrastructure.for('openstack')).to be_an(Infrastructure::OpenStack)
-        expect(Infrastructure.for('aws')).to be_an(Infrastructure::Aws)
-        expect(Infrastructure.for('vsphere')).to be_a(Infrastructure::Vsphere)
-      end
-
-      it 'raises for unknown instructures' do
-        expect {
-          Infrastructure.for('BAD_INFRASTRUCTURE')
-        }.to raise_error(ArgumentError, /invalid infrastructure: BAD_INFRASTRUCTURE/)
-      end
-    end
-  end
-
-  describe Infrastructure::Base do
-    it 'requires a name to be specified' do
-      expect {
-        Infrastructure::Base.new
-      }.to raise_error /key not found: :name/
-    end
-
-    it 'requires a hypervisor' do
-      expect {
-        Infrastructure::Base.new(name: 'foo', default_disk_size: 1024)
-      }.to raise_error /key not found: :hypervisor/
-    end
-
-    it 'requires a default_disk_size' do
-      expect {
-        Infrastructure::Base.new(name: 'foo', hypervisor: 'xen')
-      }.to raise_error /key not found: :default_disk_size/
-    end
-
-    it 'defaults to not supporting light stemcells' do
-      infrastructure = Infrastructure::Base.new(name: 'foo', hypervisor: 'bar', default_disk_size: 1024)
-      expect(infrastructure).not_to be_light
-    end
-  end
-
-  describe Infrastructure::Aws do
-    its(:name)              { should eq('aws') }
-    its(:hypervisor)        { should eq('xen') }
-    its(:default_disk_size) { should eq(2048) }
-    it { should be_light }
-  end
-
-  describe Infrastructure::OpenStack do
-    its(:name)              { should eq('openstack') }
-    its(:hypervisor)        { should eq('kvm') }
-    its(:default_disk_size) { should eq(10240) }
-    it { should_not be_light }
-  end
-
-  describe Infrastructure::Vsphere do
-    its(:name)              { should eq('vsphere') }
-    its(:hypervisor)        { should eq('esxi') }
-    its(:default_disk_size) { should eq(3072) }
-    it { should_not be_light }
-  end
-end

data/spec/bosh/stemcell/operating_system_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-require 'bosh/stemcell/operating_system'
-
-module Bosh::Stemcell
-  describe OperatingSystem do
-    describe '.for' do
-      it 'returns the correct infrastrcture' do
-        expect(OperatingSystem.for('centos')).to be_a(OperatingSystem::Centos)
-        expect(OperatingSystem.for('ubuntu')).to be_a(OperatingSystem::Ubuntu)
-      end
-
-      it 'raises for unknown operating system' do
-        expect {
-          OperatingSystem.for('BAD_OPERATING_SYSTEM')
-        }.to raise_error(ArgumentError, /invalid operating system: BAD_OPERATING_SYSTEM/)
-      end
-    end
-  end
-
-  describe OperatingSystem::Base do
-    describe '#initialize' do
-      it 'requires :name to be specified' do
-        expect {
-          OperatingSystem::Base.new
-        }.to raise_error /key not found: :name/
-      end
-    end
-
-    describe '#name' do
-      subject { OperatingSystem::Base.new(name: 'CLOUDY_PONY_OS') }
-
-      its(:name) { should eq('CLOUDY_PONY_OS') }
-    end
-  end
-
-  describe OperatingSystem::Centos do
-    subject { OperatingSystem::Centos.new }
-
-    its(:name) { should eq('centos') }
-  end
-
-  describe OperatingSystem::Ubuntu do
-    subject { OperatingSystem::Ubuntu.new }
-
-    its(:name) { should eq('ubuntu') }
-  end
-end

data/spec/bosh/stemcell/stage_collection_spec.rb

@@ -1,279 +0,0 @@
-require 'spec_helper'
-require 'bosh/stemcell/stage_collection'
-
-module Bosh::Stemcell
-  describe StageCollection do
-    subject(:stage_collection) do
-      StageCollection.new(
-        infrastructure: infrastructure,
-        operating_system: operating_system,
-        agent_name: agent_name,
-      )
-    end
-
-    let(:ubuntu_stages) {
-      [
-        :base_debootstrap,
-        :base_apt,
-        :bosh_users,
-        :bosh_monit,
-        :bosh_sysstat,
-        :bosh_sysctl,
-        :bosh_ntpdate,
-        :bosh_sudoers,
-        :system_grub,
-        :system_kernel,
-      ]
-    }
-
-    let(:centos_stages) {
-      [
-        :base_centos,
-        :base_yum,
-        :bosh_users,
-        :bosh_monit,
-        #:bosh_sysstat,
-        #:bosh_sysctl,
-        :bosh_ntpdate,
-        :bosh_sudoers,
-        :system_grub,
-      #:system_kernel,
-      ]
-    }
-
-    let(:aws_infrastructure_stages) {
-      [
-        :system_aws_network,
-        :system_aws_clock,
-        :system_aws_modules,
-        :system_parameters,
-        :bosh_clean,
-        :bosh_harden,
-        :bosh_harden_ssh,
-        :bosh_dpkg_list,
-        :image_create,
-        :image_install_grub,
-        :image_aws_update_grub,
-        :image_aws_prepare_stemcell,
-        :stemcell
-      ]
-    }
-
-    let(:openstack_infrastructure_stages) {
-      [
-        :system_openstack_network,
-        :system_openstack_clock,
-        :system_openstack_modules,
-        :system_parameters,
-        :bosh_clean,
-        :bosh_harden,
-        :bosh_harden_ssh,
-        :bosh_dpkg_list,
-        :image_create,
-        :image_install_grub,
-        :image_openstack_qcow2,
-        :image_openstack_prepare_stemcell,
-        :stemcell_openstack
-      ]
-    }
-
-    let(:vsphere_infrastructure_stages) {
-      [
-        :system_open_vm_tools,
-        :system_parameters,
-        :bosh_clean,
-        :bosh_harden,
-        :bosh_dpkg_list,
-        :image_create,
-        :image_install_grub,
-        :image_vsphere_vmx,
-        :image_vsphere_ovf,
-        :image_vsphere_prepare_stemcell,
-        :stemcell
-      ]
-    }
-
-    let(:vsphere_centos_infrastructure_stages) {
-      [
-        #:system_open_vm_tools,
-        :system_parameters,
-        :bosh_clean,
-        :bosh_harden,
-        #:bosh_dpkg_list,
-        :image_create,
-        :image_install_grub,
-        :image_vsphere_vmx,
-        :image_vsphere_ovf,
-        :image_vsphere_prepare_stemcell,
-        :stemcell
-      ]
-    }
-
-    describe '#all_stages' do
-      context 'when using the ruby agent' do
-        let(:agent_name) { 'ruby' }
-        let(:agent_stages) {
-          [
-            :bosh_ruby,
-            :bosh_agent,
-            :bosh_micro,
-          ]
-        }
-
-        context 'when infrastructure is AWS' do
-          let(:infrastructure) { Infrastructure.for('aws') }
-
-          context 'when operating system is Ubuntu' do
-            let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(ubuntu_stages +
-                                                          agent_stages +
-                                                          aws_infrastructure_stages)
-            end
-          end
-
-          context 'when operating system is Centos' do
-            let(:operating_system) { OperatingSystem.for('centos') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(centos_stages +
-                                                          agent_stages +
-                                                          aws_infrastructure_stages)
-            end
-          end
-        end
-
-        context 'when infrastructure is OpenStack' do
-          let(:infrastructure) { Infrastructure.for('openstack') }
-
-          context 'when operating system is Ubuntu' do
-            let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(ubuntu_stages +
-                                                          agent_stages +
-                                                          openstack_infrastructure_stages)
-            end
-          end
-
-          context 'when operating system is CentOS' do
-            let(:operating_system) { OperatingSystem.for('centos') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(centos_stages +
-                                                          agent_stages +
-                                                          openstack_infrastructure_stages)
-            end
-          end
-        end
-
-        context 'when infrastructure is vSphere' do
-          let(:infrastructure) { Infrastructure.for('vsphere') }
-
-          context 'when operating system is Ubuntu' do
-            let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(ubuntu_stages +
-                                                          agent_stages +
-                                                          vsphere_infrastructure_stages)
-            end
-          end
-
-          context 'when operating system is CentOS' do
-            let(:operating_system) { OperatingSystem.for('centos') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(centos_stages +
-                                                          agent_stages +
-                                                          vsphere_centos_infrastructure_stages)
-            end
-          end
-        end
-      end
-
-      context 'when using the go agent' do
-        let(:agent_name) { 'go' }
-        let(:agent_stages) {
-          [
-            :bosh_go_agent,
-            #:bosh_micro,
-          ]
-        }
-
-        context 'when infrastructure is AWS' do
-          let(:infrastructure) { Infrastructure.for('aws') }
-
-          context 'when operating system is Ubuntu' do
-            let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(ubuntu_stages +
-                                                          agent_stages +
-                                                          aws_infrastructure_stages)
-            end
-          end
-
-          context 'when operating system is Centos' do
-            let(:operating_system) { OperatingSystem.for('centos') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(centos_stages +
-                                                          agent_stages +
-                                                          aws_infrastructure_stages)
-            end
-          end
-        end
-
-        context 'when infrastructure is OpenStack' do
-          let(:infrastructure) { Infrastructure.for('openstack') }
-
-          context 'when operating system is Ubuntu' do
-            let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(ubuntu_stages +
-                                                          agent_stages +
-                                                          openstack_infrastructure_stages)
-            end
-          end
-
-          context 'when operating system is CentOS' do
-            let(:operating_system) { OperatingSystem.for('centos') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(centos_stages +
-                                                          agent_stages +
-                                                          openstack_infrastructure_stages)
-            end
-          end
-        end
-
-        context 'when infrastructure is vSphere' do
-          let(:infrastructure) { Infrastructure.for('vsphere') }
-
-          context 'when operating system is Ubuntu' do
-            let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(ubuntu_stages +
-                                                          agent_stages +
-                                                          vsphere_infrastructure_stages)
-            end
-          end
-
-          context 'when operating system is CentOS' do
-            let(:operating_system) { OperatingSystem.for('centos') }
-
-            it 'has the correct stages' do
-              expect(stage_collection.all_stages).to eq(centos_stages +
-                                                          agent_stages +
-                                                          vsphere_centos_infrastructure_stages)
-            end
-          end
-        end
-      end
-    end
-  end
-end