bosh-bootstrap 0.10.2 → 0.11.0

data/spec/integration/aws/aws_edge_spec.rb

@@ -1,45 +0,0 @@
-require File.expand_path("../../../spec_helper", __FILE__)
-require File.expand_path("../aws_helpers", __FILE__)
-
-require "active_support/core_ext/hash/keys"
-
-describe "AWS deployment using Bosh edge from source" do
-  include FileUtils
-  include Bosh::Bootstrap::Helpers::SettingsSetter
-  include AwsHelpers
-
-  attr_reader :bosh_name
-
-  before { prepare_aws("bosh-edge", aws_region) }
-  # after { destroy_test_constructs(bosh_name) unless keep_after_test? }
-
-  def aws_region
-    ENV['AWS_REGION'] || "us-west-2"
-  end
-
-  it "creates an EC2 inception/microbosh with the associated resources" do
-    create_manifest("edge" => true)
-
-    manifest_file = home_file(".bosh_bootstrap", "manifest.yml")
-    File.should be_exists(manifest_file)
-
-    cmd.deploy
-
-    ip_adresses = fog.addresses
-    public_ips = ip_adresses.map(&:public_ip)
-
-    inception_vms = provider.servers_with_sg("#{bosh_name}-inception-vm")
-    inception_vms.size.should == 1
-
-    # TODO inception VM is not getting its IP address bound correctly
-    # https://github.com/StarkAndWayne/bosh-bootstrap/issues/174
-    # public_ips.include?(inception_vms.first.public_ip_address).should be_true
-
-    micrboshes = provider.servers_with_sg(bosh_name)
-    micrboshes.size.should == 1
-    public_ips.include?(micrboshes.first.public_ip_address).should be_true
-
-    # TODO - microbosh stemcell in /var/vcap/store/stemcells
-  end
-
-end

data/spec/unit/aws_spec.rb

@@ -1,177 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-require "active_support/core_ext/hash/keys"
-
-describe "AWS deployment" do
-  include FileUtils
-  include Bosh::Bootstrap::Helpers::SettingsSetter
-
-  before do
-    Fog.mock!
-    Fog::Mock.reset
-    @cmd = Bosh::Bootstrap::Cli.new
-    @fog_credentials = {
-      :provider                 => 'AWS',
-      :aws_secret_access_key    => 'XXX',
-      :aws_access_key_id        => 'YYY'
-    }
-
-    @region = "us-west-2"
-    setting "bosh_provider", "aws"
-    setting "region_code", @region
-    setting "bosh_name", "test-bosh"
-    setting "inception.create_new", true
-    setting "bosh_username", "testuser"
-    setting "bosh_password", "testpass"
-    setting "fog_credentials", @fog_credentials.stringify_keys
-    setting "bosh.salted_password", "pepper"
-    setting "bosh.persistent_disk", 16384
-    setting "git.name", "Dr Nic Williams"
-    setting "git.email", "drnicwilliams@gmail.com"
-  end
-
-  # used by +SettingsSetter+ to access the settings
-  def settings
-    @cmd.settings
-  end
-
-  def fog
-    @fog ||= connection = Fog::Compute.new(@fog_credentials.merge(:region => @region))
-  end
-
-  def expected_manifest_content(filename, public_ip, subnet_id = nil)
-    file = File.read(filename)
-    file.gsub!('$MICROBOSH_IP$', public_ip)
-    file.gsub!('$SUBNET_ID$', subnet_id) if subnet_id
-    YAML.load(file)
-  end
-
-  xit "creates a VPC inception/microbosh with the associated resources" do
-    # create a VPC
-    # create a BOSH subnet 10.10.0.0/24
-    # create BOSH security group
-    # create INCEPTION security group allowing only 22
-    # create NATS security group, allowing only 4222
-    # create DHCP options with 2 nameserver (1 amazon for public resolves, 1 for private resolves (.bosh)?)
-    # create Internet Gateway, attach to VPC
-    # create default route (0.0.0.0/0) to IG
-
-    # create inception VM (attaching elastic IP, sg of [BOSH, INCEPTION]) in BOSH subnet at 10.10.0.5
-    # create MB VM from inception VM (sg of [BOSH, NATS])  in BOSH subnet at 10.10.0.6
-
-    setting "use_vpc", true # TODO include in cli.rb
-
-    @cmd.should_receive(:provision_and_mount_volume)
-    @cmd.stub(:run_server).and_return(true)
-    @cmd.stub(:sleep)
-    @cmd.should_receive(:deploy_stage_8_setup_new_bosh)
-    @cmd.deploy
-
-    fog.addresses.should have(1).item # assigned to inception VM
-    inception_ip_address = fog.addresses.first
-
-    fog.vpcs.should have(1).item
-    vpc = fog.vpcs.first
-    vpc.cidr_block.should == "10.0.0.0/16"
-
-    fog.servers.should have(1).item
-    inception = fog.servers.first
-    inception_ip_address.domain.should == "vpc"
-
-    # TODO - fix fog so we can test public_ip_address
-    # inception.public_ip_address.should == inception_ip_address.public_ip
-
-    # TODO - fix fog so we can test private_ip_address
-    # inception.private_ip_address.should == "10.0.0.5"
-
-    fog.security_groups.should have(3).item
-
-    fog.internet_gateways.should have(1).item
-    ig = fog.internet_gateways.first
-
-    fog.subnets.should have(1).item
-    subnet = fog.subnets.first
-    subnet.vpc_id.should == vpc.id
-    subnet.cidr_block.should == "10.0.0.0/24"
-
-    # fog.route_tables.should have(1).item
-    # a IG that is assigned to the VPN
-    # a subnet (contains the inception VM; is included in micro_bosh_yml)
-
-    # TODO - fix fog so we can test private_ip_address
-    # settings["inception"]["ip_address"].should == "10.0.0.5"
-
-    inception_server = fog.servers.first
-    inception_server.dns_name.should == settings["inception"]["host"]
-    inception_server.groups.should == [settings["inception"]["security_group"]]
-
-    public_ip = settings["bosh"]["ip_address"]
-    public_ip.should == "10.0.0.6"
-
-    manifest_path = spec_asset("micro_bosh_yml/micro_bosh.aws_ec2.yml")
-    YAML.load(@cmd.micro_bosh_yml).should == expected_manifest_content(manifest_path, public_ip, subnet.subnet_id)
-  end
-
-  it "creates an EC2 inception/microbosh with the associated resources" do
-    setting "use_vpc", false
-
-    @cmd.should_receive(:provision_and_mount_volume)
-    @cmd.stub(:run_server).and_return(true)
-    @cmd.stub(:sleep)
-    @cmd.should_receive(:deploy_stage_8_setup_new_bosh)
-    @cmd.deploy
-    @settings = nil # reload settings file
-
-    # TODO we are temporarily using prebuilt stemcells by default for AWS
-    settings["micro_bosh_stemcell_type"].should == "edge-prebuilt"
-
-    fog.addresses.should have(2).item
-    inception_ip_address = fog.addresses.first
-    inception_ip_address.domain.should == "standard"
-
-    inception_kp = fog.key_pairs.find { |kp| kp.name == "inception" }
-    inception_kp.should_not be_nil
-
-    inception_kp = fog.key_pairs.find { |kp| kp.name == "fog_default" }
-    inception_kp.should be_nil
-
-    fog.key_pairs.should have(2).item
-
-    settings["inception"].should_not be_nil
-    settings["inception"]["key_pair"].should_not be_nil
-    settings["inception"]["key_pair"]["name"].should_not be_nil
-    settings["inception"]["key_pair"]["private_key"].should_not be_nil
-    settings["inception"]["local_private_key_path"].should == File.join(ENV['HOME'], ".bosh_bootstrap", "ssh", "inception")
-    File.should_not be_world_readable(settings["inception"]["local_private_key_path"])
-
-    fog.vpcs.should have(0).item
-    fog.servers.should have(1).item
-    fog.security_groups.should have(3).item
-
-    inception_server = fog.servers.first
-    inception_server.dns_name.should == settings["inception"]["host"]
-    inception_server.groups.should == [settings["inception"]["security_group"]]
-    
-    public_ip = settings["bosh"]["ip_address"]
-    manifest_path = spec_asset("micro_bosh_yml/micro_bosh.aws_ec2.yml")
-    YAML.load(@cmd.micro_bosh_yml).should == expected_manifest_content(manifest_path, public_ip)
-  end
-
-  it "uses pre-built gems and AMIs for us-east-1 created from jenkins" do
-    @cmd.should_receive(:provision_and_mount_volume)
-    @cmd.stub(:run_server).and_return(true)
-    @cmd.stub(:sleep)
-    @cmd.should_receive(:deploy_stage_8_setup_new_bosh)
-    @cmd.should_receive(:latest_prebuilt_microbosh_ami).and_return("ami-123456")
-
-    setting "edge-prebuilt", true
-    @cmd.deploy
-
-    settings["micro_bosh_stemcell_type"].should == "ami"
-    settings["micro_bosh_stemcell_name"].should == "ami-123456"
-
-    public_ip = settings["bosh"]["ip_address"]
-    manifest_path = spec_asset("micro_bosh_yml/micro_bosh.aws_ec2.yml")
-    YAML.load(@cmd.micro_bosh_yml).should == expected_manifest_content(manifest_path, public_ip)
-  end
-end

data/spec/unit/bosh/providers/aws_spec.rb

@@ -1,174 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require File.expand_path("../../../../spec_helper", __FILE__)
-
-# Specs for the aws provider
-describe Bosh::Providers do
-  include FileUtils
-
-  describe "AWS" do
-    before do
-      Fog.mock!
-      @fog_compute =  Fog::Compute.new(
-          :provider  => 'AWS', 
-          :aws_access_key_id  => 'MOCK_AWS_ACCESS_KEY_ID',
-          :aws_secret_access_key  => 'MOCK_AWS_SECRET_ACCESS_KEY')
-      @aws_provider = Bosh::Providers.for_bosh_provider_name("aws", @fog_compute)
-    end
-
-    describe "create security group" do
-      it "should open a single TCP port on a security group" do
-        ports = { ssh: 22 }
-        @aws_provider.create_security_group("sg1-name", "sg1-desc", ports)
-        created_sg = @fog_compute.security_groups.get("sg1-name")
-        created_sg.name.should == "sg1-name"
-        created_sg.description.should == "sg1-desc"
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"tcp",
-            "fromPort"=>22, 
-            "toPort"=>22, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-      it "should open a range of TCP ports" do
-        ports = { ssh: (22..30) }
-        @aws_provider.create_security_group("sg-range-name", "sg-range-desc", ports)
-        created_sg = @fog_compute.security_groups.get("sg-range-name")
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"tcp",
-            "fromPort"=>22, 
-            "toPort"=>30, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-      it "should open a range of UDP ports" do
-        ports = { ssh: { protocol: "udp", ports: (60000..600050) } }
-        @aws_provider.create_security_group("sg-range-udp-name", "sg-range-udp-name", ports)
-        created_sg = @fog_compute.security_groups.get("sg-range-udp-name")
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"udp",
-            "fromPort"=>60000, 
-            "toPort"=>600050, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-      it "should open a range of ICMP ports" do
-        ports = { ping: { protocol: "icmp", ports: (3..4) } }
-        @aws_provider.create_security_group("sg-range-icmp-name", "sg-range-icmp-name", ports)
-        created_sg = @fog_compute.security_groups.get("sg-range-icmp-name")
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"icmp",
-            "fromPort"=>3, 
-            "toPort"=>4, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-      it "should open not open ports if they are already open" do
-        @aws_provider.create_security_group("sg2", "", { ssh: { protocol: "udp", ports: (60000..600050) } })
-        @aws_provider.create_security_group("sg2", "", { ssh: { protocol: "udp", ports: (60010..600040) } })
-        @aws_provider.create_security_group("sg2", "", { ssh: { protocol: "udp", ports: (60000..600050) } })
-        created_sg = @fog_compute.security_groups.get("sg2")
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"udp",
-            "fromPort"=>60000, 
-            "toPort"=>600050, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-      it "should open ports even if they are already open for a different protocol" do
-        @aws_provider.create_security_group("sg3", "", { ssh: { protocol: "udp", ports: (60000..600050) } })
-        @aws_provider.create_security_group("sg3", "", { ssh: { protocol: "tcp", ports: (60000..600050) } })
-        created_sg = @fog_compute.security_groups.get("sg3")
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"udp",
-            "fromPort"=>60000, 
-            "toPort"=>600050, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          },
-          { 
-            "ipProtocol"=>"tcp",
-            "fromPort"=>60000, 
-            "toPort"=>600050, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-      it "should open ports even if they are already open for a different ip_range" do
-        default_ports = {
-           all_internal_tcp: { protocol: "tcp", ip_range: "1.1.1.1/32", ports: (0..65535) }
-        }
-        @aws_provider.create_security_group("sg6", "sg6", default_ports)
-        @aws_provider.create_security_group("sg6", "sg6", { mosh: { protocol: "tcp", ports: (15..30) } })
-        created_sg = @fog_compute.security_groups.get("sg6")
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"tcp",
-            "fromPort"=>0, 
-            "toPort"=>65535, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"1.1.1.1/32" } ] 
-          },
-          { 
-            "ipProtocol"=>"tcp",
-            "fromPort"=>15, 
-            "toPort"=>30, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-      it "should open ports on the default sg" do
-        @aws_provider.create_security_group("default", "default", { mosh: { protocol: "tcp", ports: (15..30) } })
-        created_sg = @fog_compute.security_groups.get("default")
-        expected_rule = { 
-            "ipProtocol"=>"tcp",
-            "fromPort"=>15, 
-            "toPort"=>30, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        created_sg.ip_permissions.should include expected_rule
-      end
-      #AWS allows overlapping port ranges, and it makes it easier to see the separate "rules" that were added
-      it "should create overlapping port ranges" do
-        @aws_provider.create_security_group("sg4", "", { ssh: { protocol: "udp", ports: (10..20) } })
-        @aws_provider.create_security_group("sg4", "", { ssh: { protocol: "udp", ports: (15..30) } })
-        created_sg = @fog_compute.security_groups.get("sg4")
-        created_sg.ip_permissions.should == [
-          { 
-            "ipProtocol"=>"udp",
-            "fromPort"=>10, 
-            "toPort"=>20, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          },
-          { 
-            "ipProtocol"=>"udp",
-            "fromPort"=>15, 
-            "toPort"=>30, 
-            "groups"=>[], 
-            "ipRanges"=>[ { "cidrIp"=>"0.0.0.0/0" } ] 
-          }
-        ]
-      end
-    end
-  end
-end

data/spec/unit/cli_spec.rb

@@ -1,134 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-describe Bosh::Bootstrap do
-  include FileUtils
-  include Bosh::Bootstrap::Helpers::SettingsSetter
-
-  before do
-    @cmd = Bosh::Bootstrap::Cli.new
-    setting "git.name", "Dr Nic Williams"
-    setting "git.email", "drnicwilliams@gmail.com"
-  end
-
-  # stub out all stages except a specific one
-  # +stage+ can either be the stage number or name
-  def testing_stage(stage)
-    stage_methods = %w[
-      deploy_stage_1_choose_infrastructure_provider
-      deploy_stage_2_bosh_configuration
-      deploy_stage_3_create_allocate_inception_vm
-      deploy_stage_4_prepare_inception_vm
-      deploy_stage_5_salted_password
-      deploy_stage_6_download_micro_bosh
-      deploy_stage_7_deploy_micro_bosh
-      deploy_stage_8_setup_new_bosh
-    ]
-    stage_methods.each do |method|
-      unless method =~ /#{stage}/
-        @cmd.should_receive(method.to_sym)
-      end
-    end
-  end
-
-  # used by +SettingsSetter+ to access the settings
-  def settings
-    @cmd.settings
-  end
-
-  describe "deploy" do
-    it "goes through stages" do
-      @cmd.should_receive(:deploy_stage_1_choose_infrastructure_provider)
-      @cmd.should_receive(:deploy_stage_2_bosh_configuration)
-      @cmd.should_receive(:deploy_stage_3_create_allocate_inception_vm)
-      @cmd.should_receive(:deploy_stage_4_prepare_inception_vm)
-      @cmd.should_receive(:deploy_stage_5_salted_password)
-      @cmd.should_receive(:deploy_stage_6_download_micro_bosh)
-      @cmd.should_receive(:deploy_stage_7_deploy_micro_bosh)
-      @cmd.should_receive(:deploy_stage_8_setup_new_bosh)
-      @cmd.deploy
-    end
-
-    it "stage 3 - create inception VM" do
-      testing_stage(3)
-      setting "inception.username", "ubuntu"
-      setting "inception.key_pair.private_key", "INCEPTION_PRIVATE_KEY"
-      setting "inception.key_pair.public_key", "INCEPTION_PUBLIC_KEY"
-      setting "inception.key_pair.name", "inception"
-      setting "fog_credentials.provider", "AWS"
-      @cmd.should_receive(:run_server).and_return(true)
-      @cmd.deploy
-    end
-
-    it "stage 4 - prepare inception VM" do
-      testing_stage(4)
-      @cmd.should_receive(:recreate_local_ssh_keys_for_inception_vm)
-      setting "inception.username", "ubuntu"
-      setting "bosh.password", "UNSALTED"
-      @cmd.should_receive(:run_server).and_return(true)
-      @cmd.deploy
-    end
-
-    it "stage 7 - deploy microbosh" do
-      testing_stage(7)
-      @cmd.should_receive(:recreate_local_ssh_keys_for_inception_vm)
-      setting "bosh_provider", "aws"
-      setting "micro_bosh_stemcell_name", "micro-bosh-stemcell-aws-0.8.1.tgz"
-      setting "bosh_username", "drnic"
-      setting "bosh_password", "password"
-      setting "bosh.salted_password", "SALTED"
-      setting "bosh.ip_address", "1.2.3.4"
-      setting "bosh.persistent_disk", 16384
-      setting "bosh_resources_cloud_properties", {}
-      setting "bosh_cloud_properties", {}
-      setting "bosh_key_pair.private_key", "PRIVATE_KEY"
-      setting "bosh_key_pair.name", "KEYNAME"
-      @cmd.should_receive(:run_server).and_return(true)
-      @cmd.deploy
-    end
-
-    it "stage 8 - sets up new microbosh" do
-      testing_stage(8)
-      setting "bosh_name", "microbosh-aws-us-east-1"
-      setting "bosh_username", "drnic"
-      setting "bosh_password", "password"
-      setting "bosh.ip_address", "1.2.3.4"
-      @cmd.should_receive(:sleep)
-      @cmd.should_receive(:run_server).and_return(true)
-      @cmd.should_receive(:sh).with("bosh -u drnic -p password target 1.2.3.4")
-      @cmd.should_receive(:sh).with("bosh login drnic password")
-      @cmd.deploy
-    end
-  end
-
-  describe "micro_bosh_stemcell_name" do
-    # The +bosh_stemcells_cmd+ has an output that looks like:
-    # +-----------------------------------+--------------------+
-    # | Name                              | Tags               |
-    # +-----------------------------------+--------------------+
-    # | micro-bosh-stemcell-aws-0.6.4.tgz | aws, micro, stable |
-    # | micro-bosh-stemcell-aws-0.7.0.tgz | aws, micro, test   |
-    # | micro-bosh-stemcell-aws-0.8.1.tgz | aws, micro, test   |
-    # +-----------------------------------+--------------------+
-    #
-    # So to get the latest version for the filter tags,
-    # get the Name field, reverse sort, and return the first item
-    it "should return the latest stable stemcell by default for AWS" do
-      @cmd.settings["bosh_provider"] = "aws"
-      @cmd.settings["fog_credentials"] = {}
-      @cmd.settings["fog_credentials"]["provider"] = "aws"
-      @cmd.should_receive(:known_stable_micro_bosh_stemcell_version).and_return("0.8.1")
-      @cmd.micro_bosh_stemcell_name.should == "micro-bosh-stemcell-aws-0.8.1.tgz"
-    end
-
-    it "should return the latest stable stemcell by default for OpenStack" do
-      @cmd.settings["bosh_provider"] = "openstack"
-      @cmd.settings["fog_credentials"] = {}
-      @cmd.settings["fog_credentials"]["provider"] = "OpenStack"
-      @cmd.should_receive(:known_stable_micro_bosh_stemcell_version).and_return("0.8.1")
-      @cmd.micro_bosh_stemcell_name.should == "micro-bosh-stemcell-openstack-kvm-0.8.1.tgz"
-    end
-  end
-
-end

data/spec/unit/cli_ssh_spec.rb

@@ -1,95 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-# Specs for 'ssh' related behavior. Includes CLI commands:
-# * ssh
-# * tmux
-# * mosh
-describe Bosh::Bootstrap do
-  include FileUtils
-  include Bosh::Bootstrap::Helpers::SettingsSetter
-
-  before do
-    @cmd = Bosh::Bootstrap::Cli.new
-  end
-
-  # used by +SettingsSetter+ to access the settings
-  def settings
-    @cmd.settings
-  end
-
-  describe "ssh" do
-    before do
-      setting "inception.host", "5.5.5.5"
-      setting "inception.key_pair.private_key", "PRIVATE"
-      setting "inception.key_pair.public_key", "PUBLIC"
-      @private_key_path = File.join(ENV['HOME'], ".bosh_bootstrap", "ssh", "inception")
-    end
-
-    describe "normal" do
-      it "launches ssh session" do
-        @cmd.should_receive(:exit)
-        @cmd.should_receive(:system).
-          with("ssh -i #{@private_key_path} vcap@5.5.5.5")
-        @cmd.ssh
-      end
-      it "runs ssh command" do
-        @cmd.should_receive(:exit)
-        @cmd.should_receive(:system).
-          with("ssh -i #{@private_key_path} vcap@5.5.5.5 'some command'")
-        @cmd.ssh("some command")
-      end
-    end
-
-    describe "tmux" do
-      it "launches ssh session" do
-        @cmd.should_receive(:exit)
-        @cmd.should_receive(:system).
-          with("ssh -i #{@private_key_path} vcap@5.5.5.5 -t 'tmux attach || tmux new-session'")
-        @cmd.tmux
-      end
-    end
-
-    describe "mosh" do
-      before do
-        @cmd.settings['bosh_provider'] = 'aws'
-        Fog.mock!
-        fog_compute = Fog::Compute.new(
-          :provider  => 'AWS', 
-          :aws_access_key_id  => 'MOCK_AWS_ACCESS_KEY_ID',
-          :aws_secret_access_key  => 'MOCK_AWS_SECRET_ACCESS_KEY')
-        @cmd.stub!(:provider).and_return(Bosh::Providers.for_bosh_provider_name('aws', fog_compute))
-        @cmd.stub!(:fog_compute).and_return(fog_compute)
-        @cmd.fog_compute.stub!(:servers).and_return(double(:get => double(:groups => ['default'])))
-      end
-      after do
-        Fog.unmock!
-      end
-      it "should check whether mosh is installed" do
-         @cmd.should_receive(:system).
-          with("mosh --version")
-        @cmd.stub!(:exit)
-        @cmd.ensure_mosh_installed
-      end
-      it "launches mosh session" do
-        @cmd.stub!(:ensure_mosh_installed).and_return(true)
-        @cmd.should_receive(:exit)
-        @cmd.should_receive(:system).
-          with("mosh vcap@5.5.5.5")
-        @cmd.mosh
-      end
-      it "should ensure that the mosh ports are opened" do
-        expected_ports = {
-          mosh: { 
-            protocol: "udp", 
-            ports: (60000..60050) 
-          }
-        } 
-        @cmd.provider.stub!(:create_security_group)
-          .with('default','not used', expected_ports)
-        @cmd.ensure_security_group_allows_mosh
-      end
-    end
-  end
-end

data/spec/unit/cli_upgrade_inception_spec.rb

@@ -1,29 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-# Specs for 'upgrade' command
-describe Bosh::Bootstrap do
-  include FileUtils
-  include Bosh::Bootstrap::Helpers::SettingsSetter
-
-  # used by +SettingsSetter+ to access the settings
-  def settings
-    @cmd.settings
-  end
-
-  before do
-    @cmd = Bosh::Bootstrap::Cli.new
-  end
-
-  it "runs 'upgrade' command on an existing inception VM" do
-    setting "inception.prepared", true
-    setting "inception.username", "ubuntu"
-    setting "git.name", "Dr Nic Williams"
-    setting "git.email", "drnicwilliams@gmail.com"
-    setting "bosh.password", "UNSALTED"
-    setting "bosh.salted_password", "SALTED"
-    @cmd.should_receive(:run_server).and_return(true)
-    @cmd.upgrade_inception
-  end
-end

data/spec/unit/settings_setter_spec.rb

@@ -1,29 +0,0 @@
-# Copyright (c) 2012-2013 Stark & Wayne, LLC
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-describe Bosh::Bootstrap::Helpers::SettingsSetter do
-  include Bosh::Bootstrap::Helpers::SettingsSetter
-
-  attr_reader :settings
-  before do
-    @settings = {}
-  end
-
-  def save_settings!
-  end
-
-  it "with_setting 'a'" do
-    with_setting "a" do |setting|
-      setting['value'] = "abc"
-    end
-    settings["a"]["value"].should == "abc"
-  end
-
-  it "with_setting 'a.b.c'" do
-    with_setting "a.b.c" do |setting|
-      setting['value'] = "abc"
-    end
-    settings["a"]["b"]["c"]["value"].should == "abc"
-  end
-end