seed_builder 1.3.0 → 1.3.1

data/spec/seed_builder/loader_spec.rb

@@ -1,299 +0,0 @@
-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
-
-describe SeedBuilder::Loader do
-  subject(:loader) { described_class.new }
-
-  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
-      SeedUser.delete_all
-      SeedBuilderUser.delete_all
-    end
-
-    context "when loading default seeds" do
-      let(:load_default_seeds) { true }
-      let(:load_seeds) { true }
-
-      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
-    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"
-          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

data/spec/seed_builder/railtie_spec.rb

@@ -1,118 +0,0 @@
-require "spec_helper"
-
-# Define Rails::Railtie stub for testing
-unless defined?(Rails::Railtie)
-  module Rails
-    class Railtie
-      def self.config
-        @config ||= Class.new do
-          def to_prepare(&block)
-            @to_prepare_blocks ||= []
-            if block_given?
-              @to_prepare_blocks << block
-            end
-            self
-          end
-
-          def call_to_prepare
-            (@to_prepare_blocks || []).each(&:call)
-          end
-        end.new
-      end
-    end
-  end
-end
-
-# Load the Railtie manually since it's conditionally required
-require_relative "../../lib/seed_builder/railtie"
-
-class SeedBuilderUser < ActiveRecord::Base; end
-class SeedUser < SeedBuilderUser; end
-
-describe SeedBuilder::Railtie do
-  let(:app_class) do
-    Class.new do
-      def initialize
-        @prepared = false
-      end
-
-      def load_seed
-        # Default implementation - should be patched by Railtie
-        raise "Original load_seed called"
-      end
-
-      def prepare!
-        @prepared = true
-      end
-
-      def prepared?
-        @prepared
-      end
-    end
-  end
-
-  let(:rails_application) { app_class.new }
-  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
-    # Set up Rails.application mock
-    # In Rails, Rails.application.class_eval works because Rails.application is an instance
-    # and class_eval is called on it, which modifies the class.
-    # We need to stub this properly.
-    allow(Rails).to receive(:application).and_return(rails_application)
-    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=)
-
-    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
-      config.use_seed_loader = true
-    end
-
-    # Clear any existing data
-    SeedUser.delete_all
-    SeedBuilderUser.delete_all
-  end
-
-  describe "Rails.application.load_seed integration" do
-    context "when use_seed_loader is enabled" do
-      before do
-        # Ensure rails_application is created before calling to_prepare
-        # so that Rails.application returns the correct instance
-        rails_application
-        # Simulate Rails initialization by running the Railtie's to_prepare blocks
-        SeedBuilder::Railtie.config.call_to_prepare
-      end
-
-      it "patches Rails.application.load_seed to use SeedBuilder loader" do
-        expect { rails_application.load_seed }.not_to raise_error
-      end
-
-      it "loads seeds using SeedBuilder loader" do
-        rails_application.load_seed
-        expect(SeedUser.count).to eq 1
-        expect(SeedBuilderUser.count).to eq 1
-      end
-    end
-
-    context "when use_seed_loader is disabled" do
-      before do
-        SeedBuilder.configure do |config|
-          config.use_seed_loader = false
-        end
-        # Simulate Rails initialization by running the Railtie's to_prepare blocks
-        SeedBuilder::Railtie.config.call_to_prepare
-      end
-
-      it "does not patch Rails.application.load_seed" do
-        expect { rails_application.load_seed }.to raise_error("Original load_seed called")
-      end
-    end
-  end
-end

data/spec/seed_builder_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-describe SeedBuilder do
-  let(:gem_specification) { Gem::Specification.load(File.expand_path("../../seed_builder.gemspec", __FILE__)) }
-
-  it "has a version number" do
-    expect(described_class::VERSION).to eq gem_specification.version.to_s
-  end
-
-  let(:changelog_file) { File.expand_path("../../CHANGELOG.md", __FILE__) }
-  it "has changelog for the version" do
-    expect(File.exist?(changelog_file)).to be true
-    expect(File.read(changelog_file)).to include("# #{gem_specification.version}")
-  end
-
-  let(:license_file) { File.expand_path("../../LICENSE.md", __FILE__) }
-  it "has license" do
-    expect(File.exist?(license_file)).to be true
-  end
-
-  let(:readme_file) { File.expand_path("../../README.md", __FILE__) }
-  it "has readme" do
-    expect(File.exist?(readme_file)).to be true
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-require "simplecov"
-SimpleCov.start do
-  add_filter "/spec/"
-  add_filter { |source_file| source_file.lines.count < 5 }
-end
-
-require "simplecov-cobertura"
-SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
-
-# Fix for Rails 6.1 compatibility: require Logger before ActiveRecord
-# to avoid "uninitialized constant ActiveSupport::LoggerThreadSafeLevel::Logger" error
-require "logger"
-require "active_record"
-
-require "seed_builder"
-
-Dir[File.expand_path("support/**/*.rb", __dir__)].each { |f| require_relative f }
-
-RSpec.configure do |config|
-  include RailsHelpers
-
-  config.before(:suite) do
-    ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-    load File.expand_path("../fixtures/schema.rb", __FILE__)
-  end
-end

data/spec/support/junit_formatter.rb

@@ -1,6 +0,0 @@
-if ENV["CI"]
-  require "rspec_junit_formatter"
-  RSpec.configure do |config|
-    config.add_formatter RspecJunitFormatter, "coverage/junit-coverage.xml"
-  end
-end

data/spec/support/rails_helpers.rb

@@ -1,41 +0,0 @@
-module RailsHelpers
-  def rails_root(destination_root = File.expand_path("../../tmp/rspec", __dir__))
-    Class.new do
-      def initialize(destination_root)
-        @destination_root = destination_root
-      end
-
-      def to_s
-        @destination_root
-      end
-
-      def join(*args)
-        File.join(@destination_root, *args)
-      end
-    end.new(destination_root)
-  end
-
-  def rails_env(env = "development")
-    Class.new do
-      def initialize(env)
-        @env = env.to_s
-      end
-
-      def development?
-        @env == "development"
-      end
-
-      def test?
-        @env == "test"
-      end
-
-      def production?
-        @env == "production"
-      end
-
-      def to_s
-        @env
-      end
-    end.new(env)
-  end
-end

data/usr/bin/release.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-
-set -e
-
-e() {
-  GREEN='\033[0;32m'
-  NC='\033[0m'
-  echo -e "${GREEN}$1${NC}"
-  eval "$1"
-}
-
-e "bundle"
-e "bundle exec rspec"
-
-if [[ $(git diff --shortstat 2>/dev/null | tail -n1) != "" ]]; then
-  echo -e "\033[1;31mgit working directory not clean, please commit your changes first \033[0m"
-  exit 1
-fi
-
-GEM_NAME="seed_builder"
-VERSION=$(grep -Eo "VERSION\s*=\s*\".+\"" lib/seed_builder.rb | grep -Eo "[0-9.]{5,}")
-GEM_FILE="$GEM_NAME-$VERSION.gem"
-
-e "gem build $GEM_NAME.gemspec"
-
-echo "Ready to release $GEM_FILE $VERSION"
-read -p "Continue? [Y/n] " answer
-if [[ "$answer" != "Y" ]]; then
-  echo "Exiting"
-  exit 1
-fi
-
-e "gem push $GEM_FILE"
-e "git tag $VERSION && git push --tags"
-e "gh release create $VERSION --generate-notes"