aws-codedeploy-agent 0.0.2 → 0.0.3

data/test/instance_agent/{codedeploy_plugin → plugins/codedeploy}/hook_executor_test.rb

@@ -1,15 +1,17 @@
 require 'test_helper'
 require 'stringio'
 require 'fileutils'
-require 'instance_agent/codedeploy_plugin/installer'
 require 'com/amazon/codedeploy/command/v20141006/host_command_instance'
 
 class HookExecutorTest < InstanceAgentTestCase
 
-  include InstanceAgent::CodeDeployPlugin
+  include InstanceAgent::Plugins::CodeDeployPlugin
 
   def create_full_hook_executor
     HookExecutor.new ({:lifecycle_event => @lifecycle_event,
+                        :application_name => @application_name,
+                        :deployment_id => @deployment_id,
+                        :deployment_group_name => @deployment_group_name,
                         :deployment_root_dir => @deployment_root_dir,
                         :last_successful_deployment_dir => @last_successful_deployment_dir,
                         :app_spec_path => @app_spec_path})
@@ -17,6 +19,9 @@ class HookExecutorTest < InstanceAgentTestCase
 
   context "testing hook executor" do
     setup do
+      @deployment_id='12345'
+      @application_name='TestApplication'
+      @deployment_group_name='TestDeploymentGroup'
       @deployment_root_dir = "deployment/root/dir"
       @last_successful_deployment_dir = "last/deployment/root/dir"
       @app_spec_path = "app_spec"
@@ -33,6 +38,9 @@ class HookExecutorTest < InstanceAgentTestCase
 
         should "do nothing" do
           @hook_executor = HookExecutor.new ({:lifecycle_event => @lifecycle_event,
+                                              :application_name => @application_name,
+                                              :deployment_id => @deployment_id,
+                                              :deployment_group_name => @deployment_group_name,
                                               :deployment_root_dir => @deployment_root_dir,
                                               :app_spec_path => @app_spec_path})
         end
@@ -47,7 +55,10 @@ class HookExecutorTest < InstanceAgentTestCase
         should "raise an error" do
           assert_raise do
             @hook_executor = HookExecutor.new ({:lifecycle_event => @lifecycle_event,
-                                               :deployment_root_dir => @deployment_root_dir})
+                                                :application_name => @application_name,
+                                                :deployment_group_name => @deployment_gtroup_name,
+                                                :deployment_id => @deployment_id,
+                                                :deployment_root_dir => @deployment_root_dir})
           end
         end
       end
@@ -80,6 +91,10 @@ class HookExecutorTest < InstanceAgentTestCase
       setup do
         @lifecycle_event = "ValidateService"
         File.stubs(:read).with(File.join(@deployment_root_dir, 'deployment-archive', @app_spec_path))
+        @child_env={'LIFECYCLE_EVENT' => @lifecycle_event.to_s,
+                    'DEPLOYMENT_ID'   => @deployment_id.to_s,
+                    'APPLICATION_NAME' => @application_name.to_s,
+                    'DEPLOYMENT_GROUP_NAME' => @deployment_group_name.to_s}
       end
 
       context "no scripts to run for a given hook" do
@@ -122,7 +137,7 @@ class HookExecutorTest < InstanceAgentTestCase
           context "and isn't executable" do
             setup do
               File.stubs(:executable?).with(@script_location).returns(false)
-              InstanceAgent::Log.expects(:send).with(:warn, 'InstanceAgent::CodeDeployPlugin::HookExecutor: Script at specified location: test is not executable.  Trying to make it executable.')
+              InstanceAgent::Log.expects(:send).with(:warn, 'InstanceAgent::Plugins::CodeDeployPlugin::HookExecutor: Script at specified location: test is not executable.  Trying to make it executable.')
             end
 
             should "log and make the hook script executable" do
@@ -165,26 +180,46 @@ class HookExecutorTest < InstanceAgentTestCase
                 YAML.stubs(:load).returns(@app_spec)
                 @hook_executor = create_full_hook_executor
                 @wait_thr.stubs(:join).with(30).returns(nil)
-                @wait_thr.stubs(:pid)
+                @wait_thr.stubs(:pid).returns(1234)
                 mock_pipe = mock
-                Open3.stubs(:popen3).with(@script_location, :pgroup=>true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
-                Process.stubs(:kill)
               end
 
-              should "raise and exception" do
-                assert_raised_with_message('Script at specified location: test failed to complete in 30 seconds', ScriptError) do
-                  @hook_executor.execute
+              context "with process group support" do
+                setup do
+                  Open3.stubs(:popen3).with(@child_env, @script_location, :pgroup => true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                  InstanceAgent::LinuxUtil.stubs(:supports_process_groups?).returns(true)
+                end
+
+                should "raise an exception" do
+                  Process.expects(:kill).with('-TERM', 1234)
+                  assert_raised_with_message('Script at specified location: test failed to complete in 30 seconds', ScriptError) do
+                    @hook_executor.execute
+                  end
                 end
               end
-            end
 
+              context "without process group support" do
+                setup do
+                  Open3.stubs(:popen3).with(@child_env, @script_location, {}).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                  InstanceAgent::LinuxUtil.stubs(:supports_process_groups?).returns(false)
+                end
+
+                should "raise an exception" do
+                  Process.expects(:kill).with('KILL', 1234)
+                  assert_raised_with_message('Script at specified location: test failed to complete in 30 seconds', ScriptError) do
+                    @hook_executor.execute
+                  end
+                end
+              end
+            end
+            
             context "Scripts run with a runas" do
               setup do
                 @app_spec =  { "version" => 0.0, "os" => "linux", "hooks" => {'ValidateService'=> [{"location"=>"test", "runas"=>"user"}]}}
                 YAML.stubs(:load).returns(@app_spec)
                 @hook_executor = create_full_hook_executor
                 mock_pipe = mock
-                Open3.stubs(:popen3).with('su user -c ' + @script_location, :pgroup=>true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                Open3.stubs(:popen3).with(@child_env, 'su user -c ' + @script_location, :pgroup => true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
               end
 
               context "scripts fail" do
@@ -205,7 +240,7 @@ class HookExecutorTest < InstanceAgentTestCase
                 end
 
                 should "execute script with runas" do
-                  Open3.expects(:popen3).with('su user -c ' + @script_location, :pgroup=>true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                  Open3.expects(:popen3).with(@child_env, 'su user -c ' + @script_location, :pgroup => true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
                   @hook_executor.execute
                 end
               end
@@ -216,7 +251,40 @@ class HookExecutorTest < InstanceAgentTestCase
                 @app_spec =  { "version" => 0.0, "os" => "linux", "hooks" => {'ValidateService'=> [{"location"=>"test"}]}}
                 YAML.stubs(:load).returns(@app_spec)
                 @hook_executor = create_full_hook_executor
-                Open3.stubs(:popen3).with(@script_location, :pgroup=>true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                Open3.stubs(:popen3).with(@child_env, @script_location, :pgroup => true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+              end
+
+              context "Scripts fail" do
+                setup do
+                  @value.stubs(:exitstatus).returns(1)
+                end
+
+                should "raise an exception" do
+                  assert_raised_with_message('Script at specified location: test failed with exit code 1', ScriptError) do
+                    @hook_executor.execute
+                  end
+                end
+              end
+
+              context "Scripts pass" do
+                setup do
+                  @value.stubs(:exitstatus).returns(0)
+                end
+
+                should "execute script" do
+                  Open3.expects(:popen3).with(@child_env, @script_location, :pgroup => true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                  @hook_executor.execute
+                end
+              end
+            end
+            
+            context "Scripts run without process group support" do
+              setup do
+                @app_spec =  { "version" => 0.0, "os" => "linux", "hooks" => {'ValidateService'=> [{"location"=>"test"}]}}
+                YAML.stubs(:load).returns(@app_spec)
+                @hook_executor = create_full_hook_executor
+                Open3.stubs(:popen3).with(@child_env, @script_location, {}).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                InstanceAgent::LinuxUtil.stubs(:supports_process_groups?).returns(false)
               end
 
               context "Scripts fail" do
@@ -237,7 +305,7 @@ class HookExecutorTest < InstanceAgentTestCase
                 end
 
                 should "execute script" do
-                  Open3.expects(:popen3).with(@script_location, :pgroup=>true).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
+                  Open3.expects(:popen3).with(@child_env, @script_location, {}).yields([@mock_pipe,@mock_pipe,@mock_pipe,@wait_thr])
                   @hook_executor.execute
                 end
               end

data/test/instance_agent/plugins/codedeploy/install_instruction_test.rb

@@ -0,0 +1,568 @@
+require 'test_helper'
+require 'json'
+require 'fileutils'
+
+module InstanceAgent
+  module Plugins
+    module CodeDeployPlugin
+      class InstallInstructionTest < InstanceAgentTestCase
+        context "parsing an install file" do
+          context "a single mapped file" do
+            setup do
+              install_instructions = { "revisionId" => "foo" , 'instructions' => [{"type" => :copy, "source" => "test_source", "destination" => "test_destination"}]}
+              @parse_string = JSON.dump(install_instructions)
+              @mock_file = mock
+              @mock_file.stubs(:puts)
+              @mock_file.stubs(:size).returns(0)
+              @mock_file.stubs(:close)
+              File.stubs(:open).returns(@mock_file)
+            end
+
+            should "return a collection containing a single CopyCommand which copies from test_source to test_destination" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              FileUtils.expects(:copy).with("test_source","test_destination", :preserve => true)
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute(@mock_file)
+              end
+            end
+          end
+
+          context "multiple mapped files" do
+            setup do
+              install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "copy", "source" => "test_source", "destination" => "test_destination"}, {"type" => "copy", "source" => "source_2", "destination"=>"destination_2"}]}
+              @parse_string = JSON.dump(install_instructions)
+              @mock_file = mock
+              @mock_file.stubs(:puts)
+              @mock_file.stubs(:size).returns(0)
+              @mock_file.stubs(:close)
+              File.stubs(:open).returns(@mock_file)
+            end
+
+            should "return a collection containing multiple copy commands" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              FileUtils.expects(:copy).with("test_source","test_destination", :preserve => true)
+              FileUtils.expects(:copy).with("source_2","destination_2", :preserve => true)
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute(@mock_file)
+              end
+            end
+          end
+
+          context "contains a mkdir command" do
+            setup do
+              install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "copy", "source" => "test_source", "destination" => "test_destination"}, {"type" => "mkdir", "directory"=>"directory"}]}
+              @parse_string = JSON.dump(install_instructions)
+              @mock_file = mock
+              @mock_file.stubs(:puts)
+              @mock_file.stubs(:size).returns(0)
+              @mock_file.stubs(:close)
+              @mock_file.stubs(:exist?).returns(false)
+              File.stubs(:open).returns(@mock_file)
+              File.stubs(:exists?).returns(false)
+            end
+
+            should "return a collection containing a copy command and a mkdir command" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              FileUtils.expects(:copy).with("test_source","test_destination", :preserve => true)
+              FileUtils.expects(:mkdir).with("directory")
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute(@mock_file)
+              end
+            end
+
+            should "raise an error if a file exists at the mkdir location" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              File.stubs(:exists?).with("directory").returns(true)
+              FileUtils.stubs(:copy)
+
+              assert_raised_with_message("File already exists at directory") do
+                commands.each do |command|
+                  command.execute(@mock_file)
+                end
+              end
+            end
+          end
+
+          context "correctly determines method from file type" do
+            setup do
+              install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "copy", "source" => "test_source", "destination" => "test_destination"}, {"type" => "copy", "source" => "source_2", "destination"=>"destination_2"}]}
+              @parse_string = JSON.dump(install_instructions)
+              @instruction_file = mock
+              @instruction_file.stubs(:read).returns(@parse_string)
+              @instruction_file.stubs(:path).returns("test/123-install.json")
+              @instruction_file.stubs(:close)
+              File.stubs(:open).with("test/123-install.json", 'r').returns(@instruction_file)
+            end
+
+            should "call parse_install_commands" do
+              InstallInstruction.expects(:parse_install_commands).with(@parse_string)
+              commands = InstallInstruction.generate_commands_from_file(@instruction_file)
+            end
+          end
+
+          context "contains a chmod command" do
+            setup do
+              install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "chmod", "mode" => "0740", "file" => "testfile.txt"}]}
+              @parse_string = JSON.dump(install_instructions)
+              @mock_file = mock
+              File.stubs(:chmod)
+            end
+
+            should "set the mode of the object" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              File.expects(:chmod).with("740".to_i(8), "testfile.txt")
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute(@mock_file)
+              end
+            end
+          end
+
+          context "contains a chown command" do
+            setup do
+              install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "chown", "owner" => "bob", "group" => "dev", "file" => "testfile.txt"}]}
+              @parse_string = JSON.dump(install_instructions)
+              @mock_etc = mock
+              @mock_etc.stubs(:gid).returns(222)
+              @mock_etc.stubs(:uid).returns(111)
+              @mock_file = mock
+              Etc.stubs(:getpwnam).with("bob").returns(@mock_etc)
+              Etc.stubs(:getgrnam).with("dev").returns(@mock_etc)
+              File.stubs(:chchown)
+            end
+
+            should "set the owner of the object" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              File.expects(:chown).with(111, 222, "testfile.txt")
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute(@mock_file)
+              end
+            end
+          end
+
+          context "contains a setfacl command" do
+            setup do
+              install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "setfacl", "acl" => ["user:bob:rwx","default:user:bob:rwx"], "file" => "testfile.txt"}]}
+              @parse_string = JSON.dump(install_instructions)
+              @mock_file = mock
+              @mock_stat = mock
+              @mock_stat.stubs(:mode).returns("100421".to_i(8))
+              ChangeAclCommand.any_instance.stubs(:system).returns(false)
+              @full_acl = "user:bob:rwx,default:user:bob:rwx,user::r--,group::-w-,other::--x,mask::-w-,default:user::r--,default:group::-w-,default:other::--x,default:mask::-w-"
+              File.stubs(:stat).returns(@mock_stat)
+            end
+
+            should "set the acl of the object" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              ChangeAclCommand.any_instance.expects(:system).with("setfacl --set #{@full_acl} testfile.txt").returns(true)
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute(@mock_file)
+              end
+            end
+
+            should "throw if system call fails" do
+              commands = InstallInstruction.parse_install_commands(@parse_string)
+              ChangeAclCommand.any_instance.expects(:system).with("setfacl --set #{@full_acl} testfile.txt").returns(false)
+              assert_not_equal nil, commands
+              assert_raise(RuntimeError) do
+                commands.each do |command|
+                  command.execute(@mock_file)
+                end
+              end
+            end
+          end
+
+          context "contains a semanage command" do
+
+            context "with a role" do
+              setup do
+                install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "semanage", "context" => {"name" => "name", "role" => "role", "type" => "type", "range" => "s0" }, "file" => "testfile.txt"}]}
+                @parse_string = JSON.dump(install_instructions)
+                ChangeContextCommand.any_instance.stubs(:system).returns(true)
+                @mock_file = mock
+              end
+
+              should "raise an exception" do
+                assert_raise(RuntimeError) do
+                  commands = InstallInstruction.parse_install_commands(@parse_string)
+                end
+              end
+            end
+
+            context "which is valid" do
+              setup do
+                install_instructions = { "revisionId" => "foo" , "instructions" => [{"type" => "semanage", "context" => {"name" => "name", "role" => nil, "type" => "type", "range" => "s0" }, "file" => "testfile.txt"}]}
+                @parse_string = JSON.dump(install_instructions)
+                @mock_file = mock
+                ChangeContextCommand.any_instance.stubs(:system).returns(false)
+                File.stubs(:realpath).returns("testfile.txt")
+              end
+
+              should "set the context of the object" do
+                commands = InstallInstruction.parse_install_commands(@parse_string)
+                ChangeContextCommand.any_instance.expects(:system).with("semanage fcontext -a -s name -t type -r s0 testfile.txt").returns(true)
+                ChangeContextCommand.any_instance.expects(:system).with("restorecon -v testfile.txt").returns(true)
+                @mock_file.expects(:puts).with("semanage\0testfile.txt")
+                assert_not_equal nil, commands
+                commands.each do |command|
+                  command.execute(@mock_file)
+                end
+              end
+
+              should "throw if semanage system call fails" do
+                commands = InstallInstruction.parse_install_commands(@parse_string)
+                ChangeContextCommand.any_instance.expects(:system).with("semanage fcontext -a -s name -t type -r s0 testfile.txt").returns(false)
+                assert_not_equal nil, commands
+                assert_raise(RuntimeError) do
+                  commands.each do |command|
+                    command.execute(@mock_file)
+                  end
+                end
+              end
+
+              should "throw if system call fails" do
+                commands = InstallInstruction.parse_install_commands(@parse_string)
+                ChangeContextCommand.any_instance.expects(:system).with("semanage fcontext -a -s name -t type -r s0 testfile.txt").returns(true)
+                ChangeContextCommand.any_instance.expects(:system).with("restorecon -v testfile.txt").returns(false)
+                assert_not_equal nil, commands
+                assert_raise(RuntimeError) do
+                  commands.each do |command|
+                    command.execute(@mock_file)
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        context "Parsing a delete file" do
+          context "an empty delete file" do
+            setup do
+              @parse_string = <<-END
+            END
+          end
+
+          should "return an empty command collection" do
+            commands = InstallInstruction.parse_remove_commands(@parse_string)
+            assert_equal 0, commands.length
+          end
+        end
+
+        context "a single file to delete" do
+          setup do
+            @parse_string = <<-END
+            test_delete_path
+              END
+              File.stubs(:exist?).with("test_delete_path").returns(true)
+            end
+
+            should "produce a command that deletes test_delete_path" do
+              commands = InstallInstruction.parse_remove_commands(@parse_string)
+              FileUtils.expects(:rm).with("test_delete_path")
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute
+              end
+            end
+          end
+
+          context "multiple files to delete" do
+            setup do
+              @parse_string = <<-END
+            test_delete_path
+            another_delete_path
+              END
+              File.stubs(:directory?).returns(false)
+              File.stubs(:exist?).with("test_delete_path").returns(true)
+              File.stubs(:exist?).with("another_delete_path").returns(true)
+            end
+
+            should "produce a command that deletes test_delete_path" do
+              commands = InstallInstruction.parse_remove_commands(@parse_string)
+              FileUtils.expects(:rm).with("test_delete_path")
+              FileUtils.expects(:rm).with("another_delete_path")
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute
+              end
+            end
+
+            should "use rmdir for directories" do
+              File.stubs(:directory?).with("test_delete_path").returns(true)
+
+              commands = InstallInstruction.parse_remove_commands(@parse_string)
+              FileUtils.expects(:rmdir).with("test_delete_path")
+              FileUtils.expects(:rm).with("another_delete_path")
+
+              commands.each do |command|
+                command.execute
+              end
+            end
+          end
+
+          context "removes mangled line at the end" do
+            setup do
+              @parse_string = <<-END
+            test_delete_path
+            another_delete_path
+              END
+              @parse_string << "mangled"
+              File.stubs(:exist?).with("test_delete_path").returns(true)
+              File.stubs(:exist?).with("another_delete_path").returns(true)
+            end
+
+            should "produce a command that deletes test_delete_path" do
+              commands = InstallInstruction.parse_remove_commands(@parse_string)
+              FileUtils.expects(:rm).with("test_delete_path")
+              FileUtils.expects(:rm).with("another_delete_path")
+              FileUtils.expects(:rm).with("mangled").never
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute
+              end
+            end
+          end
+
+          context "correctly determines method from file type" do
+            setup do
+              @parse_string = 'foo'
+              @instruction_file = mock
+              @instruction_file.stubs(:path).returns("test/123-cleanup")
+              File.stubs(:open).with("test/123-cleanup", 'r').returns(@instruction_file)
+              @instruction_file.stubs(:read).returns(@parse_string)
+              @instruction_file.stubs(:close)
+            end
+
+            should "call parse_remove_commands" do
+              InstallInstruction.expects(:parse_remove_commands).with(@parse_string)
+              commands = InstallInstruction.generate_commands_from_file(@instruction_file)
+            end
+          end
+
+          context "with a semanage command" do
+            setup do
+              @parse_string = "semanage\0testfile.txt\n"
+              RemoveContextCommand.any_instance.stubs(:system)
+            end
+
+            should "remove the context of the object" do
+              commands = InstallInstruction.parse_remove_commands(@parse_string)
+              RemoveContextCommand.any_instance.expects(:system).with("semanage fcontext -d testfile.txt")
+              assert_not_equal nil, commands
+              commands.each do |command|
+                command.execute
+              end
+            end
+          end
+        end
+
+        context "Testing the command builder" do
+          setup do
+            @command_builder = CommandBuilder.new()
+            Dir.chdir "/tmp"
+          end
+
+          should "Have an empty command array" do
+            assert_equal @command_builder.command_array, []
+          end
+
+          context "with a single copy command" do
+            setup do
+              @command_builder = CommandBuilder.new()
+              @command_builder.copy("source", "destination")
+              @expected_json = {"instructions"=>[{"type"=>"copy","source"=>"source","destination"=>"/tmp/destination"}]}.to_json
+            end
+
+            should "have a single copy in the returned JSON" do
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+
+            should "raise a duplicate exception when a copy collides with another copy" do
+              assert_raised_with_message("Duplicate copy instruction to /tmp/destination from source and source") do
+                @command_builder.copy("source", "destination")
+              end
+            end
+          end
+
+          context "with a single mkdir command" do
+            setup do
+              @command_builder = CommandBuilder.new()
+              @command_builder.mkdir("directory")
+              @expected_json = {"instructions"=>[{"type"=>"mkdir","directory"=>"/tmp/directory"}]}.to_json
+            end
+
+            should "have a single mkdir in the returned JSON" do
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+
+            should "raise a duplicate exception when trying to create a directory collides with a copy" do
+              @command_builder.copy("source", "directory/dir1")
+              assert_raised_with_message("Duplicate mkdir instruction for /tmp/directory/dir1 which is already being copied from source") do
+                @command_builder.mkdir("directory/dir1")
+              end
+            end
+          end
+
+          context "with one of each command (copy and mkdir)" do
+            setup do
+              @command_builder = CommandBuilder.new()
+              @command_builder.mkdir("directory/target")
+              @command_builder.copy( "file_target", "directory/target/file_target")
+            end
+
+            should "raise a duplicate exception when trying to make a copy collides with a mkdir" do
+              assert_raised_with_message("Duplicate copy instruction to /tmp/directory/target from target which is already being installed as a directory") do
+                @command_builder.copy( "target", "directory/target")
+              end
+            end
+
+            should "say it is copying the appropriate file" do
+              assert @command_builder.copying_file?("/tmp/directory/target/file_target")
+              assert !@command_builder.copying_file?("/tmp/directory/target")
+            end
+
+            should "say it is making the appropriate directory" do
+              assert !@command_builder.making_directory?("/tmp/directory/target/file_target")
+              assert @command_builder.making_directory?("/tmp/directory/target")
+            end
+
+            should "match the file when appropriate" do
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/target", {
+                :type => ["file"],
+                :pattern => "file*",
+                :except => []})
+              assert @command_builder.find_matches(permission).include?("/tmp/directory/target/file_target")
+
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/target", {
+                :type => ["directory"],
+                :pattern => "file*",
+                :except => []})
+              assert !@command_builder.find_matches(permission).include?("/tmp/directory/target/file_target")
+
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/target", {
+                :type => ["file"],
+                :pattern => "filefile*",
+                :except => []})
+              assert !@command_builder.find_matches(permission).include?("/tmp/directory/target/file_target")
+
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/target", {
+                :type => ["file"],
+                :pattern => "file*",
+                :except => ["*target"]})
+              assert !@command_builder.find_matches(permission).include?("/tmp/directory/target/file_target")
+            end
+
+            should "match the directory when appropriate" do
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/", {
+                :type => ["directory"],
+                :pattern => "tar*",
+                :except => []})
+              assert @command_builder.find_matches(permission).include?("/tmp/directory/target")
+
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/", {
+                :type => ["file"],
+                :pattern => "tar*",
+                :except => []})
+              assert !@command_builder.find_matches(permission).include?("/tmp/directory/target")
+
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/", {
+                :type => ["directory"],
+                :pattern => "tarr*",
+                :except => []})
+              assert !@command_builder.find_matches(permission).include?("/tmp/directory/target")
+
+              permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/", {
+                :type => ["directory"],
+                :pattern => "tar*",
+                :except => ["*et"]})
+              assert !@command_builder.find_matches(permission).include?("/tmp/directory/target")
+            end
+          end
+
+          context "two mkdirs to the same place" do
+            setup do
+              @command_builder = CommandBuilder.new()
+              @command_builder.mkdir("directory")
+              @command_builder.mkdir("directory")
+              @expected_json = {"instructions"=>[{"type"=>"mkdir","directory"=>"/tmp/directory"}]}.to_json
+            end
+
+            should "have a single mkdir in the returned JSON" do
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+          end
+
+          context "two mkdirs to the same place one has a trailing /" do
+            setup do
+              @command_builder = CommandBuilder.new()
+              @command_builder.mkdir("directory")
+              @command_builder.mkdir("directory/")
+              @expected_json = {"instructions"=>[{"type"=>"mkdir","directory"=>"/tmp/directory"}]}.to_json
+            end
+
+            should "have a single mkdir in the returned JSON" do
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+          end
+
+          context "setting permissions" do
+            should "raise a duplicate exception when trying to set permissions twice" do
+              @permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("testfile.txt")
+              @command_builder = CommandBuilder.new()
+              @command_builder.set_permissions("testfile.txt", @permission)
+              assert_raised_with_message("Duplicate permission setting instructions for /tmp/testfile.txt") do
+                @command_builder.set_permissions("testfile.txt", @permission)
+              end
+            end
+
+            should "not add any commands for empty permissions" do
+              @permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("testfile.txt")
+              @command_builder = CommandBuilder.new()
+              @command_builder.set_permissions("testfile.txt", @permission)
+              @expected_json = {"instructions"=>[]}.to_json
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+
+            should "add commands for each part of permisssions" do
+              @permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("testfile.txt", {
+                :mode=>InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::ModeInfo.new(744),
+                :acls=>InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::AclInfo.new(["u:bob:7","d:g:dev:4"]),
+                :context=>InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::ContextInfo.new({"name"=>"name","type"=>"type","range"=>"s2-s3:c0,c2.c4,c6"}),
+                :owner=>"bob",
+                :group=>"dev"})
+              @command_builder = CommandBuilder.new()
+              @command_builder.set_permissions("testfile.txt", @permission)
+              @expected_json = {"instructions"=>[{"type"=>"chmod","mode"=>"744","file"=>"/tmp/testfile.txt"},
+                {"type"=>"setfacl","acl"=>["user:bob:rwx","default:group:dev:r--"],"file"=>"/tmp/testfile.txt"},
+                {"type"=>"semanage","context"=>{"user"=>"name","role"=>nil,"type"=>"type","range"=>"s2-s3:c0,c2.c4,c6"},"file"=>"/tmp/testfile.txt"},
+                {"type"=>"chown","owner"=>"bob","group"=>"dev","file"=>"/tmp/testfile.txt"}
+                ]}.to_json
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+
+            should "add chown command with just owner" do
+              @permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("testfile.txt", {:owner=>"bob"})
+              @command_builder = CommandBuilder.new()
+              @command_builder.set_permissions("testfile.txt", @permission)
+              @expected_json = {"instructions"=>[{"type"=>"chown","owner"=>"bob","group"=>nil,"file"=>"/tmp/testfile.txt"}]}.to_json
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+
+            should "add chown command with just group" do
+              @permission = InstanceAgent::Plugins::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("testfile.txt", {:group=>"dev"})
+              @command_builder = CommandBuilder.new()
+              @command_builder.set_permissions("testfile.txt", @permission)
+              @expected_json = {"instructions"=>[{"type"=>"chown","owner"=>nil,"group"=>"dev","file"=>"/tmp/testfile.txt"}]}.to_json
+              assert_equal JSON.parse(@expected_json), JSON.parse(@command_builder.to_json)
+            end
+          end
+        end
+      end
+    end
+  end
+end