has_helpers 5.0.2

data/spec/lib/has_helpers/data_migration/base_spec.rb

@@ -0,0 +1,470 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::DataMigration::Base do
+  # Dummy class to override `run`
+  class DummyMigration < described_class
+    self.idempotent = false
+    self.urgent = true
+
+    def run
+      "dummy run"
+    end
+  end
+
+  describe "#internal_run" do
+    let(:model) { double("model", update: true, started_at: nil) }
+
+    before do
+      allow(DummyMigration).to receive(:model).and_return(model)
+      allow(DummyMigration).to receive(:idempotent?).and_return(true)
+      allow(::Rails.logger).to receive(:info)
+    end
+
+    it "runs the migration and logs" do
+      expect(model).to receive(:update).with(started_at: kind_of(Time))
+      expect(model).to receive(:update).with(completed_at: kind_of(Time))
+
+      DummyMigration.new.send(:internal_run)
+
+      expect(::Rails.logger).to have_received(:info).with(/started/)
+      expect(::Rails.logger).to have_received(:info).with(/completed/)
+    end
+
+    it "calls upload_migrate_output if S3 constants are defined" do
+      stub_const("DummyMigration::BUCKET_NAME", "bucket-test")
+      stub_const("DummyMigration::S3_FILE_PATH", "some/path/output")
+
+      allow(model).to receive(:update).with(started_at: kind_of(Time))
+      allow(model).to receive(:update).with(completed_at: kind_of(Time))
+
+      # Stubear el método para solo verificar que se llamó
+      dummy_instance = DummyMigration.new
+      allow(dummy_instance).to receive(:upload_migrate_output)
+
+      dummy_instance.send(:internal_run)
+
+      expect(dummy_instance).to have_received(:upload_migrate_output)
+    end
+  end
+
+  describe "#upload_migrate_output" do
+    let(:dummy_instance) { DummyMigration.new }
+    let(:file_content) { ["line 1", "line 2"] }
+
+    before do
+      stub_const("DummyMigration::BUCKET_NAME", "bucket-test")
+      stub_const("DummyMigration::S3_FILE_PATH", "some/path/output")
+
+      allow(DummyMigration).to receive(:get_s3_key).and_return("final/path/output.txt")
+
+      allow(::HasHelpers::DataMigration::Model).to receive(:where).and_return(double(first_or_create: double))
+
+      s3_client = instance_double("Aws::S3::Client")
+      allow(::HasHelpers::Aws).to receive(:new_s3_client).and_return(s3_client)
+      allow(s3_client).to receive(:put_object)
+
+      dummy_instance.send(:upload_migrate_output, file_content)
+    end
+
+    it "writes the file and uploads to S3" do
+      expect(::HasHelpers::Aws).to have_received(:new_s3_client)
+      expect(::HasHelpers::DataMigration::Model).to have_received(:where).with(class_name: "DummyMigration")
+      expect(::HasHelpers::Aws.new_s3_client).to have_received(:put_object).with(
+        bucket: "bucket-test",
+        key: "final/path/output.txt",
+        body: kind_of(Tempfile)
+      )
+    end
+  end
+
+  describe ".enqueue" do
+    let(:model) { double("model", update: true) }
+    let(:worker_klass) { class_double("WorkerClass") }
+
+    before do
+      allow(DummyMigration).to receive(:model).and_return(model)
+      allow(DummyMigration).to receive(:worker_klass).and_return(worker_klass)
+      allow(worker_klass).to receive(:perform_later)
+    end
+
+    it "updates enqueued_at and calls perform_later with class name" do
+      freeze_time do
+        DummyMigration.enqueue
+
+        expect(model).to have_received(:update).with(enqueued_at: Time.zone.now)
+        expect(worker_klass).to have_received(:perform_later).with(DummyMigration.name)
+      end
+    end
+  end
+
+  describe ".continue_in_one_minute" do
+    let(:model) { double("model", update: true) }
+    let(:worker_klass) { class_double("WorkerClass") }
+    let(:set_proxy) { double("ActiveJob::Set") }
+    let(:current_time) { Time.current }
+
+    before do
+      allow(DummyMigration).to receive(:model).and_return(model)
+      allow(DummyMigration).to receive(:worker_klass).and_return(worker_klass)
+      allow(worker_klass).to receive(:set).with(wait: 1.minute).and_return(set_proxy)
+      allow(set_proxy).to receive(:perform_later)
+    end
+
+    it "updates enqueued_at and schedules job to run in 1 minute" do
+      freeze_time do
+        DummyMigration.continue_in_one_minute
+
+        expect(model).to have_received(:update).with(enqueued_at: Time.zone.now)
+        expect(worker_klass).to have_received(:set).with(wait: 1.minute)
+        expect(set_proxy).to have_received(:perform_later).with(DummyMigration.name)
+      end
+    end
+  end
+
+  describe ".rerun" do
+    let(:model) { double("model") }
+
+    it "resets timestamps and enqueues" do
+      allow(DummyMigration).to receive(:model).and_return(model)
+      expect(model).to receive(:update).with(enqueued_at: nil, started_at: nil, completed_at: nil)
+      DummyMigration.rerun
+    end
+  end
+
+  describe "#dependencies_met?" do
+    context "when there are no dependencies" do
+      before do
+        allow(DummyMigration).to receive(:dependencies).and_return([])
+      end
+
+      it "returns true" do
+        expect(DummyMigration.dependencies_met?).to eq(true)
+      end
+    end
+
+    context "when all dependencies have completed" do
+      let(:deps) { ["Dependency1", "Dependency2"] }
+
+      before do
+        allow(DummyMigration).to receive(:dependencies).and_return(deps)
+        deps.each do |dep|
+          allow(DummyMigration).to receive(:dependency_has_completed).with(dep).and_return(Time.current)
+        end
+      end
+
+      it "returns true" do
+        expect(DummyMigration.dependencies_met?).to eq(true)
+      end
+    end
+
+    context "when any dependency has not completed" do
+      let(:deps) { ["Dependency1", "Dependency2"] }
+
+      before do
+        allow(DummyMigration).to receive(:dependencies).and_return(deps)
+        allow(DummyMigration).to receive(:dependency_has_completed).with("Dependency1").and_return(Time.current)
+        allow(DummyMigration).to receive(:dependency_has_completed).with("Dependency2").and_return(nil)
+      end
+
+      it "returns false" do
+        expect(DummyMigration.dependencies_met?).to eq(false)
+      end
+    end
+  end
+
+  describe ".enqueued?" do
+    it "returns true if enqueued_at is present" do
+      allow(DummyMigration).to receive(:model).and_return(double(enqueued_at: Time.current))
+      expect(DummyMigration.enqueued?).to eq(true)
+    end
+
+    it "returns false if enqueued_at is nil" do
+      allow(DummyMigration).to receive(:model).and_return(double(enqueued_at: nil))
+      expect(DummyMigration.enqueued?).to eq(false)
+    end
+  end
+  
+  describe ".started?" do
+    it "returns true if started_at is present" do
+      allow(DummyMigration).to receive(:model).and_return(double(started_at: Time.current))
+      expect(DummyMigration.started?).to eq(true)
+    end
+
+    it "returns false if started_at is nil" do
+      allow(DummyMigration).to receive(:model).and_return(double(started_at: nil))
+      expect(DummyMigration.started?).to eq(false)
+    end
+  end
+
+  describe ".complete?" do
+    it "returns true if completed_at is present" do
+      allow(DummyMigration).to receive(:model).and_return(double(completed_at: Time.current))
+      expect(DummyMigration.complete?).to eq(true)
+    end
+
+    it "returns false if completed_at is nil" do
+      allow(DummyMigration).to receive(:model).and_return(double(completed_at: nil))
+      expect(DummyMigration.complete?).to eq(false)
+    end
+  end
+
+  describe ".ready?" do
+    before do
+      allow(described_class).to receive(:dependencies_met?).and_return(true)
+      allow(described_class).to receive(:complete?).and_return(false)
+      allow(described_class).to receive(:run_in_current_environment?).and_return(true)
+      allow(described_class).to receive(:valid_to_start_now?).and_return(true)
+    end
+
+    context "when all conditions are true and migration is idempotent" do
+      before do
+        allow(described_class).to receive(:idempotent?).and_return(true)
+      end
+
+      it "returns true" do
+        expect(described_class.ready?).to eq(true)
+      end
+    end
+
+    context "when all conditions are true and migration is not idempotent" do
+      before do
+        allow(described_class).to receive(:idempotent?).and_return(false)
+      end
+
+      context "and migration has not started" do
+        before do
+          allow(described_class).to receive(:started?).and_return(false)
+        end
+
+        it "returns true" do
+          expect(described_class.ready?).to eq(true)
+        end
+      end
+
+      context "and migration has started" do
+        before do
+          allow(described_class).to receive(:started?).and_return(true)
+        end
+
+        it "returns nil (falsey)" do
+          expect(described_class.ready?).to be_nil
+        end
+      end
+    end
+
+    context "when dependencies_met? is false" do
+      before do
+        allow(described_class).to receive(:dependencies_met?).and_return(false)
+      end
+
+      it "returns nil (falsey)" do
+        expect(described_class.ready?).to be_nil
+      end
+    end
+
+    context "when complete? is true" do
+      before do
+        allow(described_class).to receive(:complete?).and_return(true)
+      end
+
+      it "returns nil (falsey)" do
+        expect(described_class.ready?).to be_nil
+      end
+    end
+
+    context "when run_in_current_environment? is false" do
+      before do
+        allow(described_class).to receive(:run_in_current_environment?).and_return(false)
+      end
+
+      it "returns nil (falsey)" do
+        expect(described_class.ready?).to be_nil
+      end
+    end
+
+    context "when valid_to_start_now? is false" do
+      before do
+        allow(described_class).to receive(:valid_to_start_now?).and_return(false)
+      end
+
+      it "returns nil (falsey)" do
+        expect(described_class.ready?).to be_nil
+      end
+    end
+  end
+
+  describe ".valid_to_start_now?" do
+    before do
+      allow(described_class).to receive(:urgent?).and_return(false)
+    end
+
+    around do |example|
+      Time.use_zone("Central Time (US & Canada)") do
+        example.run
+      end
+    end
+
+    it "returns true if urgent?" do
+      allow(described_class).to receive(:urgent?).and_return(true)
+      expect(described_class.valid_to_start_now?).to eq(true)
+    end
+
+    it "returns true if today is not a business day" do
+      allow(Date).to receive(:current).and_return(Date.new(2025, 6, 7)) # saturday
+      allow(Date.current).to receive(:business_day?).and_return(false)
+      expect(described_class.valid_to_start_now?).to eq(true)
+    end
+
+    context "when urgent? is false and today is a business day" do
+      before do
+        allow(Date).to receive(:current).and_return(Date.new(2025, 6, 5)) # thursday
+        allow(Date.current).to receive(:business_day?).and_return(true)
+        allow(described_class).to receive(:urgent?).and_return(false)
+      end
+
+      it "returns true if time is before 7 AM" do
+        time = Time.zone.parse("06:59:59")
+        allow(Time).to receive(:current).and_return(time)
+        expect(described_class.valid_to_start_now?).to eq(true)
+      end
+
+      it "returns true if time is within last 5 hours of the day" do
+        time = Time.zone.parse("20:01:00") # assuming 24h = 0, so 20:01 is last 4h approx
+        allow(Time).to receive(:current).and_return(time)
+        expect(described_class.valid_to_start_now?).to eq(true)
+      end
+
+      it "returns false if time is between 7 AM and last 5 hours of day" do
+        time = Time.zone.parse("12:00:00")
+        allow(Time).to receive(:current).and_return(time)
+        expect(described_class.valid_to_start_now?).to eq(false)
+      end
+    end
+  end
+
+  describe ".idempotent?" do
+    before { described_class.instance_variable_set(:@idempotent, nil) }
+
+    it "returns false by default" do
+      expect(described_class.idempotent?).to eq(false)
+    end
+
+    it "returns true when set" do
+      described_class.idempotent = true
+      expect(described_class.idempotent?).to eq(true)
+    end
+  end
+
+  describe ".dependencies" do
+    before { described_class.instance_variable_set(:@depends_on, nil) }
+
+    it "returns empty array by default" do
+      expect(described_class.dependencies).to eq([])
+    end
+
+    it "returns dependencies when set" do
+      described_class.depends_on = "OtherMigration"
+      expect(described_class.dependencies).to eq(["OtherMigration"])
+    end
+  end
+
+  describe ".expected_duration" do
+    before { described_class.instance_variable_set(:@expected_duration, nil) }
+
+    it "returns default of 24 hours" do
+      expect(described_class.expected_duration).to eq(24.hours)
+    end
+
+    it "returns custom duration when set" do
+      described_class.expected_duration = 36.hours
+      expect(described_class.expected_duration).to eq(36.hours)
+    end
+  end
+
+  describe ".is_large?" do
+    before { described_class.instance_variable_set(:@expected_duration, nil) }
+
+    it "returns true for default duration" do
+      expect(described_class.is_large?).to eq(true)
+    end
+
+    it "returns true for > 12h" do
+      described_class.expected_duration = 13.hours
+      expect(described_class.is_large?).to eq(true)
+    end
+
+    it "returns false for <= 12h" do
+      described_class.expected_duration = 2.hours
+      expect(described_class.is_large?).to eq(false)
+    end
+  end
+
+  describe ".model" do
+    it "finds or creates model based on class name" do
+      model_instance = DummyMigration.send(:model)
+      expect(model_instance).to be_a(HasHelpers::DataMigration::Model)
+      expect(model_instance.class_name).to eq("DummyMigration")
+      expect(DummyMigration.send(:model).id).to eq(model_instance.id)
+    end
+  end
+
+  describe ".start!" do
+    let(:model) { double("model") }
+
+    it "updates started_at" do
+      allow(DummyMigration).to receive(:model).and_return(model)
+      expect(model).to receive(:update).with(started_at: kind_of(Time))
+      DummyMigration.send(:start!)
+    end
+  end
+
+  describe ".complete!" do
+    let(:model) { double("model") }
+
+    it "updates completed_at" do
+      allow(DummyMigration).to receive(:model).and_return(model)
+      expect(model).to receive(:update).with(completed_at: kind_of(Time))
+      DummyMigration.send(:complete!)
+    end
+  end
+
+  describe ".dependency_has_completed" do
+    let(:dependency_class_name) { Faker::Name.name }
+
+    context "when no record is found" do
+      it "returns nil" do
+        expect(described_class.send(:dependency_has_completed, dependency_class_name)).to be_nil
+      end
+    end
+
+    context "when a record is found without completed_at" do
+      before do
+        HasHelpers::DataMigration::Model.create!(class_name: dependency_class_name)
+      end
+
+      it "returns nil" do
+        expect(described_class.send(:dependency_has_completed, dependency_class_name)).to be_nil
+      end
+    end
+
+    context "when a record is found with completed_at set" do
+      it "returns the completed_at timestamp" do
+        freeze_time do
+          completed_time = Time.current
+
+          FactoryBot.create(
+            :data_migration_model,
+            class_name: dependency_class_name,
+            completed_at: completed_time
+          )
+
+          expect(
+            described_class.send(:dependency_has_completed, dependency_class_name)
+          ).to eq(completed_time)
+        end
+      end
+    end
+  end
+end

data/spec/lib/has_helpers/data_migration/large_worker_spec.rb

@@ -0,0 +1,34 @@
+require "rails_helper"
+
+RSpec.describe HasHelpers::DataMigration::LargeWorker, type: :job do
+  let(:dummy_class) do
+    Class.new do
+      def internal_run; end
+    end
+  end
+
+  let(:class_name) { "DummyMigrationClass" }
+
+  before do
+    stub_const(class_name, dummy_class)
+  end
+
+  it "calls internal_run on the given class" do
+    instance = instance_double(dummy_class)
+    allow(dummy_class).to receive(:new).and_return(instance)
+    expect(instance).to receive(:internal_run)
+
+    described_class.perform_now(class_name)
+  end
+
+  it "is enqueued in the data_migrations_large queue" do
+    expect(described_class.queue_name).to eq("data_migrations_large")
+  end
+
+  it "has concurrency limit configured" do
+    concurrency = described_class.good_job_concurrency_config
+
+    expect(concurrency[:perform_limit]).to eq(1)
+    expect(concurrency[:key]).to eq("data_migration-large")
+  end
+end

data/spec/lib/has_helpers/data_migration/master_worker_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::DataMigration::MasterWorker, type: :job do
+  describe "#perform" do
+    before do
+      HasHelpers::DataMigration::Model.delete_all
+      allow(::HasHelpers::DataMigration::Migrator).to receive(:run_async)
+    end
+
+    it "calls Migrator.run_async" do
+      described_class.perform_now
+      expect(::HasHelpers::DataMigration::Migrator).to have_received(:run_async)
+    end
+
+    context "when a migration has blank klass" do
+      let!(:invalid_migration) do
+        FactoryBot.create(:data_migration_model, started_at: 1.hour.ago, completed_at: nil, class_name: "NonExistentClass")
+      end
+
+      before do
+        allow_any_instance_of(::HasHelpers::DataMigration::Model).to receive(:klass).and_return(nil)
+      end
+
+      it "logs and destroys the migration" do
+        expect {
+          described_class.perform_now
+        }.to change(::HasHelpers::DataMigration::Model, :count).by(-1)
+      end
+    end
+
+    context "when a migration has exceeded expected duration" do
+      let!(:expired_migration) do
+        FactoryBot.create(:data_migration_model, started_at: 2.hours.ago, completed_at: nil, class_name: "ExistingMigration")
+      end
+
+      before do
+        stub_const("ExistingMigration", Class.new)
+        allow_any_instance_of(::HasHelpers::DataMigration::Model).to receive(:klass).and_return(ExistingMigration)
+        allow_any_instance_of(::HasHelpers::DataMigration::Model).to receive(:exceeded_expected_duration?).and_return(true)
+      end
+
+      it "logs the exceeded migration but does not delete it" do
+        expect {
+          described_class.perform_now
+        }.not_to change(::HasHelpers::DataMigration::Model, :count)
+      end
+    end
+  end
+end

data/spec/lib/has_helpers/data_migration/migrator_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::DataMigration::Migrator do
+  let(:model) { HasHelpers::DataMigration::Model.find_or_create_by!(class_name: "DummyMigration") }
+
+  before do
+    class DummyMigration < HasHelpers::DataMigration::Base
+      def run; end
+    end
+
+    allow(DummyMigration).to receive(:enqueued?).and_return(false)
+    allow(DummyMigration).to receive(:ready?).and_return(true)
+    allow_any_instance_of(DummyMigration).to receive(:internal_run)
+  end
+
+  describe ".migration_classes" do
+    it "includes the defined dummy migration class" do
+      expect(described_class.migration_classes).to include(DummyMigration)
+    end
+  end
+
+  describe ".non_queued_classes" do
+    it "includes only migrations that are not enqueued" do
+      expect(described_class.non_queued_classes).to include(DummyMigration)
+
+      allow(DummyMigration).to receive(:enqueued?).and_return(true)
+      expect(described_class.non_queued_classes).not_to include(DummyMigration)
+    end
+  end
+
+  describe ".run" do
+    context "when given a valid migration name" do
+      it "executes internal_run and updates the model" do
+        freeze_time do
+          expect_any_instance_of(DummyMigration).to receive(:internal_run)
+          expect {
+            described_class.run("DummyMigration")
+          }.to change { model.reload.enqueued_at }.from(nil).to(Time.zone.now)
+        end
+      end
+    end
+
+    context "when migration is already enqueued" do
+      it "skips execution" do
+        allow(DummyMigration).to receive(:enqueued?).and_return(true)
+        expect_any_instance_of(DummyMigration).not_to receive(:internal_run)
+        described_class.run("DummyMigration")
+      end
+    end
+
+    context "when migration is not ready" do
+      it "skips execution" do
+        allow(DummyMigration).to receive(:ready?).and_return(false)
+        expect_any_instance_of(DummyMigration).not_to receive(:internal_run)
+        described_class.run("DummyMigration")
+      end
+    end
+
+    context "when invalid class name is passed" do
+      it "prints an error and does not raise" do
+        expect {
+          described_class.run("NonExistentMigration")
+        }.to output(/not a valid DataMigration/).to_stdout
+      end
+    end
+
+    context "when migration is already complete" do
+      it "skips execution" do
+        allow(DummyMigration).to receive(:complete?).and_return(true)
+        expect {
+          described_class.run("DummyMigration")
+        }.to output(/already complete/).to_stdout
+      end
+    end
+  end
+
+  describe ".run_async" do
+    it "calls enqueue on ready and non-enqueued migrations" do
+      dummy = class_double("DummyMigration", ready?: true, enqueued?: false)
+
+      stub_const("DummyMigration", dummy)
+      allow(::HasHelpers::DataMigration::Base).to receive(:descendants).and_return([dummy])
+
+      expect(dummy).to receive(:enqueue)
+
+      described_class.run_async
+    end
+
+    it "does not call enqueue if migration is not ready" do
+      dummy = class_double("DummyMigration", ready?: false, enqueued?: false)
+
+      stub_const("DummyMigration", dummy)
+      allow(::HasHelpers::DataMigration::Base).to receive(:descendants).and_return([dummy])
+
+      expect(dummy).not_to receive(:enqueue)
+
+      described_class.run_async
+    end
+
+    it "does not call enqueue if migration is already enqueued" do
+      dummy = class_double("DummyMigration", ready?: true, enqueued?: true)
+
+      stub_const("DummyMigration", dummy)
+      allow(::HasHelpers::DataMigration::Base).to receive(:descendants).and_return([dummy])
+
+      expect(dummy).not_to receive(:enqueue)
+
+      described_class.run_async
+    end
+  end
+end