dew 0.1.0

data/lib/dew/tasks/spec.rake

@@ -0,0 +1,14 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  # Put spec opts in a file named .rspec in root
+end
+
+namespace :spec do
+  desc "Run tests with coverage check"
+  task :covered do
+    ENV['RSPEC_COVERED'] = '1'
+    Rake::Task['spec'].execute
+  end
+end

data/lib/dew/validations.rb

@@ -0,0 +1,8 @@
+module Validations
+
+  class Validation
+    def self.validates_format_of string, regex
+      raise ArgumentError, "Validation error. '#{string}' does not match '#{regex.inspect}'" unless regex.match(string)
+    end
+  end
+end

data/lib/dew/version.rb

@@ -0,0 +1,3 @@
+module Dew
+  VERSION = "0.1.0"
+end

data/lib/dew/view.rb

@@ -0,0 +1,39 @@
+require 'terminal-table/import'
+
+class String
+  def indent(n)
+     if n >= 0
+       gsub(/^/, ' ' * n)
+     else
+       gsub(/^ {0,#{-n}}/, "")
+     end
+   end
+end
+
+
+class View
+  def initialize(name, items, keys)
+    @name = name
+    @items = items
+    @keys = keys
+  end
+
+  def index
+    rows = @items.collect { |item| collect_values(item) }
+    "#{@name}:\n#{rows.empty? ? "None\n".indent(2) : table(@keys, *rows).to_s.indent(2)}"
+  end
+
+  def show(i)
+    "#{@name}:\n" +
+    table(nil, *@keys.collect { |item| item }.zip( collect_values(@items[i]))).to_s.indent(2)
+  end
+
+  private
+  def collect_values(item)
+    @keys.collect { |key|
+      v = item.is_a?(Hash) ? (item.has_key?(key) && item.fetch(key) || item.has_key?(key.to_sym) && item.fetch(key.to_sym)) : item.send(key)
+      v.inspect
+    }
+  end
+end
+

data/lib/tasks/spec.rake

@@ -0,0 +1,14 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  # Put spec opts in a file named .rspec in root
+end
+
+namespace :spec do
+  desc "Run tests with coverage check"
+  task :covered do
+    ENV['RSPEC_COVERED'] = '1'
+    Rake::Task['spec'].execute
+  end
+end

data/spec/dew/cloud_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe :Cloud do
+  
+  let (:region) { 'ap-southeast-1' }
+  let (:account_name) { 'development' }
+  let (:profile_name) { 'test-light' }
+
+  let (:aws_credentials) { {:aws_access_key_id => '1234', :aws_secret_access_key => '5678', :region => region} }
+  let (:root_aws_credentials) { aws_credentials.merge(:provider => 'AWS')}
+  let (:account) { double('Account', aws_credentials) }
+  let (:profile) { double('Profile') }
+  
+  context "after connect is called" do
+    before :each do
+      Account.stub(:read => account)
+      Cloud.connect(region, account_name, profile_name)
+    end
+    
+    it { Cloud.region.should == region }
+    it { Cloud.account_name.should == account_name }
+    it { Cloud.profile_name.should == profile_name }
+
+    it "should provide the Account" do
+      Account.should_receive(:read).with(account_name).and_return(account)
+      Cloud.account.should == account
+    end
+    
+    it "should provide the Profile" do
+      Profile.should_receive(:read).with(profile_name).and_return(profile)
+      Cloud.profile.should == profile
+    end
+    
+    it "should provide a compute hook" do
+      Fog::Compute.should_receive(:new).with(root_aws_credentials).and_return('compute')
+      Cloud.compute.should == 'compute'
+    end
+
+    it "should provide a security groups hook" do
+      security_group = double(:security_group, :name => 'foo')
+      Fog::Compute.should_receive(:new).with(root_aws_credentials).and_return(double(:compute, :security_groups => [security_group]))
+      Cloud.security_groups.should == { 'foo' => security_group }
+    end
+
+    it "should return valid servers" do
+      servers = [
+        double(:server, :state => 'running'),
+        double(:server, :state => 'terminated'),
+        double(:server, :state => 'pending')
+      ]
+      Cloud.stub_chain(:compute, :servers).and_return( servers )
+      Cloud.valid_servers.should == [servers[0], servers[2]]
+    end
+
+    it "should check AWS to ensure the given keypair exists" do
+      Fog::Compute.should_receive(:new).with(root_aws_credentials).and_return(
+        double(:compute, :key_pairs => mock(:some_key_pairs, :get => true))
+      )
+      Cloud.keypair_exists?('a_keypair').should be_true
+    end
+
+    it "should provide an ELB hook" do
+      Fog::AWS::ELB.should_receive(:new).with(aws_credentials).and_return('elb')
+      Cloud.elb.should == 'elb'
+    end
+    
+    it "should provide an RDS hook" do
+      Fog::AWS::RDS.should_receive(:new).with(aws_credentials).and_return('rds')
+      Cloud.rds.should == 'rds'
+    end
+
+    # TODO: should this be here?
+    it "should provide a hook to the rds_authorized_ec2_owner_ids" do
+      Fog::AWS::RDS.should_receive(:new).with(aws_credentials).and_return(
+        double(:rds, :security_groups => [ double(:security_group, :id => 'default', :ec2_security_groups => [
+          { "EC2SecurityGroupName" => "default", "Status" => "authorized", "EC2SecurityGroupOwnerId" => '12345' }
+        ]) ])
+      )
+      Cloud.rds_authorized_ec2_owner_ids.should == ['12345']
+    end
+    
+    describe :keyfile_path do
+      it "should look for the keypair in the ~/.dew/accounts directory" do
+        Cloud.connect(region, account_name)
+        Cloud.keyfile_path('devops').should == "#{ENV['HOME']}/.dew/accounts/keys/#{account_name}/#{region}/devops.pem"
+      end
+    end
+    
+  end
+end

data/spec/dew/controllers/amis_controller_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe AMIsController do
+
+  let (:controller) { AMIsController.new }
+  let (:ami_name) { 'my-ami' }
+  let (:puppet_node_name) { 'puppet-node-name' }
+  let (:ssh) { double('SSH', :run => nil, :upload => nil) }
+  let (:server) { double('Server', :id => 'i-12345', :ssh => ssh, :public_ip_address => '127.0.0.1', :create_ami => nil) }
+  let (:environment) { double('Environment', :servers => [server], :destroy => nil) }
+  let (:ami) { double('AMI', :owner_id => '1234') }
+  let (:images) { double('ComputeImages') }
+
+  before { Cloud.stub(:compute => double('Compute', :images => images)) }
+
+  describe :create do
+    before :each do
+      Profile.stub(:read => nil)
+      Environment.stub(:create => environment)
+    end
+    after :each do
+      controller.create(ami_name, puppet_node_name)
+    end
+    it "should create a new environment using the ami-prototype profile" do
+      Profile.should_receive(:read).with('ami-prototype').and_return('ami_profile')
+      Environment.should_receive(:create).with(/#{ami_name}/, 'ami_profile').and_return environment
+    end
+    # Not all elements of the script are tested - just the important bits
+    it "should upload our puppet configuration to the instance" do
+      ssh.should_receive(:upload)#.with(File.join(ROOT_DIR, 'puppet'), '/tmp/puppet')
+    end
+    it "should run puppet using the node name we specified" do
+      ssh.should_receive(:run).with(%r{puppet.+/etc/puppet/manifests/nodes/#{puppet_node_name}.pp})
+    end
+    it "should create an AMI from the resulting server" do
+      server.should_receive(:create_ami).with(ami_name)
+    end
+    it "should finally destroy the environment" do
+      environment.should_receive(:destroy)
+    end
+  end
+
+  describe :index do
+    before { images.stub(:all => [ami]) }
+    after { controller.index }
+
+    it "should show an index of the amis" do
+      Cloud.should_receive(:account).at_least(1).and_return(double(:account, :aws_user_id => '1234'))
+      View.should_receive(:new).at_least(1).and_return(double(:view, :index => true))
+      Inform.should_receive(:info).at_least(1)
+    end
+  end
+
+  describe :show do
+    context "AMI doesn't exist" do
+      it "should raise error" do
+        images.stub(:all => [])
+        lambda { controller.show(ami_name) }.should raise_error /not found/i
+      end
+    end
+
+    context "AMI exists" do
+      before { images.stub(:all => [ami]) }
+      after { controller.show(ami_name) }
+
+      it "should show the ami" do
+        View.should_receive(:new).and_return(double(:view, :show => true))
+        Inform.should_receive(:info)
+      end
+    end
+  end
+
+  describe :show do
+    context "AMI doesn't exist" do
+      it "should raise error" do
+        images.stub(:all => [])
+        lambda { controller.show(ami_name) }.should raise_error /not found/i
+      end
+    end
+
+    context "AMI exists" do
+      before { images.stub(:all => [ami]) }
+      after { controller.show(ami_name) }
+
+      it "should show the ami" do
+        View.should_receive(:new).and_return(double(:view, :show => true))
+        Inform.should_receive(:info)
+      end
+    end
+  end
+
+  describe :destroy do
+    context "AMI doesn't exist" do
+      it "should error if the ami doesn't exist" do
+        images.stub(:all => [])
+        lambda { controller.destroy(ami_name) }.should raise_error /not found/i
+      end
+    end
+
+    context "AMI exists" do
+      before do
+        controller.stub(:agree => true)
+        images.stub(:all => [ami])
+      end
+
+      after { controller.destroy(ami_name, options) }
+
+      context "with no options" do
+        let(:options) { {} }
+
+        it "should find an AMI and destroy it if agreement is given" do
+          images.should_receive(:all).with('name' => ami_name).and_return([ami])
+          ami.should_receive(:deregister)
+        end
+
+        it "should ask the user for confirmation before destroying the AMI" do
+          controller.should_receive(:agree).and_return(true)
+          ami.should_receive(:deregister)
+        end
+
+        it "should not destroy the AMI if agreement is not given" do
+          controller.should_receive(:agree).and_return(false)
+          ami.should_not_receive(:deregister)
+        end
+      end
+
+      context "with :force => true" do
+        let(:options) { { :force => true } }
+
+        it "should not ask for agreement" do
+          controller.should_not_receive(:agree)
+          ami.should_receive(:deregister)
+        end
+      end
+    end
+  end
+end

data/spec/dew/controllers/deploy_controller_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe DeployController do
+
+  let (:type) { 'puge' }
+  let (:tag) { 'puge-1.16.1' }
+  let (:rails_env) { 'development' }
+  let (:environment_name) { 'myenvironment' }
+  let (:opts) { { 'tag' => tag, 'rails_env' => rails_env } }
+
+  describe :create do
+    before :each do
+      @servers = []
+      (0..1).each { @servers << double('Server').as_null_object }
+      @server = @servers.first
+      Server.stub(:find => [])
+      Database.stub(:get => nil)
+      @environment = double('Environment', :servers => @servers)
+      Environment.stub(:get => @environment)
+    end
+
+    context "no servers exist for the nominated environment" do
+      it "should not raise an error" do
+        environment = double('Environment', :servers => [])
+        Environment.stub(:get).and_return(environment)
+        lambda { DeployController.new.create(type, environment_name, { 'tag' => tag, 'rails_env' => rails_env }) }.should raise_error /instances already terminated/
+      end
+    end
+
+    it "should create an instance of Deploy and deploy" do
+      deploy_run = double('Deploy::Run')
+      Deploy::Run.should_receive(:new).with(type, @environment, opts).and_return(deploy_run)
+      deploy_run.should_receive(:deploy)
+      DeployController.new.create(type, environment_name, opts)
+    end
+
+  end
+end

data/spec/dew/controllers/environments_controller_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe EnvironmentsController do
+  subject { EnvironmentsController.new }
+
+  after { subject }
+
+  describe :create do
+    let(:profile) { mock(:profile, :keypair => 'default') }
+    before {
+      @env = double(:environment)
+      Profile.should_receive(:read).with('profile_name').and_return(profile)
+      subject.stub(:agree => true)
+    }
+
+    after { subject.create(:name , 'profile_name', options) }
+
+
+    context "no options" do
+        let(:options) { {} }
+
+        it "should ask the user for confirmation before destroying the environment" do
+          Environment.should_receive(:create).with(:name, profile).and_return(@env)
+          @env.should_receive(:show)
+          subject.should_receive(:agree).and_return(true)
+        end
+
+        it "should not create the environment if agreement is not given" do
+          subject.should_receive(:agree).and_return(false)
+          @env.should_not_receive(:create)
+        end
+    end
+
+    context ":force => true" do
+        let(:options) { {:force => true} }
+
+        it "should not ask for agreement" do
+          Environment.should_receive(:create).with(:name, profile).and_return(@env)
+          subject.should_not_receive(:agree)
+          @env.should_receive(:show)
+        end
+    end
+  end
+
+  describe :index do
+    after { subject.index }
+
+    it "should index the environments" do
+      Environment.should_receive(:index)
+    end
+  end
+
+  describe :show do
+    let(:name) { 'foo' }
+
+    before {
+      Environment.should_receive(:get).with(name).and_return(environment)
+    }
+
+    context "environment doesn't exist" do
+      let(:environment) { nil }
+
+      it "should raise an exception" do
+        lambda { subject.show('foo') }.should raise_error /not found/
+      end
+    end
+
+    context "environment exists" do
+      let(:environment) { double('Environment') }
+
+      after { subject.show(name) }
+
+      it "should show an environment" do
+        environment.should_receive(:show)
+      end
+    end
+
+  end
+
+  describe :destroy do
+    let(:name) { 'foo' }
+
+    before {
+      Environment.should_receive(:get).with(name).and_return(environment)
+    }
+
+    context "environment doesn't exist" do
+      let(:environment) { nil }
+
+      it "should raise an exception" do
+        lambda { subject.destroy(name) }.should raise_error /not found/
+      end
+    end
+
+    context "environment exists" do
+      let(:environment) { double('Environment', :destroy => true, :show => true) }
+
+      before { subject.stub(:agree => true) }
+
+      after { subject.destroy(name, options) }
+
+      context "no options" do
+        let(:options) { {} }
+
+        it "should show the environment before destroying it" do
+          environment.should_receive(:show)
+        end
+
+        it "should find an environment and destroy it if agreement is given" do
+          environment.should_receive(:destroy)
+        end
+
+        it "should ask the user for confirmation before destroying the environment" do
+          subject.should_receive(:agree).and_return(true)
+        end
+
+        it "should not destroy the environment if agreement is not given" do
+          subject.should_receive(:agree).and_return(false)
+          environment.should_not_receive(:destroy)
+        end
+      end
+
+      context ":force => true" do
+        let(:options) { {:force => true} }
+
+        it "should not ask for agreement" do
+          subject.should_not_receive(:agree)
+          environment.should_receive(:destroy)
+        end
+      end
+    end
+  end
+end