pups 1.0.0 → 1.1.1

data/test/config_test.rb

@@ -1,55 +1,217 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'tempfile'
 
 module Pups
   class ConfigTest < MiniTest::Test
-
     def test_config_from_env
-      ENV["HELLO"] = "world"
+      ENV['HELLO'] = 'world'
       config = Config.new({})
-      assert_equal("world", config.params["$ENV_HELLO"])
+      assert_equal('world', config.params['$ENV_HELLO'])
     end
 
-    def test_integration
+    def test_env_param
+      ENV['FOO'] = 'BAR'
+      config = <<~YAML
+        env:
+          BAR: baz
+          hello: WORLD
+          one: 1
+      YAML
 
-      f = Tempfile.new("test")
-      f.close
+      config = Config.new(YAML.safe_load(config))
+      %w[BAR hello one].each { |e| ENV.delete(e) }
+      assert_equal('BAR', config.params['$ENV_FOO'])
+      assert_equal('baz', config.params['$ENV_BAR'])
+      assert_equal('WORLD', config.params['$ENV_hello'])
+      assert_equal('1', config.params['$ENV_one'])
+    end
+
+    def test_env_with_template
+      ENV['FOO'] = 'BAR'
+      config = <<~YAML
+        env:
+          greeting: "{{hello}}, {{planet}}!"
+          one: 1
+          other: "where are we on {{planet}}?"
+        env_template:
+          planet: pluto
+          hello: hola
+      YAML
+      config_hash = YAML.safe_load(config)
+
+      config = Config.new(config_hash)
+      %w[greeting one other].each { |e| ENV.delete(e) }
+      assert_equal('hola, pluto!', config.params['$ENV_greeting'])
+      assert_equal('1', config.params['$ENV_one'])
+      assert_equal('BAR', config.params['$ENV_FOO'])
+      assert_equal('where are we on pluto?', config.params['$ENV_other'])
+    end
+
+    def test_label_with_template
+      ENV["FOO"] = "BAR"
+      config = <<~YAML
+      env:
+        greeting: "{{hello}}, {{planet}}!"
+        one: 1
+        other: "where are we on {{planet}}?"
+      env_template:
+        planet: pluto
+        hello: hola
+        config: various
+      labels:
+        app_name: "{{config}}_discourse"
+      YAML
+      config_hash = YAML.load(config)
+
+      config = Config.new(config_hash)
+      %w[greeting one other].each { |e| ENV.delete(e) }
+      assert_equal("various_discourse", config.config['labels']['app_name'])
+    end
+
+    def test_env_with_ENV_templated_variable
+      ENV['env_template_config'] = 'my_application'
+      config = <<~YAML
+        env:
+          greeting: "{{hello}}, {{planet}}!"
+          one: 1
+          other: "building {{config}}"
+        env_template:
+          planet: pluto
+          hello: hola
+      YAML
+      config_hash = YAML.safe_load(config)
+
+      config = Config.new(config_hash)
+      %w[greeting one other].each { |e| ENV.delete(e) }
+      assert_equal('hola, pluto!', config.params['$ENV_greeting'])
+      assert_equal('1', config.params['$ENV_one'])
+      assert_equal('building my_application', config.params['$ENV_other'])
+      ENV["env_template_config"] = nil
+    end
 
-      config = <<YAML
-params:
-  run: #{f.path}
-run:
-  - exec: echo hello world >> #{f.path}
-YAML
+    def test_integration
+      f = Tempfile.new('test')
+      f.close
 
-      Config.new(YAML.load(config)).run
-      assert_equal("hello world", File.read(f.path).strip)
+      config = <<~YAML
+        env:
+          PLANET: world
+        params:
+          run: #{f.path}
+          greeting: hello
+        run:
+          - exec: echo $greeting $PLANET >> #{f.path}
+      YAML
 
+      Config.new(YAML.safe_load(config)).run
+      ENV.delete('PLANET')
+      assert_equal('hello world', File.read(f.path).strip)
     ensure
       f.unlink
     end
 
     def test_hooks
-      yaml = <<YAML
-run:
-  - exec: 1
-  - exec:
-      hook: middle
-      cmd: 2
-  - exec: 3
-hooks:
-  after_middle:
-    - exec: 2.1
-  before_middle:
-    - exec: 1.9
-YAML
+      yaml = <<~YAML
+        run:
+          - exec: 1
+          - exec:
+              hook: middle
+              cmd: 2
+          - exec: 3
+        hooks:
+          after_middle:
+            - exec: 2.1
+          before_middle:
+            - exec: 1.9
+      YAML
 
       config = Config.load_config(yaml).config
-      assert_equal({ "exec" => 1.9 }, config["run"][1])
-      assert_equal({ "exec" => 2.1 }, config["run"][3])
+      assert_equal({ 'exec' => 1.9 }, config['run'][1])
+      assert_equal({ 'exec' => 2.1 }, config['run'][3])
+    end
+
+    def test_ignored_elements
+      f = Tempfile.new('test')
+      f.close
+
+      yaml = <<~YAML
+        env:
+          PLANET: world
+        params:
+          greeting: hello
+        run:
+          - exec: 1
+          - exec:
+              hook: middle
+              cmd: 2
+          - exec: 3
+          - exec: echo $greeting $PLANET >> #{f.path}
+        hooks:
+          after_middle:
+            - exec: 2.1
+          before_middle:
+            - exec: 1.9
+      YAML
 
+      conf = Config.load_config(yaml, %w[hooks params])
+      config = conf.config
+      assert_equal({ 'exec' => 1 }, config['run'][0])
+      assert_equal({ 'exec' => { 'hook' => 'middle', 'cmd' => 2 } }, config['run'][1])
+      assert_equal({ 'exec' => 3 }, config['run'][2])
+      assert_equal({ 'exec' => "echo $greeting $PLANET >> #{f.path}" }, config['run'][3])
 
+      # $greet from params will be an empty var as it was ignored
+      conf.run
+      ENV.delete('PLANET')
+      assert_equal('world', File.read(f.path).strip)
+    end
+
+    def test_generate_docker_run_arguments
+      yaml = <<~YAML
+      env:
+        foo: 1
+        bar: 2
+        baz: 'hello_{{spam}}'
+      env_template:
+        spam: 'eggs'
+        config: my_app
+      expose:
+        - "2222:22"
+        - "127.0.0.1:20080:80"
+        - 5555
+      volumes:
+        - volume:
+            host: /var/discourse/shared
+            guest: /shared
+        - volume:
+            host: /bar
+            guest: /baz
+      links:
+        - link:
+            name: postgres
+            alias: postgres
+        - link:
+            name: foo
+            alias: bar
+      labels:
+        monitor: "true"
+        app_name: "{{config}}_discourse"
+      YAML
+
+      config = Config.load_config(yaml)
+      args = config.generate_docker_run_arguments
+
+      expected = []
+      expected << "--env foo=1 --env bar=2 --env baz=hello_eggs"
+      expected << "--publish 2222:22 --publish 127.0.0.1:20080:80 --expose 5555"
+      expected << "--volume /var/discourse/shared:/shared --volume /bar:/baz"
+      expected << "--link postgres:postgres --link foo:bar"
+      expected << "--label monitor=true --label app_name=my_app_discourse"
+      expected.sort!
+
+      assert_equal(expected.join(" "), args)
     end
   end
 end
-

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(RuntimeError) do
-        ExecCommand.from_str("chgrp -a",{}).run
+      assert_raises(Pups::ExecError) do
+        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