cluster_chef 3.0.5

data/lib/cluster_chef/volume.rb

@@ -0,0 +1,93 @@
+module ClusterChef
+  #
+  # Internal or external storage
+  #
+  class Volume < ClusterChef::DslObject
+    attr_reader   :parent
+    attr_accessor :fog_volume
+    has_keys(
+      :name,
+      # mountable volume attributes
+      :device, :mount_point, :mount_options, :fstype, :mount_dump, :mount_pass,
+      # cloud volume attributes
+      :attachable, :create_at_launch, :volume_id, :snapshot_id, :size, :keep, :availability_zone,
+      # arbitrary tags
+      :tags
+      )
+
+    VOLUME_DEFAULTS = {
+      :fstype          => 'xfs',
+      :mount_options    => 'defaults,nouuid,noatime',
+      :attachable       => :ebs,
+      :create_at_launch => false,
+      :keep             => true,
+    }
+
+    # Describes a volume
+    #
+    # @example
+    #   ClusterChef::Volume.new( :name => 'redis',
+    #     :device => '/dev/sdp', :mount_point => '/data/redis', :fstype => 'xfs', :mount_options => 'defaults,nouuid,noatime'
+    #     :size => 1024, :snapshot_id => 'snap-66494a08', :volume_id => 'vol-12312',
+    #     :tags => {}, :keep => true )
+    #
+    def initialize attrs={}
+      @parent = attrs.delete(:parent)
+      super(attrs)
+      @settings[:tags] ||= {}
+    end
+
+    # human-readable description for logging messages and such
+    def desc
+      "#{name} on #{parent.fullname} (#{volume_id} @ #{device})"
+    end
+
+    def defaults
+      self.configure(VOLUME_DEFAULTS)
+    end
+
+    def ephemeral_device?
+      volume_id =~ /^ephemeral/
+    end
+
+    # With snapshot specified but volume missing, have it auto-created at launch
+    #
+    # Be careful with this -- you can end up with multiple volumes claiming to
+    # be the same thing.
+    #
+    def create_at_launch?
+      volume_id.blank? && self.create_at_launch
+    end
+
+    def in_cloud?
+      !! fog_volume
+    end
+
+    def has_server?
+      in_cloud? && fog_volume.server_id.present?
+    end
+
+    def reverse_merge!(other_hsh)
+      super(other_hsh)
+      self.tags.reverse_merge!(other_hsh.tags) if other_hsh.respond_to?(:tags) && other_hsh.tags.present?
+      self
+    end
+
+    # An array of hashes with dorky-looking keys, just like Fog wants it.
+    def block_device_mapping
+      hsh = { 'DeviceName' => device }
+      if ephemeral_device?
+        hsh['VirtualName'] = volume_id
+      elsif create_at_launch?
+        hsh.merge!({
+            'Ebs.SnapshotId' => snapshot_id,
+            'Ebs.VolumeSize' => size,
+            'Ebs.DeleteOnTermination' => (! keep).to_s })
+      else
+        return
+      end
+      hsh
+    end
+
+  end
+end

data/lib/cluster_chef.rb

@@ -0,0 +1,137 @@
+require 'chef/mash'
+require 'gorillib/metaprogramming/class_attribute'
+require 'gorillib/hash/reverse_merge'
+require 'gorillib/object/blank'
+require 'gorillib/hash/compact'
+require 'set'
+
+require 'cluster_chef/dsl_object'
+require 'cluster_chef/cloud'
+require 'cluster_chef/security_group'
+require 'cluster_chef/compute'           # base class for machine attributes
+require 'cluster_chef/facet'             # similar machines within a cluster
+require 'cluster_chef/cluster'           # group of machines with a common mission
+require 'cluster_chef/server'            # realization of a specific facet
+require 'cluster_chef/discovery'         # pair servers with Fog and Chef objects
+require 'cluster_chef/server_slice'      # collection of server objects
+require 'cluster_chef/volume'            # configure external and internal volumes
+require 'cluster_chef/private_key'       # coordinate chef keys, cloud keypairs, etc
+require 'cluster_chef/role_implications' # make roles trigger other actions (security groups, etc)
+#
+require 'cluster_chef/chef_layer'        # interface to chef for server actions
+require 'cluster_chef/fog_layer'         # interface to fog  for server actions
+#
+require 'cluster_chef/deprecated'        # stuff slated to go away
+
+module ClusterChef
+
+  # path to search for cluster definition files
+  def self.cluster_path
+    Chef::Config[:cluster_path] ||= Chef::Config[:cookbooks_path].map{|dir| File.expand_path('../clusters', dir) }
+  end
+
+  #
+  # Delegates
+  def self.clusters
+    Chef::Config[:clusters] ||= Mash.new
+  end
+
+  def self.ui=(ui) @ui = ui ; end
+  def self.ui()    @ui      ; end
+
+  def self.chef_config=(cc) @chef_config = cc ; end
+  def self.chef_config()    @chef_config      ; end
+
+  #
+  # Defines a cluster with the given name.
+  #
+  # @example
+  #   ClusterChef.cluster 'demosimple' do
+  #     cloud :ec2 do
+  #       availability_zones  ['us-east-1d']
+  #       flavor              "t1.micro"
+  #       image_name          "ubuntu-natty"
+  #     end
+  #     role                  :base_role
+  #     role                  :chef_client
+  #
+  #     facet :sandbox do
+  #       instances 2
+  #       role                :nfs_client
+  #     end
+  #   end
+  #
+  #
+  def self.cluster(name, attrs={}, &block)
+    name = name.to_sym
+    cl = ( self.clusters[name] ||= ClusterChef::Cluster.new(name, attrs) )
+    cl.configure(&block)
+    cl
+  end
+
+  #
+  # Return cluster if it's defined. Otherwise, search ClusterChef.cluster_path
+  # for an eponymous file, load it, and return the cluster it defines.
+  #
+  # Raises an error if a matching file isn't found, or if loading that file
+  # doesn't define the requested cluster.
+  #
+  # @return [ClusterChef::Cluster] the requested cluster
+  def self.load_cluster(cluster_name)
+    raise ArgumentError, "Please supply a cluster name" if cluster_name.to_s.empty?
+    return clusters[cluster_name] if clusters[cluster_name]
+
+    cluster_file = cluster_filenames[cluster_name] or die("Couldn't find a definition for #{cluster_name} in cluster_path: #{cluster_path.inspect}")
+
+    Chef::Log.info("Loading cluster #{cluster_file}")
+
+    require cluster_file
+    unless clusters[cluster_name] then  die("#{cluster_file} was supposed to have the definition for the #{cluster_name} cluster, but didn't") end
+
+    clusters[cluster_name]
+  end
+
+  #
+  # Map from cluster name to file name
+  #
+  # @return [Hash] map from cluster name to file name
+  def self.cluster_filenames
+    return @cluster_filenames if @cluster_filenames
+    @cluster_filenames = {}
+    cluster_path.each do |cp_dir|
+      Dir[ File.join(cp_dir, '*.rb') ].each do |filename|
+        cluster_name = File.basename(filename).gsub(/\.rb$/, '')
+        @cluster_filenames[cluster_name] ||= filename
+      end
+    end
+    @cluster_filenames
+  end
+
+  #
+  # Utility to die with an error message.
+  # If the last arg is an integer, use it as the exit code.
+  #
+  def self.die *strings
+    exit_code = strings.last.is_a?(Integer) ? strings.pop : -1
+    strings.each{|str| ui.warn str }
+    exit exit_code
+  end
+
+  #
+  # Utility to turn an error into a warning
+  #
+  # @example
+  #   ClusterChef.safely do
+  #     ClusterChef.fog_connection.associate_address(self.fog_server.id, address)
+  #   end
+  #
+  def self.safely
+    begin
+      yield
+    rescue StandardError => boom
+      ui.info( boom )
+      Chef::Log.error( boom )
+      Chef::Log.error( boom.backtrace.join("\n") )
+    end
+  end
+end

data/rspec.watchr

@@ -0,0 +1,29 @@
+# -*- ruby -*-
+
+def run_spec(file)
+  unless File.exist?(file)
+    puts "#{file} does not exist"
+    return
+  end
+
+  puts   "Running #{file}"
+  system "rspec #{file}"
+  puts
+end
+
+watch("spec/.*/*_spec\.rb") do |match|
+  run_spec match[0]
+end
+
+watch("lib/(.*)\.rb") do |match|
+  file = %{spec/#{match[1]}_spec.rb}
+  run_spec file if File.exists?(file)
+end
+
+# watch('lib/cluster_chef/cookbook_munger\.rb') do |match|
+#   system match[0]
+# end
+#
+# watch('lib/cluster_chef/cookbook_munger/.*\.erb') do |match|
+#   system 'lib/cluster_chef/cookbook_munger.rb'
+# end

data/spec/cluster_chef/cluster_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require CLUSTER_CHEF_DIR("lib/cluster_chef")
+
+describe ClusterChef::Cluster do
+  describe 'discover!' do
+    let(:cluster){ get_example_cluster(:monkeyballs) }
+
+    it 'enumerates chef nodes' do
+      cluster.discover!
+    end
+  end
+end

data/spec/cluster_chef/facet_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require CLUSTER_CHEF_DIR("lib/cluster_chef")
+
+describe ClusterChef::Facet do
+  let(:cluster){ ClusterChef.cluster(:gibbon) }
+  let(:facet){
+    cluster.facet(:namenode) do
+      instances 5
+    end
+  }
+
+  describe 'slicing' do
+    it 'has servers' do
+      facet.indexes.should == [0, 1, 2, 3, 4]
+      facet.valid_indexes.should == [0, 1, 2, 3, 4]
+      facet.server(3){ name(:bob) }
+      svrs = facet.servers
+      svrs.length.should == 5
+      svrs.map{|svr| svr.name }.should == ["gibbon-namenode-0", "gibbon-namenode-1", "gibbon-namenode-2", :bob, "gibbon-namenode-4"]
+    end
+
+    it 'servers have bogosity if out of range' do
+      facet.server(69).should be_bogus
+      facet.servers.select(&:bogus?).map(&:facet_index).should == [69]
+      facet.indexes.should       == [0, 1, 2, 3, 4, 69]
+      facet.valid_indexes.should == [0, 1, 2, 3, 4]
+    end
+
+    it 'returns all on nil or "", but [] means none' do
+      facet.server(69)
+      facet.slice('' ).map(&:facet_index).should == [0, 1, 2, 3, 4, 69]
+      facet.slice(nil).map(&:facet_index).should == [0, 1, 2, 3, 4, 69]
+      facet.slice([] ).map(&:facet_index).should == []
+    end
+
+    it 'slice returns all by default' do
+      facet.server(69)
+      facet.slice().map(&:facet_index).should == [0, 1, 2, 3, 4, 69]
+    end
+
+    it 'with an array returns specified indexes (bogus or not) in sorted order' do
+      facet.server(69)
+      facet.slice( [3, 1, 0]     ).map(&:facet_index).should == [0, 1, 3]
+      facet.slice( [3, 1, 69, 0] ).map(&:facet_index).should == [0, 1, 3, 69]
+    end
+
+    it 'with an array does not create new dummy servers' do
+      facet.server(69)
+      facet.slice( [3, 1, 69, 0, 75, 123] ).map(&:facet_index).should == [0, 1, 3, 69]
+      facet.has_server?(75).should be_false
+      facet.has_server?(69).should be_true
+    end
+
+    it 'with a string, converts to intervals' do
+      facet.slice('1'      ).map(&:facet_index).should == [1]
+      facet.slice('5'      ).map(&:facet_index).should == []
+      facet.slice('1-1'    ).map(&:facet_index).should == [1]
+      facet.slice('0-1'    ).map(&:facet_index).should == [0,1]
+      facet.slice('0-1,3-4').map(&:facet_index).should == [0,1,3,4]
+      facet.slice('0-1,69' ).map(&:facet_index).should == [0,1,69]
+      facet.slice('0-2,1-3').map(&:facet_index).should == [0,1,2,3]
+      facet.slice('3-1'    ).map(&:facet_index).should == []
+      facet.slice('2-5'    ).map(&:facet_index).should == [2,3,4]
+      facet.slice(1).map(&:facet_index).should == [1]
+    end
+
+  end
+end
+

data/spec/cluster_chef/server_slice_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require CLUSTER_CHEF_DIR("lib/cluster_chef")
+
+describe ClusterChef::ServerSlice do
+  before do
+    @slice = ClusterChef.slice('webserver_demo')
+  end
+
+  describe 'attributes' do
+    it 'security groups' do
+      @slice.security_groups.keys.sort.should == [
+        "default",
+        "webserver_demo", "webserver_demo-awesome_website", "webserver_demo-dbnode", "webserver_demo-esnode",
+        "webserver_demo-redis_client", "webserver_demo-redis_server",
+        "webserver_demo-webnode", "nfs_client", "ssh"
+      ]
+    end
+  end
+end

data/spec/cluster_chef/server_spec.rb

@@ -0,0 +1,112 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require CLUSTER_CHEF_DIR("lib/cluster_chef")
+
+describe ClusterChef::Server do
+  include_context 'dummy_chef'
+
+  ClusterChef::Server.class_eval do
+    def chef_node
+      Chef::Node.new
+    end
+  end
+
+  ClusterChef::DryRunnable.class_eval do
+    def unless_dry_run
+      puts "Not doing that"
+    end
+  end
+
+  before do
+    ClusterChef::Server.stub!(:chef_node).and_return( "HI" )
+    Chef::Config.stub!(:validation_key).and_return("I_AM_VALID")
+
+    foo = ClusterChef::Server.new(ClusterChef::Facet.new(ClusterChef::Cluster.new('hi'),'there'),0)
+    puts foo.inspect
+    puts foo.chef_node
+    @cluster = get_example_cluster('webserver_demo')
+    @cluster.resolve!
+    @facet   = @cluster.facet(:dbnode)
+    @server  = @facet.server(0)
+  end
+
+  describe 'volumes' do
+    describe '#composite_volumes' do
+      it 'assembles cluster, facet and server volumes' do
+        @server.composite_volumes.length.should == 5
+        @cluster.volumes.length.should == 4
+        @facet.volumes.length.should   == 1
+        @server.volumes.length.should  == 1
+      end
+
+      it 'composites server attributes onto a volume defined in the facet' do
+        vol = @server.composite_volumes[:data]
+        vol.to_hash.should == {
+          :name              => :data,
+          :tags              => {},
+          :snapshot_id       => "snap-d9c1edb1",
+          :size              => 50,
+          :keep              => true,
+          :device            => "/dev/sdi",
+          :mount_point       => "/data/db",
+          :mount_options     => "defaults,nouuid,noatime",
+          :fs_type           => "xfs",
+          :availability_zone => "us-east-1d"
+        }
+      end
+
+      it 'makes block_device_mapping for non-ephemeral storage' do
+        vol = @server.composite_volumes[:data]
+        vol.block_device_mapping.should == {
+          "DeviceName"              => "/dev/sdi",
+          "Ebs.SnapshotId"          => "snap-d9c1edb1",
+          "Ebs.VolumeSize"          => 50,
+          "Ebs.DeleteOnTermination" => "false"
+        }
+      end
+
+      it 'skips block_device_mapping for non-ephemeral storage if volume id is present' do
+        vol = @facet.server(1).composite_volumes[:data]
+        vol.block_device_mapping.should be_nil
+      end
+
+    end
+  end
+
+  describe 'launch' do
+    describe '#fog_description_for_launch' do
+      it 'has right attributes' do
+
+        hsh = @server.fog_description_for_launch
+        hsh.delete(:user_data)
+        hsh.should == {
+          :image_id             => "ami-08f40561",
+          :flavor_id            => "m1.large",
+          :groups               => ["webserver_demo-redis_client", "webserver_demo-dbnode", "default", "ssh", "nfs_client", "webserver_demo"],
+          :key_name             => :webserver_demo,
+          :tags                 => {:cluster=>:webserver_demo, :facet=>:dbnode, :index=>0},
+          :block_device_mapping => [
+            {"DeviceName"=>"/dev/sdi", "Ebs.SnapshotId"=>"snap-d9c1edb1", "Ebs.VolumeSize"=>50, "Ebs.DeleteOnTermination"=>"false"},
+            {"DeviceName"=>"/dev/sdb", "VirtualName"=>"ephemeral0"},
+            {"DeviceName"=>"/dev/sdc", "VirtualName"=>"ephemeral1"},
+            {"DeviceName"=>"/dev/sdd", "VirtualName"=>"ephemeral2"},
+            {"DeviceName"=>"/dev/sde", "VirtualName"=>"ephemeral3"},
+          ],
+          :availability_zone    => "us-east-1d",
+          :monitoring           => nil
+        }
+      end
+
+      it 'has right user_data' do
+        hsh = @server.fog_description_for_launch
+        user_data_hsh = JSON.parse( hsh[:user_data] )
+        user_data_hsh.keys.should == ["chef_server", "validation_client_name", "validation_key", "attributes"]
+        user_data_hsh["attributes"].keys.sort.should == [
+          "cluster_name", "facet_name", "facet_index",
+          "node_name",
+          "webnode_count",
+        ]
+      end
+    end
+
+  end
+end

data/spec/cluster_chef_spec.rb

@@ -0,0 +1,193 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require CLUSTER_CHEF_DIR("lib/cluster_chef")
+
+describe "cluster_chef" do
+  describe 'successfuly runs example' do
+
+    describe 'webserver_demo:' do
+      before :all do
+        @cluster = get_example_cluster(:webserver_demo)
+        @cluster.resolve!
+      end
+
+      it 'loads successfuly' do
+        @cluster.should be_a(ClusterChef::Cluster)
+        @cluster.name.should == :webserver_demo
+      end
+
+      it 'cluster is right' do
+        @cluster.to_hash.should == {
+          :name            => :webserver_demo,
+          :run_list        => ["role[base_role]", "role[chef_client]", "role[ssh]", "role[nfs_client]", "role[big_package]", "role[webserver_demo_cluster]"],
+          :chef_attributes => { :webnode_count => 6 },
+          :facet_name    => "webserver_demo_cluster",
+        }
+      end
+
+      it 'defaults cluster' do
+        defaults_cluster = ClusterChef.cluster(:defaults)
+        cloud_hash = defaults_cluster.cloud.to_hash
+        [:security_groups, :user_data].each{|k| cloud_hash.delete k }
+        cloud_hash.should == {
+          :availability_zones => ['us-east-1d'],
+          :region             => "us-east-1",
+          :flavor             => "m1.small",
+          :image_name         => "lucid",
+          :backing            => "ebs",
+          :disable_api_termination => false,
+          :public_ip         => false,
+          :bootstrap_distro   => "ubuntu10.04-cluster_chef",
+        }
+      end
+
+      it 'cluster cloud is right' do
+        cloud_hash = @cluster.cloud.to_hash
+        [:security_groups, :user_data].each{|k| cloud_hash.delete k }
+        cloud_hash.should == {
+          :availability_zones => ['us-east-1d'],
+          :region             => "us-east-1",
+          :flavor             => "t1.micro",
+          :image_name         => "maverick",
+          :backing            => "instance",
+          :disable_api_termination => false,
+          :public_ip         => false,
+          :bootstrap_distro   => "ubuntu10.04-cluster_chef",
+          :keypair            => :webserver_demo,
+        }
+      end
+
+      it 'facet cloud is right' do
+        cloud_hash = @cluster.facet(:webnode).cloud.to_hash
+        [:security_groups, :user_data].each{|k| cloud_hash.delete k }
+        cloud_hash.should == {
+          :backing            => "ebs",
+        }
+      end
+
+      it 'webnode facets are right' do
+        @cluster.facets.length.should == 3
+        fct = @cluster.facet(:webnode)
+        fct.to_hash.should == {
+          :name            => :webnode,
+          :run_list        => ["role[nginx]", "role[redis_client]", "role[mysql_client]", "role[elasticsearch_client]", "role[awesome_website]", "role[webserver_demo_webnode]"],
+          :chef_attributes => {:split_testing=>{:group=>"A"}},
+          :facet_role      => "webserver_demo_webnode",
+          :instances       => 6,
+        }
+      end
+
+      it 'dbnode facets are right' do
+        fct = @cluster.facet(:dbnode)
+        fct.to_hash.should == {
+          :name            => :dbnode,
+          :run_list        => ["role[mysql_server]", "role[redis_client]", "role[webserver_demo_dbnode]" ],
+          :chef_attributes => {},
+          :facet_role      => "webserver_demo_dbnode",
+          :instances       => 2,
+        }
+        fct.cloud.flavor.should == 'c1.xlarge'
+        fct.server(0).cloud.flavor.should == 'm1.large'
+      end
+
+      it 'esnode facets are right' do
+        fct = @cluster.facet(:esnode)
+        fct.to_hash.should == {
+          :name            => :esnode,
+          :run_list        => ["role[nginx]", "role[redis_server]", "role[elasticsearch_data_esnode]", "role[elasticsearch_http_esnode]", "role[webserver_demo_esnode]"],
+          :chef_attributes => {},
+          :facet_role      => "webserver_demo_esnode",
+          :instances       => 1,
+        }
+        fct.cloud.flavor.should == 'm1.large'
+      end
+
+      it 'cluster security groups are right' do
+        gg = @cluster.security_groups
+        gg.keys.should == ['default', 'ssh', 'nfs_client', 'webserver_demo']
+      end
+
+      it 'facet webnode security groups are right' do
+        gg = @cluster.facet(:webnode).security_groups
+        gg.keys.sort.should == ["default", "webserver_demo", "webserver_demo-awesome_website", "webserver_demo-redis_client", "webserver_demo-webnode", "nfs_client", "ssh"]
+        gg['webserver_demo-awesome_website'].range_authorizations.should == [[80..80, "0.0.0.0/0", "tcp"], [443..443, "0.0.0.0/0", "tcp"]]
+      end
+
+      it 'facet dbnode security groups are right' do
+        gg = @cluster.facet(:dbnode).security_groups
+        gg.keys.sort.should == ["default", "webserver_demo", "webserver_demo-dbnode", "webserver_demo-redis_client", "nfs_client", "ssh"]
+      end
+
+      it 'facet esnode security groups are right' do
+        gg = @cluster.facet(:esnode).security_groups
+        gg.keys.sort.should == ["default", "webserver_demo", "webserver_demo-esnode", "webserver_demo-redis_server", "nfs_client", "ssh"]
+        gg['webserver_demo-redis_server'][:name].should == "webserver_demo-redis_server"
+        gg['webserver_demo-redis_server'][:description].should == "cluster_chef generated group webserver_demo-redis_server"
+        gg['webserver_demo-redis_server'].group_authorizations.should == [['webserver_demo-redis_client', nil]]
+      end
+
+      it 'has servers' do
+        @cluster.servers.map(&:fullname).should == [
+          "webserver_demo-dbnode-0", "webserver_demo-dbnode-1",
+          "webserver_demo-esnode-0",
+          "webserver_demo-webnode-0", "webserver_demo-webnode-1", "webserver_demo-webnode-2", "webserver_demo-webnode-3", "webserver_demo-webnode-4", "webserver_demo-webnode-5"
+        ]
+      end
+
+      describe 'resolving servers gets right' do
+        before do
+          @server = @cluster.slice(:webnode, 5).first
+          @server.cloud.stub!(:validation_key).and_return("I_AM_VALID")
+          @server.resolve!
+        end
+
+        it 'attributes' do
+          @server.to_hash.should == {
+            :name            => 'webserver_demo-webnode-5',
+            :run_list        => ["role[base_role]", "role[chef_client]", "role[ssh]", "role[nfs_client]", "role[big_package]", "role[webserver_demo_cluster]", "role[nginx]", "role[redis_client]", "role[mysql_client]", "role[elasticsearch_client]", "role[awesome_website]", "role[webserver_demo_webnode]"],
+            :instances => 6,
+            :chef_attributes => {
+              :split_testing  => {:group=>"B"},
+              :webnode_count  => 6,
+              :node_name      => "webserver_demo-webnode-5",
+              :cluster_name => :webserver_demo, :facet_name => :webnode, :facet_index => 5,
+            },
+          }
+        end
+
+        it 'security groups' do
+          @server.security_groups.keys.sort.should == ['default', 'webserver_demo', 'webserver_demo-awesome_website', 'webserver_demo-redis_client', 'webserver_demo-webnode', 'nfs_client', 'ssh']
+        end
+        it 'run list' do
+          @server.run_list.should == ["role[base_role]", "role[chef_client]", "role[ssh]", "role[nfs_client]", "role[big_package]", "role[webserver_demo_cluster]", "role[nginx]", "role[redis_client]", "role[mysql_client]", "role[elasticsearch_client]", "role[awesome_website]", "role[webserver_demo_webnode]"]
+        end
+
+        it 'user_data' do
+          @server.cloud.user_data.should == {
+            "chef_server"            => "https://api.opscode.com/organizations/infochimps",
+            "validation_client_name" => "chef-validator",
+            "validation_key"         => "I_AM_VALID",
+          }
+        end
+
+        it 'cloud settings' do
+          hsh = @server.cloud.to_hash
+          hsh.delete(:security_groups)
+          hsh.delete(:user_data)
+          hsh.should == {
+            :availability_zones => ["us-east-1c"],
+            :region             => "us-east-1",
+            :flavor             => "t1.micro",
+            :image_name         => "maverick",
+            :backing            => "ebs",
+            :disable_api_termination => false,
+            :public_ip         => false,
+            :bootstrap_distro   => "ubuntu10.04-cluster_chef",
+            :keypair            => :webserver_demo,
+          }
+        end
+
+      end
+    end
+  end
+end