bosh-stemcell 1.5.0.pre.1209 → 1.5.0.pre.1210

data/Berksfile

@@ -0,0 +1,3 @@
+site :opscode
+
+cookbook 'golang'

data/Berksfile.lock

@@ -0,0 +1,28 @@
+{
+  "sources": {
+    "golang": {
+      "locked_version": "1.1.2"
+    },
+    "git": {
+      "locked_version": "2.7.0"
+    },
+    "dmg": {
+      "locked_version": "2.0.4"
+    },
+    "build-essential": {
+      "locked_version": "1.4.2"
+    },
+    "yum": {
+      "locked_version": "2.4.0"
+    },
+    "windows": {
+      "locked_version": "1.11.0"
+    },
+    "chef_handler": {
+      "locked_version": "1.1.4"
+    },
+    "runit": {
+      "locked_version": "1.3.0"
+    }
+  }
+}

data/Vagrantfile

@@ -33,5 +33,18 @@ Vagrant.configure('2') do |config|
     BASH
   end
 
+  config.omnibus.chef_version = :latest
+  config.berkshelf.enabled = true
+
+  config.vm.provision :chef_solo do |chef|
+    chef.run_list = %w(recipe[golang])
+
+    chef.json = {
+      go: {
+        version: '1.1.2',
+      }
+    }
+  end
+
   config.vm.synced_folder '../', '/bosh'
 end

data/lib/bosh/stemcell/builder_command.rb

@@ -14,6 +14,7 @@ module Bosh::Stemcell
       @environment = env
       @infrastructure = Infrastructure.for(options.fetch(:infrastructure_name))
       @operating_system = OperatingSystem.for(options.fetch(:operating_system_name))
+      @agent_name = options.fetch(:agent_name) || 'ruby'
 
       @stemcell_builder_options = BuilderOptions.new(
         env,
@@ -40,7 +41,8 @@ module Bosh::Stemcell
 
       stage_collection = StageCollection.new(
         infrastructure: infrastructure,
-        operating_system: operating_system
+        operating_system: operating_system,
+        agent_name: agent_name,
       )
       stage_runner = StageRunner.new(
         build_path: build_path,
@@ -48,8 +50,7 @@ module Bosh::Stemcell
         settings_file: settings_path,
         work_path: work_root
       )
-      stage_runner.configure_and_apply(stage_collection.operating_system_stages)
-      stage_runner.configure_and_apply(stage_collection.infrastructure_stages)
+      stage_runner.configure_and_apply(stage_collection.all_stages)
       system(rspec_command) || raise('Stemcell specs failed')
 
       stemcell_file
@@ -66,6 +67,7 @@ module Bosh::Stemcell
       :environment,
       :infrastructure,
       :operating_system,
+      :agent_name,
       :stemcell_builder_options
     )
 
@@ -75,6 +77,7 @@ module Bosh::Stemcell
         "STEMCELL_IMAGE=#{image_file_path}",
         'bundle exec rspec -fd',
         "spec/stemcells/#{operating_system.name}_spec.rb",
+        "spec/stemcells/#{agent_name}_agent_spec.rb",
         "spec/stemcells/#{infrastructure.name}_spec.rb",
       ].join(' ')
     end

data/lib/bosh/stemcell/builder_options.rb

@@ -27,6 +27,7 @@ module Bosh::Stemcell
         'ruby_bin' => ruby_bin,
         'bosh_release_src_dir' => File.join(source_root, 'release/src/bosh'),
         'bosh_agent_src_dir' => File.join(source_root, 'bosh_agent'),
+        'go_agent_src_dir' => File.join(source_root, 'go_agent'),
         'image_create_disk_size' => image_create_disk_size
       }.merge(bosh_micro_options).merge(environment_variables).merge(vsphere_options)
     end

data/lib/bosh/stemcell/stage_collection.rb

@@ -5,8 +5,33 @@ module Bosh::Stemcell
   class StageCollection
 
     def initialize(options)
-      @infrastructure   = options.fetch(:infrastructure)
+      @infrastructure = options.fetch(:infrastructure)
       @operating_system = options.fetch(:operating_system)
+      @agent_name = options.fetch(:agent_name)
+    end
+
+    def all_stages
+      operating_system_stages + agent_stages + infrastructure_stages
+    end
+
+    private
+
+    attr_reader :infrastructure, :operating_system, :agent_name
+
+    def agent_stages
+      case agent_name
+        when 'go'
+          [
+            :bosh_go_agent,
+            #:bosh_micro,
+          ]
+        else
+          [
+            :bosh_ruby,
+            :bosh_agent,
+            :bosh_micro,
+          ]
+      end
     end
 
     def operating_system_stages
@@ -29,26 +54,18 @@ module Bosh::Stemcell
       end
     end
 
-    private
-
-    attr_reader :infrastructure, :operating_system
-
     def hacked_centos_common
       [
         # Bosh steps
         :bosh_users,
         :bosh_monit,
-        :bosh_ruby,
-        :bosh_agent,
         #:bosh_sysstat,
         #:bosh_sysctl,
         :bosh_ntpdate,
         :bosh_sudoers,
-        # Micro BOSH
-        :bosh_micro,
         # Install GRUB/kernel/etc
         :system_grub,
-        #:system_kernel,
+      #:system_kernel,
       ]
     end
 
@@ -73,14 +90,10 @@ module Bosh::Stemcell
         # Bosh steps
         :bosh_users,
         :bosh_monit,
-        :bosh_ruby,
-        :bosh_agent,
         :bosh_sysstat,
         :bosh_sysctl,
         :bosh_ntpdate,
         :bosh_sudoers,
-        # Micro BOSH
-        :bosh_micro,
         # Install GRUB/kernel/etc
         :system_grub,
         :system_kernel,

data/lib/bosh/stemcell/version.rb

@@ -1,5 +1,5 @@
 module Bosh
   module Stemcell
-    VERSION = '1.5.0.pre.1209'
+    VERSION = '1.5.0.pre.1210'
   end
 end

data/spec/bosh/stemcell/builder_command_spec.rb

@@ -8,6 +8,7 @@ module Bosh::Stemcell
         env,
         infrastructure_name: infrastructure.name,
         operating_system_name: operating_system.name,
+        agent_name: agent_name,
         release_tarball_path: release_tarball_path,
         version: version
       )
@@ -15,6 +16,9 @@ module Bosh::Stemcell
 
     let(:env) { {} }
 
+    let(:agent_name) { 'ruby' }
+    let(:expected_agent_name) { 'ruby' }
+
     let(:infrastructure) do
       instance_double(
         'Bosh::Stemcell::Infrastructure::Vsphere',
@@ -32,7 +36,8 @@ module Bosh::Stemcell
       OperatingSystem.stub(:for).with(operating_system.name).and_return(operating_system)
       StageCollection.stub(:new).with(
         infrastructure: infrastructure,
-        operating_system: operating_system
+        operating_system: operating_system,
+        agent_name: agent_name,
       ).and_return(stage_collection)
 
       StageRunner.stub(:new).with(
@@ -62,8 +67,7 @@ module Bosh::Stemcell
     let(:stage_collection) do
       instance_double(
         'Bosh::Stemcell::StageCollection',
-        operating_system_stages: ['FAKE_OS_STAGES'],
-        infrastructure_stages: ['FAKE_INFRASTRUCTURE_STAGES']
+        all_stages: %w(FAKE_OS_STAGES FAKE_INFRASTRUCTURE_STAGES)
       )
     end
 
@@ -97,6 +101,36 @@ module Bosh::Stemcell
         end
       end
 
+      context 'when agent_name is nil' do
+        let(:agent_name) { nil }
+        let(:expected_agent_name) { 'ruby' }
+
+        it 'uses the correct agent name for the stage collection' do
+          StageCollection.should_receive(:new).with(
+            infrastructure: infrastructure,
+            operating_system: operating_system,
+            agent_name: expected_agent_name,
+          ).and_return(stage_collection)
+
+          stemcell_builder_command.build
+        end
+      end
+
+      context 'when agent_name is foo' do
+        let(:agent_name) { 'foo' }
+        let(:expected_agent_name) { 'foo' }
+
+        it 'uses the correct agent name for the stage collection' do
+          StageCollection.should_receive(:new).with(
+            infrastructure: infrastructure,
+            operating_system: operating_system,
+            agent_name: expected_agent_name,
+          ).and_return(stage_collection)
+
+          stemcell_builder_command.build
+        end
+      end
+
       describe 'sanitizing the environment' do
         it 'removes any tgz files from current working directory' do
           expect {
@@ -170,15 +204,14 @@ module Bosh::Stemcell
             "STEMCELL_IMAGE=#{File.join(root_dir, 'work', 'work', 'fake-root-disk-image.raw')}",
             'bundle exec rspec -fd',
             "spec/stemcells/#{operating_system.name}_spec.rb",
+            "spec/stemcells/#{agent_name}_agent_spec.rb",
             "spec/stemcells/#{infrastructure.name}_spec.rb",
           ].join(' ')
         end
 
         it 'calls #configure_and_apply' do
           stage_runner.should_receive(:configure_and_apply).
-            with(['FAKE_OS_STAGES']).ordered
-          stage_runner.should_receive(:configure_and_apply).
-            with(['FAKE_INFRASTRUCTURE_STAGES']).ordered
+            with(%w(FAKE_OS_STAGES FAKE_INFRASTRUCTURE_STAGES)).ordered
           stemcell_builder_command.should_receive(:system).
             with(expected_rspec_command).ordered
 
@@ -190,9 +223,7 @@ module Bosh::Stemcell
 
           it 'calls #configure_and_apply' do
             stage_runner.should_receive(:configure_and_apply).
-              with(['FAKE_OS_STAGES']).ordered
-            stage_runner.should_receive(:configure_and_apply).
-              with(['FAKE_INFRASTRUCTURE_STAGES']).ordered
+              with(%w(FAKE_OS_STAGES FAKE_INFRASTRUCTURE_STAGES)).ordered
             stemcell_builder_command.should_receive(:system).
               with(expected_rspec_command).ordered
 

data/spec/bosh/stemcell/builder_options_spec.rb

@@ -108,6 +108,7 @@ module Bosh::Stemcell
             expect(result['ruby_bin']).to eq('fake_ruby_bin')
             expect(result['bosh_release_src_dir']).to eq(File.join(expected_source_root, '/release/src/bosh'))
             expect(result['bosh_agent_src_dir']).to eq(File.join(expected_source_root, 'bosh_agent'))
+            expect(result['go_agent_src_dir']).to eq(File.join(expected_source_root, 'go_agent'))
             expect(result['image_create_disk_size']).to eq(default_disk_size)
             expect(result['bosh_micro_enabled']).to eq('yes')
             expect(result['bosh_micro_package_compiler_path']).to eq(

data/spec/bosh/stemcell/stage_collection_spec.rb

@@ -5,206 +5,272 @@ module Bosh::Stemcell
   describe StageCollection do
     subject(:stage_collection) do
       StageCollection.new(
-        infrastructure:   infrastructure,
-        operating_system: operating_system
+        infrastructure: infrastructure,
+        operating_system: operating_system,
+        agent_name: agent_name,
       )
     end
 
-    describe '#operating_system_stages' do
-      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.operating_system_stages).to eq([
-              :base_debootstrap,
-              :base_apt,
-              :bosh_users,
-              :bosh_monit,
-              :bosh_ruby,
-              :bosh_agent,
-              :bosh_sysstat,
-              :bosh_sysctl,
-              :bosh_ntpdate,
-              :bosh_sudoers,
-              :bosh_micro,
-              :system_grub,
-              :system_kernel,
-            ])
+    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
-        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.operating_system_stages).to eq([
-              :base_debootstrap,
-              :base_apt,
-              :bosh_users,
-              :bosh_monit,
-              :bosh_ruby,
-              :bosh_agent,
-              :bosh_sysstat,
-              :bosh_sysctl,
-              :bosh_ntpdate,
-              :bosh_sudoers,
-              :bosh_micro,
-              :system_grub,
-              :system_kernel,
-            ])
+          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
-      end
 
-      context 'when infrastructure is vSphere' do
-        let(:infrastructure) { Infrastructure.for('vsphere') }
-
-        context 'when operating system is CentOS' do
-          let(:operating_system) { OperatingSystem.for('centos') }
-
-          it 'has the correct stages' do
-            expect(stage_collection.operating_system_stages).to eq([
-              :base_centos,
-              :base_yum,
-              :bosh_users,
-              :bosh_monit,
-              :bosh_ruby,
-              :bosh_agent,
-              #:bosh_sysstat,
-              #:bosh_sysctl,
-              :bosh_ntpdate,
-              :bosh_sudoers,
-              :bosh_micro,
-              :system_grub,
-              #:system_kernel,
-            ])
+        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
-        end
 
-        context 'when operating system is Ubuntu' do
-          let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-          it 'has the correct stages' do
-            expect(stage_collection.operating_system_stages).to eq([
-              :base_debootstrap,
-              :base_apt,
-              :bosh_users,
-              :bosh_monit,
-              :bosh_ruby,
-              :bosh_agent,
-              :bosh_sysstat,
-              :bosh_sysctl,
-              :bosh_ntpdate,
-              :bosh_sudoers,
-              :bosh_micro,
-              :system_grub,
-              :system_kernel,
-            ])
+          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
-      end
-    end
 
-    describe '#infrastructure_stages' do
-      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.infrastructure_stages).to eq([
-              :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
-            ])
+        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 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.infrastructure_stages).to eq([
-              :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
-            ])
+      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
-      end
 
-      context 'when infrastructure is vSphere' do
-        let(:infrastructure) { Infrastructure.for('vsphere') }
-
-        context 'when operating system is CentOS' do
-          let(:operating_system) { OperatingSystem.for('centos') }
-
-          it 'has the correct stages' do
-            expect(stage_collection.infrastructure_stages).to eq([
-              #: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
-            ])
+        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 operating system is Ubuntu' do
-          let(:operating_system) { OperatingSystem.for('ubuntu') }
-
-          it 'has the correct stages' do
-            expect(stage_collection.infrastructure_stages).to eq([
-              :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
-            ])
+        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

data/spec/stemcells/go_agent_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'Stemcell with Go Agent' do
+  describe 'installed by bosh_go_agent' do
+    describe file('/var/vcap/bosh/bin/bosh-agent') do
+      it { should be_file }
+      it { should be_executable }
+    end
+  end
+end

data/spec/stemcells/ruby_agent_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Stemcell with Ruby Agent' do
+  describe 'installed by bosh_ruby' do
+    describe command('/var/vcap/bosh/bin/ruby -r yaml -e "Psych::SyntaxError"') do
+      it { should return_exit_status(0) }
+    end
+  end
+
+  describe 'installed by bosh_agent' do
+    describe command('/var/vcap/bosh/bin/ruby -r bosh_agent -e "Bosh::Agent"') do
+      it { should return_exit_status(0) }
+    end
+  end
+
+  context 'installed by bosh_micro' do
+    describe file('/var/vcap/micro/apply_spec.yml') do
+      it { should be_file }
+      it { should contain 'deployment: micro' }
+      it { should contain 'powerdns' }
+    end
+
+    describe file('/var/vcap/micro_bosh/data/cache') do
+      it { should be_a_directory }
+    end
+  end
+end

data/spec/support/stemcell_shared_examples.rb

@@ -1,16 +1,4 @@
 shared_examples_for 'a stemcell' do
-  describe 'installed by bosh_ruby' do
-    describe command('/var/vcap/bosh/bin/ruby -r yaml -e "Psych::SyntaxError"') do
-      it { should return_exit_status(0) }
-    end
-  end
-
-  describe 'installed by bosh_agent' do
-    describe command('/var/vcap/bosh/bin/ruby -r bosh_agent -e "Bosh::Agent"') do
-      it { should return_exit_status(0) }
-    end
-  end
-
   context 'installed by bosh_sudoers' do
     describe file('/etc/sudoers') do
       it { should be_file }
@@ -18,18 +6,6 @@ shared_examples_for 'a stemcell' do
     end
   end
 
-  context 'installed by bosh_micro' do
-    describe file('/var/vcap/micro/apply_spec.yml') do
-      it { should be_file }
-      it { should contain 'deployment: micro' }
-      it { should contain 'powerdns' }
-    end
-
-    describe file('/var/vcap/micro_bosh/data/cache') do
-      it { should be_a_directory }
-    end
-  end
-
   # currently `should cotain` on a file does not properly escape $PATH
   context 'installed by bosh_users' do
     describe command("grep -q 'export PATH=/var/vcap/bosh/bin:\\$PATH\n' /root/.bashrc") do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bosh-stemcell
 version: !ruby/object:Gem::Version
-  version: 1.5.0.pre.1209
+  version: 1.5.0.pre.1210
   prerelease: 6
 platform: ruby
 authors:
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.0.pre.1209
+        version: 1.5.0.pre.1210
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.0.pre.1209
+        version: 1.5.0.pre.1210
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -130,6 +130,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .rspec
+- Berksfile
+- Berksfile.lock
 - README.md
 - Vagrantfile
 - bosh-stemcell.gemspec
@@ -169,7 +171,9 @@ files:
 - spec/spec_helper.rb
 - spec/stemcells/aws_spec.rb
 - spec/stemcells/centos_spec.rb
+- spec/stemcells/go_agent_spec.rb
 - spec/stemcells/openstack_spec.rb
+- spec/stemcells/ruby_agent_spec.rb
 - spec/stemcells/ubuntu_spec.rb
 - spec/stemcells/vsphere_spec.rb
 - spec/support/rspec_fire.rb
@@ -225,7 +229,9 @@ test_files:
 - spec/spec_helper.rb
 - spec/stemcells/aws_spec.rb
 - spec/stemcells/centos_spec.rb
+- spec/stemcells/go_agent_spec.rb
 - spec/stemcells/openstack_spec.rb
+- spec/stemcells/ruby_agent_spec.rb
 - spec/stemcells/ubuntu_spec.rb
 - spec/stemcells/vsphere_spec.rb
 - spec/support/rspec_fire.rb