chef_cap 0.0.5

data/recipes/rvm_bootstrap.rb

@@ -0,0 +1,34 @@
+depend :remote, :command, "rvm"
+depend :remote, :command, "chef-solo"
+
+before "chef:setup", "rvm:bootstrap"
+
+namespace :rvm do
+  desc "Create a standalone rvm installation with a default ruby to use with chef-solo"
+  task :bootstrap do
+    rvm_standup_script = <<-SH
+      #!/bin/bash
+      RVM_URL="http://rvm.beginrescueend.com/releases/rvm-install-latest"
+      export PATH=$PATH:/usr/local/bin
+      HAVE_RVM_ALREADY=`which rvm 2>/dev/null`
+      if [ ! -z $HAVE_RVM_ALREADY ]; then
+        echo "Looks like RVM is already on this machine. Skipping."
+        exit 0
+      fi
+
+      HAVE_CURL=`which curl 2>/dev/null`
+      if [ ! -z $HAVE_CURL ]; then
+        RVM_TEMP_FILE=`mktemp /tmp/rvm_bootstrap.XXXXXX`
+        curl $RVM_URL > $RVM_TEMP_FILE
+        chmod u+rx $RVM_TEMP_FILE
+        sh $RVM_TEMP_FILE
+        rm -f $RVM_TEMP_FILE
+      else
+        echo "FATAL ERROR: I have no idea how to download RVM without curl!"
+        exit 1
+      fi
+    SH
+    put rvm_standup_script, "/tmp/chef-cap-#{rails_env}-rvm-standup.sh", :mode => "0700"
+    sudo "/tmp/chef-cap-#{rails_env}-rvm-standup.sh"
+  end
+end

data/recipes/unset_default_deploy.rb

@@ -0,0 +1,44 @@
+namespace :deploy do
+  task :default do
+    chef.deploy
+  end
+
+  task :long do
+    # do nothing
+  end
+
+  task :update_code do
+    # do nothing
+  end
+
+  task :finalize_update do
+    # do nothing
+  end
+
+  task :symlink do
+    # do nothing
+  end
+
+  task :restart do
+    # do nothing
+  end
+
+  task :migrate do
+    # do nothing
+  end
+
+  task :start do
+    # do nothing
+  end
+
+  task :setup do
+    # do nothing
+  end
+end
+
+# Finally load deploy.rb if it exists and allow it to overwrite anything we've done here
+unless File.exist?("config/deploy.rb")
+  def load(*args)
+    return true
+  end
+end

data/spec/chef_cap_configuration_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe ChefCapConfiguration do
+  describe ".set_repository_settings" do
+    it "should set repository values for a git repository" do
+      configuration = mock("Configuration")
+      configuration.stub!(:repository => "git@somegitrepo")
+      configuration.should_receive(:set).with(:scm, :git)
+      configuration.should_receive(:set).with(:git_enable_submodules, 1)
+      configuration.should_receive(:default_run_options).and_return({})
+      configuration.should_receive(:depend).with(:remote, :command, "git")
+      ChefCapConfiguration.configuration = configuration
+
+      ChefCapConfiguration.set_repository_settings
+    end
+
+    it "should set repository values for an svn repository" do
+      configuration = mock("Configuration")
+      ChefCapConfiguration.configuration = configuration
+      configuration.stub!(:repository => "svn://somesvnrepo")
+      configuration.should_receive(:set).with(:scm, :svn)
+      configuration.should_receive(:depend).with(:remote, :command, "svn")
+
+      ChefCapConfiguration.set_repository_settings
+    end
+  end
+end

data/spec/chef_cap_helper_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe ChefDnaParser do
+
+  describe ".recursive_merge" do
+
+    it "assigns a key value if the original has does not have the key" do
+      original_hash = {}
+
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "newkey", "somevalue")
+      resulting_hash["newkey"].should == "somevalue"
+    end
+
+    it "overwrites a value with the new value if there is a type mismatch" do
+      original_hash = {"key" => "value"}
+
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "key", 1)
+      resulting_hash["key"].should == 1
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "key", ["value"])
+      resulting_hash["key"].should == ["value"]
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "key", {:key => :value})
+      resulting_hash["key"].should == {:key => :value}
+    end
+
+    it "uniquely merges the values of two arrays" do
+      original_hash = {"key" => ["original", "duplicate"]}
+
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "key", ["duplicate", "newvalue"])
+      resulting_hash["key"].should =~ ["original", "duplicate", "newvalue"]
+    end
+
+    it "merges arrays of arrays" do
+      original_hash = {"key" => ["one", ["two", "three"]]}
+
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "key", ["onepointfive", ["two", "three"]])
+      resulting_hash["key"].should =~  ["one", "onepointfive", ["two", "three"]]
+    end
+
+    it "merges keys and values of hashes" do
+      original_hash = {"key" => { "one" => "two" }}
+
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "key", {"one" => "nottwo"})
+      resulting_hash["key"].should == { "one" => "nottwo" }
+    end
+
+    it "merge will overwrite hashes with arrays" do
+      original_hash = {"key" => {"array" => ["one"] }}
+
+      resulting_hash = ChefCapHelper.recursive_merge(original_hash, "key", {"array" => ["two", "three"]})
+      resulting_hash["key"].should == {"array" => ["two", "three"]}
+    end
+
+  end
+
+  describe ".roles_for_host" do
+    it "returns the list of roles that match for a given host" do
+      otherserver = stub("Server", :host => "somehostname")
+      matchserver = stub("Server", :host => "myhostname")
+
+      roles = { :matchrole => stub("Role", :servers => [otherserver, matchserver]),
+                :otherrole => stub("Role", :servers => [otherserver])}
+      ChefCapHelper.roles_for_host(roles, "myhostname").should == ["matchrole"]
+    end
+  end
+
+  describe ".merge_roles_for_host" do
+    it "merges the run list if the host has multiple roles" do
+      roles_hash = {
+        "role1" => {
+          "something else" => "yes",
+          "run_list" => ["role1run"]
+        },
+        "role2" => {
+          "something else" => "yup",
+          "run_list" => ["role1run, role2run"]
+        },
+        "role3" => {
+          "something else" => "nope",
+          "run_list" => ["role3run"]
+        }
+      }
+
+      ChefCapHelper.merge_roles_for_host(roles_hash, ["role1", "role2"]).should == {"run_list"=>["role1run", "role1run, role2run"], "something else"=>"yup"}
+    end
+
+    it "returns empty hash" do
+      ChefCapHelper.merge_roles_for_host(nil, ["role1", "role2"]).should == {}
+    end
+  end
+
+  describe ".rewrite_run_list_for_deploy" do
+    it "should move the deploy recipe to the end of the run list if it is specified" do
+      json_with_run_list = {
+        "run_list" => ["something", "something", "deployrecipe", "darkside"],
+        "deploy_recipe" => "deployrecipe"
+      }
+
+      ChefCapHelper.rewrite_run_list_for_deploy(json_with_run_list).should == ["something", "something", "darkside", "deployrecipe"]
+    end
+
+    it "should do nothing if the run list does not contain the deploy recipe" do
+      json_with_run_list = {
+        "run_list" => ["something", "something", "darkside"],
+        "deploy_recipe" => "deployrecipe"
+      }
+
+      ChefCapHelper.rewrite_run_list_for_deploy(json_with_run_list).should == ["something", "something", "darkside"]
+    end
+  end
+
+  describe ".intialize_primary_values" do
+    it "should make sure each server has a primary key with a value of empty array of it has nothing" do
+      array_of_servers_hash = [
+        { "host" => "server1"}
+        ]
+      ChefCapHelper.intialize_primary_values(array_of_servers_hash).should == [{"host" => "server1", "primary" => []}]
+    end
+
+    it "should not touch the setting of a server if it already has a value" do
+      array_of_servers_hash = [
+        { "host" => "server1", "primary" => ["one", "two"]}
+        ]
+      ChefCapHelper.intialize_primary_values(array_of_servers_hash).should == array_of_servers_hash
+    end
+  end
+end

data/spec/chef_cap_mock_cap.rb

@@ -0,0 +1,267 @@
+def parent
+  self
+end
+
+def namespace_objects
+  @namespace_objects ||= {}
+end
+
+def default_environment
+  @default_environment ||= {}
+end
+
+def find_servers(options = {})
+  servers = []
+  options[:roles].each do |role|
+    if @servers.has_key? role
+      @servers[role][:servers].each do |server|
+        servers << TestCapServer.new(server)
+      end
+    end
+  end
+  servers
+end
+
+def task(name, *args)
+  @tasks ||= {}
+  @tasks[@curent_namespace ? "#{@curent_namespace}:#{name}" : name] = proc { yield }
+  if @curent_namespace
+    namespace_objects[@curent_namespace].instance_eval(<<-EOS)
+      def #{name}
+        configuration.cap_task["#{@current_namespace}:#{name}"]
+      end
+    EOS
+  end
+  @tasks
+end
+
+def cap_task
+  @tasks ||= {}
+end
+
+def role(name, hostname, options = {})
+  @servers ||= {}
+  @servers[name] ||= {:servers => []}
+  @servers[name][:servers] = @servers[name][:servers] << hostname
+  @servers[name][:primary] = hostname if options[:primary]
+end
+
+def roles
+  if JSON.parse(ChefDnaParser.test_dna)["roles"]
+    role_hash = {}
+    JSON.parse(ChefDnaParser.test_dna)["roles"].each_pair do |key, value|
+      role_klass = TestCapRole.new
+
+      role_klass.instance_eval(<<-EOS)
+        def name
+          #{key.inspect}
+        end
+
+        def servers
+          []
+        end
+      EOS
+      if cap_role.any?
+        role_klass.instance_eval(<<-EOS)
+          def servers
+            role_servers = []
+            #{cap_role[key.to_sym][:servers].inspect}.each do |server_hostname|
+              host = TestCapServer.new
+              host.instance_eval(<<-EOH)
+                def host
+                  \#{server_hostname.inspect}
+                end
+              EOH
+              role_servers << host
+            end
+            role_servers
+          end
+        EOS
+      end
+      role_hash[key] = role_klass
+    end
+    role_hash
+  else
+    []
+  end
+end
+
+def cap_role
+  @servers ||= {}
+end
+
+def set(key, value)
+  key.to_s.gsub!(/\.|-/, '_')
+  self.instance_eval(<<-EOS)
+    def #{key}
+      #{value.inspect}
+    end
+  EOS
+  @variables ||= {}
+  @variables[key] = value
+end
+
+def cap_variable
+  @variables ||= {}
+end
+
+def depend(local_or_remote, dependency_type, path)
+  @dependencies ||= {}
+  @dependencies[path] = { local_or_remote => dependency_type }
+end
+
+def cap_depends
+  @dependencies ||= {}
+end
+
+def desc(message)
+  @task_description = message
+end
+
+def current_description
+  @task_description
+end
+
+def namespace(name, &block)
+  @namespaces ||= {}
+  @namespaces[name] = true
+  @curent_namespace = name
+  @namespace_objects ||= {}
+  namespace_objects[name] = TestCapMockNamespace.new
+  namespace_objects[name].configuration = self
+  self.instance_eval(<<-EOS)
+    def #{name}
+      namespace_objects['#{name}'.to_sym]
+    end
+  EOS
+
+  yield
+ensure
+  @curent_namespace = nil
+end
+
+def cap_namespace
+  @namespaces ||= {}
+end
+
+def before(task_name, task_to_call, &block)
+  @before_callchain ||= {}
+  @before_callchain[task_name] ||= []
+  @before_callchain[task_name] << task_to_call
+end
+
+def cap_before
+  @before_callchain ||= {}
+end
+
+def after(task_name, task_to_call, &block)
+  @after_callchain ||= {}
+  @after_callchain[task_name] ||= []
+  @after_callchain[task_name] << task_to_call
+end
+
+def ssh_options
+  @ssh_options ||= {}
+end
+
+def cap_after
+  @after_callchain ||= {}
+end
+
+def cap_ssh_options
+  @ssh_options ||= {}
+end
+
+def default_run_options
+  @default_run_options ||= {}
+end
+
+def parallel_sessions
+  @parallel_sessions ||= []
+end
+
+def run(command, &block)
+  @commands_run ||= {}
+  if block_given?
+    @commands_run[command] = proc { yield }
+  else
+    @commands_run[command] = true
+  end
+  @commands_run
+end
+
+def cap_run
+  @commands_run ||= {}
+end
+
+def cap_servers
+  cap_role.each_value.map do |hash|
+    hash[:servers]
+  end.flatten.uniq
+end
+
+def parallel_mocks
+  @parallel_mocks ||= []
+end
+
+def parallel(options={})
+  cap_servers.each do |server|
+    session_klass = TestCapSession.new
+    session_klass.instance_eval do
+      def set_channel=(hash)
+        @channel = hash
+      end
+
+      def channel
+        @channel
+      end
+
+      def set_roles=(rolez)
+        @roles = rolez
+      end
+
+      def roles
+        @roles
+      end
+
+      def else(command, &block)
+        instance_exec(channel, &block)
+      end
+
+      def set_environment_settings=(something)
+        @env_settings = something
+      end
+
+      def environment_settings
+        @env_settings
+      end
+
+      def set(key, value)
+        @set ||= {}
+        @set[key] = value
+      end
+
+      def things_that_were_set
+        @set
+      end
+
+      def rails_env
+        @set ||= {}
+        @set[:rails_env]
+      end
+
+    end
+    session_klass.set_channel = {:host => server}
+    session_klass.set_roles = roles
+    session_klass.set_environment_settings = cap_variable["environment_settings"]
+    parallel_mocks.each do |mock|
+      mock.call(session_klass)
+    end
+    @parallel_sessions ||= []
+    @parallel_sessions << session_klass
+    session_klass.instance_eval do
+      yield session_klass
+    end
+  end
+  @parallel_sessions
+end