Merge pull request #3652 from akostadinov/tenant_id

[THREESCALE-7676] fix all alerts

app/workers/set_tenant_id_worker.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
 class SetTenantIdWorker < ApplicationJob
+  include Sidekiq::Throttled::Worker
+
   queue_as :low
+  sidekiq_throttle({ concurrency: { limit: 10 } })
 
-  RELATIONS = ["backend_apis", "log_entries", "alerts"].freeze
+  TENANT_RELATIONS = %w[backend_apis log_entries"]
+  ACCOUNT_RELATIONS = %w[alerts]
+  RELATIONS = (TENANT_RELATIONS + ACCOUNT_RELATIONS).freeze
 
-  def perform(provider, relations)
+  def perform(object, relations)
     relations.each do |relation|
-      assoc = provider.public_send(relation)
+      assoc = object.public_send(relation)
       assoc.select(:id).where(tenant_id: nil).find_in_batches(batch_size: 100) do |instances|
-        ModelTenantIdWorker.perform_later(assoc.klass, instances.map(&:id), provider.tenant_id)
+        ModelTenantIdWorker.perform_later(assoc.klass, instances.map(&:id), object.tenant_id)
       end
     end
   end
@@ -22,19 +27,38 @@ def self.validate_params(*relations)
       raise "you must pass relations to fix" if relations.empty?
       raise "Only relations #{RELATIONS} are supported" unless (relations - RELATIONS).empty?
     end
+
     delegate :validate_params, :to => :class
 
     def perform(*relations)
       validate_params(*relations)
 
-      Account.tenants.select(:id).find_each do |provider|
-        SetTenantIdWorker.perform_later(provider, relations)
+      enqueue_tenant_relations(relations)
+      enqueue_account_relations(relations)
+    end
+
+    def enqueue_scope(scope, relations)
+      scope.select(:id).find_each do |object|
+        SetTenantIdWorker.perform_later(object, relations)
       end
     end
+
+    def enqueue_tenant_relations(relations)
+      tenant_relations = relations & TENANT_RELATIONS
+      enqueue_scope(Account.tenants, tenant_relations) if tenant_relations.present?
+    end
+
+    def enqueue_account_relations(relations)
+      account_relations = relations & ACCOUNT_RELATIONS
+      enqueue_scope(Account.not_master, account_relations) if account_relations.present?
+    end
   end
 
   class ModelTenantIdWorker < ApplicationJob
+    include Sidekiq::Throttled::Worker
+
     queue_as :low
+    sidekiq_throttle({ concurrency: { limit: 10 } })
 
     def perform(model, ids, tenant_id)
       model.where(id: ids).update_all(tenant_id: tenant_id)

test/workers/set_tenant_id_worker_test.rb

@@ -31,6 +31,29 @@ class BatchEnqueueWorkerTest < ActiveSupport::TestCase
       assert_nil alert.reload.tenant_id
     end
 
+    test "account relations are also fixed for buyer accounts" do
+      provider = FactoryBot.create(:simple_provider)
+      buyer = FactoryBot.create(:simple_buyer, provider_account: provider)
+
+      assert_equal provider.id, buyer.reload.tenant_id
+
+      alert_provider = FactoryBot.create(:limit_alert, account: provider)
+      alert_buyer = FactoryBot.create(:limit_alert, account: buyer)
+
+      [alert_provider, alert_buyer].each do |alert|
+        assert_equal provider.id, alert.reload.tenant_id
+        alert.tenant_id = nil
+        assert_nil alert.tenant_id
+      end
+
+      perform_enqueued_jobs(only: [SetTenantIdWorker, SetTenantIdWorker::ModelTenantIdWorker]) do
+        SetTenantIdWorker::BatchEnqueueWorker.new.perform("backend_apis", "alerts")
+      end
+
+      assert_equal provider.id, alert_provider.reload.tenant_id
+      assert_equal provider.id, alert_buyer.reload.tenant_id
+    end
+
     test "raises on empty params" do
       assert_raises do
         SetTenantIdWorker::BatchEnqueueWorker.new.perform