aws-codedeploy-agent 0.0.1

data/test/instance_agent/codedeploy_plugin/install_instruction_test.rb

@@ -0,0 +1,566 @@
+require 'test_helper'
+require 'json'
+require 'fileutils'
+
+module InstanceAgent
+  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::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::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::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::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::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/", {
+                                                                                                           :type => ["directory"],
+                                                                                                           :pattern => "tar*",
+                                                                                                           :except => []})
+            assert @command_builder.find_matches(permission).include?("/tmp/directory/target")
+
+            permission = InstanceAgent::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/", {
+                                                                                                           :type => ["file"],
+                                                                                                           :pattern => "tar*",
+                                                                                                           :except => []})
+            assert !@command_builder.find_matches(permission).include?("/tmp/directory/target")
+
+            permission = InstanceAgent::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("/tmp/directory/", {
+                                                                                                           :type => ["directory"],
+                                                                                                           :pattern => "tarr*",
+                                                                                                           :except => []})
+            assert !@command_builder.find_matches(permission).include?("/tmp/directory/target")
+
+            permission = InstanceAgent::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::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::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::CodeDeployPlugin::ApplicationSpecification::LinuxPermissionInfo.new("testfile.txt", {
+                                                                   :mode=>InstanceAgent::CodeDeployPlugin::ApplicationSpecification::ModeInfo.new(744),
+                                                                   :acls=>InstanceAgent::CodeDeployPlugin::ApplicationSpecification::AclInfo.new(["u:bob:7","d:g:dev:4"]),
+                                                                   :context=>InstanceAgent::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::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::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