dew 0.3.0 → 0.4.0

data/lib/dew/models/account.rb

@@ -2,16 +2,24 @@ require 'yaml'
 
 class Account
 
+  def initialize(yaml)
+    @yaml = yaml
+  end
+
   def self.read(account_name)
-    Account.new YAML.load File.read File.join [ ENV['HOME'], '.dew', 'accounts', "#{account_name}.yaml" ]
+    Account.new(YAML.load_file(account_path(account_name)))
   end
 
   def self.user_ids
-    Dir[File.join(ENV['HOME'], '.dew', 'accounts', '*.yaml')].map do |filename|
-      Account.read(File.basename(filename).gsub(/.yaml$/, '')).aws_user_id
+    Dir[account_path('*')].map do |filename|
+      read(File.basename(filename, '.yaml')).aws_user_id
     end
   end
 
+  def self.account_path(account_name)
+    File.join(ENV['HOME'], '.dew', 'accounts', "#{account_name}.yaml")
+  end
+
   def aws_access_key_id
     @yaml['aws']['access_key_id']
   end
@@ -36,7 +44,4 @@ class Account
     @yaml['dns']['domain']
   end
   
-  def initialize(yaml)
-    @yaml = yaml
-  end
 end

data/lib/dew/models/environment.rb

@@ -5,7 +5,7 @@ class Environment
 
   attr_reader :name, :servers, :database
 
-  def initialize name, servers=[], database=nil
+  def initialize(name, servers=[], database=nil)
     @name = name
     @servers = servers
     @database = database
@@ -34,14 +34,23 @@ class Environment
     environment.add_database(profile.rds_size, profile.rds_storage_size, password) if profile.has_rds?
 
     (1..profile.count).each do
-      environment.add_server(profile.ami, profile.size, profile.keypair, profile.security_groups, profile.username)
+      environment.add_server(
+        profile.username,
+        :ami => profile.ami,
+        :size => profile.size,
+        :keypair => profile.keypair,
+        :groups => profile.security_groups,
+        :disk_size => profile.instance_disk_size
+      )
     end
   
     environment.add_elb(profile.elb_listener_ports) if profile.has_elb?
   
     environment.wait_until_ready
-
+    
+    environment.resize_disks if profile.instance_disk_size?
     environment.configure_servers_for_database password if profile.has_rds?
+    
     Inform.info "Environment %{name} ready!", :name => name
     environment
   end
@@ -117,18 +126,17 @@ class Environment
     end
   end
 
-  def add_server(ami, size, keypair, groups, username)
-    Inform.info "Adding server using AMI %{ami} of size %{size}, keypair %{keypair} and security groups %{groups}",
-      :ami => ami, :size => size, :keypair => keypair, :groups => groups.join(',') do
-      server = Server.create!( ami, size, keypair, groups )
-      server.add_tag('Environment', name)
-      server.add_tag('Creator', ENV['USER'])
-      server_name = "#{name} #{servers.count + 1}"
-      server.add_tag('Name', server_name)
-      server.add_tag('Username', username) # Needed for SSH
-      Inform.debug("%{name} ID: %{id} AZ: %{az}", :name => server_name, :id =>server.id, :az => server.availability_zone)
-      servers << server
-    end
+  def add_server(username, create_options)
+    server_name = "#{name} #{servers.count + 1}"
+
+    server = Server.create!(create_options)
+    server.add_tag('Environment', name)
+    server.add_tag('Creator', ENV['USER'])
+    server.add_tag('Name', server_name)
+    server.add_tag('Username', username) # Needed for SSH
+    Inform.debug("%{name} ID: %{id} AZ: %{az}", :name => server_name, :id =>server.id, :az => server.availability_zone)
+
+    servers << server
   end
 
   def add_server_to_elb server
@@ -185,6 +193,12 @@ class Environment
     end
   end
 
+  def resize_disks
+    Inform.info "Resizing disks on servers" do
+      servers.each { |s| s.resize_disk }
+    end
+  end
+
   def elb
     @elb ||= Cloud.elb.load_balancers.detect { |elb| elb.id == name }  # XXX - need to refactor
   end

data/lib/dew/models/profile.rb

@@ -5,31 +5,22 @@ class Profile
   attr_reader :profile_name
   attr_accessor :ami, :size, :security_groups, :keypair, :count
   attr_accessor :rds_size, :rds_storage_size, :elb_listener_ports, :username
-
-  AWS_RESOURCES = YAML.load(File.read(File.join(File.dirname(__FILE__), '..', 'aws_resources.yaml')))
+  attr_reader :instance_disk_size
+  
+  AWS_RESOURCES = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'aws_resources.yaml'))
 
   DEFAULT_RDS_STORAGE_SIZE = 5
-
+  DEFAULT_USERNAME = 'ubuntu'
+  
   def self.read(profile_name)
-    yaml = YAML.load_file(File.join(ENV['HOME'], '.dew', 'profiles', "#{profile_name}.yaml"))
-    profile = new(profile_name)
-    profile.username = 'ubuntu'
-    if yaml['instances']
-      profile.ami = yaml['instances']['amis'][Cloud.region]
-      profile.size = yaml['instances']['size']
-      profile.security_groups = yaml['instances']['security-groups'] || ['default'] #XXX is this fallback tested?
-      profile.keypair = yaml['instances']['keypair']
-      profile.count = yaml['instances']['count'].to_i
-      profile.username = yaml['instances']['username'] if yaml['instances'].include?('username')
-    end
-    if yaml['elb']
-      profile.elb_listener_ports = yaml['elb']['listener_ports']
-    end
-    if yaml['rds']
-      profile.rds_size = yaml['rds']['size']
-      profile.rds_storage_size = yaml['rds'].fetch('storage', DEFAULT_RDS_STORAGE_SIZE)
-    end
-    profile
+    new(
+      profile_name,
+      YAML.load_file(profile_path(profile_name))
+    )
+  end
+  
+  def self.profile_path(profile_name)
+    File.join(ENV['HOME'], '.dew', 'profiles', "#{profile_name}.yaml")
   end
 
   def has_elb?
@@ -40,18 +31,40 @@ class Profile
     rds_size != nil
   end
 
-  def initialize(profile_name)
+  def initialize(profile_name, init_yaml = nil)
     @profile_name = profile_name
-    # :ami, :size, :security_groups, :keypair, :count
-    # :rds_size, :elb_listener_ports
+    populate_from_yaml(Cloud.region, init_yaml) if init_yaml
+  end
+  
+  def populate_from_yaml(region, yaml)
+    @username = DEFAULT_USERNAME    # do we actually need this?  There are no instances...
+  
+    if yaml['instances']
+      @ami = yaml['instances'].fetch('amis', {})[region]
+      @size = yaml['instances']['size']
+      @security_groups = yaml['instances'].fetch('security-groups', ['default']) #TODO is this fallback tested?
+      @keypair = yaml['instances']['keypair']
+      @count = yaml['instances']['count'].to_i
+      @username = yaml['instances'].fetch('username', DEFAULT_USERNAME) #TODO is this fallback tested?
+      @instance_disk_size = yaml['instances'].fetch('disk-size', nil)
+    end
+    
+    if yaml['elb']
+      @elb_listener_ports = yaml['elb']['listener_ports']
+    end
+    
+    if yaml['rds']
+      @rds_size = yaml['rds']['size']
+      @rds_storage_size = yaml['rds'].fetch('storage', DEFAULT_RDS_STORAGE_SIZE)
+    end  
   end
+  
+  TO_STRING_TEMPLATE = "%{memory} GB memory, %{processor} ECUs processor, %{storage} GB storage, %{platform}-bit platform"
 
   def self.size_to_s(size)
-    #instance_str = "%{memory} memory, %{processor} processor, %{storage} storage, %{platform} platform, %{io_performance} I/O performance"
-    instance_str = "%{memory} GB memory, %{processor} ECUs processor, %{storage} GB storage, %{platform}-bit platform, %{io_performance} I/O performance"
     flavor = Cloud.compute.flavors.detect { |f| f.id == size }
-    instance_hash = { :memory => flavor.ram.to_s, :processor => flavor.cores.to_s, :storage => flavor.disk.to_s, :platform => flavor.bits.to_s, :io_performance => '??' }
-    instance_hash.inject(instance_str) { |res,(k,v)| res.gsub(/%\{#{k}\}/, v) }
+    instance_hash = { :memory => flavor.ram.to_s, :processor => flavor.cores.to_s, :storage => flavor.disk.to_s, :platform => flavor.bits.to_s }
+    instance_hash.inject(TO_STRING_TEMPLATE) { |res,(k,v)| res.gsub(/%\{#{k}\}/, v) }
   end
 
   def to_s
@@ -65,4 +78,8 @@ class Profile
       t << ['keypair', keypair.inspect]
     }.to_s
   end
+  
+  def instance_disk_size?
+    !!@instance_disk_size
+  end
 end

data/lib/dew/models/server.rb

@@ -1,12 +1,40 @@
 class Server < FogModel
-  TEN_SECONDS = 10
-  SIXTY_SECONDS = 60
-  TWO_MINUTES = 120
-  THREE_MINUTES = 180
+  TAG_CREATION_TIMEOUT = 60
+  AMI_RECOGNITION_TIMEOUT = 60
+  DEFAULT_SSH_CONNECTION_TIMEOUT = 180
+ 
   RUNNING_SERVER_STATES = %w{pending running}
 
-  def self.create! ami, size, keypair, groups
-    new(Cloud.compute.servers.create(:image_id => ami, :flavor_id => size, :key_name => keypair, :groups => groups))
+  def self.create!(options)
+    ami = options.fetch(:ami)
+    size = options.fetch(:size)
+    keypair = options.fetch(:keypair)
+    groups = options.fetch(:groups)
+    disk_size = options.fetch(:disk_size, nil)
+    
+    Inform.info "Creating server using AMI %{ami} of size %{size}, keypair %{keypair} and security groups %{groups}",
+      :ami => ami, :size => size, :keypair => keypair, :groups => groups.join(',') do
+  
+      server_options = {
+        :image_id => ami,
+        :flavor_id => size,
+        :key_name => keypair,
+        :groups => groups      
+      }
+      
+      if disk_size
+        server_options.merge!(
+          :block_device_mapping => [
+            {
+              'DeviceName' => '/dev/sda1',
+              'Ebs.VolumeSize' => disk_size.to_s
+            }
+          ]        
+        )
+      end
+  
+      new(Cloud.compute.servers.create(server_options))
+    end
   end
 
   def self.find tag_name, tag_value
@@ -18,15 +46,19 @@ class Server < FogModel
   end
 
   def add_tag key, val
-    try_for(SIXTY_SECONDS) {
+    try_for(TAG_CREATION_TIMEOUT) do
       Cloud.compute.tags.create(:resource_id => id, :key => key, :value => val)
-    }
+    end
   end
 
   def configure_for_database database, password
     ssh.write(database.db_environment_file(password), '/tmp/envfile')
     ssh.run('sudo mv /tmp/envfile /etc/environment')
   end
+  
+  def resize_disk
+    ssh.run('sudo resize2fs -p /dev/sda1')
+  end
 
   def username
     fog_object.tags['Username'] || 'ubuntu'
@@ -40,7 +72,7 @@ class Server < FogModel
     Gofer::Host.new(public_ip_address, username, :port => ssh_port, :key_data => [File.read(Cloud.keyfile_path(key_name))], :paranoid => false, :quiet => true)
   end
 
-  def wait_until_ready ssh_timeout=THREE_MINUTES
+  def wait_until_ready ssh_timeout=DEFAULT_SSH_CONNECTION_TIMEOUT
     super()
     Inform.debug("%{id} online at %{ip}, waiting for SSH connection...", :id => id, :ip => public_ip_address)
     wait_for_ssh ssh_timeout
@@ -52,7 +84,7 @@ class Server < FogModel
 
     Inform.debug("Created image at %{id}, waiting for AWS to recognize it...", :id => image_id)
     # Sometimes takes a while for AWS to realise there's a new image...
-    image = Timeout::timeout(SIXTY_SECONDS) do
+    image = Timeout::timeout(AMI_RECOGNITION_TIMEOUT) do
       image = nil
       while image == nil
         image = Cloud.compute.images.get(image_id)

data/lib/dew/version.rb

@@ -1,3 +1,3 @@
 module Dew
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/dew/cloud_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require 'spec_helper'
 
 describe :Cloud do
   

data/spec/dew/controllers/amis_controller_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'spec_helper'
 
 describe AMIsController do
 

data/spec/dew/controllers/deploy_controller_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'spec_helper'
 
 describe DeployController do
 
@@ -35,4 +35,4 @@ describe DeployController do
     end
 
   end
-end
+end

data/spec/dew/controllers/environments_controller_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'spec_helper'
 
 describe EnvironmentsController do
   subject { EnvironmentsController.new }

data/spec/dew/models/account_spec.rb

@@ -1,29 +1,32 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'spec_helper'
 
 describe Account do
 
-  describe :initialize do
+  describe '::read' do
     it "should look for the named account file in the ~/.dew/accounts dir" do
       name = 'a_development_name'
-      File.should_receive(:read).with("#{ENV['HOME']}/.dew/accounts/#{name}.yaml").and_return("---")
+      YAML.should_receive(:load_file).with("#{ENV['HOME']}/.dew/accounts/#{name}.yaml").and_return({})
       Account.read(name)
     end
   end
 
   describe "parsing yaml" do
     before :each do
-      File.stub(:read).and_return(yaml)
+      YAML.stub(:load_file).and_return(yaml)
     end
 
     subject { Account.read('foo') }
 
     describe "with an aws section" do
-      let (:yaml) {
-        "aws:
-          user_id: 9999-3333-2222
-          access_key_id: foo
-          secret_access_key: bar"
-      }
+      let (:yaml) do
+        { 
+          'aws' => {
+            'user_id' => '9999-3333-2222',
+            'access_key_id' => 'foo',
+            'secret_access_key' => 'bar'
+          }
+        }
+      end
 
       it "should have a user_id stripped of dashes" do
         subject.aws_user_id.should == '999933332222'
@@ -35,16 +38,18 @@ describe Account do
     end
 
     describe "with a DNS section" do
-      let (:yaml) {
-        "
-        dns:
-          domain: mydomain.com
-          key: a1b2c3d4e5
-        "
-      }
-      it { subject.has_dns?.should be_true }
-      it { subject.dns_key.should == 'a1b2c3d4e5' }
-      it { subject.dns_domain.should == 'mydomain.com' }
+      let (:yaml) do
+        {
+          'dns' => {
+            'domain' => 'mydomain.com',
+            'key' => 'a1b2c3d4e5'
+          }
+        }
+      end
+      
+      it { subject.should have_dns }
+      its(:dns_key) { should == 'a1b2c3d4e5' }
+      its(:dns_domain) { should == 'mydomain.com' }
     end
   end
   

data/spec/dew/models/database_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'spec_helper'
 
 describe Database do
 

data/spec/dew/models/deploy/puge_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper'))
+require 'spec_helper'
 
 describe Deploy::Puge do
 

data/spec/dew/models/deploy/run_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 describe Deploy::Run do
 
@@ -35,4 +35,4 @@ describe Deploy::Run do
       @deploy_run.deploy
     end
   end
-end
+end

data/spec/dew/models/environment_spec.rb

@@ -1,10 +1,9 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'spec_helper'
 
 describe Environment do
 
   let (:name) { 'my-environment' }
-  let (:bad_name) { 'my_environment' }
-  let (:server) { double('Server', :id => 'i-12345', :add_tag => nil, :wait_until_ready => nil, :availability_zone => 'ap-southeast-1') }
+#  let (:server) { double('Server', :id => 'i-12345', :add_tag => nil, :wait_until_ready => nil, :availability_zone => 'ap-southeast-1') }
   let(:groups) { %w(non_default) }
   let (:server) { double('Server', :id => 'i-12345', :add_tag => nil, :wait_until_ready => nil, :availability_zone => 'ap-southeast-1', :groups => groups) }
   let (:servers) { [] }
@@ -13,25 +12,26 @@ describe Environment do
   let (:database) { double('Database') }
   let(:keypair_available_in_aws) { true }
   let(:profile_count) { 2 }
-  let (:profile) do
-    double('Profile',
-      :ami => 'ami-12345', :size => 'm1.large',
-      :keypair => 'devops', :count => profile_count,
-      :has_rds? => false, :has_elb? => false
-    )
-  end
+  
+  let(:instance_disk_size) { rand(234) }
+  let(:database) { mock('Database', :destroy => true, :wait_until_ready => true) }
+  
+  let(:environment) { Environment.new(name, servers, database) }    
 
   before :each do
-    @environment = Environment.new(name, servers)
     Cloud.connect(name, 'development')
     Cloud.stub(:elb => elb, :keypair_exists? => keypair_available_in_aws)
   end
 
-  it { @environment.name.should == name }
-  it { @environment.servers.should == [] }
-  it { @environment.database.should == nil }
+  describe "initialization" do
+    subject { environment }
 
-  describe ".get" do
+    its(:name) { should == name }
+    its(:servers) { should == [] }
+    its(:database) { should == database }
+  end
+  
+  describe "::get" do
     before :each do
       Server.stub(:find => [])
       Database.stub(:get => nil)
@@ -49,13 +49,26 @@ describe Environment do
     end
   end
 
-  describe ".create" do
-    let (:security_groups) { %w(non_default) }
-    let(:profile) { double(:profile, :username => 'username', :keypair => 'default', :security_groups => security_groups, :ami => 'i-1234', :has_rds? => false, :has_elb? => false, :count => 2, :size => 'small' ) }
-
+  describe "::create" do
+    let (:profile) do
+      double('Profile',
+        :username => 'username',
+        :security_groups => %w(default),
+        :ami => 'ami-12345', :size => 'm1.large',
+        :keypair => 'devops', :count => profile_count,
+        :has_rds? => false, :has_elb? => false,
+        :instance_disk_size => instance_disk_size,
+        :instance_disk_size? => !!instance_disk_size
+      )
+    end
+  
+    subject { Environment.create(name, profile) }
+  
     context "when environment name is invalid" do
+      let(:name) { 'my_bad_name' }
+      
       it "should raise an error" do
-        lambda { Environment.create(bad_name, profile) }.should raise_error /does not match/
+        lambda { subject }.should raise_error(ArgumentError, /does not match/)
       end
     end
 
@@ -63,16 +76,31 @@ describe Environment do
       let(:keypair_available_in_aws) { false }
 
       it "should raise an error" do
-        lambda { Environment.create(name, profile) }.should raise_error /is not available/
+        lambda { subject }.should raise_error /is not available/
+      end
+    end
+    
+    context "when no instance disk size is specified" do
+      let(:instance_disk_size) { nil }
+      let(:environment) { mock(:add_server => true, :wait_until_ready => true) }
+      
+      before do
+        Environment.stub(:new => environment)
+      end
+      
+      it "should not resize_disks on the environment" do
+        environment.should_not_receive(:resize_disks)
+        subject
       end
     end
 
     context "when profile keypair is available in AWS" do
 
-      before {
-        @env = double(:environment, :name => name, :add_database => true, :wait_until_ready => true, :add_server => true)
-        Environment.should_receive(:new).with(name).and_return(@env)
-      }
+      let(:environment) { double(:environment, :name => name, :add_database => true, :wait_until_ready => true, :add_server => true, :resize_disks => true) }
+
+      before do
+        Environment.stub(:new => environment)
+      end
 
       after { Environment.create(name, profile) }
 
@@ -80,12 +108,19 @@ describe Environment do
         let(:profile_count) { 2 }
 
         it "should add two instances to that environment with the chosen AMI, size and keypair" do
-          @env.should_receive(:add_server).with(profile.ami, profile.size, profile.keypair, profile.security_groups, profile.username).twice
+          environment.should_receive(:add_server).with(
+            profile.username,
+            :ami => profile.ami, 
+            :size => profile.size,
+            :keypair => profile.keypair,
+            :groups => profile.security_groups,
+            :disk_size => profile.instance_disk_size
+          ).twice
         end
       end
 
       it "should wait for our environment to become ready" do
-        @env.should_receive(:wait_until_ready)
+        environment.should_receive(:wait_until_ready)
       end
 
       describe "with an ELB specified in the profile" do
@@ -94,41 +129,41 @@ describe Environment do
         end
 
         it "should add an ELB to the environment with the required ports" do
-          @env.should_receive(:add_elb).with([80])
+          environment.should_receive(:add_elb).with([80])
         end
       end
 
       describe "with an RDS specified in the profile" do
         before :each do
           profile.stub(:has_rds? => true, :rds_size => 'db.m1.small', :rds_storage_size => 5)
-          @env.stub(:add_database => nil, :configure_servers_for_database => nil)
+          environment.stub(:add_database => nil, :configure_servers_for_database => nil)
           Password.stub(:random => 'abcdef')
         end
 
         it "should add an RDS to the environment with the required size and a random password" do
-          @env.should_receive(:add_database).with('db.m1.small', 5, 'abcdef')
+          environment.should_receive(:add_database).with('db.m1.small', 5, 'abcdef')
         end
 
         it "should ask the environment to update the database configuration on the servers" do
-          @env.should_receive(:configure_servers_for_database).with('abcdef')
+          environment.should_receive(:configure_servers_for_database).with('abcdef')
         end
       end
 
     end
   end
 
-  describe ".names" do
-    before {
+  describe "::owners" do
+    before do
       Cloud.should_receive(:valid_servers).at_least(1).and_return( [
         double(:server, :tags => {"Environment" => "test-1", "Creator" => "chris" }),
         double(:server, :tags => {"Environment" => "test-2", "Creator" => "ash"   })
       ])
-    }
+    end
 
     it { Environment.owners.should == [{:name=>"test-1", :owner=>"chris"}, {:name=>"test-2", :owner=>"ash"}] }
   end
 
-  describe ".index" do
+  describe "::index" do
     before {
       Cloud.should_receive(:valid_servers).at_least(1).and_return( [
         double(:server, :tags => {"Environment" => "test-1", "Creator" => "chris" }),
@@ -152,119 +187,140 @@ EOF
     end
   end
 
-  describe :show do
-    before {
+  describe '#show' do
+    before do
       Cloud.stub_chain(:account, :aws_user_id).and_return('12345')
-    }
-    after { @environment.show }
+    end
+    
+    subject { environment.show }
 
     context "with servers" do
       let(:servers) { [server] }
-
-      before { @environment.stub(:elb => nil) }
+      let(:database) { nil }
+      
+      before { environment.stub(:elb => nil) }
       it "should show the servers" do
         View.should_receive(:new).with(
           "SERVERS", [server], %w(id flavor_id public_ip_address state created_at groups key_name availability_zone creator)
         ).and_return(double(:servers_view, :index => 'servers'))
+        subject
       end
     end
 
     context "with an elb" do
+      let(:database) { nil }
+
       it "should show the elb" do
         elb_view = double(:elb_view)
         View.should_receive(:new).with(
           "ELB", [an_elb], %w(created_at dns_name instances availability_zones)
         ).and_return(elb_view)
         elb_view.should_receive(:show).and_return('stuff')
+        subject
       end
     end
 
     context "with a database" do
-      before {
-        @environment.stub(:database => database)
-        @environment.stub(:elb => nil)
-      }
+      before { environment.stub(:elb => nil) }
 
       it "should show the database" do
         View.should_receive(:new).with(
           "DATABASE", [database], %w(flavor_id state created_at availability_zone db_security_groups)
-        ).and_return(double(:database_view, :index => 'database', :show => "some_ stuff"))
+        ).and_return(mock('database_view', :index => 'database', :show => "some_ stuff"))
+        subject
       end
     end
 
   end
 
-  describe :destroy do
-    before :each do
-      @environment.stub(:has_elb? => false)
+  describe '#destroy' do
+    subject { environment.destroy }
+  
+    before do
+      environment.stub(:has_elb? => false)
     end
+    
     it "should destroy the database if there is one" do
-      @environment.stub(:database => database)
+      environment.stub(:database => database)
       database.should_receive(:destroy)
-      @environment.destroy
+      
+      subject
     end
     it "should destroy the servers if there are any" do
-      @environment.stub(:servers => [server])
+      environment.stub(:servers => [server])
       server.should_receive(:destroy)
-      @environment.destroy
+
+      subject
     end
+
     it "should destroy the ELB if there is one" do
-      @environment.stub(:has_elb? => true)
+      environment.stub(:has_elb? => true)
       elb.should_receive(:delete_load_balancer).with(name)
-      @environment.destroy
+
+      subject
     end
   end
 
-  describe :add_server do
+  describe '#add_server' do
+    let(:create_options) { mock('create options') }
+    let(:username) { 'username' }
+
+    subject { environment.add_server(username, create_options) }
+    
     before :each do
-      @args = 'ami', 'size', 'keypair', %w(non_default)
       Server.stub(:create!).and_return(server)
     end
 
     it "should create a Server from the provided ami, size and keypair" do
-      Server.should_receive(:create!).with(*@args)
-      @environment.add_server(*@args, 'username')
+      Server.should_receive(:create!).with(create_options)
+      subject
     end
 
     it "should add the Server to its servers array" do
-      @environment.add_server(*@args, 'username')
-      @environment.add_server(*@args, 'username')
-      @environment.servers.should == [server, server]
+      # don't use subject here, is memoized
+      environment.add_server(username, create_options)
+      environment.add_server(username, create_options)
+      environment.servers.should == [server, server]
     end
 
     it "should tag the server with the environment name, creator and username" do
       server.should_receive(:add_tag).with('Environment', name)
       server.should_receive(:add_tag).with('Creator', ENV['USER'])
       server.should_receive(:add_tag).with('Username', 'username')
-      @environment.add_server(*@args, 'username')
+      subject
     end
 
     it "should tag the server with an indexed name" do
       server.should_receive(:add_tag).with('Name', "#{name} 1")
-      @environment.add_server(*@args, 'username')
+      environment.add_server('username', create_options)
 
       server.should_receive(:add_tag).with('Name', "#{name} 2")
-      @environment.add_server(*@args, 'username')
+      environment.add_server('username', create_options)
     end
   end
 
-  describe :remove_server_from_elb do
+  describe '#remove_server_from_elb' do
+    subject { environment.remove_server_from_elb(server) }
+    
     it "should remove the server from the ELB" do
       elb.should_receive(:deregister_instances_from_load_balancer).with([server.id], name)
-      @environment.remove_server_from_elb(server)
+      subject
     end
   end
   
-  describe :add_server_to_elb do
+  describe '#add_server_to_elb' do
+    subject { environment.add_server_to_elb(server) }
+    
     it "should add the server to the ELB" do
       elb.should_receive(:register_instances_with_load_balancer).with([server.id], name)
-      @environment.add_server_to_elb(server)
+      subject
     end
   end
 
   context "with one server" do
-    before :each do
-      @environment.stub(:servers => [server])
+
+    before do
+      environment.stub(:servers => [server])
     end
 
     describe :add_elb do
@@ -279,17 +335,17 @@ EOF
             ['ap-southeast-1a'], name,
             [{'Protocol' => 'TCP', 'LoadBalancerPort' => 80, 'InstancePort' => 80}]
         )
-        @environment.add_elb [80]
+        environment.add_elb [80]
       end
       it "should add the servers to the elb" do
         elb.should_receive(:register_instances_with_load_balancer).with([server.id], name)
-        @environment.add_elb [80]
+        environment.add_elb [80]
       end
 
     end
 
     describe :add_database do
-      before :each do
+      before do
         Database.stub(:create! => database)
       end
 
@@ -297,12 +353,12 @@ EOF
 
       it "should create an RDS of the requested size, using the environment name and a random password" do
         Database.should_receive(:create!).with(name, 'db.m1.small', storage_size, 'password')
-        @environment.add_database 'db.m1.small', storage_size, 'password'
+        environment.add_database 'db.m1.small', storage_size, 'password'
       end
 
       it "should make the database available on the 'database' accessor" do
-        @environment.add_database 'db.m1.small', storage_size, 'password'
-        @environment.database.should == database
+        environment.add_database 'db.m1.small', storage_size, 'password'
+        environment.database.should == database
       end
     end
 
@@ -310,7 +366,7 @@ EOF
       before {
         Cloud.stub(:security_groups => { 'non_default' => double(:group, :ip_permissions => ip_permissions) } )
       }
-      after { @environment.wait_until_ready }
+      after { environment.wait_until_ready }
 
       context "with no ip_permissions" do
         let(:ip_permissions) { [:some_ip_permissions] }
@@ -332,20 +388,20 @@ EOF
     context "with an RDS" do
       before :each do
         Cloud.stub(:security_groups => { 'non_default' => double(:group, :ip_permissions => true) } )
-        @environment.stub(:database => database)
+        environment.stub(:database => database)
       end
 
       describe :wait_until_ready do
         it "should wait for the database to be ready" do
           database.should_receive(:wait_until_ready)
-          @environment.wait_until_ready
+          environment.wait_until_ready
         end
       end
 
       describe :configure_servers_for_database do
         it "should ask each server to apply credentials from our database" do
           server.should_receive(:configure_for_database).with(database, 'password')
-          @environment.configure_servers_for_database 'password'
+          environment.configure_servers_for_database 'password'
         end
       end
 
@@ -361,34 +417,43 @@ EOF
     end
   end
 
-  describe :has_elb? do
+  describe '#has_elb?' do
+    subject { environment.has_elb? }
+  
     it "return true if we have a load balancer" do
       mock_describe_load_balancers([{'LoadBalancerName' => name}])
-      @environment.has_elb?.should be_true
+      subject.should be_true
     end
 
     it "return false if we don't" do
       mock_describe_load_balancers([{'LoadBalancerName' => "XXXX"}])
-      @environment.has_elb?.should be_false
+      subject.should be_false
     end
 
   end
   
   describe "#show_json" do
-  
     let(:servers) { [mock(:dns_name => 'fish.com', :public_ip_address => '1.2.3.4'), mock(:dns_name => 'fish2.com', :public_ip_address => '1.2.3.5')] }
     let(:output) { servers.map { |s| { 'public_dns' => s.dns_name, 'public_ip' => s.public_ip_address } } }
     
-    before do
-      @environment.stub(:servers => servers)
-    end
-  
-    subject { @environment.show_json }
+    subject { environment.show_json }
   
     it "should return the correct JSON" do
       STDOUT.should_receive(:puts).with(JSON.pretty_generate(output))
       subject
     end
+  end
+  
+  describe '#resize_disks' do
+  
+    let(:servers) { [mock('server1'), mock('server2')] }  
+
+    subject { environment.resize_disks }
+  
+    it "should resize_disk on each server" do
+      servers.each { |s| s.should_receive(:resize_disk).with() }
+      subject
+    end
   
   end