test-prof 0.12.0 → 1.0.7

data/README.md

@@ -1,7 +1,7 @@
 [![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](https://cultofmartians.com)
-[![Gem Version](https://badge.fury.io/rb/test-prof.svg)](https://rubygems.org/gems/test-prof) [![Build](https://github.com/palkan/test-prof/workflows/Build/badge.svg)](https://github.com/palkan/test-prof/actions)
-[![JRuby Build](https://github.com/palkan/test-prof/workflows/JRuby%20Build/badge.svg)](https://github.com/palkan/test-prof/actions)
-[![Code Triagers Badge](https://www.codetriage.com/palkan/test-prof/badges/users.svg)](https://www.codetriage.com/palkan/test-prof)
+[![Gem Version](https://badge.fury.io/rb/test-prof.svg)](https://rubygems.org/gems/test-prof) [![Build](https://github.com/test-prof/test-prof/workflows/Build/badge.svg)](https://github.com/test-prof/test-prof/actions)
+[![JRuby Build](https://github.com/test-prof/test-prof/workflows/JRuby%20Build/badge.svg)](https://github.com/test-prof/test-prof/actions)
+[![Code Triagers Badge](https://www.codetriage.com/test-prof/test-prof/badges/users.svg)](https://www.codetriage.com/test-prof/test-prof)
 [![Documentation](https://img.shields.io/badge/docs-link-brightgreen.svg)](https://test-prof.evilmartians.io)
 
 # Ruby Tests Profiling Toolbox
@@ -32,7 +32,7 @@ TestProf toolbox aims to help you identify bottlenecks in your test suite. It co
 📑 [Documentation](https://test-prof.evilmartians.io)
 
 <p align="center">
-  <a href="http://bit.ly/test-prof-map">
+  <a href="http://bit.ly/test-prof-map-v1">
     <img src="./docs/assets/images/coggle.png" alt="TestProf map" width="738">
   </a>
 </p>
@@ -51,7 +51,7 @@ TestProf toolbox aims to help you identify bottlenecks in your test suite. It co
 - [CodeTriage](https://github.com/codetriage/codetriage)
 - [Dev.to](https://github.com/thepracticaldev/dev.to)
 - [Open Project](https://github.com/opf/openproject)
-- [...and others](https://github.com/palkan/test-prof/issues/73)
+- [...and others](https://github.com/test-prof/test-prof/issues/73)
 
 ## Resources
 
@@ -75,7 +75,7 @@ Add `test-prof` gem to your application:
 
 ```ruby
 group :test do
-  gem "test-prof"
+  gem "test-prof", "~> 1.0"
 end
 ```
 
@@ -83,7 +83,7 @@ And that's it)
 
 Supported Ruby versions:
 
-- Ruby (MRI) >= 2.4.0 (**NOTE:** for Ruby 2.2 use TestProf < 0.7.0 or Ruby 2.3 use TestProf ~> 0.7.0)
+- Ruby (MRI) >= 2.5.0 (**NOTE:** for Ruby 2.2 use TestProf < 0.7.0, Ruby 2.3 use TestProf ~> 0.7.0, Ruby 2.4 use TestProf <0.12.0)
 
 - JRuby >= 9.1.0.0 (**NOTE:** refinements-dependent features might require 9.2.7+)
 
@@ -95,9 +95,9 @@ Check out our [docs][].
 
 ## What's next?
 
-Have an idea? [Propose](https://github.com/palkan/test-prof/issues/new) a feature request!
+Have an idea? [Propose](https://github.com/test-prof/test-prof/issues/new) a feature request!
 
-Already using TestProf? [Share your story!](https://github.com/palkan/test-prof/issues/73)
+Already using TestProf? [Share your story!](https://github.com/test-prof/test-prof/issues/73)
 
 ## License
 

data/config/default.yml

@@ -18,18 +18,3 @@ RSpec/AggregateExamples:
     - validate_length_of
     - validate_inclusion_of
     - validates_exclusion_of
-
-# TODO: remove this one we hit 1.0
-RSpec/AggregateFailures:
-  Description: Checks if example group contains two or more aggregatable examples.
-  Enabled: false
-  StyleGuide: https://rspec.rubystyle.guide/#expectation-per-example
-  AddAggregateFailuresMetadata: true
-  MatchersWithSideEffects:
-    - allow_value
-    - allow_values
-    - validate_presence_of
-    - validate_absence_of
-    - validate_length_of
-    - validate_inclusion_of
-    - validates_exclusion_of

data/config/rubocop-rspec.yml

@@ -0,0 +1,6 @@
+RSpec:
+  Language:
+    Helpers:
+      - let_it_be
+    Hooks:
+      - before_all

data/lib/test_prof/any_fixture/dump/base_adapter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module TestProf
+  module AnyFixture
+    class Dump
+      class BaseAdapter
+        def reset_sequence!(_table_name, _start)
+        end
+
+        def compile_sql(sql, _binds)
+          sql
+        end
+
+        def setup_env
+        end
+
+        def teardown_env
+        end
+
+        def import(_path)
+          false
+        end
+
+        private
+
+        def while_disconnected
+          conn.disconnect!
+          yield
+        ensure
+          conn.reconnect!
+        end
+
+        def conn
+          ActiveRecord::Base.connection
+        end
+
+        def execute(query)
+          conn.execute(query)
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump/digest.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module TestProf
+  module AnyFixture
+    class Dump
+      module Digest
+        module_function
+
+        def call(*paths)
+          files = (AnyFixture.config.default_dump_watch_paths + paths).each_with_object([]) do |path_or_glob, acc|
+            if File.file?(path_or_glob)
+              acc << path_or_glob
+            else
+              acc = acc.concat Dir[path_or_glob]
+            end
+            acc
+          end
+
+          return if files.empty?
+
+          file_ids = files.sort.map { |f| "#{File.basename(f)}/#{::Digest::SHA1.file(f).hexdigest}" }
+          ::Digest::SHA1.hexdigest(file_ids.join("/"))
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump/postgresql.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "test_prof/any_fixture/dump/base_adapter"
+
+module TestProf
+  module AnyFixture
+    class Dump
+      class PostgreSQL < BaseAdapter
+        UUID_FUNCTIONS = %w[
+          gen_random_uuid
+          uuid_generate_v4
+        ]
+
+        def reset_sequence!(table_name, start)
+          _pk, sequence = conn.pk_and_sequence_for(table_name)
+          return unless sequence
+
+          sequence_name = "#{sequence.schema}.#{sequence.identifier}"
+
+          execute <<~SQL
+            ALTER SEQUENCE #{sequence_name} RESTART WITH #{start}; -- any_fixture:dump
+          SQL
+        end
+
+        def compile_sql(sql, binds)
+          sql.gsub(/\$\d+/) { binds.shift }
+        end
+
+        def import(path)
+          # Test if psql is installed
+          `psql --version`
+
+          tasks = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(conn.pool.spec.config.with_indifferent_access)
+
+          while_disconnected do
+            tasks.structure_load(path, "--output=/dev/null")
+          end
+
+          true
+        rescue Errno::ENOENT
+          false
+        end
+
+        def setup_env
+          # Mock UUID generating functions to provide consistent results
+          quoted_functions = UUID_FUNCTIONS.map { |func| "'#{func}'" }.join(", ")
+
+          @uuid_funcs = execute <<~SQL
+            SELECT
+              pp.proname, pn.nspname,
+              pg_get_functiondef(pp.oid) AS definition
+            FROM pg_proc pp
+            JOIN pg_namespace pn
+              ON pn.oid = pp.pronamespace
+            WHERE pp.proname in (#{quoted_functions})
+            ORDER BY pp.oid;
+          SQL
+
+          uuid_funcs.each do |(func, ns, _)|
+            execute <<~SQL
+              CREATE OR REPLACE FUNCTION #{ns}.#{func}()
+                RETURNS UUID
+                LANGUAGE SQL
+                AS $$
+                  SELECT md5(random()::TEXT)::UUID;
+                $$; -- any_fixture:dump
+            SQL
+          end
+
+          execute <<~SQL
+            SELECT setseed(#{rand}); -- any_fixture:dump
+          SQL
+        end
+
+        def teardown_env
+          uuid_funcs.each do |(func, ns, definition)|
+            execute "#{definition}; -- any_fixture:dump"
+          end
+        end
+
+        private
+
+        attr_reader :uuid_funcs
+
+        def execute(query)
+          super.values
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump/sqlite.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "test_prof/any_fixture/dump/base_adapter"
+
+module TestProf
+  module AnyFixture
+    class Dump
+      class SQLite < BaseAdapter
+        def reset_sequence!(table_name, start)
+          execute <<~SQL.chomp
+            DELETE FROM sqlite_sequence WHERE name=#{table_name}
+          SQL
+
+          execute <<~SQL.chomp
+            INSERT INTO sqlite_sequence (name, seq)
+            VALUES (#{table_name}, #{start})
+          SQL
+        end
+
+        def compile_sql(sql, binds)
+          sql.gsub(/\?/) { binds.shift }
+        end
+
+        def import(path)
+          db = conn.pool.spec.config[:database]
+          return false if %r{:memory:}.match?(db)
+
+          # Check that sqlite3 is installed
+          `sqlite3 --version`
+
+          while_disconnected do
+            `sqlite3 #{db} < "#{path}"`
+          end
+
+          true
+        rescue Errno::ENOENT
+          false
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture/dump.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "test_prof/any_fixture/dump/digest"
+
+require "set"
+
+module TestProf
+  module AnyFixture
+    MODIFY_RXP = /^(INSERT INTO|UPDATE|DELETE FROM) (\S+)/i.freeze
+    ANY_FIXTURE_RXP = /(\/\*|--).*\bany_fixture:dump/.freeze
+    ANY_FIXTURE_IGNORE_RXP = /(\/\*|--).*\bany_fixture:ignore/.freeze
+
+    using(Module.new do
+      refine Object do
+        def to_digest
+          to_s
+        end
+      end
+
+      refine NilClass do
+        def to_digest
+          nil
+        end
+      end
+
+      refine Hash do
+        def to_digest
+          map { |k, v| [k.to_digest, v.to_digest].compact.join("_") }
+        end
+      end
+
+      refine Array do
+        def to_digest
+          map { |v| v.to_digest }.compact.join("-")
+        end
+      end
+    end)
+
+    class Dump
+      class Subscriber
+        attr_reader :path, :tmp_path
+
+        def initialize(path, adapter)
+          @path = path
+          @adapter = adapter
+          @tmp_path = path + ".tmp"
+          @reset_pk = Set.new
+        end
+
+        def start(_event, _id, payload)
+          sql = payload.fetch(:sql)
+          return if sql.match?(ANY_FIXTURE_IGNORE_RXP)
+
+          matches = sql.match(MODIFY_RXP)
+          return unless matches
+
+          reset_pk!(matches[2]) if /insert/i.match?(matches[1])
+        end
+
+        def finish(_event, _id, payload)
+          sql = payload.fetch(:sql)
+          return unless trackable_sql?(sql)
+
+          sql = payload[:binds].any? ? adapter.compile_sql(sql, quoted(payload[:binds])) : +sql
+
+          sql.tr!("\n", " ")
+
+          file.write(sql + ";\n")
+        end
+
+        def commit
+          return unless defined?(:@file)
+
+          file.close
+
+          FileUtils.mv(tmp_path, path)
+        end
+
+        private
+
+        attr_reader :reset_pk, :adapter
+
+        def file
+          @file ||= File.open(tmp_path, "w")
+        end
+
+        def reset_pk!(table_name)
+          return if /sqlite_sequence/.match?(table_name)
+
+          return if reset_pk.include?(table_name)
+
+          adapter.reset_sequence!(table_name, AnyFixture.config.dump_sequence_random_start)
+          reset_pk << table_name
+        end
+
+        def trackable_sql?(sql)
+          return false if sql.match?(ANY_FIXTURE_IGNORE_RXP)
+
+          sql.match?(MODIFY_RXP) || sql.match?(ANY_FIXTURE_RXP) || sql.match?(AnyFixture.config.dump_matching_queries)
+        end
+
+        def quoted(val)
+          if val.is_a?(Array)
+            val.map { |v| quoted(v) }
+          elsif val.is_a?(ActiveModel::Attribute)
+            quoted(val.value_for_database)
+          else
+            ActiveRecord::Base.connection.quote(val)
+          end
+        end
+      end
+
+      attr_reader :name, :digest, :path, :subscriber, :success
+      alias_method :success?, :success
+
+      def initialize(name, watch: [], cache_key: nil)
+        @name = name
+        @digest = [
+          Digest.call(*watch),
+          cache_key.to_digest
+        ].compact.join("-")
+
+        @path = build_path(name, digest)
+
+        @success = false
+
+        @adapter =
+          case ActiveRecord::Base.connection.adapter_name
+          when /sqlite/i
+            require "test_prof/any_fixture/dump/sqlite"
+            SQLite.new
+          when /postgresql/i
+            require "test_prof/any_fixture/dump/postgresql"
+            PostgreSQL.new
+          else
+            raise ArgumentError,
+              "Your current database adapter (#{ActiveRecord::Base.connection.adapter_name}) " \
+              "is currently not supported. So far, we only support SQLite and PostgreSQL"
+          end
+
+        @subscriber = Subscriber.new(path, adapter)
+      end
+
+      def exists?
+        File.exist?(path)
+      end
+
+      def force?
+        AnyFixture.config.force_matching_dumps.match?(name)
+      end
+
+      def load
+        return import_via_active_record unless AnyFixture.config.import_dump_via_cli?
+
+        adapter.import(path) || import_via_active_record
+      end
+
+      def commit!
+        subscriber.commit
+      end
+
+      def within_prepared_env(before: nil, after: nil, import: false)
+        run_before_callbacks(callback: before, dump: self, import: false)
+        yield.tap do
+          @success = true
+        end
+      ensure
+        run_after_callbacks(callback: after, dump: self, import: false)
+      end
+
+      private
+
+      attr_reader :adapter
+
+      def import_via_active_record
+        conn = ActiveRecord::Base.connection
+
+        File.open(path).each_line do |query|
+          next if query.empty?
+
+          conn.execute query
+        end
+      end
+
+      def build_path(name, digest)
+        dir = TestProf.artifact_path(
+          File.join(AnyFixture.config.dumps_dir)
+        )
+
+        FileUtils.mkdir_p(dir)
+
+        File.join(dir, "#{name}-#{digest}.sql")
+      end
+
+      def run_before_callbacks(callback:, **options)
+        # First, call config-defined setup callbacks
+        AnyFixture.config.before_dump.each { |clbk| clbk.call(**options) }
+        # Then, adapter-defined callbacks
+        adapter.setup_env unless options[:import]
+        # Finally, user-provided callback
+        callback&.call(**options)
+      end
+
+      def run_after_callbacks(callback:, **options)
+        # The order is vice versa to setup
+        callback&.call(**options)
+        adapter.teardown_env unless options[:import]
+        AnyFixture.config.after_dump.each { |clbk| clbk.call(**options) }
+      end
+    end
+  end
+end

data/lib/test_prof/any_fixture.rb

@@ -1,14 +1,67 @@
 # frozen_string_literal: true
 
 require "test_prof/ext/float_duration"
+require "test_prof/any_fixture/dump"
 
 module TestProf
   # Make DB fixtures from blocks.
   module AnyFixture
-    INSERT_RXP = /^INSERT INTO ([\S]+)/.freeze
+    INSERT_RXP = /^INSERT INTO (\S+)/.freeze
 
     using FloatDuration
 
+    # AnyFixture configuration
+    class Configuration
+      attr_accessor :reporting_enabled, :dumps_dir, :dump_sequence_start,
+        :import_dump_via_cli, :dump_matching_queries, :force_matching_dumps
+      attr_reader :default_dump_watch_paths
+
+      alias_method :reporting_enabled?, :reporting_enabled
+      alias_method :import_dump_via_cli?, :import_dump_via_cli
+
+      def initialize
+        @reporting_enabled = ENV["ANYFIXTURE_REPORT"] == "1"
+        @dumps_dir = "any_dumps"
+        @default_dump_watch_paths = %w[
+          db/schema.rb
+          db/structure.sql
+        ]
+        @dump_sequence_start = 123_654
+        @dump_matching_queries = /^$/
+        @import_dump_via_cli = ENV["ANYFIXTURE_IMPORT_DUMP_CLI"] == "1"
+        @before_dump = []
+        @after_dump = []
+        @force_matching_dumps =
+          if ENV["ANYFIXTURE_FORCE_DUMP"] == "1"
+            /.*/
+          elsif ENV["ANYFIXTURE_FORCE_DUMP"]
+            /#{ENV["ANYFIXTURE_FORCE_DUMP"]}/
+          else
+            /^$/
+          end
+      end
+
+      def before_dump(&block)
+        if block
+          @before_dump << block
+        else
+          @before_dump
+        end
+      end
+
+      def after_dump(&block)
+        if block
+          @after_dump << block
+        else
+          @after_dump
+        end
+      end
+
+      def dump_sequence_random_start
+        rand(dump_sequence_start..(dump_sequence_start * 2))
+      end
+    end
+
     class Cache # :nodoc:
       attr_reader :store, :stats
 
@@ -40,22 +93,74 @@ module TestProf
     class << self
       include Logging
 
-      attr_accessor :reporting_enabled
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Backward compatibility
+      def reporting_enabled=(val)
+        warn "AnyFixture.reporting_enabled is deprecated and will be removed in 1.1. Use AnyFixture.config.reporting_enabled instead"
+        config.reporting_enabled = val
+      end
 
-      def reporting_enabled?
-        reporting_enabled == true
+      def reporting_enabled
+        warn "AnyFixture.reporting_enabled is deprecated and will be removed in 1.1. Use AnyFixture.config.reporting_enabled instead"
+        config.reporting_enabled
       end
 
+      alias_method :reporting_enabled?, :reporting_enabled
+
       # Register a block of code as a fixture,
       # returns the result of the block execution
       def register(id)
-        cache.fetch(id) do
+        cached(id) do
           ActiveSupport::Notifications.subscribed(method(:subscriber), "sql.active_record") do
             yield
           end
         end
       end
 
+      def cached(id)
+        cache.fetch(id) { yield }
+      end
+
+      # Create and register new SQL dump.
+      # Use `watch` to provide additional paths to watch for
+      # dump re-generation
+      def register_dump(name, clean: true, **options)
+        called_from = caller_locations(1, 1).first.path
+        watch = options.delete(:watch) || [called_from]
+        cache_key = options.delete(:cache_key)
+        skip = options.delete(:skip_if)
+
+        id = "sql/#{name}"
+
+        register_method = clean ? :register : :cached
+
+        public_send(register_method, id) do
+          dump = Dump.new(name, watch: watch, cache_key: cache_key)
+
+          unless dump.force?
+            next if skip&.call(dump: dump)
+
+            next dump.within_prepared_env(import: true, **options) { dump.load } if dump.exists?
+          end
+
+          subscriber = ActiveSupport::Notifications.subscribe("sql.active_record", dump.subscriber)
+          res = dump.within_prepared_env(**options) { yield }
+
+          dump.commit!
+
+          res
+        ensure
+          ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+        end
+      end
+
       # Clean all affected tables (but do not reset cache)
       def clean
         disable_referential_integrity do
@@ -76,7 +181,13 @@ module TestProf
 
       def subscriber(_event, _start, _finish, _id, data)
         matches = data.fetch(:sql).match(INSERT_RXP)
-        tables_cache[matches[1]] = true if matches
+        return unless matches
+
+        table_name = matches[1]
+
+        return if /sqlite_sequence/.match?(table_name)
+
+        tables_cache[table_name] = true
       end
 
       def report_stats
@@ -148,7 +259,5 @@ module TestProf
         connection.disable_referential_integrity { yield }
       end
     end
-
-    self.reporting_enabled = ENV["ANYFIXTURE_REPORT"] == "1"
   end
 end