blimpy 0.0.1 → 0.1.0

data/.gitignore

@@ -15,3 +15,6 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.blimpy.d
+.rvmrc
+Blimpyfile

data/Rakefile

@@ -1,2 +1,30 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
+
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = '--color --fail-fast'
+end
+
+
+namespace :cucumber do
+  cucumber_opts = '--color --format progress --tags ~@wip'
+
+  Cucumber::Rake::Task.new('basic') do |t|
+    t.cucumber_opts = cucumber_opts + ' --tags ~@slow'
+  end
+
+  Cucumber::Rake::Task.new('integration') do |t|
+    t.cucumber_opts = cucumber_opts + ' --tags @slow'
+  end
+end
+
+desc 'Run the basic test suite'
+task :test => [:spec, :"cucumber:basic"]
+
+namespace :test do
+  desc 'Run all the tests, including the slow integration tests'
+  task :all => [:spec, :'cucumber:basic', :'cucumber:integration']
+end
+

data/bin/blimpy

@@ -1,88 +1,11 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
-require 'thor'
-
 begin
-  require 'blimpy'
+  require 'blimpy/cli'
 rescue LoadError
   $:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib/')
-  require 'blimpy'
-end
-
-module Blimpy
-  class CLI < Thor
-    BLIMPFILE = File.join(Dir.pwd, 'Blimpfile')
-
-    no_tasks do
-      def ensure_blimpfile
-        unless File.exists? Blimpy::CLI::BLIMPFILE
-          puts 'Please create a Blimpfile in your current directory'
-          exit 1
-        end
-      end
-    end
-
-    desc 'start', 'Start up a fleet of blimps'
-    method_options :"dry-run" => :boolean
-    def start
-      ensure_blimpfile
-      engine = Blimpy::Engine.new
-      engine.load_file(File.open(BLIMPFILE).read)
-      puts 'Up, up and away!'
-
-      if options[:'dry-run']
-        puts 'skipping actually starting the fleet'
-        exit 0
-      end
-
-      engine.fleet.start
-    end
-
-    desc 'list', 'List running blimps'
-    def list
-      ensure_blimpfile
-      blimps = Dir["#{Dir.pwd}/.blimpy.d/*.blimp"]
-      if blimps.empty?
-        puts 'No currently running VMs'
-        exit 0
-      end
-
-      blimps.each do |blimp|
-        data = YAML.load_file(blimp)
-        instance_id = File.basename(blimp)
-        instance_id = instance_id.split('.blimp').first
-        puts "#{data['name']} (#{instance_id}) is: online at #{data['dns']}"
-      end
-    end
-
-    desc 'destroy', 'Destroy all running blimps'
-    def destroy
-      ensure_blimpfile
-      fleet = Blimpy::Fleet.new
-      fleet.destroy
-    end
-
-
-    desc 'init', 'Create a skeleton Blimpfile in the current directory'
-    def init
-      File.open(File.join(Dir.pwd, 'Blimpfile'), 'w') do |f|
-        f.write(
-"""# vim: ft=ruby
-# Blimpfile created on #{Time.now}
-
-Blimpy.fleet do |fleet|
-  fleet.add do |ship|
-    ship.name = 'Excelsior'
-    ship.group = 'default'
-  end
-end
-""")
-      end
-    end
-  end
+  require 'blimpy/cli'
 end
 
 Blimpy::CLI.start
-
 exit 0

data/features/cli/ssh.feature

@@ -0,0 +1,39 @@
+Feature: SSH into a named VM
+  In order to directly access running VMs
+  As a Blimpy user
+  I should be able to run `blimpy ssh <name>` and be logged in
+
+  Scenario: SSHing with an invalid name
+    Given I have the Blimpfile:
+      """
+      Blimpy.fleet do |f|
+        f.add do |host|
+          host.name = 'Cucumber Host'
+        end
+      end
+      """
+    When I run `blimpy ssh Gherkins`
+    Then the exit status should be 1
+    And the output should contain:
+      """
+      Could not find blimp named "Gherkins"
+      """
+
+
+  # This test is really frustrating and I can't get aruba and the ssh code
+  # to work together here :-/
+  @slow @destroy @wip
+  Scenario: SSHing into a remote host should work
+    Given I have the Blimpfile:
+      """
+      Blimpy.fleet do |f|
+        f.add do |host|
+          host.group = 'Simple'
+          host.name = 'Cucumber Host'
+        end
+      end
+      """
+    When I ssh into the machine
+    And I type "hostname -f"
+    And I type "exit"
+    Then the output should contain the right DNS info

data/features/cli/start.feature

@@ -9,19 +9,41 @@ Feature: Start a VM or cluster of VMs in the cloud
       """
     And the exit status should be 1
 
-    Scenario: With a simple Blimpfile
-      Given I have the Blimpfile:
-        """
-        Blimpy.fleet do |f|
-          f.add do |host|
-            host.group = 'Simple'
-            host.name = 'Cucumber Host'
-          end
+  Scenario: dry-run start with a simple Blimpfile
+    Given I have the Blimpfile:
+      """
+      Blimpy.fleet do |f|
+        f.add do |host|
+          host.group = 'Simple'
+          host.name = 'Cucumber Host'
+        end
+      end
+      """
+    When I run `blimpy start --dry-run`
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      Up, up and away!
+      """
+
+  @slow @destroy
+  Scenario: start with a functional Blimpfile
+    Given I have the Blimpfile:
+      """
+      Blimpy.fleet do |f|
+        f.add do |host|
+          host.group = 'Simple'
+          host.name = 'Cucumber Host'
         end
-        """
-      When I run `blimpy start --dry-run`
-      Then the exit status should be 0
-      And the output should contain:
-        """
-        Up, up and away!
-        """
+      end
+      """
+    When I run `blimpy start`
+    Then the exit status should be 0
+    And the output should contain:
+      """
+      Up, up and away!
+      """
+    And the output should contain:
+      """
+      online at:
+      """

data/features/step_definitions/cli_steps.rb

@@ -26,7 +26,23 @@ Given /^I have a single VM running$/ do
   end
 end
 
+When /^I ssh into the machine$/ do
+  step %{I run `blimpy start`}
+  step %{I run `blimpy ssh "Cucumber Host" -o StrictHostKeyChecking=no` interactively}
+end
+
 Then /^the output should list the VM$/ do
   expected = 'Cucumber host (0xdeadbeef) is: online at foo.bar'
   assert_partial_output(expected, all_output)
 end
+
+Then /^the output should contain the right DNS info$/ do
+  terminate_processes!
+  internal_name = nil
+  Dir["#{@tempdir}/.blimpy.d/*.blimp"].each do |filename|
+    data = YAML.load_file(filename)
+    internal_name = data['internal_dns']
+    break unless internal_name.nil?
+  end
+  step %{the output should contain "#{internal_name}"}
+end

data/features/support/hooks.rb

@@ -6,6 +6,16 @@ Before do
   @dirs = [@tempdir]
 end
 
+Before '@slow' do
+  @aruba_timeout_seconds = 90
+end
+
+After '@destroy' do |scenario|
+  Dir.chdir(@tempdir) do
+    `blimpy destroy`
+  end
+end
+
 After do |scenario|
   Dir.chdir(@cwd)
 

data/lib/blimpy.rb

@@ -19,4 +19,6 @@ module Blimpy
   end
   class BoxValidationError < Exception
   end
+  class SSHKeyNotFoundError < Exception
+  end
 end

data/lib/blimpy/box.rb

@@ -1,24 +1,39 @@
+require 'blimpy/helpers/state'
+require 'blimpy/keys'
 
 module Blimpy
   class Box
-    attr_reader :allowed_regions, :region, :server
-    attr_accessor :image_id, :livery, :group, :name, :tags, :fleet_id
+    include Blimpy::Helpers::State
 
-    def self.from_instance_id(an_id)
-      server = Fog::Compute[:aws].servers.get(an_id)
+    # Default to US West (Oregon)
+    DEFAULT_REGION = 'us-west-2'
+    # Default to 10.04 64-bit
+    DEFAULT_IMAGE_ID = 'ami-ec0b86dc'
+
+    attr_reader :allowed_regions, :region
+    attr_accessor :image_id, :livery, :group
+    attr_accessor :name, :tags, :fleet_id, :username
+
+    def self.from_instance_id(an_id, data)
+      region = data['region'] || DEFAULT_REGION
+      fog = Fog::Compute.new(:provider => 'AWS', :region => region)
+      server = fog.servers.get(an_id)
       if server.nil?
         return nil
       end
-      self.new(server)
+      box = self.new(server)
+      box.name = data['name']
+      box
     end
 
     def initialize(server=nil)
       @allowed_regions = ['us-west-1', 'us-west-2', 'us-east-1']
-      @region = 'us-west-2' # Default to US West (Oregon) for now
-      @image_id = 'ami-349b495d' # Default to Ubuntu 10.04 LTS (64bit)
+      @region = DEFAULT_REGION
+      @image_id = DEFAULT_IMAGE_ID
       @livery = nil
       @group = nil
       @name = 'Unnamed Box'
+      @username = 'ubuntu'
       @tags = {}
       @server = server
       @fleet_id = 0
@@ -38,18 +53,16 @@ module Blimpy
     end
 
     def online!
-      File.open(File.join(state_dir, state_file), 'a') do |f|
+      File.open(state_file, 'a') do |f|
         f.write("dns: #{@server.dns_name}\n")
+        f.write("internal_dns: #{@server.private_dns_name}\n")
       end
     end
 
     def start
-      ensure_state_dir
+      ensure_state_folder
       @server = create_host
-
-      File.open(File.join(state_dir, state_file), 'w') do |f|
-        f.write("name: #{@name}\n")
-      end
+      write_state_file
     end
 
     def stop
@@ -58,35 +71,83 @@ module Blimpy
       end
     end
 
+    def resume
+      unless @server.nil?
+        @server.start
+      end
+    end
+
     def destroy
       unless @server.nil?
         @server.destroy
-        File.unlink(File.join(state_dir, state_file))
+        File.unlink(state_file)
       end
     end
 
-    def state_dir
-      File.join(Dir.pwd, '.blimpy.d')
+    def write_state_file
+      File.open(state_file, 'w') do |f|
+        f.write("name: #{@name}\n")
+        f.write("region: #{@region}\n")
+      end
     end
 
+
     def state_file
       if @server.nil?
         raise Exception, "I can't make a state file without a @server!"
       end
-      "#{@server.id}.blimp"
+      File.join(state_folder, "#{@server.id}.blimp")
     end
 
-    def ensure_state_dir
-      unless File.exist? state_dir
-        Dir.mkdir(state_dir)
+    def wait_for_state(until_state, &block)
+      if @server.nil?
+        return
+      end
+
+      @server.wait_for do
+        block.call
+        state == until_state
+      end
+    end
+
+    def dns_name
+      return @server.dns_name unless @server.nil?
+      'no name'
+    end
+
+    def internal_dns_name
+      return @server.private_dns_name unless @server.nil?
+      'no name'
+    end
+
+    def ssh_into
+      start = Time.now.to_i
+      print "..making sure #{@name} is online"
+      begin
+        TCPSocket.new(dns_name, 22)
+      rescue Errno::ECONNREFUSED
+        if (Time.now.to_i - start) < 30
+          print '.'
+          retry
+        end
       end
+      puts
+      ::Kernel.exec('ssh', '-l', username, dns_name, *ARGV[2..-1])
     end
 
     private
 
     def create_host
       tags = @tags.merge({:Name => @name, :CreatedBy => 'Blimpy', :BlimpyFleetId => @fleet_id})
-      Fog::Compute[:aws].servers.create(:image_id => @image_id, :region => @region, :tags => tags)
+      if @fog.nil?
+        @fog = Fog::Compute.new(:provider => 'AWS', :region => @region)
+      end
+
+      Blimpy::Keys.import_key(@fog)
+      @fog.servers.create(:image_id => @image_id,
+                          :key_name => Blimpy::Keys.key_name,
+                          :groups => [@group],
+                          :tags => tags)
     end
   end
 end

data/lib/blimpy/cli.rb

@@ -0,0 +1,102 @@
+require 'rubygems'
+require 'thor'
+
+require 'blimpy'
+require 'blimpy/engine'
+
+module Blimpy
+  class CLI < Thor
+    BLIMPFILE = File.join(Dir.pwd, 'Blimpfile')
+
+    no_tasks do
+      def ensure_blimpfile
+        unless File.exists? Blimpy::CLI::BLIMPFILE
+          puts 'Please create a Blimpfile in your current directory'
+          exit 1
+        end
+      end
+    end
+
+    desc 'start', 'Start up a fleet of blimps'
+    method_options :"dry-run" => :boolean
+    def start
+      ensure_blimpfile
+      engine = Blimpy::Engine.new
+      engine.load_file(File.open(BLIMPFILE).read)
+      puts 'Up, up and away!'
+
+      if options[:'dry-run']
+        puts 'skipping actually starting the fleet'
+        exit 0
+      end
+
+      engine.fleet.start
+    end
+
+    desc 'list', 'List running blimps'
+    def list
+      ensure_blimpfile
+      blimps = Dir["#{Dir.pwd}/.blimpy.d/*.blimp"]
+      if blimps.empty?
+        puts 'No currently running VMs'
+        exit 0
+      end
+
+      blimps.each do |blimp|
+        data = YAML.load_file(blimp)
+        instance_id = File.basename(blimp)
+        instance_id = instance_id.split('.blimp').first
+        puts "#{data['name']} (#{instance_id}) is: online at #{data['dns']}"
+      end
+    end
+
+    desc 'destroy', 'Destroy all running blimps'
+    def destroy
+      ensure_blimpfile
+      fleet = Blimpy::Fleet.new
+      fleet.destroy
+    end
+
+    desc 'stop', 'Stop the running blimps'
+    def stop
+      ensure_blimpfile
+      fleet = Blimpy::Fleet.new
+      fleet.stop
+    end
+
+    desc 'init', 'Create a skeleton Blimpfile in the current directory'
+    def init
+      File.open(File.join(Dir.pwd, 'Blimpfile'), 'w') do |f|
+        f.write(
+"""# vim: ft=ruby
+# Blimpfile created on #{Time.now}
+
+Blimpy.fleet do |fleet|
+  fleet.add do |ship|
+    ship.name = 'Excelsior'
+    ship.group = 'default'
+  end
+end
+""")
+      end
+    end
+
+    desc 'ssh BLIMP_NAME', 'Log into a running blimp'
+    def ssh(name, *args)
+      ensure_blimpfile
+      fleet = Blimpy::Fleet.new
+      box = nil
+      fleet.members.each do |instance_id, data|
+        box_name = data['name']
+        next unless box_name == name
+        box  = Blimpy::Box.from_instance_id(instance_id, data)
+      end
+      if box.nil?
+        puts "Could not find blimp named \"#{name}\""
+        exit 1
+      end
+
+      box.ssh_into
+    end
+  end
+end

data/lib/blimpy/fleet.rb

@@ -1,11 +1,13 @@
+require 'blimpy/helpers/state'
 
 module Blimpy
   class Fleet
-    attr_reader :hosts
+    include Blimpy::Helpers::State
+
+    attr_reader :hosts, :id
 
     def initialize
       @hosts = []
-      @servers = []
       @id = Time.now.utc.to_i
     end
 
@@ -19,49 +21,97 @@ module Blimpy
       block.call(box)
     end
 
+    def state_file
+      File.join(state_folder, 'manifest')
+    end
+
+    def save!
+      File.open(state_file, 'w') do |f|
+        f.write("id=#{id}\n")
+      end
+    end
+
+    def resume(instances)
+      boxes = []
+      print '>> Resuming: '
+      instances.each do |instance_id, instance_data|
+        print "#{instance_data['name']},"
+        box = Blimpy::Box.from_instance_id(instance_id, instance_data)
+        box.resume
+        boxes << box
+      end
+
+      boxes.each do |box|
+        box.wait_for_state('running') { print '.' }
+      end
+      puts
+    end
+
     def start
+      instances = members
+      unless instances.empty?
+        return resume(instances)
+      end
+
       # Make sure all our hosts are valid first!
       @hosts.each do |host|
         host.validate!
       end
 
+      puts '>> Starting:'
       @hosts.each do |host|
-        @servers << host.start
+        puts "..#{host.name}"
+        host.start
       end
 
       @hosts.each do |host|
         print ">> #{host.name} "
-        host.server.wait_for do
-          print '.'
-          ready?
-        end
-        print ".. online at: #{host.server.dns_name}"
+        host.wait_for_state('running') { print '.' }
+        print ".. online at: #{host.dns_name}"
         host.online!
         puts
       end
+
+      save!
     end
 
     def members
-      instance_ids = []
+      instances = []
       Dir["#{Dir.pwd}/.blimpy.d/*.blimp"].each do |d|
         filename = File.basename(d)
-        instance_ids << filename.split('.blimp').first
+        instance_id = filename.split('.blimp').first
+        instance_data = YAML.load_file(d)
+        instances << [instance_id, instance_data]
       end
-      instance_ids
+      instances
     end
 
     def stop
-      members.each do |instance_id|
-        box = Blimpy::Box.from_instance_id(instance_id)
+      print '>> Stopping: '
+      boxes = []
+
+      members.each do |instance_id, instance_data|
+        box = Blimpy::Box.from_instance_id(instance_id, instance_data)
+        print "#{instance_data['name']},"
         box.stop
+        boxes << box
       end
+
+      boxes.each do |box|
+        box.wait_for_state('stopped')  { print '.' }
+      end
+      puts
     end
 
     def destroy
-      members.each do |instance_id|
-        box = Blimpy::Box.from_instance_id(instance_id)
+      members.each do |instance_id, instance_data|
+        box = Blimpy::Box.from_instance_id(instance_id, instance_data)
         box.destroy
       end
+
+      if File.exists? state_file
+        File.unlink(state_file)
+      end
     end
   end
 end

data/lib/blimpy/helpers/state.rb

@@ -0,0 +1,20 @@
+module Blimpy
+  module Helpers
+    module State
+      def state_folder
+        File.join(Dir.pwd, '.blimpy.d')
+      end
+
+      def ensure_state_folder
+        unless File.exist? state_folder
+          Dir.mkdir(state_folder)
+        end
+      end
+
+      def state_file
+        raise NotImplementedError, '#state_file should be implemented in a consumer'
+      end
+    end
+  end
+end
+

data/lib/blimpy/keys.rb

@@ -0,0 +1,26 @@
+require 'fog'
+require 'socket'
+
+module Blimpy
+  module Keys
+    def self.import_key(fog)
+      filename = File.expand_path('~/.ssh/id_rsa.pub')
+      unless File.exists? filename
+        filename = File.expand_path('~/.ssh/id_dsa.pub')
+        unless File.exists? filename
+          raise Blimpy::SSHKeyNotFoundError, 'Expected either ~/.ssh/id_rsa.pub or ~/.ssh/id_dsa.pub but found neither'
+        end
+      end
+
+      material = File.open(filename, 'r').read
+      begin
+        fog.import_key_pair(key_name, material)
+      rescue Fog::Compute::AWS::Error => e
+      end
+    end
+
+    def self.key_name
+      "Blimpy-#{ENV['USER']}@#{Socket.gethostname}"
+    end
+  end
+end

data/lib/blimpy/version.rb

@@ -1,3 +1,3 @@
 module Blimpy
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/{box_spec.rb → blimpy/box_spec.rb}

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Blimpy::Box do
   describe '#image_id' do
     it 'should be the Ubuntu 10.04 AMI ID by default' do
-      subject.image_id.should == 'ami-349b495d'
+      subject.image_id.should == Blimpy::Box::DEFAULT_IMAGE_ID
     end
   end
 
@@ -99,17 +99,16 @@ describe Blimpy::Box do
       before :each do
         # Mocking out #create_host so we don't actually create EC2 instance
         Blimpy::Box.any_instance.should_receive(:create_host).and_return(server)
-        Blimpy::Box.any_instance.should_receive(:ensure_state_dir).and_return(true)
+        Blimpy::Box.any_instance.should_receive(:ensure_state_folder).and_return(true)
       end
 
       it 'should create a state file' do
-        path = File.join(subject.state_dir, "#{server_id}.blimp")
-        File.should_receive(:open).with(path, 'w')
+        subject.stub(:state_file).and_return('fake-state-file')
+        File.should_receive(:open).with('fake-state-file', 'w')
         subject.start
       end
     end
 
-
     describe '#stop' do
       before :each do
         server.should_receive(:stop)
@@ -121,6 +120,7 @@ describe Blimpy::Box do
         subject.stop
       end
     end
+
     describe '#destroy' do
       before :each do
         server.should_receive(:destroy)
@@ -128,36 +128,24 @@ describe Blimpy::Box do
       subject { Blimpy::Box.new(server) }
 
       it 'should remove its state file' do
-        subject.should_receive(:state_file).and_return('foo')
-        File.should_receive(:unlink).with(File.join(subject.state_dir, 'foo'))
+        subject.should_receive(:state_file).and_return('fake-state-file')
+        File.should_receive(:unlink).with('fake-state-file')
         subject.destroy
       end
     end
-  end
 
-  describe '#ensure_state_dir' do
-    let(:path) { File.join(Dir.pwd, '.blimpy.d') }
-
-    context 'if ./.blimpy.d does not exist' do
+    describe '#from_instance_id' do
+      let(:fog) { double('Fog::Compute') }
       before :each do
-        File.should_receive(:exist?).with(path).and_return(false)
+        fog.stub_chain(:servers, :get).and_return(server)
+        Fog::Compute.should_receive(:new).and_return(fog)
       end
 
-      it 'should create directory' do
-        Dir.should_receive(:mkdir).with(path)
-        subject.ensure_state_dir
+      it 'should create a new Box instance' do
+        result = Blimpy::Box.from_instance_id('someid', {})
+        result.should be_instance_of Blimpy::Box
       end
-    end
 
-    context 'if ./blimpy.d does exist' do
-      before :each do
-        File.should_receive(:exist?).with(path).and_return(true)
-      end
-
-      it 'should create directory' do
-        Dir.should_receive(:mkdir).with(path).never
-        subject.ensure_state_dir
-      end
     end
   end
 end

data/spec/blimpy/fleet_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Blimpy::Fleet do
+  describe '#hosts' do
+    it 'should be an Array' do
+      subject.hosts.should be_instance_of Array
+      subject.hosts.size.should == 0
+    end
+  end
+
+  describe '#add' do
+    it 'should return false if no Box was properly added' do
+      subject.add.should == false
+    end
+
+    it 'should pass a Box instance to the block' do
+      invoked_block = false
+      subject.add do |box|
+        invoked_block = true
+        box.should be_instance_of Blimpy::Box
+      end
+      invoked_block.should be true
+    end
+
+    context 'with a block' do
+      before :each do
+        subject.add do |b|
+          @box = b
+        end
+      end
+
+      it 'should add the box the fleet' do
+        @box.should_not be nil
+        subject.hosts.should include(@box)
+      end
+    end
+  end
+
+  describe '#save!' do
+    let(:manifest) { 'fake-manifest' }
+    let(:manifest_file) do
+      fd = mock('Manifest File Descriptor')
+      fd
+    end
+
+    before :each do
+      subject.should_receive(:state_file).and_return(manifest)
+    end
+
+    it 'should save the fleet id' do
+      fleet_id = 1337
+      subject.should_receive(:id).and_return(fleet_id)
+      File.should_receive(:open).with(manifest, 'w').and_yield(manifest_file)
+      manifest_file.should_receive(:write).with("id=#{fleet_id}\n")
+      subject.save!
+    end
+  end
+
+  describe '#state_file' do
+    it 'should return a file named manifest' do
+      subject.should_receive(:state_folder).and_return('fake-state-folder')
+      subject.state_file.should == 'fake-state-folder/manifest'
+    end
+  end
+
+  context 'group operations' do
+    let(:members) do
+      members = []
+      members << [0xdeadbeef, {}]
+      members
+    end
+    let(:box) do
+      box = double('Blimpy::Box')
+      box.stub(:stop)
+      box.stub(:destroy)
+      box.stub(:wait_for_state)
+      box
+    end
+
+    before :each do
+      Blimpy::Box.should_receive(:from_instance_id).with(0xdeadbeef, {}).and_return(box)
+      subject.should_receive(:members).and_return(members)
+      # Stub out output methods, this will keep our output clean in RSpec
+      subject.stub(:print)
+      subject.stub(:puts)
+    end
+
+    describe '#stop' do
+      it 'should run stop' do
+        subject.stop
+      end
+    end
+
+    describe '#destroy' do
+      it 'should run destroy' do
+        subject.destroy
+      end
+    end
+
+    describe '#start' do
+      it 'should invoke resume' do
+        box.should_receive(:resume)
+        subject.start
+      end
+    end
+  end
+end

data/spec/blimpy/helpers/state_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'blimpy/helpers/state'
+
+describe Blimpy::Helpers::State do
+  include Blimpy::Helpers::State
+
+  describe '#state_folder' do
+    it 'should be .blimpy.d in the working directory' do
+      pwd = '/fake-pwd'
+      Dir.should_receive(:pwd).and_return(pwd)
+      state_folder.should == "#{pwd}/.blimpy.d"
+    end
+  end
+
+  describe '#state_file' do
+    it 'should raise an error since it must be defined by consumer classes' do
+      expect {
+        state_file
+      }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#ensure_state_folder' do
+    it 'should make the dir if it doesn\'t exist' do
+      File.should_receive(:exist?).and_return(false)
+      Dir.should_receive(:mkdir)
+      ensure_state_folder
+    end
+
+    it 'should not make the dir if it exists' do
+      File.should_receive(:exist?).and_return(true)
+      Dir.should_receive(:mkdir).never
+      ensure_state_folder
+    end
+  end
+end
+
+

data/spec/blimpy/keys_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'blimpy/keys'
+
+describe Blimpy::Keys do
+  describe '#import_key' do
+    context 'with no SSH keys' do
+      it 'should raise a SSHKeyNotFoundError' do
+        File.stub(:exists?).and_return(false)
+        expect {
+          subject.import_key(nil)
+        }.to raise_error(Blimpy::SSHKeyNotFoundError)
+      end
+    end
+  end
+
+  describe '#key_name' do
+    before :each do
+      ENV['USER'] = 'tester'
+    end
+
+    it do
+      hostname = 'rspec'
+      Socket.should_receive(:gethostname).and_return(hostname)
+      subject.key_name.should == "Blimpy-tester@#{hostname}"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blimpy
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-23 00:00:00.000000000Z
+date: 2012-04-28 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
-  requirement: &6750880 !ruby/object:Gem::Requirement
+  requirement: &6754760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *6750880
+  version_requirements: *6754760
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &6747240 !ruby/object:Gem::Requirement
+  requirement: &6754100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *6747240
+  version_requirements: *6754100
 description: Blimpy is a tool for managing a fleet of machines in the CLOUD!
 email:
 - tyler@monkeypox.org
@@ -50,19 +50,25 @@ files:
 - blimpy.gemspec
 - features/cli/init.feature
 - features/cli/list.feature
+- features/cli/ssh.feature
 - features/cli/start.feature
 - features/step_definitions/cli_steps.rb
 - features/support/env.rb
 - features/support/hooks.rb
 - lib/blimpy.rb
 - lib/blimpy/box.rb
+- lib/blimpy/cli.rb
 - lib/blimpy/engine.rb
 - lib/blimpy/fleet.rb
+- lib/blimpy/helpers/state.rb
+- lib/blimpy/keys.rb
 - lib/blimpy/version.rb
+- spec/blimpy/box_spec.rb
+- spec/blimpy/engine_spec.rb
+- spec/blimpy/fleet_spec.rb
+- spec/blimpy/helpers/state_spec.rb
+- spec/blimpy/keys_spec.rb
 - spec/blimpy_spec.rb
-- spec/box_spec.rb
-- spec/engine_spec.rb
-- spec/fleet_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/rtyler/blimpy
 licenses: []
@@ -91,12 +97,15 @@ summary: Ruby + CLOUD = Blimpy
 test_files:
 - features/cli/init.feature
 - features/cli/list.feature
+- features/cli/ssh.feature
 - features/cli/start.feature
 - features/step_definitions/cli_steps.rb
 - features/support/env.rb
 - features/support/hooks.rb
+- spec/blimpy/box_spec.rb
+- spec/blimpy/engine_spec.rb
+- spec/blimpy/fleet_spec.rb
+- spec/blimpy/helpers/state_spec.rb
+- spec/blimpy/keys_spec.rb
 - spec/blimpy_spec.rb
-- spec/box_spec.rb
-- spec/engine_spec.rb
-- spec/fleet_spec.rb
 - spec/spec_helper.rb

data/spec/fleet_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe Blimpy::Fleet do
-  describe '#hosts' do
-    it 'should be an Array' do
-      subject.hosts.should be_instance_of Array
-      subject.hosts.size.should == 0
-    end
-  end
-
-  describe '#add' do
-    it 'should return false if no Box was properly added' do
-      subject.add.should == false
-    end
-
-    it 'should pass a Box instance to the block' do
-      invoked_block = false
-      subject.add do |box|
-        invoked_block = true
-        box.should be_instance_of Blimpy::Box
-      end
-      invoked_block.should be true
-    end
-
-    context 'with a block' do
-      before :each do
-        subject.add do |b|
-          @box = b
-        end
-      end
-
-      it 'should add the box the fleet' do
-        @box.should_not be nil
-        subject.hosts.should include(@box)
-      end
-    end
-  end
-
-
-  context 'group operations' do
-    before :each do
-      subject.should_receive(:members).and_return([])
-    end
-    describe '#stop' do
-      it 'should run stop' do
-        subject.stop
-      end
-    end
-
-    describe '#destroy' do
-      it 'should run destroy' do
-        subject.destroy
-      end
-    end
-  end
-end