seed_builder 1.2.1 → 1.3.0

data/lib/seed_builder/loader.rb

@@ -1,20 +1,18 @@
 module SeedBuilder
   class Loader
     def load_seed
-      initial_logger = Rails.logger
-
-      Rails.logger = Logger.new($stdout)
-      Rails.logger.level = Logger::INFO
-
-      ActiveRecord::Base.connection.schema_cache.clear!
-      ActiveRecord::Base.descendants.each(&:reset_column_information)
+      prepare_active_record
 
       default_seeds_rb = SeedBuilder.config.default_seeds_full_path
       if File.exist?(default_seeds_rb) && SeedBuilder.config.load_default_seeds?
         started_at = Time.current
-        puts "== #{SeedBuilder.config.default_seeds_path}: seeding"
-        require default_seeds_rb
-        puts "== #{SeedBuilder.config.default_seeds_path}: seeded (#{(Time.current - started_at).round(4)}s)"
+        logger.tagged("seed") do
+          logger.info "== #{SeedBuilder.config.default_seeds_path}: seeding"
+        end
+        load default_seeds_rb
+        logger.tagged("seed") do
+          logger.info "== #{SeedBuilder.config.default_seeds_path}: seeded (#{(Time.current - started_at).round(4)}s)"
+        end
       end
 
       base_path = SeedBuilder.config.seeds_full_path
@@ -22,29 +20,139 @@ module SeedBuilder
         Dir[SeedBuilder.config.seeds_path_glob]
           .map { |f| File.basename(f, ".*") }
           .each do |seed_path|
-            require "#{base_path}/#{seed_path}.rb"
+            load "#{base_path}/#{seed_path}.rb"
             timestamp, klass_name = seed_path.scan(/^([0-9]+)_(.+)$/).first
             next if klass_name.blank?
 
-            klass = klass_name.camelize.constantize
-            puts "== #{timestamp} #{klass.name}: seeding"
-            started_at = Time.current
-            seed_instance = klass.new
-            if seed_instance.respond_to?(:change)
-              seed_instance.change
-            else
-              raise "Seed #{klass.name} does not respond to :change"
-            end
-            puts "== #{timestamp} #{klass.name}: seeded (#{(Time.current - started_at).round(4)}s)"
-          rescue ActiveRecord::RecordInvalid => e
-            puts "Seeding #{klass.name} failed: #{e.record.errors.full_messages}"
-            raise e
+            execute_seed_class(klass_name, timestamp)
           end
       else
-        puts "Seed directory #{base_path} does not exist"
+        logger.tagged("seed") do
+          logger.warn "Seed directory #{base_path} does not exist"
+        end
       end
+    end
+
+    def load_seed_file(seed_name)
+      prepare_active_record
 
-      Rails.logger = initial_logger
+      base_path = SeedBuilder.config.seeds_full_path
+      unless File.exist?(base_path)
+        logger.tagged("seed") do
+          logger.warn "Seed directory #{base_path} does not exist"
+        end
+        return
+      end
+
+      # Find the seed file by name
+      # Supports: "create_users", "20241206200111_create_users", "20241206200111"
+      result = find_seed_file(base_path, seed_name)
+
+      if result.nil?
+        logger.tagged("seed") do
+          logger.warn "Seed file '#{seed_name}' not found in #{base_path}"
+        end
+        return
+      elsif result == :ambiguous
+        matches = find_seed_file_matches(base_path, seed_name)
+        logger.tagged("seed") do
+          logger.warn "Multiple seed files match '#{seed_name}':"
+          matches.each do |file|
+            logger.warn "  - #{File.basename(file, ".*")}"
+          end
+          logger.warn "Please be more specific using the full name with timestamp (e.g., 20241206200111_create_users)"
+        end
+        return
+      end
+
+      seed_file = result
+
+      seed_path = File.basename(seed_file, ".*")
+      timestamp, klass_name = seed_path.scan(/^([0-9]+)_(.+)$/).first
+
+      if klass_name.blank?
+        logger.tagged("seed") do
+          logger.warn "Invalid seed file format: #{seed_path}. Expected format: TIMESTAMP_CLASS_NAME.rb"
+        end
+        return
+      end
+
+      load seed_file
+      execute_seed_class(klass_name, timestamp, seed_name)
+    end
+
+    private
+
+    def logger
+      SeedBuilder.logger
+    end
+
+    def prepare_active_record
+      ActiveRecord::Base.connection.schema_cache.clear!
+      ActiveRecord::Base.descendants.each(&:reset_column_information)
+    end
+
+    def execute_seed_class(klass_name, timestamp, seed_name = nil)
+      klass = klass_name.camelize.constantize
+      klass_name_display = klass.name
+      logger.tagged("seed") do
+        logger.info "== #{timestamp} #{klass_name_display}: seeding"
+      end
+      started_at = Time.current
+      seed_instance = klass.new
+      if seed_instance.respond_to?(:change)
+        seed_instance.change
+      else
+        raise "Seed #{klass_name_display} does not respond to :change"
+      end
+      logger.tagged("seed") do
+        logger.info "== #{timestamp} #{klass_name_display}: seeded (#{(Time.current - started_at).round(4)}s)"
+      end
+    rescue ActiveRecord::RecordInvalid => e
+      klass_name_display = defined?(klass) ? klass.name : (klass_name&.camelize || seed_name || klass_name)
+      logger.tagged("seed") do
+        logger.error "Seeding #{klass_name_display} failed: #{e.record.errors.full_messages}"
+      end
+      raise e
+    rescue => e
+      logger.tagged("seed") do
+        logger.error "Error loading seed: #{e.message}"
+      end
+      raise e
+    end
+
+    def find_seed_file(base_path, seed_name)
+      # Try exact match first
+      exact_match = File.join(base_path, "#{seed_name}.rb")
+      return exact_match if File.exist?(exact_match)
+
+      # Collect all matching files
+      matches = find_seed_file_matches(base_path, seed_name)
+
+      # Return appropriate result based on number of matches
+      case matches.length
+      when 0
+        nil
+      when 1
+        matches.first
+      else
+        :ambiguous
+      end
+    end
+
+    def find_seed_file_matches(base_path, seed_name)
+      matches = []
+      Dir[SeedBuilder.config.seeds_path_glob].each do |file|
+        basename = File.basename(file, ".*")
+        # Match by class name (e.g., "create_users")
+        if basename.end_with?("_#{seed_name}") || basename == seed_name
+          matches << file
+        # Match by timestamp (e.g., "20241206200111")
+        elsif basename.start_with?("#{seed_name}_")
+          matches << file
+        end
+      end
+      matches
     end
   end
 end

data/lib/seed_builder/railtie.rb

@@ -0,0 +1,15 @@
+module SeedBuilder
+  class Railtie < ::Rails::Railtie
+    config.to_prepare do
+      if SeedBuilder.config.use_seed_loader?
+        # Patch Rails.application.load_seed to use our custom loader
+        Rails.application.class.class_eval do
+          define_method(:load_seed) do
+            loader = SeedBuilder::Loader.new
+            loader.load_seed
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seed_builder.rb

@@ -1,8 +1,9 @@
+require "active_support/tagged_logging"
 require "seed_builder/config"
 require "seed_builder/loader"
 
 module SeedBuilder
-  VERSION = "1.2.1".freeze
+  VERSION = "1.3.0".freeze
 
   module_function
 
@@ -13,6 +14,26 @@ module SeedBuilder
   def configure
     yield config
   end
+
+  def logger
+    # Use configured logger if set
+    base_logger = if config.logger
+      config.logger
+    elsif defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+      Rails.logger
+    else
+      Logger.new($stdout)
+    end
+
+    # If the logger already supports tagging (e.g., Rails.logger is already TaggedLogging),
+    # use it directly to avoid double-wrapping and ensure tags propagate properly
+    if base_logger.respond_to?(:tagged)
+      base_logger
+    else
+      ActiveSupport::TaggedLogging.new(base_logger)
+    end
+  end
 end
 
 require "rails_config"
+require "seed_builder/railtie" if defined?(Rails::Railtie)

data/lib/tasks/seed.rake

@@ -0,0 +1,22 @@
+namespace :seed do
+  desc "Run a specific seed file by name"
+  task :run, [:seed_name] => :environment do |_task, args|
+    if args[:seed_name].nil? || args[:seed_name].empty?
+      puts "Usage: bin/rails seed:run[SEED_NAME]"
+      puts ""
+      puts "Run a specific seed file by name."
+      puts ""
+      puts "Examples:"
+      puts "  bin/rails seed:run[create_users]"
+      puts "  bin/rails seed:run[20241206200111_create_users]"
+      puts "  bin/rails seed:run[20241206200111]"
+      puts ""
+      puts "Note: If multiple seed files match the name, use the full name with"
+      puts "      timestamp to avoid ambiguity (e.g., 20241206200111_create_users)."
+      exit 1
+    end
+
+    loader = SeedBuilder::Loader.new
+    loader.load_seed_file(args[:seed_name])
+  end
+end

data/seed_builder.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |gem|
   gem.platform = Gem::Platform::RUBY
 
   gem.authors = ["Andrei Makarov"]
-  gem.email = ["andrei@kiskolabs.com"]
+  gem.email = ["contact@kiskolabs.com"]
   gem.homepage = repository_url
   gem.summary = "Seed builder with loader and generator"
   gem.description = "Extension for ActiveRecord to organize seeds in a directory and generate them as migrations"
@@ -23,15 +23,15 @@ Gem::Specification.new do |gem|
     "rubygems_mfa_required" => "true"
   }
 
-  gem.files = `git ls-files`.split("\n")
+  gem.files = `git ls-files`.split("\n").reject { |f| f.match?(%r{^(test|spec|features)/}) }
   gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
 
   gem.required_ruby_version = ">= 3"
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "rails", ">= 6", "< 8.1"
-  gem.add_dependency "activerecord", ">= 6", "< 8.1"
+  gem.add_dependency "rails", ">= 6.1", "< 8.2"
+  gem.add_dependency "activerecord", ">= 6.1", "< 8.2"
 
   gem.add_development_dependency "bundler", "~> 2"
   gem.add_development_dependency "rspec", "~> 3"
@@ -39,4 +39,7 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "simplecov", "~> 0.21"
   gem.add_development_dependency "simplecov-cobertura", "~> 2"
   gem.add_development_dependency "sqlite3", "~> 2.4"
+  gem.add_development_dependency "standard", "~> 1.0"
+  gem.add_development_dependency "rbs", "~> 3.0"
+  gem.add_development_dependency "appraisal", "~> 2.4"
 end

data/sig/seed_builder/config.rbs

@@ -0,0 +1,22 @@
+module SeedBuilder
+  class Config
+    def default_seeds_path: () -> String
+    def default_seeds_path=: (String) -> String
+    def default_seeds_full_path: () -> Pathname
+    def default_seeds_full_path=: (Pathname) -> Pathname
+    def seeds_path: () -> String
+    def seeds_path=: (String) -> String
+    def seeds_full_path: () -> Pathname
+    def seeds_full_path=: (Pathname) -> Pathname
+    def seeds_path_glob: () -> String
+    def load_default_seeds?: () -> bool
+    def load_default_seeds=: (bool) -> bool
+    def load_seeds?: () -> bool
+    def load_seeds=: (bool) -> bool
+    def generate_spec?: () -> bool
+    def generate_spec=: (bool) -> bool
+    def use_seed_loader?: () -> bool
+    def use_seed_loader=: (bool) -> bool
+  end
+end
+

data/sig/seed_builder/loader.rbs

@@ -0,0 +1,8 @@
+module SeedBuilder
+  class Loader
+    def initialize: () -> void
+    def load_seed: () -> void
+    def load_seed_file: (String seed_name) -> void
+  end
+end
+

data/sig/seed_builder/railtie.rbs

@@ -0,0 +1,5 @@
+module SeedBuilder
+  class Railtie < ::Rails::Railtie
+  end
+end
+

data/sig/seed_builder.rbs

@@ -0,0 +1,7 @@
+module SeedBuilder
+  VERSION: String
+
+  def self.config: () -> Config
+  def self.configure: () { (Config) -> void } -> void
+end
+

data/spec/seed_builder/config_spec.rb

@@ -1,5 +1,14 @@
 require "spec_helper"
 
+# Define Rails module if not already defined
+unless defined?(Rails)
+  module Rails
+    class << self
+      attr_accessor :root, :env, :logger
+    end
+  end
+end
+
 describe SeedBuilder::Config do
   subject(:config) { described_class.new }
 
@@ -30,4 +39,10 @@ describe SeedBuilder::Config do
   it "has default seeds_path_glob" do
     expect(config.seeds_path_glob).to eq Rails.root.join("db/seeds/*.rb").to_s
   end
+
+  it "allows setting a custom logger" do
+    custom_logger = Logger.new($stdout)
+    config.logger = custom_logger
+    expect(config.logger).to eq custom_logger
+  end
 end

data/spec/seed_builder/loader_spec.rb

@@ -1,5 +1,14 @@
 require "spec_helper"
 
+# Define Rails module if not already defined
+unless defined?(Rails)
+  module Rails
+    class << self
+      attr_accessor :root, :env, :logger
+    end
+  end
+end
+
 class SeedBuilderUser < ActiveRecord::Base; end
 
 class SeedUser < SeedBuilderUser; end
@@ -7,29 +16,284 @@ class SeedUser < SeedBuilderUser; end
 describe SeedBuilder::Loader do
   subject(:loader) { described_class.new }
 
-  describe "#load_seed" do
-    let(:load_default_seeds) { true }
-    let(:load_seeds) { true }
-    let(:logger) { Logger.new($stdout) }
+  let(:logger) { Logger.new($stdout) }
+  let(:seeds_path) { File.expand_path("../../fixtures/seeds", __FILE__) }
+  let(:default_seeds_path) { File.expand_path("../../fixtures/seeds.rb", __FILE__) }
+
+  before do
+    allow(Rails).to receive(:root).and_return(rails_root)
+    allow(Rails).to receive(:env).and_return(rails_env)
+    allow(Rails).to receive(:logger).and_return(logger)
+    allow(Rails).to receive(:logger=)
+    # Reset SeedBuilder logger to pick up the stubbed Rails.logger
+    SeedBuilder.instance_variable_set(:@logger, nil) if SeedBuilder.instance_variable_defined?(:@logger)
 
+    SeedBuilder.configure do |config|
+      config.seeds_full_path = seeds_path
+      config.default_seeds_full_path = default_seeds_path
+      config.load_default_seeds = true
+      config.load_seeds = true
+    end
+  end
+
+  describe "#load_seed" do
     before do
-      allow(Rails).to receive(:root).and_return(rails_root)
-      allow(Rails).to receive(:env).and_return(rails_env)
-      allow(Rails).to receive(:logger).and_return(logger)
-      allow(Rails).to receive(:logger=)
+      SeedUser.delete_all
+      SeedBuilderUser.delete_all
+    end
+
+    context "when loading default seeds" do
+      let(:load_default_seeds) { true }
+      let(:load_seeds) { true }
 
-      SeedBuilder.configure do |config|
-        config.seeds_full_path = File.expand_path("../../fixtures/seeds", __FILE__)
-        config.default_seeds_full_path = File.expand_path("../../fixtures/seeds.rb", __FILE__)
-        config.load_default_seeds = load_default_seeds
-        config.load_seeds = load_seeds
+      before do
+        SeedBuilder.configure do |config|
+          config.load_default_seeds = load_default_seeds
+          config.load_seeds = load_seeds
+        end
+        loader.load_seed
+      end
+
+      it "loads the seeds" do
+        expect(SeedUser.count).to eq 1
+        expect(SeedBuilderUser.count).to eq 1
       end
-      loader.load_seed
     end
 
-    it "loads the seeds" do
-      expect(SeedUser.count).to eq 1
-      expect(SeedBuilderUser.count).to eq 1
+    context "when seeds directory does not exist" do
+      let(:log_output) { StringIO.new }
+      let(:test_logger) { Logger.new(log_output) }
+
+      before do
+        allow(Rails).to receive(:logger).and_return(test_logger)
+        # Reset SeedBuilder logger to pick up the stubbed Rails.logger
+        SeedBuilder.instance_variable_set(:@logger, nil) if SeedBuilder.instance_variable_defined?(:@logger)
+        SeedBuilder.configure do |config|
+          config.seeds_full_path = "/non/existent/path"
+          config.load_default_seeds = false
+          config.load_seeds = true
+        end
+      end
+
+      it "outputs a message" do
+        loader.load_seed
+        expect(log_output.string).to match(/Seed directory.*does not exist/)
+      end
+    end
+  end
+
+  describe "#load_seed_file" do
+    context "when loading by class name" do
+      before do
+        SeedBuilderUser.delete_all
+        loader.load_seed_file("create_users")
+      end
+
+      it "loads the specific seed file" do
+        expect(SeedBuilderUser.count).to eq 1
+        expect(SeedBuilderUser.first.email).to eq "test@example.com"
+      end
+    end
+
+    context "when loading by full name" do
+      before do
+        SeedBuilderUser.delete_all
+        loader.load_seed_file("20241206200111_create_users")
+      end
+
+      it "loads the specific seed file" do
+        expect(SeedBuilderUser.count).to eq 1
+      end
+    end
+
+    context "when loading by timestamp" do
+      before do
+        SeedBuilderUser.delete_all
+        loader.load_seed_file("20241206200111")
+      end
+
+      it "loads the specific seed file" do
+        expect(SeedBuilderUser.count).to eq 1
+      end
+    end
+
+    context "when seed file does not exist" do
+      let(:log_output) { StringIO.new }
+      let(:test_logger) { Logger.new(log_output) }
+
+      before do
+        allow(Rails).to receive(:logger).and_return(test_logger)
+        # Reset SeedBuilder logger to pick up the stubbed Rails.logger
+        SeedBuilder.instance_variable_set(:@logger, nil) if SeedBuilder.instance_variable_defined?(:@logger)
+      end
+
+      it "outputs an error message" do
+        loader.load_seed_file("nonexistent_seed")
+        expect(log_output.string).to match(/Seed file 'nonexistent_seed' not found/)
+      end
+
+      it "does not raise an error" do
+        expect { loader.load_seed_file("nonexistent_seed") }.not_to raise_error
+      end
+    end
+
+    context "when multiple seed files match the name" do
+      let(:seed_path_1) { File.expand_path("../../tmp/rspec/db/seeds/20241206200111_create_users.rb", __FILE__) }
+      let(:seed_path_2) { File.expand_path("../../tmp/rspec/db/seeds/20241206200112_create_users.rb", __FILE__) }
+      let(:log_output) { StringIO.new }
+      let(:test_logger) { Logger.new(log_output) }
+
+      before do
+        allow(Rails).to receive(:logger).and_return(test_logger)
+        # Reset SeedBuilder logger to pick up the stubbed Rails.logger
+        SeedBuilder.instance_variable_set(:@logger, nil) if SeedBuilder.instance_variable_defined?(:@logger)
+        FileUtils.mkdir_p(File.dirname(seed_path_1))
+        File.write(seed_path_1, "class CreateUsers; def change; end; end")
+        File.write(seed_path_2, "class CreateUsers; def change; end; end")
+        SeedBuilder.configure do |config|
+          config.seeds_full_path = File.dirname(seed_path_1)
+        end
+      end
+
+      after do
+        File.delete(seed_path_1) if File.exist?(seed_path_1)
+        File.delete(seed_path_2) if File.exist?(seed_path_2)
+      end
+
+      it "outputs an error message listing all matching files" do
+        loader.load_seed_file("create_users")
+        expect(log_output.string).to match(
+          /Multiple seed files match 'create_users':.*20241206200111_create_users.*20241206200112_create_users.*Please be more specific/m
+        )
+      end
+
+      it "does not raise an error" do
+        expect { loader.load_seed_file("create_users") }.not_to raise_error
+      end
+
+      it "works when using the full name with timestamp" do
+        SeedBuilderUser.delete_all
+        loader.load_seed_file("20241206200111_create_users")
+        expect(log_output.string).not_to match(/Multiple seed files/)
+        expect(SeedBuilderUser.count).to eq 0 # The seed doesn't actually create anything, just checks it runs
+      end
+    end
+
+    context "when seeds directory does not exist" do
+      let(:log_output) { StringIO.new }
+      let(:test_logger) { Logger.new(log_output) }
+
+      before do
+        allow(Rails).to receive(:logger).and_return(test_logger)
+        # Reset SeedBuilder logger to pick up the stubbed Rails.logger
+        SeedBuilder.instance_variable_set(:@logger, nil) if SeedBuilder.instance_variable_defined?(:@logger)
+        SeedBuilder.configure do |config|
+          config.seeds_full_path = "/non/existent/path"
+        end
+      end
+
+      it "outputs an error message" do
+        loader.load_seed_file("create_users")
+        expect(log_output.string).to match(/Seed directory.*does not exist/)
+      end
+
+      it "does not raise an error" do
+        expect { loader.load_seed_file("create_users") }.not_to raise_error
+      end
+    end
+
+    context "when seed file has invalid format" do
+      let(:invalid_seed_path) { File.expand_path("../../tmp/rspec/invalid_seed.rb", __FILE__) }
+      let(:log_output) { StringIO.new }
+      let(:test_logger) { Logger.new(log_output) }
+
+      before do
+        allow(Rails).to receive(:logger).and_return(test_logger)
+        # Reset SeedBuilder logger to pick up the stubbed Rails.logger
+        SeedBuilder.instance_variable_set(:@logger, nil) if SeedBuilder.instance_variable_defined?(:@logger)
+        FileUtils.mkdir_p(File.dirname(invalid_seed_path))
+        File.write(invalid_seed_path, "class InvalidSeed; end")
+        SeedBuilder.configure do |config|
+          config.seeds_full_path = File.dirname(invalid_seed_path)
+        end
+      end
+
+      after do
+        File.delete(invalid_seed_path) if File.exist?(invalid_seed_path)
+      end
+
+      it "outputs an error message" do
+        loader.load_seed_file("invalid_seed")
+        expect(log_output.string).to match(/Invalid seed file format/)
+      end
+
+      it "does not raise an error" do
+        expect { loader.load_seed_file("invalid_seed") }.not_to raise_error
+      end
+    end
+
+    context "when seed class does not respond to change" do
+      let(:invalid_seed_path) { File.expand_path("../../tmp/rspec/db/seeds/20241206200112_no_change.rb", __FILE__) }
+
+      before do
+        FileUtils.mkdir_p(File.dirname(invalid_seed_path))
+        File.write(invalid_seed_path, <<~RUBY)
+          class NoChange
+            # Does not have change method
+          end
+        RUBY
+        SeedBuilder.configure do |config|
+          config.seeds_full_path = File.dirname(invalid_seed_path)
+        end
+      end
+
+      after do
+        File.delete(invalid_seed_path) if File.exist?(invalid_seed_path)
+      end
+
+      it "raises an error" do
+        expect { loader.load_seed_file("no_change") }.to raise_error(/does not respond to :change/)
+      end
+    end
+
+    context "when seed raises RecordInvalid" do
+      let(:invalid_seed_path) { File.expand_path("../../tmp/rspec/db/seeds/20241206200113_invalid_record.rb", __FILE__) }
+      let(:log_output) { StringIO.new }
+      let(:test_logger) { Logger.new(log_output) }
+
+      before do
+        allow(Rails).to receive(:logger).and_return(test_logger)
+        # Reset SeedBuilder logger to pick up the stubbed Rails.logger
+        SeedBuilder.instance_variable_set(:@logger, nil) if SeedBuilder.instance_variable_defined?(:@logger)
+        # Add a validation to SeedBuilderUser to make save! fail
+        SeedBuilderUser.class_eval do
+          validates :email, presence: true
+        end
+
+        FileUtils.mkdir_p(File.dirname(invalid_seed_path))
+        File.write(invalid_seed_path, <<~RUBY)
+          class InvalidRecord
+            def change
+              user = SeedBuilderUser.new # Missing required email
+              user.save! # This will fail validation
+            end
+          end
+        RUBY
+        SeedBuilder.configure do |config|
+          config.seeds_full_path = File.dirname(invalid_seed_path)
+        end
+      end
+
+      after do
+        File.delete(invalid_seed_path) if File.exist?(invalid_seed_path)
+        # Remove the validation
+        SeedBuilderUser.reset_column_information
+      end
+
+      it "outputs error message and re-raises" do
+        expect { loader.load_seed_file("invalid_record") }.to raise_error(ActiveRecord::RecordInvalid)
+        expect(log_output.string).to match(/Seeding.*failed/)
+      end
     end
   end
 end