has_helpers 5.0.2

data/spec/utils/sync_utils_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe HasHelpers::SyncUtils, type: :module do
+  describe ".apply_mapping" do
+    let(:resource_key) { :user }
+
+    let!(:user) { FactoryBot.create(:user, last_name: "Name", username: "oldemail@example.com") }
+
+    context "when there is no custom mapping" do
+      let(:external_data) do
+        {
+          "lastName" => "Doe",
+          "username" => "john.doe@example.com"
+        }
+      end
+
+      before do
+        HasHelpers.config.sync_custom_mapping = {}
+      end
+
+      it "updates the resource with the external data" do
+        described_class.apply_mapping(user, external_data, resource_key: resource_key)
+
+        expect(user.reload.last_name).to eq("Doe")
+        expect(user.reload.username).to eq("john.doe@example.com")
+      end
+    end
+
+    context "when there is a custom mapping" do
+      let(:external_data_two) do
+        {
+          "lastName" => "Anna",
+          "username" => "john.doe@example.com"
+        }
+      end
+
+      let(:external_data_nil) do
+        {
+          "lastName" => nil,
+          "username" => "nil.name@example.com"
+        }
+      end
+
+      before do
+        HasHelpers.config.sync_custom_mapping = {
+          user: {
+            last_name: ->(data) { data[:last_name] },
+            username: :username
+          }
+        }
+      end
+
+      it "applies the mapping and updates the resource" do
+        described_class.apply_mapping(user, external_data_two, resource_key: resource_key)
+
+        expect(user.reload.last_name).to eq("Anna")
+        expect(user.reload.username).to eq("john.doe@example.com")
+      end
+    end
+
+    context "when the record is new (create)" do
+      let(:external_data_new_user) do
+        {
+          "id" => SecureRandom.uuid,
+          "name" => "Jeff",
+          "lastName" => "Newbie",
+          "username" => "new.user@example.com"
+        }
+      end
+
+      before do
+        HasHelpers.config.sync_custom_mapping = {
+          user: {
+            name: :name,
+            last_name: ->(data) { data[:last_name] },
+            username: :username
+          }
+        }
+      end
+
+      it "creates a new user with the mapped attributes" do
+        new_user = User.new(id: external_data_new_user["id"])
+        result = described_class.apply_mapping(new_user, external_data_new_user, resource_key: resource_key)
+
+        expect(result).to eq(true)
+        created_user = User.find(external_data_new_user["id"])
+        expect(created_user.last_name).to eq("Newbie")
+        expect(created_user.username).to eq("new.user@example.com")
+      end
+    end
+
+    context "when the resource is marked for destruction" do
+      let(:external_data_to_destroy) do
+        {
+          "id" => user.id
+        }
+      end
+
+      before do
+        HasHelpers.config.sync_custom_mapping = {}
+      end
+
+      it "destroys the resource" do
+        # Ensure that the user exists
+        expect(User.exists?(user.id)).to be(true)
+
+        # Mark the resource for destruction
+        result = described_class.apply_mapping(user, external_data_to_destroy, resource_key: resource_key, is_destroyed: true)
+
+        expect(result).to eq(true)
+        expect(User.exists?(user.id)).to be(false)
+      end
+    end
+  end
+
+  describe ".deep_transform_keys_to_snake_case" do
+    it "deserializes aj_serialized objects" do
+      date_example = Time.zone.now
+      data = ActiveJob::Serializers.serialize(date_example)
+      expect(data.class).to eq(Hash) # aj serialized objects are serialized into a hash
+
+      result = described_class.deep_transform_keys_to_snake_case(data)
+      expect(result.class).to eq(ActiveSupport::TimeWithZone)
+      expect(result).to eq(date_example)
+    end
+
+    it "transforms a simple hash" do
+      data = { "lastName" => "Doe" }
+      result = described_class.deep_transform_keys_to_snake_case(data)
+
+      expect(result).to eq({ last_name: "Doe" })
+    end
+
+    it "transforms a nested hash" do
+      data = { "user" => { "lastName" => "Doe" } }
+      result = described_class.deep_transform_keys_to_snake_case(data)
+
+      expect(result).to eq({ user: { last_name: "Doe" } })
+    end
+
+    it "transforms an array of hashes" do
+      data = [
+        { "lastName" => "Doe" },
+        { "lastName" => "Smith" }
+      ]
+      result = described_class.deep_transform_keys_to_snake_case(data)
+
+      expect(result).to eq([
+        { last_name: "Doe" },
+        { last_name: "Smith" }
+      ])
+    end
+
+    it "returns non-hash and non-array data unchanged" do
+      expect(described_class.deep_transform_keys_to_snake_case("Some String")).to eq("Some String")
+      expect(described_class.deep_transform_keys_to_snake_case(123)).to eq(123)
+    end
+  end
+
+  describe ".save_with_result" do
+    it "returns true when the resource saves successfully" do
+      resource = instance_double(User, save: true)
+
+      result = described_class.save_with_result(resource)
+
+      expect(result).to eq(true)
+    end
+
+    it "returns validation messages when the resource save fails" do
+      errors = instance_double(ActiveModel::Errors, full_messages: ["Username can't be blank"])
+      resource = instance_double(User, save: false, errors: errors)
+
+      result = described_class.save_with_result(resource)
+
+      expect(result).to eq("Username can't be blank")
+    end
+  end
+
+  describe ".handle_destruction" do
+    it "returns true when destruction succeeds" do
+      errors = instance_double(ActiveModel::Errors, full_messages: [])
+      resource = instance_double(User, id: SecureRandom.uuid, destroy: true, errors: errors)
+
+      result = described_class.handle_destruction(resource)
+
+      expect(result).to eq(true)
+    end
+
+    it "returns validation messages when destruction fails" do
+      errors = instance_double(ActiveModel::Errors, full_messages: ["Cannot delete while linked records exist"])
+      resource = instance_double(User, id: SecureRandom.uuid, destroy: false, errors: errors)
+
+      result = described_class.handle_destruction(resource)
+
+      expect(result).to include("Cannot delete while linked records exist")
+    end
+  end
+
+  describe ".touch_dependencies!" do
+    let!(:user) { FactoryBot.create(:user) }
+
+    it "touches dependency records when ids are present" do
+      previous_updated_at = 2.days.ago.change(usec: 0)
+      user.update_columns(updated_at: previous_updated_at)
+
+      described_class.touch_dependencies!({ "user_id" => user.id }, ["user"])
+
+      expect(user.reload.updated_at).to be >= previous_updated_at
+    end
+
+    it "logs warning and does not raise when a dependency record is missing" do
+      allow(Rails.logger).to receive(:warn)
+
+      expect do
+        described_class.touch_dependencies!({ "user_id" => SecureRandom.uuid }, ["user"])
+      end.not_to raise_error
+
+      expect(Rails.logger).to have_received(:warn).with(include("Could not touch dependency user"))
+    end
+
+    it "is a no-op when dependencies are empty" do
+      allow(Rails.logger).to receive(:warn)
+
+      expect do
+        described_class.touch_dependencies!({ "user_id" => user.id }, [])
+      end.not_to raise_error
+
+      expect(Rails.logger).not_to have_received(:warn)
+    end
+  end
+end

data/spec/workers/goodjob/elasticsearch_process_batch_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe GoodJob::ElasticsearchProcessBatch, type: :worker do
+  let(:index_class_name) { "TestIndex" }
+  let(:index_name) { "test_index" }
+  let(:record_ids) { Array.new(2) { Faker::Internet.uuid } }
+  let(:view_name) { "test_view" }
+
+  let(:org_id) { Faker::Number.number(digits: 3) }
+
+  let(:record_data) do
+    [
+      {
+        "id" => record_ids.first,
+        "name" => Faker::Name.name,
+        "organization_id" => org_id,
+        "numbers" => "{1,2,3}"
+      }
+    ]
+  end
+
+  let(:column_types) do
+    {
+      "id" => double("Type"),
+      "name" => double("Type"),
+      "organization_id" => double("Type"),
+      "numbers" => instance_double(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array, deserialize: [1, 2, 3])
+    }
+  end
+
+  let(:active_record_double) { double(primary_key: "id") }
+
+  let(:index_class) do
+    class_double("TestIndex",
+      view_name: view_name,
+      active_record: active_record_double,
+      type: "_doc",
+      is_global?: false,
+      index_name: index_name,
+      keyword_search_index_name: "#{index_name}_keyword",
+      all_values_from_attributes: {},
+      name: index_class_name
+    )
+  end
+
+	let(:select_result) do
+		double("ActiveRecord::Result").tap do |result|
+			allow(result).to receive(:to_a).and_return(record_data)
+			allow(result).to receive(:each).and_return(record_data.each)
+			allow(result).to receive(:map) { |&block| block ? record_data.map(&block) : record_data.map }
+			allow(result).to receive(:column_types).and_return(column_types)
+		end
+	end
+
+	before do
+		stub_const("TestIndex", index_class)
+
+		allow(ActiveRecord::Base.connection).to receive(:select_all).and_return(select_result)
+		allow(::HasHelpers::Index).to receive(:default_attributes).and_return({ name: Faker::Name.name })
+		allow(Searchkick).to receive_message_chain(:client, :indices, :exists_alias?).and_return(true)
+		allow(Searchkick.indexer).to receive(:queue)
+	end
+
+
+  it "queues documents when index exists" do
+    described_class.new.perform(index_class_name, index_name, record_ids)
+
+    expect(Searchkick.indexer).to have_received(:queue).with(array_including(
+      hash_including(
+        index: hash_including(
+          _id: record_ids.first.to_s,
+          routing: org_id,
+          data: hash_including(organization_id: org_id)
+        )
+      )
+    ))
+  end
+
+	it "retries the job if index is unknown" do
+		allow(index_class).to receive(:index_name).and_return(index_name)
+		allow(index_class).to receive(:keyword_search_index_name).and_return(index_name)
+
+		allow(Searchkick).to receive_message_chain(:client, :indices, :exists_alias?).and_return(false)
+
+		worker = described_class.new
+		allow(worker).to receive(:retry_job)
+
+		worker.perform(index_class_name, index_name, record_ids)
+
+		expect(worker).to have_received(:retry_job).with(wait: 1.minute)
+	end
+end

data/spec/workers/goodjob/elasticsearch_process_change_logs_master_worker_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require "rails_helper"
+
+RSpec.describe GoodJob::ElasticsearchProcessChangeLogsMasterWorker, type: :worker do
+  describe "#perform" do
+    it "enqueues one processor job for each indexed model and dependency model" do
+      advisor_index = double(
+        "AdvisorIndex",
+        model: Advisor,
+        depends_on: [{ "Contract" => { dependent_attributes: %w[writing_number] } }]
+      )
+      firm_index = double("FirmIndex", model: Firm, depends_on: [])
+
+      allow(::HasHelpers::Index).to receive(:indices).and_return([advisor_index, firm_index])
+      allow(GoodJob::ElasticsearchProcessChangeLogsWorker).to receive(:perform_later)
+
+      described_class.perform_now
+
+      expect(GoodJob::ElasticsearchProcessChangeLogsWorker).to have_received(:perform_later).with("Advisor").once
+      expect(GoodJob::ElasticsearchProcessChangeLogsWorker).to have_received(:perform_later).with("Firm").once
+      expect(GoodJob::ElasticsearchProcessChangeLogsWorker).to have_received(:perform_later).with("Contract").once
+    end
+
+    it "skips dependencies that cannot be constantized" do
+      index = double(
+        "AdvisorIndex",
+        model: Advisor,
+        depends_on: [{ "MissingDependencyClass" => { dependent_attributes: %w[name] } }]
+      )
+
+      allow(::HasHelpers::Index).to receive(:indices).and_return([index])
+      allow(GoodJob::ElasticsearchProcessChangeLogsWorker).to receive(:perform_later)
+
+      described_class.perform_now
+
+      expect(GoodJob::ElasticsearchProcessChangeLogsWorker).to have_received(:perform_later).with("Advisor").once
+      expect(GoodJob::ElasticsearchProcessChangeLogsWorker).not_to have_received(:perform_later).with("MissingDependencyClass")
+    end
+  end
+end

data/spec/workers/goodjob/elasticsearch_process_change_logs_worker_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require "rails_helper"
+
+RSpec.describe GoodJob::ElasticsearchProcessChangeLogsWorker, type: :worker do
+  describe "#perform" do
+    let(:worker) { described_class.new }
+    let(:change_log) do
+      double(
+        "ChangeLog",
+        id: 123,
+        record_id: "456",
+        table_name: Advisor.table_name,
+        type: "update",
+        changed_columns: ["name"]
+      )
+    end
+    let(:relation) do
+      double("ChangeLogRelation").tap do |rel|
+        allow(rel).to receive(:find_each).and_yield(change_log)
+      end
+    end
+    let(:advisor) { instance_double("Advisor", id: 456, try: 1) }
+    let(:normal_queue) { instance_double("HasHelpers::ReindexQueue", push: true) }
+    let(:keyword_queue) { instance_double("HasHelpers::ReindexQueue", push: true) }
+
+    before do
+      # ChangeLog is a host-app model; the worker only checks `defined?(::ChangeLog)`
+      # and reaches it via `build_query`, which is stubbed below. A plain class stub
+      # avoids class_double loading the real AR model (no `change_logs` table in the dummy).
+      stub_const("ChangeLog", Class.new)
+      allow(worker).to receive(:build_query).with(Advisor).and_return(relation)
+      allow(worker).to receive(:constantize_index_class).with(Advisor).and_return(AdvisorIndex)
+      allow(worker).to receive(:define_inheritance_search)
+      allow(worker).to receive(:has_dependencies?).and_return(false)
+      allow(Advisor).to receive(:find_by).with(id: "456").and_return(advisor)
+      allow(AdvisorIndex).to receive(:reindex_queue).and_return(normal_queue)
+      allow(AdvisorIndex).to receive(:keyword_reindex_queue).and_return(keyword_queue)
+      allow(GoodJob::ElasticsearchProcessQueue).to receive(:perform_later)
+    end
+
+    it "queues pending change logs for normal and keyword Elasticsearch indices" do
+      worker.perform("Advisor")
+
+      expect(normal_queue).to have_received(:push).with("456", 123, routing_key: 1)
+      expect(keyword_queue).to have_received(:push).with("456", 123, routing_key: 1)
+      expect(GoodJob::ElasticsearchProcessQueue).to have_received(:perform_later).with("AdvisorIndex", AdvisorIndex.index_name)
+      expect(GoodJob::ElasticsearchProcessQueue).to have_received(:perform_later).with("AdvisorIndex", AdvisorIndex.keyword_search_index_name)
+    end
+
+    it "does nothing when ChangeLog is not available in the host app" do
+      hide_const("ChangeLog")
+
+      worker.perform("Advisor")
+
+      expect(normal_queue).not_to have_received(:push)
+      expect(keyword_queue).not_to have_received(:push)
+      expect(GoodJob::ElasticsearchProcessQueue).not_to have_received(:perform_later)
+    end
+  end
+
+  describe "#has_dependencies?" do
+    let(:worker) { described_class.new }
+
+    it "matches dependency table names and changed attributes" do
+      index = double("AdvisorIndex", depends_on: [{ "Contract" => { dependent_attributes: %w[writing_number] } }])
+      change_log = double("ChangeLog", table_name: "contracts", type: "update", changed_columns: ["writing_number"])
+
+      allow(::HasHelpers::Index).to receive(:indices).and_return([index])
+
+      expect(worker.send(:has_dependencies?, change_log)).to eq(true)
+    end
+
+    it "does not match unrelated changed attributes" do
+      index = double("AdvisorIndex", depends_on: [{ "Contract" => { dependent_attributes: %w[writing_number] } }])
+      change_log = double("ChangeLog", table_name: "contracts", type: "update", changed_columns: ["updated_at"])
+
+      allow(::HasHelpers::Index).to receive(:indices).and_return([index])
+
+      expect(worker.send(:has_dependencies?, change_log)).to eq(false)
+    end
+  end
+end

data/spec/workers/goodjob/elasticsearch_process_queue_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+require "rails_helper"
+
+RSpec.describe GoodJob::ElasticsearchProcessQueue, type: :worker do
+  let(:index_class_name) { "TestIndex" }
+  let(:index_name) { "test_index" }
+  let(:limit) { 100 }
+  let(:starting_time) { Process.clock_gettime(Process::CLOCK_MONOTONIC) - Faker::Number.within(range: 1..5) }
+
+  let(:record_ids) { Array.new(limit) { Faker::Number.number(digits: 5).to_s } }
+  let(:key) { Faker::Lorem.unique.word }
+
+  let(:records) { record_ids.map { |id| { record_id: id, key: key, routing_key: nil } } }
+  let(:reindex_queue) { double(reserve: records) }
+
+  let(:index_class) do
+    class_double("TestIndex",
+      name: "TestIndex",
+      reindex_queue: reindex_queue,
+      keyword_reindex_queue: reindex_queue
+    )
+  end
+
+  let(:batch) do
+    instance_double(GoodJob::Batch,
+      properties: {
+        index_class_name: index_class_name,
+        record_ids_count: record_ids.size,
+        key: key,
+        starting_time: starting_time
+      }
+    )
+  end
+
+  before do
+		stat_instance = instance_double("Stat")
+		stat_class = class_double("Stat", new: stat_instance, save_to_stats: nil)
+		stub_const("Stat", stat_class)
+
+    stub_const("TestIndex", index_class)
+    allow(GoodJob::ElasticsearchProcessBatch).to receive(:perform_later)
+    allow(GoodJob::ElasticsearchProcessQueue).to receive(:perform_later)
+    allow(::HasHelpers::Feature).to receive(:active?).with(:elasticsearch_reindex_stat).and_return(true)
+    allow(::Stat).to receive(:save_to_stats)
+    allow(::HasHelpers::Index).to receive(:after_index)
+    allow(Searchkick).to receive_message_chain(:client, :indices, :exists_alias?).and_return(true)
+
+		@stat_instance = stat_instance
+  end
+
+  describe "#perform" do
+    it "calls perform_later and re-enqueues if needed" do
+      described_class.new.perform(index_class_name, index_name)
+
+      routing_map = record_ids.each_with_object({}) { |id, h| h[id] = nil }
+      expect(GoodJob::ElasticsearchProcessBatch).to have_received(:perform_later)
+        .with(index_class_name, index_name, record_ids, routing_map)
+      expect(GoodJob::ElasticsearchProcessQueue).to have_received(:perform_later)
+        .with(index_class_name, index_name)
+    end
+  end
+
+  describe ".on_success" do
+    it "saves stats and calls after_index if the feature flag is active" do
+      described_class.on_success(batch, nil)
+
+      expect(::Stat).to have_received(:save_to_stats).with(
+        @stat_instance,
+        "::GoodJob::ElasticsearchProcessQueue",
+        "elasticsearch",
+        index_class_name,
+        { record_ids_count: limit },
+        kind_of(Float),
+        kind_of(Float)
+      )
+
+      expect(::HasHelpers::Index).to have_received(:after_index).with(key)
+    end
+
+    it "skips saving stats if the feature flag is inactive" do
+      allow(::HasHelpers::Feature).to receive(:active?).with(:elasticsearch_reindex_stat).and_return(false)
+
+      described_class.on_success(batch, nil)
+
+      expect(::Stat).not_to have_received(:save_to_stats)
+      expect(::HasHelpers::Index).to have_received(:after_index).with(key)
+    end
+  end
+end

data/spec/workers/goodjob/elasticsearch_reindex_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe GoodJob::ElasticsearchReindex, type: :worker do
+  let(:index_class_name) { "TestIndex" }
+  let(:index_name) { "test_index" }
+
+  let(:id1) { Faker::Number.number(digits: 5) }
+  let(:id2) { Faker::Number.number(digits: 5) }
+
+  let(:active_record_double) { double(select: double(to_sql: "SELECT id FROM test_table")) }
+
+  let(:index_class) do
+    double("TestIndex",
+      name: "TestIndex",
+      active_record: active_record_double,
+      promote: nil,
+      keyword_reindex_queue: [],
+      reindex_queue: [],
+      update_settings: nil
+    )
+  end
+
+  let(:cursor_double) do
+    double("Cursor").tap do |c|
+      allow(c).to receive(:next).and_return(
+        [{ "id" => id1 }, { "id" => id2 }],
+        nil
+      )
+    end
+  end
+
+  before do
+    stub_const("TestIndex", index_class)
+    allow(Cursor).to receive(:execute).and_yield(cursor_double)
+    allow(GoodJob::ElasticsearchProcessBatch).to receive(:perform_deferred_bulk)
+    allow(GoodJob::ElasticsearchProcessQueue).to receive(:perform_deferred)
+  end
+
+  describe "#perform" do
+    it "enqueues process batch jobs from cursor" do
+      described_class.new.perform(index_class_name, index_name)
+
+      expect(GoodJob::ElasticsearchProcessBatch).to have_received(:perform_deferred_bulk)
+        .with([[index_class_name, index_name, [id1, id2]]])
+    end
+  end
+end