dew 0.1.0

data/spec/dew/models/account_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Account do
+
+  describe :initialize 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("---")
+      Account.read(name)
+    end
+  end
+
+  describe "parsing yaml" do
+    before :each do
+      yaml =
+        "aws:
+          user_id: 9999-3333-2222
+          access_key_id: foo
+          secret_access_key: bar"
+
+      File.stub(:read).and_return(yaml)
+      @account = Account.read('foo')
+    end
+
+    it "should have a user_id stripped of dashes" do
+      @account.aws_user_id.should == '999933332222'
+    end
+
+    it "should have an aws access key id" do
+      @account.aws_access_key_id.should == 'foo'
+    end
+
+    it "should have an aws secret access key" do
+      @account.aws_secret_access_key.should == 'bar'
+    end
+  end
+  
+  describe ".user_ids" do
+    it "should return the user_ids of each account file in config/accounts" do
+      Dir.should_receive(:[]).with("#{ENV['HOME']}/.dew/accounts/*.yaml").and_return(["accounts/file1.yaml", "accounts/file2.yaml"])
+      Account.should_receive(:read).with("file1").and_return(double('account', :aws_user_id => 'id1'))
+      Account.should_receive(:read).with("file2").and_return(double('account', :aws_user_id => 'id2'))
+      Account.user_ids.sort.should == ['id1', 'id2']
+    end
+  end
+
+end

data/spec/dew/models/database_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Database do
+
+  let (:rds) { double('RDS', :servers => double('RDSServers')) }
+  let (:id) { 'mydatabase' }
+  let (:fog_database) { double('FogDatabase', :id => id) }
+  
+  before :each do
+    Cloud.stub(:rds => rds)
+    rds.servers.stub(:create => fog_database)
+  end
+  
+  describe ".create!" do
+    it "should ask Fog to create a new RDS with the provided name, size, username and password" do
+      rds.servers.should_receive(:create).with(hash_including(:id => id, :flavor_id => 'db.m1.small', :master_username => 'root', :password => 'password'))
+      Database.create!(id, 'db.m1.small', 'password')
+    end
+    
+    it "should return a new Database object with an ID" do
+      database = Database.create!(id, 'b', 'd')
+      database.id.should == id
+    end
+  end
+  
+  describe ".get" do
+    it "should return nil if the database doesn't exist" do
+      rds.servers.should_receive(:get).with(id).and_return nil
+      Database.get(id).should == nil
+    end
+    
+    it "should return a Database object if the database does exist" do
+      rds.servers.should_receive(:get).with(id).and_return fog_database
+      Database.get(id).id.should == id
+    end
+      
+  end
+  
+  context "with a database created" do
+    before :each do
+      @database = Database.create!(id, 'db.m1.small', 'password')
+      fog_database.stub(:endpoint => {'Address' => '127.0.0.1'}, :master_username => 'root')
+    end
+    describe "db_environment_file" do
+      it "should return the contents of a file to use as /etc/environment that can be used to connct to this database" do
+        data = @database.db_environment_file('password')
+        data.should =~ /PUGE_DB_NAME=#{id}/
+        data.should =~ /PUGE_DB_USERNAME=root/
+        data.should =~ /PUGE_DB_PASSWORD=password/
+        data.should =~ /PUGE_DB_HOST=127.0.0.1/
+      end
+    end
+    describe :public_address do
+      it {@database.public_address.should == '127.0.0.1'}
+    end 
+  end
+  
+end

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

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper'))
+
+describe Deploy::Puge do
+
+  let (:tag) { 'puge-1.16.1' }
+  let (:rails_env) { 'development' }
+  let (:gofer) { double('Gofer').as_null_object }
+  let (:servers) { (0..1).map { |i| double("Server #{i}").as_null_object} }
+  let (:environment) {double('Environment', :servers => servers, :database => database)}
+  let (:opts) { { 'tag' => tag, 'rails_env' => rails_env } }
+  let (:run_on_servers) { servers }
+  let (:base_path) { [ ENV['HOME'], '.dew', 'deploy', 'puge' ]}
+
+  shared_examples_for "script runner" do
+    it "should upload the script to the EC2 instance" do
+      run_on_servers.each do |server|
+        server.ssh.should_receive(:upload).with(File.join(base_path, script), File.join('.'))
+      end
+      Deploy::Puge.new(servers, opts).deploy
+    end
+
+    it "should run the script" do
+      run_on_servers.each do |server|
+        server.ssh.should_receive(:run).with(['./' + script, arguments.map { |a| "'#{a}'"}].flatten.join(" "))
+      end
+      Deploy::Puge.new(servers, opts).deploy
+    end
+  end
+
+  describe :run do
+
+    describe "Discrete actions" do
+
+      describe "Clone PUGE" do
+        let (:script) { 'clone_puge.sh' }
+        let (:arguments) { [tag] }
+        it_should_behave_like "script runner"
+      end
+
+      describe "Bundle install" do
+        let (:script) { 'bundle_install.sh' }
+        let (:arguments) { [] }
+        it_should_behave_like "script runner"
+      end
+
+      describe "Setup Rails database" do
+        let (:run_on_servers) { servers.first }
+        let (:script) { 'setup_rails_database.sh' }
+        let (:arguments) { [rails_env] }
+        it_should_behave_like "script runner"
+      end
+
+      describe "Generate PUGE WAR" do
+        let (:script) { 'generate_puge_war.sh' }
+        let (:arguments) { [rails_env] }
+        it_should_behave_like "script runner"
+      end
+
+      describe "Copy PUGE WAR into Tomcat directory" do
+        let (:script) { 'copy_puge_war_into_tomcat.sh' }
+        let (:arguments) { [] }
+        it_should_behave_like "script runner"
+      end
+
+      describe "Restart Tomcat" do
+        let (:script) { 'restart_tomcat.sh' }
+        let (:arguments) { [] }
+        it_should_behave_like "script runner"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Deploy::Run do
+
+  let (:deploy_type) { 'puge' }
+  let (:tag) { 'puge-1.16.1' }
+  let (:rails_env) { 'development' }
+  let (:servers) { (0..1).map { |i| double("Server #{i}").as_null_object} }
+  let (:database) { double('Database')}
+  let (:environment) {double('Environment', :servers => servers, :database => database)}
+  let (:opts) { { 'tag' => tag, 'rails_env' => rails_env } }
+
+  before :each do
+    @deploy_run = Deploy::Run.new(deploy_type, environment, opts)
+    Cloud.stub(:region => 'ap-southeast-1', :account_name => 'myaccount', :profile_name => 'development')
+  end
+
+  it { @deploy_run.deploy_type.should == deploy_type }
+  it { @deploy_run.environment.should == environment }
+  it { @deploy_run.opts['tag'].should == tag }
+  it { @deploy_run.opts['rails_env'].should == rails_env }
+
+  describe :deploy do
+    before :each do
+      Deploy::Puge.stub(:run => nil)
+    end
+
+    it "should perform a deploy run for each associated server" do
+      deloy_puge_class_name = 'Deploy::Puge'
+      deploy_puge = double(deloy_puge_class_name)
+
+      Deploy.should_receive(:const_get).with(deploy_type.capitalize).and_return(deloy_puge_class_name)
+      deloy_puge_class_name.should_receive(:new).with(servers, opts).and_return(deploy_puge)
+      deploy_puge.should_receive(:deploy)
+      @deploy_run.deploy
+    end
+  end
+end

data/spec/dew/models/environment_spec.rb

@@ -0,0 +1,374 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../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(: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) { [] }
+  let(:an_elb) { double('elb1', :id => 'my-environment') }
+  let (:elb) { double('ELB', :load_balancers => [an_elb]) }
+  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
+
+  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 ".get" do
+    before :each do
+      Server.stub(:find => [])
+      Database.stub(:get => nil)
+    end
+    it "should discover servers belonging to this environment" do
+      Server.should_receive(:find).with('Environment', name).and_return [server]
+      Environment.get(name).servers.should == [server]
+    end
+    it "should discover a database belonging to this environment" do
+      Database.should_receive(:get).with(name).and_return 'database'
+      Environment.get(name).database.should == 'database'
+    end
+    it "should return nil if no servers nor database is discovered for this environment" do
+      Environment.get(name).should == nil
+    end
+  end
+
+  describe ".create" do
+    let (:security_groups) { %w(non_default) }
+    let(:profile) { double(:profile, :keypair => 'default', :security_groups => security_groups, :ami => 'i-1234', :has_rds? => false, :has_elb? => false, :count => 2, :size => 'small' ) }
+
+    context "when environment name is invalid" do
+      it "should raise an error" do
+        lambda { Environment.create(bad_name, profile) }.should raise_error /does not match/
+      end
+    end
+
+    context "when profile keypair is not available in AWS" do
+      let(:keypair_available_in_aws) { false }
+
+      it "should raise an error" do
+        lambda { Environment.create(name, profile) }.should raise_error /is not available/
+      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)
+      }
+
+      after { Environment.create(name, profile) }
+
+      context "with a profile count of 2" 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).twice
+        end
+      end
+
+      it "should wait for our environment to become ready" do
+        @env.should_receive(:wait_until_ready)
+      end
+
+      describe "with an ELB specified in the profile" do
+        before :each do
+          profile.stub(:has_elb? => true, :elb_listener_ports => [80])
+        end
+
+        it "should add an ELB to the environment with the required ports" do
+          @env.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')
+          @env.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', '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')
+        end
+      end
+
+    end
+  end
+
+  describe ".names" do
+    before {
+      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"   })
+      ])
+    }
+
+    it { Environment.owners.should == [{:name=>"test-1", :owner=>"chris"}, {:name=>"test-2", :owner=>"ash"}] }
+  end
+
+  describe ".index" do
+    before {
+      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"   })
+      ])
+    }
+    after { Environment.index }
+
+    # TODO: Have the model return what is to be displayed rather than display it itself.
+    it "should index the environments" do
+      Inform.should_receive(:info).at_least(1).with( <<EOF
+Environments:
+  +----------+---------+
+  | name     | owner   |
+  +----------+---------+
+  | "test-1" | "chris" |
+  | "test-2" | "ash"   |
+  +----------+---------+
+EOF
+      )
+    end
+  end
+
+  describe :show do
+    before {
+      Cloud.stub_chain(:account, :aws_user_id).and_return('12345')
+    }
+    after { @environment.show }
+
+    context "with servers" do
+      let(:servers) { [server] }
+
+      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'))
+      end
+    end
+
+    context "with an elb" do
+      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')
+      end
+    end
+
+    context "with a database" do
+      before {
+        @environment.stub(:database => database)
+        @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"))
+      end
+    end
+
+  end
+
+  describe :destroy do
+    before :each do
+      @environment.stub(:has_elb? => false)
+    end
+    it "should destroy the database if there is one" do
+      @environment.stub(:database => database)
+      database.should_receive(:destroy)
+      @environment.destroy
+    end
+    it "should destroy the servers if there are any" do
+      @environment.stub(:servers => [server])
+      server.should_receive(:destroy)
+      @environment.destroy
+    end
+    it "should destroy the ELB if there is one" do
+      @environment.stub(:has_elb? => true)
+      elb.should_receive(:delete_load_balancer).with(name)
+      @environment.destroy
+    end
+  end
+
+  describe :add_server do
+    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)
+    end
+
+    it "should add the Server to its servers array" do
+      @environment.add_server(*@args)
+      @environment.add_server(*@args)
+      @environment.servers.should == [server, server]
+    end
+
+    it "should tag the server with the environment name and creator" do
+      server.should_receive(:add_tag).with('Environment', name)
+      server.should_receive(:add_tag).with('Creator', ENV['USER'])
+      @environment.add_server(*@args)
+    end
+
+    it "should tag the server with an indexed name" do
+      server.should_receive(:add_tag).with('Name', "#{name} 1")
+      @environment.add_server(*@args)
+
+      server.should_receive(:add_tag).with('Name', "#{name} 2")
+      @environment.add_server(*@args)
+    end
+  end
+
+  describe :remove_server_from_elb do
+    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)
+    end
+  end
+  
+  describe :add_server_to_elb do
+    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)
+    end
+  end
+
+  context "with one server" do
+    before :each do
+      @environment.stub(:servers => [server])
+    end
+
+    describe :add_elb do
+      before :each do
+        server.stub(:availability_zone => 'ap-southeast-1a')
+        elb.stub(:create_load_balancer => nil, :register_instances_with_load_balancer => nil)
+      end
+      it "should create the ELB using the provided listeners, environment name and the availability zones of the current servers" do
+        server.should_receive(:availability_zone).and_return('ap-southeast-1a')
+
+        elb.should_receive(:create_load_balancer).with(
+            ['ap-southeast-1a'], name,
+            [{'Protocol' => 'TCP', 'LoadBalancerPort' => 80, 'InstancePort' => 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]
+      end
+
+    end
+
+    describe :add_database do
+      before :each do
+        Database.stub(:create! => database)
+      end
+
+      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', 'password')
+        @environment.add_database 'db.m1.small', 'password'
+      end
+
+      it "should make the database available on the 'database' accessor" do
+        @environment.add_database 'db.m1.small', 'password'
+        @environment.database.should == database
+      end
+    end
+
+    describe :wait_until_ready do
+      before {
+        Cloud.stub(:security_groups => { 'non_default' => double(:group, :ip_permissions => ip_permissions) } )
+      }
+      after { @environment.wait_until_ready }
+
+      context "with no ip_permissions" do
+        let(:ip_permissions) { [:some_ip_permissions] }
+
+        it "should wait for each server to be ready" do
+          server.should_receive(:wait_until_ready)
+        end
+      end
+
+      context "with ip_permissions" do
+        let(:ip_permissions) { [] }
+
+        it "should not wait for each server to be ready" do
+          server.should_not_receive(:wait_until_ready)
+        end
+      end
+    end
+
+    context "with an RDS" do
+      before :each do
+        Cloud.stub(:security_groups => { 'non_default' => double(:group, :ip_permissions => true) } )
+        @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
+        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'
+        end
+      end
+
+    end
+  end
+
+  def mock_describe_load_balancers load_balancers, name=nil
+    response = double('ELB Response', :body => { 'DescribeLoadBalancersResult' => { 'LoadBalancerDescriptions' => load_balancers }})
+    if name
+      elb.should_receive(:describe_load_balancers).with(name).and_return(response)
+    else
+      elb.should_receive(:describe_load_balancers).and_return(response)
+    end
+  end
+
+  describe :has_elb? do
+    it "return true if we have a load balancer" do
+      mock_describe_load_balancers([{'LoadBalancerName' => name}])
+      @environment.has_elb?.should be_true
+    end
+
+    it "return false if we don't" do
+      mock_describe_load_balancers([{'LoadBalancerName' => "XXXX"}])
+      @environment.has_elb?.should be_false
+    end
+
+  end
+
+end