(gh-20) Add a task to check the version of the puppet binary

Provides a consistent way of verifying the installed version for
acceptance testing.

Author: jpartlow

spec/tasks/check_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../tasks/check'
+
+describe 'openvox_bootstrap::check' do
+  before do
+    allow(Puppet).to receive(:version).and_return('8.0.0')
+  end
+
+  describe '.run' do
+    let(:input) do
+      {
+        version: nil
+      }
+    end
+    let(:expected_output) do
+      {
+        puppet_version: '8.0.0',
+        valid: true
+      }
+    end
+
+    def validate_task_run(input, expected_output = {}, exit_code: 0)
+      old_stdin = $stdin
+      $stdin = StringIO.new(input.to_json)
+      old_stdout = $stdout
+      $stdout = StringIO.new
+
+      begin
+        OpenvoxBootstrap::Check.run
+      rescue SystemExit => e
+        expect(e.status).to eq(exit_code)
+      end
+
+      output = JSON.parse($stdout.string, symbolize_names: true)
+      expect(output).to eq(expected_output)
+    ensure
+      $stdin = old_stdin
+      $stdout = old_stdout
+    end
+
+    it 'raises for empty input' do
+      expect do
+        validate_task_run(nil)
+      end.to raise_error(ArgumentError)
+    end
+
+    it 'returns version without test if given no args' do
+      validate_task_run(input, expected_output)
+    end
+
+    context 'testing valid version' do
+      it 'returns successfully' do
+        input[:version] = '8.0.0'
+
+        expected_output[:test] = 'eq'
+        expected_output[:test_version] = '8.0.0'
+
+        validate_task_run(input, expected_output)
+      end
+    end
+
+    context 'testing invalid version' do
+      it 'returns non-zero' do
+        input[:version] = '8.1.0'
+        input[:test] = 'gt'
+
+        expected_output[:valid] = false
+        expected_output[:test] = 'gt'
+        expected_output[:test_version] = '8.1.0'
+
+        validate_task_run(input, expected_output, exit_code: 1)
+      end
+    end
+  end
+
+  describe '#task' do
+    let(:check) { OpenvoxBootstrap::Check.new }
+
+    context 'eq' do
+      it 'returns true for equal versions' do
+        expect(check.task(version: '8.0.0')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: true,
+              test: 'eq',
+              test_version: '8.0.0'
+            }
+          )
+        )
+      end
+
+      it 'returns false for unequal versions' do
+        expect(check.task(version: '8.0.1')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: false,
+              test: 'eq',
+              test_version: '8.0.1'
+            }
+          )
+        )
+      end
+    end
+
+    context 'ge' do
+      it 'returns true for greater than versions' do
+        expect(check.task(version: '7.0.0', test: 'ge')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: true,
+              test: 'ge',
+              test_version: '7.0.0'
+            }
+          )
+        )
+      end
+
+      it 'returns true for equal versions' do
+        expect(check.task(version: '8.0.0', test: 'ge')).to(include(valid: true))
+      end
+
+      it 'returns false for less than versions' do
+        expect(check.task(version: '9.0.0', test: 'ge')).to(
+          eq(
+            {
+              puppet_version: '8.0.0',
+              valid: false,
+              test: 'ge',
+              test_version: '9.0.0'
+            }
+          )
+        )
+      end
+    end
+
+    context 'gt' do
+      it 'is valid for greater than versions' do
+        expect(check.task(version: '7.0.0', test: 'gt')).to(include(valid: true))
+      end
+
+      it 'is invalid for equal versions or less than versions' do
+        expect(check.task(version: '8.0.0', test: 'gt')).to(include(valid: false))
+        expect(check.task(version: '8.0.1', test: 'gt')).to(include(valid: false))
+      end
+    end
+
+    context 'lt' do
+      it 'is valid for less than versions' do
+        expect(check.task(version: '8.0.1', test: 'lt')).to(include(valid: true))
+      end
+
+      it 'is invalid for equal versions or greater than versions' do
+        expect(check.task(version: '8.0.0', test: 'lt')).to(include(valid: false))
+        expect(check.task(version: '7.0.0', test: 'lt')).to(include(valid: false))
+      end
+    end
+
+    context 'le' do
+      it 'is valid for less than or equal versions' do
+        expect(check.task(version: '9.0.0', test: 'le')).to(include(valid: true))
+        expect(check.task(version: '8.0.0', test: 'le')).to(include(valid: true))
+      end
+
+      it 'is invalid for greater than versions' do
+        expect(check.task(version: '7.0.0', test: 'le')).to(include(valid: false))
+      end
+    end
+  end
+end

tasks/check.json

@@ -0,0 +1,28 @@
+{
+  "description": "Check whether a Puppet(tm) implementation is installed. Optionally checks the version.",
+  "input_method": "stdin",
+  "parameters": {
+    "version": {
+      "description": "The version of the implementation to check. To check if version meets a minimum, set test to 'ge' and version to x, x.y or x.y.z",
+      "type": "Optional[String]"
+    },
+    "test": {
+      "description": "Version comparison operator.",
+      "type": "Enum['eq', 'lt', 'le, 'gt', 'ge']",
+      "default": "eq"
+    }
+  },
+  "implementations": [
+    {
+      "name": "check.rb",
+      "requirements": ["puppet-agent"]
+    },
+    {
+      "name": "check_linux.sh",
+      "requirements": ["shell"],
+      "files": [
+        "openvox_bootstrap/tasks/check.rb"
+      ]
+    }
+  ]
+}

tasks/check.rb

@@ -0,0 +1,54 @@
+#! /opt/puppetlabs/puppet/bin/ruby
+# frozen_string_literal: true
+
+require 'json'
+require 'puppet/version'
+
+module OpenvoxBootstrap
+  class Check
+    def self.run
+      params = JSON.parse($stdin.read)
+      raise(ArgumentError, <<~ERR) unless params.is_a?(Hash)
+        Expected a Hash, got #{params.class}: #{params.inspect}
+      ERR
+
+      params.transform_keys!(&:to_sym)
+
+      result = Check.new.task(**params)
+      puts JSON.pretty_generate(result)
+      result[:valid] ? exit(0) : exit(1)
+    end
+
+    def task(version: nil, test: 'eq', **_kwargs)
+      puppet_version = Gem::Version.new(Puppet.version)
+      result = {
+        puppet_version: puppet_version.to_s,
+      }
+      result[:valid] = if version.nil? || version.empty?
+                         true
+                       else
+                         test_version = Gem::Version.new(version)
+                         result[:test] = test
+                         result[:test_version] = version
+                         case test
+                         when 'eq'
+                           puppet_version == test_version
+                         when 'lt'
+                           puppet_version < test_version
+                         when 'le'
+                           puppet_version <= test_version
+                         when 'gt'
+                           puppet_version > test_version
+                         when 'ge'
+                           puppet_version >= test_version
+                         else
+                           raise ArgumentError, "Unknown test: #{test}"
+                         end
+                       end
+
+      result
+    end
+  end
+end
+
+OpenvoxBootstrap::Check.run if __FILE__ == $PROGRAM_NAME

tasks/check_linux.sh

@@ -0,0 +1,24 @@
+#! /usr/bin/env bash
+
+set -e
+
+# shellcheck disable=SC2154
+installdir=$PT__installdir
+# shellcheck disable=SC2154
+test_version="${PT_version}"
+# shellcheck disable=SC2154
+test_operator="${PT_test:-eq}"
+
+bindir='/opt/puppetlabs/bin'
+
+if ! [ -f "${bindir}/puppet" ]; then
+  echo "Error: No puppet binary found at '${bindir}/puppet'. Is the package installed?"
+  exit 1
+fi
+
+"${installdir}/openvox_bootstrap/tasks/check.rb" <<JSON
+{
+  "version": "${test_version}",
+  "test": "${test_operator}"
+}
+JSON