simmer 1.0.0.pre.alpha

data/lib/simmer/externals/mysql_database.rb

@@ -0,0 +1,114 @@
+# 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 'mysql_database/sql_fixture'
+
+module Simmer
+  module Externals
+    # Provides a wrapper around mysql2 for Simmer.
+    class MysqlDatabase
+      DATABASE_SUFFIX = 'test'
+
+      def initialize(config, fixture_set)
+        config = (config || {}).symbolize_keys
+
+        database = config[:database].to_s
+        assert_database_name(database)
+
+        @client        = Mysql2::Client.new(config)
+        @fixture_set   = fixture_set
+        exclude_tables = Array(config[:exclude_tables]).map(&:to_s)
+        @table_names   = retrieve_table_names - exclude_tables
+
+        freeze
+      end
+
+      def records(table, columns = [])
+        query = "SELECT #{sql_select_params(columns)} FROM #{table}"
+
+        client.query(query).to_a
+      end
+
+      def seed!(specification)
+        sql_statements = seed_sql_statements(specification)
+
+        shameless_execute(sql_statements)
+
+        sql_statements.length
+      end
+
+      def clean!
+        sql_statements = clean_sql_statements
+
+        shameless_execute(sql_statements)
+
+        sql_statements.length
+      end
+
+      private
+
+      attr_reader :client, :fixture_set, :table_names
+
+      def sql_select_params(columns)
+        Array(columns).any? ? Array(columns).map { |c| client.escape(c) }.join(',') : '*'
+      end
+
+      def seed_sql_statements(specification)
+        fixture_names = specification.stage.fixtures
+
+        fixture_names.map do |fixture_name|
+          fixture = fixture_set.get!(fixture_name)
+
+          SqlFixture.new(client, fixture).to_sql
+        end
+      end
+
+      def clean_sql_statements
+        table_names.map do |table_name|
+          "TRUNCATE #{table_name}"
+        end
+      end
+
+      def shameless_execute(sql_statements)
+        execute(disable_checks_sql_statement)
+        execute(sql_statements)
+        execute(enable_checks_sql_statement)
+      end
+
+      def execute(*sql_statements)
+        sql_statements.flatten.each do |sql_statement|
+          client.query(sql_statement)
+        end
+
+        nil
+      end
+
+      def disable_checks_sql_statement
+        'SET @@foreign_key_checks = 0'
+      end
+
+      def enable_checks_sql_statement
+        'SET @@foreign_key_checks = 1'
+      end
+
+      def retrieve_table_names
+        schema = client.escape(client.query_options[:database].to_s)
+        sql = "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '#{schema}'"
+
+        client.query(sql).to_a.map { |v| v['TABLE_NAME'].to_s }
+      end
+
+      def assert_database_name(name)
+        return if name.end_with?(DATABASE_SUFFIX)
+
+        raise ArgumentError, "database (#{name}) must end in #{DATABASE_SUFFIX}"
+      end
+    end
+  end
+end

data/lib/simmer/externals/mysql_database/sql_fixture.rb

@@ -0,0 +1,43 @@
+# 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
+  module Externals
+    class MysqlDatabase
+      # This class knows how to turn a fixture into sql.
+      class SqlFixture
+        extend Forwardable
+
+        def_delegators :fixture,
+                       :fields,
+                       :table
+
+        def initialize(client, fixture)
+          raise ArgumentError, 'fixture is required' unless fixture
+
+          @client  = client
+          @fixture = fixture
+
+          freeze
+        end
+
+        def to_sql
+          sql_columns = fields.keys.join(',')
+          sql_values  = fields.values.map { |v| "'#{client.escape(v.to_s)}'" }.join(',')
+
+          "INSERT INTO #{table} (#{sql_columns}) VALUES (#{sql_values})"
+        end
+
+        private
+
+        attr_reader :client, :fixture
+      end
+    end
+  end
+end

data/lib/simmer/externals/spoon_client.rb

@@ -0,0 +1,77 @@
+# 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 'spoon_client/mock'
+require_relative 'spoon_client/result'
+
+module Simmer
+  module Externals
+    # Wraps up Pdi::Spoon at a higher-level for Simmer to consume.
+    class SpoonClient
+      MOCK_KEY     = :mock
+      MOCK_ERR_KEY = :mock_err
+
+      private_constant :MOCK_KEY, :MOCK_ERR_KEY
+
+      def initialize(config, files_dir)
+        @files_dir = files_dir
+
+        config = (config || {}).symbolize_keys
+
+        @spoon =
+          if config[MOCK_KEY]
+            Mock.new
+          elsif config[MOCK_ERR_KEY]
+            Mock.new(false)
+          else
+            Pdi::Spoon.new(dir: config[:dir])
+          end
+
+        freeze
+      end
+
+      def run(specification, config = {})
+        execution_result = nil
+        time_in_seconds  = nil
+
+        begin
+          time_in_seconds = Benchmark.measure do
+            execution_result = execute!(specification, config)
+          end.real.round(2)
+        rescue Pdi::Spoon::PanError, Pdi::Spoon::KitchenError => e
+          return Result.new(
+            message: "PDI execution returned an error: #{e.class.name} (#{e.execution.code})",
+            execution_result: e.execution,
+            time_in_seconds: time_in_seconds
+          )
+        end
+
+        Result.new(
+          execution_result: execution_result,
+          time_in_seconds: time_in_seconds
+        )
+      end
+
+      private
+
+      attr_reader :files_dir, :spoon
+
+      def execute!(specification, config)
+        act = specification.act
+
+        spoon.run(
+          repository: act.repository,
+          name: act.name,
+          params: act.compiled_params(files_dir, config),
+          type: act.type
+        )
+      end
+    end
+  end
+end

data/lib/simmer/externals/spoon_client/mock.rb

@@ -0,0 +1,39 @@
+# 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
+  module Externals
+    class SpoonClient
+      # Provides a simple mock for the underlying Pdi::Spoon class.
+      class Mock
+        attr_reader :pass
+
+        def initialize(pass = true)
+          @pass = pass
+
+          freeze
+        end
+
+        def run(*)
+          raise Pdi::Spoon::KitchenError, 'mocked' unless pass
+
+          Pdi::Executor::Result.new(
+            args: [],
+            status: {
+              code: 0,
+              err: 'Some error output from PDI',
+              out: 'Some output from PDI',
+              pid: 123
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/simmer/externals/spoon_client/result.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.
+#
+
+module Simmer
+  module Externals
+    class SpoonClient
+      # The return object from a SpoonClient#run call.
+      class Result
+        attr_reader :message, :execution_result, :time_in_seconds
+
+        def initialize(message: '', execution_result:, time_in_seconds:)
+          @message          = message
+          @execution_result = execution_result
+          @time_in_seconds  = time_in_seconds
+
+          freeze
+        end
+
+        def pass?
+          execution_result.code.zero?
+        end
+
+        def fail?
+          !pass?
+        end
+
+        def to_h
+          {
+            'pass' => pass?,
+            'message' => message,
+            'execution_result' => {
+              'args' => execution_result.args,
+              'code' => execution_result.code,
+              'pid' => execution_result.pid
+            },
+            'time_in_seconds' => time_in_seconds
+          }
+        end
+      end
+    end
+  end
+end

data/lib/simmer/judge.rb

@@ -0,0 +1,38 @@
+# 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 'judge/result'
+require_relative 'specification'
+
+module Simmer
+  # Runs all assertions and reports back the results.
+  class Judge
+    attr_reader :database
+
+    def initialize(database)
+      raise ArgumentError, 'database is required' unless database
+
+      @database = database
+
+      freeze
+    end
+
+    def assert(specification, output)
+      assertions = specification.assert.assertions
+
+      bad_assertions = assertions.each_with_object([]) do |assertion, memo|
+        bad_assert = assertion.assert(database, output)
+
+        memo << bad_assert if bad_assert
+      end
+
+      Result.new(bad_assertions)
+    end
+  end
+end

data/lib/simmer/judge/result.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.
+#
+
+module Simmer
+  class Judge
+    # The return object of a Judge#assert call.
+    class Result
+      attr_reader :bad_assertions
+
+      def initialize(bad_assertions)
+        @bad_assertions = bad_assertions
+
+        freeze
+      end
+
+      def pass?
+        bad_assertions.empty?
+      end
+
+      def to_h
+        {
+          'pass' => pass?,
+          'bad_assertions' => bad_assertions.map(&:to_h)
+        }
+      end
+    end
+  end
+end

data/lib/simmer/runner.rb

@@ -0,0 +1,125 @@
+# 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 'judge'
+require_relative 'runner/result'
+
+module Simmer
+  # Runs a single specification.
+  class Runner
+    def initialize(database:, file_system:, out:, spoon_client:)
+      @database     = database
+      @file_system  = file_system
+      @judge        = Judge.new(database)
+      @out          = out
+      @spoon_client = spoon_client
+
+      freeze
+    end
+
+    def run(specification, config: {}, id: SecureRandom.uuid)
+      print("Name: #{specification.name}")
+      print("Path: #{specification.path}")
+
+      clean_db
+      seed_db(specification)
+      clean_file_system
+      seed_file_system(specification)
+
+      spoon_client_result = execute_spoon(specification, config)
+      judge_result        = assert(specification, spoon_client_result)
+
+      Result.new(id, judge_result, specification, spoon_client_result).tap do |result|
+        msg = result.pass? ? 'PASS' : 'FAIL'
+        print_waiting('Done', 'Final verdict')
+        print(msg)
+      end
+    end
+
+    private
+
+    attr_reader :database, :file_system, :judge, :out, :spoon_client
+
+    def clean_db
+      print_waiting('Stage', 'Cleaning database')
+      count = database.clean!
+      print("#{count} table(s) emptied")
+
+      count
+    end
+
+    def seed_db(specification)
+      print_waiting('Stage', 'Seeding database')
+      count = database.seed!(specification)
+      print("#{count} record(s) inserted")
+
+      count
+    end
+
+    def clean_file_system
+      print_waiting('Stage', 'Cleaning File System')
+      count = file_system.clean
+      print("#{count} file(s) deleted")
+
+      count
+    end
+
+    def seed_file_system(specification)
+      print_waiting('Stage', 'Seeding File System')
+      count = file_system.write(specification)
+      print("#{count} file(s) uploaded")
+
+      count
+    end
+
+    def execute_spoon(specification, config)
+      print_waiting('Act', 'Executing Spoon')
+      spoon_client_result = spoon_client.run(specification, config)
+      msg = spoon_client_result.pass? ? 'Pass' : 'Fail'
+      print(msg)
+
+      spoon_client_result
+    end
+
+    def assert(specification, spoon_client_result)
+      print_waiting('Assert', 'Checking results')
+
+      if spoon_client_result.fail?
+        print('Skipped')
+        return nil
+      end
+
+      output       = spoon_client_result.execution_result.out
+      judge_result = judge.assert(specification, output)
+      msg          = judge_result.pass? ? 'Pass' : 'Fail'
+
+      print(msg)
+
+      judge_result
+    end
+
+    def print(msg)
+      out.puts(msg)
+    end
+
+    def print_waiting(stage, msg)
+      max  = 25
+      char = '.'
+      msg  = "  > #{pad_right(stage, 6)} - #{pad_right(msg, max, char)}"
+
+      out.print(msg)
+    end
+
+    def pad_right(msg, len, char = ' ')
+      missing = len - msg.length
+
+      "#{msg}#{char * missing}"
+    end
+  end
+end