simmer 1.0.0.pre.alpha.3 → 1.0.0.pre.alpha.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f39dfd0f306f15f008f9074944a8a9f2180ba1188f45eda8568317c0a6f235d
-  data.tar.gz: 41c1d9dd94a31a6fce03ec37ba6b9fc7067672bf05047babd1858ea336055756
+  metadata.gz: 1197e913b7b6a7b9a814fb2474aa9d89844af7c4efe872ae001116354a3b6cdb
+  data.tar.gz: 6e24db3887b3abb23489642547f64ce4c68af85493b06c54d0c9bc15c637cc44
 SHA512:
-  metadata.gz: e659dde01a157945a3c7f64159384eee954696b1905200b5b1fdc3ff908f5c079ddf6dbfe2f46b3654b9ce045f504b21eff4a31eac951b54f465ba76b0dbe713
-  data.tar.gz: ef419cbe1aa6dbc729522d63b11d2e2657c2c039ecde09efafcf62619ad1e6a263dae3082be2951c0e85a243e9375fbf3bf37b66df92469144d5ac6ca25d768d
+  metadata.gz: 3e994e8d2f87598a9baa31211e5baeae2210c8dc8e5e8337579ea2417c835162b12c59dbbd5e84d34d5f969bbe5770dc02ec8017c3e45fb0a1af6572a07f5916
+  data.tar.gz: 4f15f5aadaff3d595969aee68ad8c0689f879b1f6c0fde5fc7febe0f4aeff0fa25cc04c0cfeaa263fcca9e3e33ea20598d8d586803e34db68fd58bbf1739eb19

data/.gitignore

@@ -5,3 +5,4 @@
 Gemfile.lock
 /pkg
 /bin/di
+/spec/config/simmer.yaml

data/.travis.yml

@@ -2,6 +2,8 @@ env:
   global:
     - CC_TEST_REPORTER_ID=48c3a48cc3c203ac365190a30b3c0a9aae0d2c10c9a86735e654f23b8660bb02
 language: ruby
+services:
+  - mysql
 rvm:
   # Build on the latest stable of all supported Rubies (https://www.ruby-lang.org/en/downloads/):
   - 2.4.6
@@ -13,6 +15,9 @@ before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
   - chmod +x ./cc-test-reporter
   - ./cc-test-reporter before-build
+  - cp spec/config/simmer.yaml.ci spec/config/simmer.yaml
+  - cat spec/db/database.sql | mysql
+  - cat spec/db/tables.sql | mysql
 script:
   - bundle exec rubocop
   - bundle exec rspec spec --format documentation

data/lib/simmer.rb

@@ -30,25 +30,119 @@ Hash.include Simmer::CoreExt::Hash
 require_relative 'simmer/util'
 
 # Core code
+require_relative 'simmer/configuration'
+require_relative 'simmer/database'
+require_relative 'simmer/externals'
+require_relative 'simmer/runner'
+require_relative 'simmer/specification'
+require_relative 'simmer/spoon_mock'
 require_relative 'simmer/suite'
 
 # The main entry-point API for the library.
 module Simmer
   DEFAULT_CONFIG_PATH = File.join('config', 'simmer.yaml')
-  DEFAULT_RESULTS_DIR = 'results'
   DEFAULT_SIMMER_DIR  = 'simmer'
+
   class << self
-    def run(path)
-      suite.run(path)
+    def run(
+      path,
+      config_path: DEFAULT_CONFIG_PATH,
+      out: $stdout,
+      simmer_dir: DEFAULT_SIMMER_DIR
+    )
+      # Get configuration
+      yaml_reader   = Util::YamlReader.new
+      raw_config    = yaml_reader.smash(config_path)
+      configuration = Configuration.new(raw_config, simmer_dir)
+
+      # Get fixtures
+      raw_fixtures = yaml_reader.smash(configuration.fixtures_dir)
+      fixtures     = Database::FixtureSet.new(raw_fixtures)
+
+      # Get specifications to run
+      specs = make_specifications(path, configuration.tests_dir)
+
+      # Make main executable instances
+      runner = make_runner(configuration, out, fixtures)
+      suite  = Suite.new(
+        config: configuration.config,
+        out: out,
+        results_dir: configuration.results_dir,
+        runner: runner
+      )
+
+      suite.run(specs)
+    end
+
+    private
+
+    def make_specifications(path, tests_dir)
+      path = path.to_s.empty? ? tests_dir : path
+
+      Util::YamlReader.new.read(path).map do |file|
+        config = (file.data || {}).merge(path: file.path)
+
+        Specification.make(config)
+      end
+    end
+
+    def make_runner(configuration, out, fixtures)
+      database     = make_mysql_database(configuration, fixtures)
+      file_system  = make_aws_file_system(configuration)
+      spoon_client = make_spoon_client(configuration)
+
+      Runner.new(
+        database: database,
+        file_system: file_system,
+        out: out,
+        spoon_client: spoon_client
+      )
+    end
+
+    def make_fixture_set(configuration)
+      config = Util::YamlReader.new.smash(configuration.fixtures_dir)
+
+      Database::FixtureSet.new(config)
+    end
+
+    def make_mysql_database(configuration, fixtures)
+      config         = (configuration.mysql_database_config || {}).symbolize_keys
+      client         = Mysql2::Client.new(config)
+      exclude_tables = config[:exclude_tables]
+
+      Externals::MysqlDatabase.new(client, exclude_tables, fixtures)
     end
 
-    def suite
-      Suite.new(
-        out: $stdout,
-        config_path: DEFAULT_CONFIG_PATH,
-        results_dir: DEFAULT_RESULTS_DIR,
-        simmer_dir: DEFAULT_SIMMER_DIR
+    def make_aws_file_system(configuration)
+      config = (configuration.aws_file_system_config || {}).symbolize_keys
+
+      client = Aws::S3::Client.new(
+        access_key_id: config[:access_key_id],
+        secret_access_key: config[:secret_access_key],
+        region: config[:region]
+      )
+
+      Externals::AwsFileSystem.new(
+        client,
+        config[:bucket],
+        config[:encryption],
+        configuration.files_dir
       )
     end
+
+    def make_spoon_client(configuration)
+      config = (configuration.spoon_client_config || {}).symbolize_keys
+
+      spoon =
+        if config[:mock]
+          SpoonMock.new
+        elsif config[:mock_err]
+          SpoonMock.new(false)
+        else
+          Pdi::Spoon.new(dir: config[:dir])
+        end
+
+      Externals::SpoonClient.new(configuration.files_dir, spoon)
+    end
   end
 end

data/lib/simmer/configuration.rb

@@ -19,6 +19,7 @@ module Simmer
     # Paths
     FILES    = 'files'
     FIXTURES = 'fixtures'
+    RESULTS  = 'results'
     TESTS    = 'specs'
 
     private_constant :AWS_FILE_SYSTEM_KEY,
@@ -30,27 +31,19 @@ module Simmer
 
     attr_reader :config
 
-    def initialize(
-      config_path:,
-      resolver: Objectable.resolver,
-      results_dir:,
-      simmer_dir:,
-      yaml_reader: Util::YamlReader.new
-    )
-      @config      = yaml_reader.read(config_path)
+    def initialize(config, simmer_dir, resolver: Objectable.resolver)
+      @config      = config || {}
       @resolver    = resolver
-      @results_dir = results_dir
       @simmer_dir  = simmer_dir
-      @yaml_reader = yaml_reader
 
       freeze
     end
 
-    def database_config
+    def mysql_database_config
       get(MYSQL_DATABASE_KEY) || {}
     end
 
-    def file_system_config
+    def aws_file_system_config
       get(AWS_FILE_SYSTEM_KEY) || {}
     end
 
@@ -70,16 +63,13 @@ module Simmer
       File.join(simmer_dir, FILES)
     end
 
-    def fixture_set
-      config = yaml_reader.smash(fixtures_dir)
-
-      Util::FixtureSet.new(config)
+    def results_dir
+      File.join(simmer_dir, RESULTS)
     end
 
     private
 
     attr_reader :resolver,
-                :results_dir,
                 :simmer_dir,
                 :yaml_reader
 

data/lib/simmer/database.rb

@@ -0,0 +1,10 @@
+# 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 'database/fixture_set'

data/lib/simmer/{util → database}/fixture.rb

@@ -8,7 +8,7 @@
 #
 
 module Simmer
-  module Util
+  module Database
     # A fixture is a database record that can be inserted in the Stage phase of a specification
     # execution.
     class Fixture
@@ -24,9 +24,13 @@ module Simmer
         @table  = table.to_s
       end
 
-      def to_s
-        "#{name} (#{table}) #{fields}"
+      def ==(other)
+        other.instance_of?(self.class) &&
+          fields == other.fields &&
+          name == other.name &&
+          table == other.table
       end
+      alias eql? ==
     end
   end
 end

data/lib/simmer/{util → database}/fixture_set.rb

@@ -10,13 +10,11 @@
 require_relative 'fixture'
 
 module Simmer
-  module Util
+  module Database
     # Hydrate a collection of Fixture instances from configuration.
     class FixtureSet
       def initialize(config = {})
-        @fixtures_by_name = config.each_with_object({}) do |(name, fixture_config), memo|
-          memo[name.to_s] = Fixture.make((fixture_config || {}).merge('name' => name))
-        end
+        @fixtures_by_name = config_to_fixures_by_name(config)
 
         freeze
       end
@@ -36,6 +34,14 @@ module Simmer
       private
 
       attr_reader :fixtures_by_name
+
+      def config_to_fixures_by_name(config)
+        (config || {}).each_with_object({}) do |(name, fixture_config), memo|
+          full_config = (fixture_config || {}).merge(name: name)
+
+          memo[name.to_s] = Fixture.make(full_config)
+        end
+      end
     end
   end
 end

data/lib/simmer/externals/aws_file_system.rb

@@ -15,26 +15,21 @@ module Simmer
 
       private_constant :BUCKET_SUFFIX
 
-      def initialize(config, files_dir)
-        config = (config || {}).symbolize_keys
+      def initialize(aws_s3_client, bucket, encryption, files_dir)
+        raise ArgumentError, 'aws_s3_client is required' unless aws_s3_client
+        raise ArgumentError, 'bucket is required'        if bucket.to_s.empty?
 
-        client = Aws::S3::Client.new(
-          access_key_id: config[:access_key_id],
-          secret_access_key: config[:secret_access_key],
-          region: config[:region]
-        )
-
-        bucket_name = config[:bucket].to_s
-        assert_bucket_name(bucket_name)
+        assert_bucket_name(bucket)
 
-        @bucket     = Aws::S3::Bucket.new(name: bucket_name, client: client)
-        @encryption = config[:encryption]
-        @files_dir  = files_dir
+        @aws_s3_client = aws_s3_client
+        @bucket        = bucket.to_s
+        @encryption    = encryption
+        @files_dir     = files_dir
 
         freeze
       end
 
-      def write(specification)
+      def write!(specification)
         files = specification.stage.files
 
         files.each do |file|
@@ -46,24 +41,36 @@ module Simmer
         files.length
       end
 
-      def clean
-        bucket.objects.inject(0) do |memo, object|
-          object.delete
+      def clean!
+        response    = aws_s3_client.list_objects(bucket: bucket)
+        objects     = response.contents
+        keys        = objects.map(&:key)
+        delete_keys = keys.map { |key| { key: key } }
 
-          memo + 1
-        end
+        return 0 if objects.length.zero?
+
+        aws_s3_client.delete_objects(
+          bucket: bucket,
+          delete: {
+            objects: delete_keys
+          }
+        )
+
+        delete_keys.length
       end
 
       private
 
-      attr_reader :bucket, :encryption, :files_dir
+      attr_reader :aws_s3_client, :bucket, :encryption, :files_dir
 
       def write_single(dest, src)
         src = File.expand_path(src)
 
         File.open(src, 'rb') do |file|
-          bucket.object(dest).put(
-            body: file,
+          aws_s3_client.put_object(
+            body: file.read,
+            bucket: bucket,
+            key: dest,
             server_side_encryption: encryption
           )
         end
@@ -72,7 +79,7 @@ module Simmer
       end
 
       def assert_bucket_name(name)
-        return if name.end_with?(BUCKET_SUFFIX)
+        return if name.to_s.end_with?(BUCKET_SUFFIX)
 
         raise ArgumentError, "bucket (#{name}) must end in #{BUCKET_SUFFIX}"
       end

data/lib/simmer/externals/mysql_database.rb

@@ -15,17 +15,14 @@ module 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)
+      def initialize(client, exclude_tables, fixture_set)
+        @client        = client
         @fixture_set   = fixture_set
-        exclude_tables = Array(config[:exclude_tables]).map(&:to_s)
+        exclude_tables = Array(exclude_tables).map(&:to_s)
         @table_names   = retrieve_table_names - exclude_tables
 
+        assert_database_name(schema)
+
         freeze
       end
 
@@ -97,9 +94,19 @@ module Simmer
         'SET @@foreign_key_checks = 1'
       end
 
+      def schema
+        client.query_options[:database].to_s
+      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}'"
+        escaped_schema = client.escape(schema)
+
+        sql = <<~SQL
+          SELECT TABLE_NAME
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = '#{escaped_schema}'
+            AND TABLE_TYPE = 'BASE TABLE'
+        SQL
 
         client.query(sql).to_a.map { |v| v['TABLE_NAME'].to_s }
       end

data/lib/simmer/externals/spoon_client.rb

@@ -7,36 +7,22 @@
 # 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
+      def initialize(files_dir, spoon)
+        raise ArgumentError, 'spoon is required' unless spoon
 
-      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
+        @files_dir = files_dir.to_s
+        @spoon     = spoon
 
         freeze
       end
 
-      def run(specification, config = {})
+      def run(specification, config)
         execution_result = nil
         time_in_seconds  = nil