pups 1.0.3 → 1.1.0

data/test/docker_test.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+require 'test_helper'
+require 'tempfile'
+require 'shellwords'
+
+module Pups
+  class DockerTest < MiniTest::Test
+    def test_gen_env_arguments
+      yaml = <<~YAML
+      env:
+        foo: 1
+        bar: 2
+        baz: 'hello_{{spam}}'
+      env_template:
+        spam: 'eggs'
+      YAML
+
+      config = Config.load_config(yaml)
+      Config.transform_config_with_templated_vars(config.config['env_template'], config.config["env"])
+      args = Docker.generate_env_arguments(config.config["env"])
+      assert_equal("--env foo=1 --env bar=2 --env baz=hello_eggs", args)
+    end
+
+    def test_gen_env_arguments_empty
+      yaml = <<~YAML
+      env:
+        foo: 1
+        bar: 2
+        baz: ''
+      YAML
+
+      config = Config.load_config(yaml)
+      Config.transform_config_with_templated_vars(config.config['env_template'], config.config["env"])
+      args = Docker.generate_env_arguments(config.config["env"])
+      assert_equal("--env foo=1 --env bar=2", args)
+    end
+
+    def test_gen_env_arguments_escaped
+      yaml = <<~YAML
+      env:
+        password: "{{spam}}*`echo`@e$t| = >>$()&list;#"
+      env_template:
+        spam: 'eggs'
+      YAML
+
+      config = Config.load_config(yaml)
+      Config.transform_config_with_templated_vars(config.config['env_template'], config.config["env"])
+      args = Docker.generate_env_arguments(config.config["env"])
+      assert_equal("--env password=\"#{Shellwords.escape('eggs*`echo`@e$t| = >>$()&list;#')}\"", args)
+    end
+
+    def test_gen_env_arguments_quoted_with_a_space
+      yaml = <<~YAML
+      env:
+        a_variable: here is a sentence
+      YAML
+
+      config = Config.load_config(yaml)
+      Config.transform_config_with_templated_vars(config.config['env_template'], config.config["env"])
+      args = Docker.generate_env_arguments(config.config["env"])
+      assert_equal('--env a_variable="here\ is\ a\ sentence"', args)
+    end
+
+    def test_gen_env_arguments_newline
+      pw = <<~PW
+this password is
+  a weird one
+      PW
+
+      yaml = <<~YAML
+      env:
+        password: "#{pw}"
+      env_template:
+        spam: 'eggs'
+      YAML
+
+      config = Config.load_config(yaml)
+      Config.transform_config_with_templated_vars(config.config['env_template'], config.config["env"])
+      args = Docker.generate_env_arguments(config.config["env"])
+      assert_equal('--env password="this\ password\ is\ a\ weird\ one\ "', args)
+    end
+
+    def test_gen_expose_arguments
+      yaml = <<~YAML
+      expose:
+        - "2222:22"
+        - "127.0.0.1:20080:80"
+        - 5555
+      YAML
+
+      config = Config.load_config(yaml)
+      args = Docker.generate_expose_arguments(config.config["expose"])
+      assert_equal("--publish 2222:22 --publish 127.0.0.1:20080:80 --expose 5555", args)
+    end
+
+    def test_gen_volume_arguments
+      yaml = <<~YAML
+      volumes:
+        - volume:
+            host: /var/discourse/shared
+            guest: /shared
+        - volume:
+            host: /bar
+            guest: /baz
+      YAML
+
+      config = Config.load_config(yaml)
+      args = Docker.generate_volume_arguments(config.config["volumes"])
+      assert_equal("--volume /var/discourse/shared:/shared --volume /bar:/baz", args)
+    end
+
+    def test_gen_link_arguments
+      yaml = <<~YAML
+      links:
+        - link:
+            name: postgres
+            alias: postgres
+        - link:
+            name: foo
+            alias: bar
+      YAML
+
+      config = Config.load_config(yaml)
+      args = Docker.generate_link_arguments(config.config["links"])
+      assert_equal("--link postgres:postgres --link foo:bar", args)
+    end
+
+    def test_gen_label_arguments
+      yaml = <<~YAML
+      env_template:
+        config: my_app
+      labels:
+        monitor: "true"
+        app_name: "{{config}}_discourse"
+      YAML
+
+      config = Config.load_config(yaml)
+      Config.transform_config_with_templated_vars(config.config['env_template'], config.config["labels"])
+      args = Docker.generate_label_arguments(config.config["labels"])
+      assert_equal("--label monitor=true --label app_name=my_app_discourse", args)
+    end
+
+    def test_gen_label_arguments_escaped
+      yaml = <<~YAML
+      labels:
+        app_name: "{{config}}'s_di$course"
+      env_template:
+        config: my_app
+      YAML
+
+      config = Config.load_config(yaml)
+      Config.transform_config_with_templated_vars(config.config['env_template'], config.config["labels"])
+      args = Docker.generate_label_arguments(config.config["labels"])
+      assert_equal("--label app_name=#{Shellwords.escape("my_app's_di$course")}", args)
+    end
+  end
+end

data/test/exec_command_test.rb

@@ -1,113 +1,109 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'tempfile'
 
 module Pups
   class ExecCommandTest < MiniTest::Test
-
-    def from_str(str, params={})
+    def from_str(str, params = {})
       ExecCommand.from_str(str, params).commands
     end
 
-    def from_hash(hash, params={})
+    def from_hash(hash, params = {})
       ExecCommand.from_hash(hash, params).commands
     end
 
     def test_simple_str_command
-      assert_equal(["do_something"],
-           from_str("do_something"))
+      assert_equal(['do_something'],
+                   from_str('do_something'))
     end
 
     def test_simple_str_command_with_param
-      assert_equal(["hello world"],
-           from_str("hello $bob", {"bob" => "world"}))
+      assert_equal(['hello world'],
+                   from_str('hello $bob', { 'bob' => 'world' }))
     end
 
     def test_nested_command
-      assert_equal(["first"],
-         from_hash("cmd" => "first"))
+      assert_equal(['first'],
+                   from_hash('cmd' => 'first'))
     end
 
     def test_multi_commands
-      assert_equal(["first","second"],
-          from_hash("cmd" => ["first","second"]))
+      assert_equal(%w[first second],
+                   from_hash('cmd' => %w[first second]))
     end
 
     def test_multi_commands_with_home
-      assert_equal(["cd /home/sam && first",
-                    "cd /home/sam && second"],
-          from_hash("cmd" => ["first","second"],
-                    "cd" => "/home/sam"))
+      assert_equal(['cd /home/sam && first',
+                    'cd /home/sam && second'],
+                   from_hash('cmd' => %w[first second],
+                             'cd' => '/home/sam'))
     end
 
     def test_exec_works
-      ExecCommand.from_str("ls",{}).run
+      ExecCommand.from_str('ls', {}).run
     end
 
     def test_fails_for_bad_command
       assert_raises(Errno::ENOENT) do
-        ExecCommand.from_str("boom",{}).run
+        ExecCommand.from_str('boom', {}).run
       end
     end
 
     def test_backgroud_task_do_not_fail
       cmd = ExecCommand.new({})
       cmd.background = true
-      cmd.add("sleep 10 && exit 1")
+      cmd.add('sleep 10 && exit 1')
       cmd.run
     end
 
     def test_raise_on_fail
       cmd = ExecCommand.new({})
-      cmd.add("chgrp -a")
+      cmd.add('chgrp -a')
       cmd.raise_on_fail = false
       cmd.run
     end
 
     def test_stdin
-
       `touch test_file`
       cmd = ExecCommand.new({})
-      cmd.add("read test ; echo $test > test_file")
-      cmd.stdin = "hello"
+      cmd.add('read test ; echo $test > test_file')
+      cmd.stdin = 'hello'
       cmd.run
 
-      assert_equal("hello\n", File.read("test_file"))
-
+      assert_equal("hello\n", File.read('test_file'))
     ensure
-      File.delete("test_file")
+      File.delete('test_file')
     end
 
     def test_fails_for_non_zero_exit
       assert_raises(Pups::ExecError) do
-        ExecCommand.from_str("chgrp -a",{}).run
+        ExecCommand.from_str('chgrp -a', {}).run
       end
     end
 
-
     def test_can_terminate_async
       cmd = ExecCommand.new({})
       cmd.background = true
-      pid = cmd.spawn("sleep 10 && exit 1")
+      pid = cmd.spawn('sleep 10 && exit 1')
       ExecCommand.terminate_async
       assert_raises(Errno::ECHILD) do
-        Process.waitpid(pid,Process::WNOHANG)
+        Process.waitpid(pid, Process::WNOHANG)
       end
     end
 
     def test_can_terminate_rogues
       cmd = ExecCommand.new({})
       cmd.background = true
-      pid = cmd.spawn("trap \"echo TERM && sleep 100\" TERM ; sleep 100")
+      pid = cmd.spawn('trap "echo TERM && sleep 100" TERM ; sleep 100')
       # we need to give bash enough time to trap
       sleep 0.01
 
       ExecCommand.terminate_async(wait: 0.1)
 
       assert_raises(Errno::ECHILD) do
-        Process.waitpid(pid,Process::WNOHANG)
+        Process.waitpid(pid, Process::WNOHANG)
       end
-
     end
-
   end
 end

data/test/file_command_test.rb

@@ -1,27 +1,26 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'tempfile'
 
 module Pups
   class FileCommandTest < MiniTest::Test
-
     def test_simple_file_creation
-      tmp = Tempfile.new("test")
-      tmp.write("x")
+      tmp = Tempfile.new('test')
+      tmp.write('x')
       tmp.close
 
-
       cmd = FileCommand.new
       cmd.path = tmp.path
-      cmd.contents = "hello $world"
-      cmd.params = {"world" => "world"}
+      cmd.contents = 'hello $world'
+      cmd.params = { 'world' => 'world' }
       cmd.run
 
-      assert_equal("hello world",
-                    File.read(tmp.path))
+      assert_equal('hello world',
+                   File.read(tmp.path))
     ensure
       tmp.close
       tmp.unlink
     end
-
   end
 end

data/test/merge_command_test.rb

@@ -1,56 +1,56 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'tempfile'
 
 module Pups
   class MergeCommandTest < MiniTest::Test
     def test_deep_merge_arrays
-      a = {a: {a: ["hi",1]}}
-      b = {a: {a: ["hi",2]}}
-      c = {a: {}}
+      a = { a: { a: ['hi', 1] } }
+      b = { a: { a: ['hi', 2] } }
+      c = { a: {} }
 
-      d = Pups::MergeCommand.deep_merge(a,b,:merge_arrays)
-      d = Pups::MergeCommand.deep_merge(d,c,:merge_arrays)
+      d = Pups::MergeCommand.deep_merge(a, b, :merge_arrays)
+      d = Pups::MergeCommand.deep_merge(d, c, :merge_arrays)
 
-      assert_equal(["hi", 1,"hi", 2], d[:a][:a])
+      assert_equal(['hi', 1, 'hi', 2], d[:a][:a])
     end
 
     def test_merges
+      source = <<~YAML
+        user:
+          name: "bob"
+          password: "xyz"
+      YAML
 
-      source = <<YAML
-user:
-  name: "bob"
-  password: "xyz"
-YAML
-
-      f = Tempfile.new("test")
+      f = Tempfile.new('test')
       f.write source
       f.close
 
-      merge = <<YAML
-user:
-  name: "bob2"
-YAML
+      merge = <<~YAML
+        user:
+          name: "bob2"
+      YAML
 
-    MergeCommand.from_str("#{f.path} $yaml", {"yaml" => YAML.load(merge) }).run
+      MergeCommand.from_str("#{f.path} $yaml", { 'yaml' => YAML.safe_load(merge) }).run
 
-    changed = YAML.load_file(f.path)
+      changed = YAML.load_file(f.path)
 
-    assert_equal({"user" => {
-      "name" => "bob2",
-      "password" => "xyz"
-    }}, changed)
+      assert_equal({ 'user' => {
+                     'name' => 'bob2',
+                     'password' => 'xyz'
+                   } }, changed)
 
-    def test_deep_merge_nil
-      a = {param: {venison: "yes please"}}
-      b = {param: nil}
+      def test_deep_merge_nil
+        a = { param: { venison: 'yes please' } }
+        b = { param: nil }
 
-      r1 = Pups::MergeCommand.deep_merge(a,b)
-      r2 = Pups::MergeCommand.deep_merge(b,a)
-
-      assert_equal({venison: "yes please"}, r1[:param])
-      assert_equal({venison: "yes please"}, r2[:param])
-    end
+        r1 = Pups::MergeCommand.deep_merge(a, b)
+        r2 = Pups::MergeCommand.deep_merge(b, a)
 
+        assert_equal({ venison: 'yes please' }, r1[:param])
+        assert_equal({ venison: 'yes please' }, r2[:param])
+      end
     ensure
       f.unlink
     end

data/test/replace_command_test.rb

@@ -1,34 +1,35 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'tempfile'
 
 module Pups
   class ReplaceCommandTest < MiniTest::Test
-
     def test_simple
       command = ReplaceCommand.new({})
-      command.text = "hello world"
+      command.text = 'hello world'
       command.from = /he[^o]+o/
-      command.to = "world"
+      command.to = 'world'
 
-      assert_equal("world world", command.replaced_text)
+      assert_equal('world world', command.replaced_text)
     end
 
     def test_reverse
-      source = <<SCR
-1 one thousand 1
-1 one thousand 1
-1 one thousand 1
-SCR
+      source = <<~SCR
+        1 one thousand 1
+        1 one thousand 1
+        1 one thousand 1
+      SCR
 
-      f = Tempfile.new("test")
+      f = Tempfile.new('test')
       f.write source
       f.close
 
       hash = {
-        "filename" => f.path,
-        "from" => "/one t.*d/",
-        "to" => "hello world",
-        "direction" => "reverse"
+        'filename' => f.path,
+        'from' => '/one t.*d/',
+        'to' => 'hello world',
+        'direction' => 'reverse'
       }
 
       command = ReplaceCommand.from_hash(hash, {})
@@ -39,21 +40,21 @@ SCR
     end
 
     def test_global
-      source = <<SCR
-one
-one
-one
-SCR
+      source = <<~SCR
+        one
+        one
+        one
+      SCR
 
-      f = Tempfile.new("test")
+      f = Tempfile.new('test')
       f.write source
       f.close
 
       hash = {
-        "filename" => f.path,
-        "from" => "/one/",
-        "to" => "two",
-        "global" => "true"
+        'filename' => f.path,
+        'from' => '/one/',
+        'to' => 'two',
+        'global' => 'true'
       }
 
       command = ReplaceCommand.from_hash(hash, {})
@@ -61,50 +62,47 @@ SCR
       assert_equal("two\ntwo\ntwo\n", command.replaced_text)
     ensure
       f.unlink
-
     end
 
     def test_replace_with_env
-      source = "123"
+      source = '123'
 
-      f = Tempfile.new("test")
+      f = Tempfile.new('test')
       f.write source
       f.close
 
       hash = {
-        "filename" => f.path,
-        "from" => "123",
-        "to" => "hello $hellos"
+        'filename' => f.path,
+        'from' => '123',
+        'to' => 'hello $hellos'
       }
 
-      command = ReplaceCommand.from_hash(hash, {"hello" => "world"})
-      assert_equal("hello worlds", command.replaced_text)
-
+      command = ReplaceCommand.from_hash(hash, { 'hello' => 'world' })
+      assert_equal('hello worlds', command.replaced_text)
     ensure
       f.unlink
     end
 
     def test_parse
+      source = <<~SCR
+        this {
+        is a test
+        }
+      SCR
 
-      source = <<SCR
-this {
-is a test
-}
-SCR
-
-      f = Tempfile.new("test")
+      f = Tempfile.new('test')
       f.write source
       f.close
 
       hash = {
-        "filename" => f.path,
-        "from" => "/this[^\}]+\}/m",
-        "to" => "hello world"
+        'filename' => f.path,
+        'from' => "/this[^\}]+\}/m",
+        'to' => 'hello world'
       }
 
       command = ReplaceCommand.from_hash(hash, {})
 
-      assert_equal("hello world", command.replaced_text.strip)
+      assert_equal('hello world', command.replaced_text.strip)
     ensure
       f.unlink
     end