simmer 1.0.0.pre.alpha.2

data/lib/simmer/runner/result.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Simmer
+  class Runner
+    # Return object from a Runner#run call.
+    class Result
+      extend Forwardable
+
+      attr_reader :id, :judge_result, :specification, :spoon_client_result
+
+      def_delegators :spoon_client_result, :time_in_seconds
+
+      def_delegators :specification, :name
+
+      def initialize(id, judge_result, specification, spoon_client_result)
+        @id                  = id.to_s
+        @judge_result        = judge_result
+        @specification       = specification
+        @spoon_client_result = spoon_client_result
+
+        freeze
+      end
+
+      def pass?
+        judge_result&.pass? && spoon_client_result&.pass?
+      end
+
+      def fail?
+        !pass?
+      end
+
+      def to_h
+        {
+          'name' => specification.name,
+          'id' => id,
+          'path' => specification.path,
+          'time_in_seconds' => time_in_seconds,
+          'pass' => pass?,
+          'spoon_client_result' => spoon_client_result.to_h,
+          'judge_result' => judge_result.to_h
+        }
+      end
+    end
+  end
+end

data/lib/simmer/session.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'session/reporter'
+require_relative 'session/result'
+
+module Simmer
+  # Runs a collection of specifications and then writes down the results to disk.
+  class Session
+    def initialize(
+      config:,
+      out:,
+      resolver: Objectable.resolver,
+      results_dir:,
+      runner:
+    )
+      @config      = config || {}
+      @out         = out
+      @resolver    = resolver
+      @results_dir = results_dir
+      @runner      = runner
+
+      freeze
+    end
+
+    def run(specifications)
+      runner_results = run_all_specs(specifications)
+
+      Result.new(runner_results).tap do |result|
+        if result.pass?
+          out.puts('Suite ended successfully')
+        else
+          out.puts('Suite ended but was not successful')
+        end
+
+        Reporter.new(result).write!(results_dir)
+
+        out.puts("Results can be viewed at #{results_dir}")
+      end
+    end
+
+    private
+
+    attr_reader :config, :out, :results_dir, :resolver, :runner
+
+    def run_all_specs(specifications)
+      out.puts('Simmer suite started')
+
+      count = specifications.length
+
+      out.puts("Running #{count} specification(s)")
+      print_line
+
+      specifications.map.with_index(1) do |specification, index|
+        run_single_spec(specification, index, count)
+      end
+    end
+
+    def run_single_spec(specification, index, count)
+      id = SecureRandom.uuid
+
+      out.puts("Test #{index} of #{count}: #{id}")
+
+      runner.run(specification, id: id, config: config).tap do
+        print_line
+      end
+    end
+
+    def print_line
+      out.puts('-' * 60)
+    end
+  end
+end

data/lib/simmer/session/reporter.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Simmer
+  class Session
+    # Understands how to write a SessionResult instance to disk.
+    class Reporter
+      DATA_FILE    = 'data.yaml'
+      PDI_OUT_FILE = 'pdi_out.txt'
+      PDI_ERR_FILE = 'pdi_err.txt'
+
+      def initialize(session_result)
+        raise ArgumentError, 'session_result is required' unless session_result
+
+        @session_result = session_result
+
+        freeze
+      end
+
+      def write!(dir)
+        dir = setup_directory(dir)
+
+        IO.write(data_path(dir), session_result.to_h.to_yaml)
+
+        pdi_out_file = File.open(pdi_out_path(dir), 'w')
+        pdi_err_file = File.open(pdi_err_path(dir), 'w')
+
+        write_part(session_result.runner_results, pdi_out_file, pdi_err_file)
+
+        pdi_out_file.close
+        pdi_err_file.close
+
+        self
+      end
+
+      def to_h
+        {
+          'pass' => pass?,
+          'time_in_seconds' => time_in_seconds,
+          'runner_results' => runner_results.map(&:to_h)
+        }
+      end
+
+      private
+
+      attr_reader :session_result
+
+      def data_path(dir)
+        File.join(dir, DATA_FILE)
+      end
+
+      def pdi_out_path(dir)
+        File.join(dir, PDI_OUT_FILE)
+      end
+
+      def pdi_err_path(dir)
+        File.join(dir, PDI_ERR_FILE)
+      end
+
+      def setup_directory(dir)
+        File.expand_path(dir).tap do |expanded_dir|
+          FileUtils.mkdir_p(expanded_dir)
+        end
+      end
+
+      def write_part(runner_results, pdi_out_file, pdi_err_file)
+        runner_results.each do |runner_result|
+          name         = runner_result.name
+          runner_id    = runner_result.id
+          out_contents = runner_result.spoon_client_result.execution_result.out
+          err_contents = runner_result.spoon_client_result.execution_result.err
+
+          write_block(pdi_out_file, name, runner_id, out_contents)
+          write_block(pdi_err_file, name, runner_id, err_contents)
+        end
+
+        nil
+      end
+
+      def write_block(file, name, runner_id, contents)
+        hyphens = '-' * 80
+
+        file.write("#{hyphens}\n")
+        file.write("Name: #{name}\n")
+        file.write("Runner ID: #{runner_id}\n")
+        file.write("#{hyphens}\n")
+        file.write("#{contents}\n")
+        file.write("\n")
+
+        nil
+      end
+    end
+  end
+end

data/lib/simmer/session/result.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Simmer
+  class Session
+    # The return object for a Session#run call.
+    class Result
+      attr_reader :runner_results
+
+      def initialize(runner_results = [])
+        @runner_results = Array(runner_results)
+
+        freeze
+      end
+
+      def pass?
+        !fail?
+      end
+
+      def fail?
+        runner_results.any?(&:fail?)
+      end
+
+      def time_in_seconds
+        runner_results.inject(0.0) do |memo, runner_result|
+          memo + runner_result.time_in_seconds
+        end
+      end
+
+      def to_h
+        {
+          'pass' => pass?,
+          'time_in_seconds' => time_in_seconds,
+          'runner_results' => runner_results.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/simmer/specification.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'specification/act'
+require_relative 'specification/assert'
+require_relative 'specification/stage'
+
+module Simmer
+  # Describes a specification at the highest of levels.
+  class Specification
+    acts_as_hashable
+
+    attr_reader :act, :assert, :name, :path, :stage
+
+    def initialize(act: {}, assert: {}, name:, path:, stage: {})
+      raise ArgumentError, 'name is required' if name.to_s.empty?
+      raise ArgumentError, 'path is required' if path.to_s.empty?
+
+      @act    = Act.make(act)
+      @assert = Assert.make(assert)
+      @name   = name.to_s
+      @path   = path.to_s
+      @stage  = Stage.make(stage)
+
+      freeze
+    end
+  end
+end

data/lib/simmer/specification/act.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'act/params'
+
+module Simmer
+  class Specification
+    # Describes everything necessary to execute Pdi::Spoon.
+    class Act
+      extend Forwardable
+      acts_as_hashable
+
+      module Type
+        JOB            = :job
+        TRANSFORMATION = :transformation
+      end
+
+      attr_reader :repository, :name, :type, :params
+
+      def_delegator :params, :compile, :compiled_params
+
+      def initialize(repository:, name:, type:, params: {})
+        assert_presence(repository, 'repository')
+        assert_presence(name, 'name')
+        assert_presence(type, 'type')
+
+        @repository = repository.to_s
+        @name       = name.to_s
+        @type       = Type.const_get(type.to_s.to_s.upcase.to_sym)
+        @params     = Params.make(params)
+
+        freeze
+      end
+
+      private
+
+      def assert_presence(value, name)
+        raise ArgumentError, "#{name} is required" if value.to_s.empty?
+      end
+    end
+  end
+end

data/lib/simmer/specification/act/params.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Simmer
+  class Specification
+    class Act
+      # Understands how to compile a list of files and key value pairs for Pdi::Spoon
+      # consumption.
+      class Params
+        acts_as_hashable
+
+        attr_reader :files, :keys
+
+        def initialize(files: {}, keys: {})
+          @files     = files || {}
+          @keys      = keys || {}
+          @evaluator = Util::Evaluator.new
+
+          freeze
+        end
+
+        def compile(files_path, config = {})
+          compiled_file_params(files_path, config).merge(compiled_key_params(config))
+        end
+
+        private
+
+        attr_reader :evaluator
+
+        def compiled_file_params(files_path, config)
+          files.map do |key, value|
+            evaluated_value = evaluator.evaluate(value, config)
+            expanded_value  = File.expand_path(File.join(files_path, evaluated_value))
+
+            [key, expanded_value]
+          end.to_h
+        end
+
+        def compiled_key_params(config)
+          keys.map do |key, value|
+            evaluated_value = evaluator.evaluate(value, config)
+
+            [key, evaluated_value]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/simmer/specification/assert.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'assert/assertions'
+
+module Simmer
+  class Specification
+    # Describes what should be expected after a Pdi::Spoon execution.
+    class Assert
+      acts_as_hashable
+
+      attr_reader :assertions
+
+      def initialize(assertions: [])
+        @assertions = Assertions.array(assertions)
+
+        freeze
+      end
+    end
+  end
+end