has_helpers 5.0.2

data/spec/lib/has_helpers/app/command/reports/generator_specs.rb

@@ -0,0 +1,887 @@
+# Ruby
+# frozen_string_literal: true
+
+require "rails_helper"
+require_relative "../../support/mocks/reports_api_mock"
+require_relative "../../support/mocks/graphql_reports_helpers"
+
+RSpec.describe Reports::Generator do
+  # Shared flatteners list for all examples in this file
+  let(:all_flatteners) do
+    %w[
+      Organization Sheet Text List Collection Phone Brand Row Campaign
+      CustomDomain DwDate ListFilter OptOut Price Project ProjectLink
+      ProjectPhone ProjectTeam ProjectTexter ShortenedLink Client StatusUpdate
+      Team User UserOrganization
+    ]
+  end
+
+  #========================
+  # .create_resources
+  #========================
+  describe ".create_resources" do
+    let(:all_expected_success_messages) do
+      all_flatteners.map { |name| "Successfully created resource for flattener #{name}" }
+    end
+
+    context "when a klass_name is provided" do
+      let(:resource_name) { "Organization" }
+
+      before do
+        # Simulates that the resource does not exist and is then created successfully
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name)
+                .with(hash_including(name: hash_including(klass_name: resource_name)))
+                .and_return(ReportsApiMock.query_resource_by_name_not_found)
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:create_resource)
+                .with(hash_including(
+                        attributes: hash_including(
+                          name: a_hash_including(klass_name: resource_name)
+                        )
+                      ))
+                .and_return(ReportsApiMock.create_resource_success(id: 1))
+      end
+
+      it "creates only the specified resource" do
+        result = described_class.create_resources(klass_name: resource_name)
+        expect(result).to eq(["Successfully created resource for flattener #{ { klass_name: resource_name }.inspect }"])
+      end
+    end
+
+    context "when klass_name is not provided" do
+      before do
+          # Define stub classes for each flattener
+          flattener_classes = all_flatteners.map { |name| stub_const("Flatteners::#{name}", Class.new(Flattener::Base)) }
+
+          # Stub all_flattener_classes to return the stubbed classes (replaces filesystem scan)
+          allow(described_class).to receive(:all_flattener_classes).and_return(flattener_classes)
+
+          # Stubs for ExternalGraphqlClient
+          allow(Reports::ExternalGraphqlClient)
+            .to receive(:query_resource_by_name) do |name:, **_kwargs|
+            expect(all_flatteners).to include(name),
+                                      "An unexpected flattener was queried: #{name}"
+            ReportsApiMock.query_resource_by_name_not_found
+          end
+
+          allow(Reports::ExternalGraphqlClient)
+            .to receive(:create_resource) do |mutation_name:, input_name:, attributes:|
+            expect(attributes).to include(:name)
+            expect(all_flatteners).to include(attributes[:name]),
+                                      "Tried to create an unexpected flattener: #{attributes[:name]}"
+            ReportsApiMock.create_resource_success(id: "1")
+          end
+        end
+
+        it "creates the resources for all flatteners in the defined list" do
+          result = described_class.create_resources
+          expect(result).to contain_exactly(*all_expected_success_messages)
+        end
+      end
+  end
+
+  #========================
+  # .check_resources
+  #========================
+  describe ".check_resources" do
+    let(:flatteners_list) { all_flatteners }
+    let(:flattener_classes) do
+      flatteners_list.map { |name| stub_const("Flatteners::#{name}", Class.new(Flattener::Base)) }
+    end
+
+    before do
+      stub_const("Flattener::Base", Class.new)
+      flattener_classes # trigger eager evaluation so stub_const runs before allow
+      allow(described_class).to receive(:all_flattener_classes).and_return(flattener_classes)
+    end
+
+    context "when GraphQL response is missing the 'data' key" do
+      it "logs an error and returns an empty array" do
+        expect(Reports::ExternalGraphqlClient)
+          .to receive(:query_all_resources)
+                .and_return({ "error" => "Request failed" })
+
+        expect(Rails.logger).to receive(:error).with(/Failed to fetch resources:/)
+
+        result = described_class.check_resources
+        expect(result).to eq([])
+      end
+    end
+
+    context "when all reported resources include every flattener (real-world case)" do
+      before do
+        # Build a resource array containing all names (mirroring a real output scenario)
+        resources = flatteners_list.map.with_index(155) do |name, idx|
+          { "id" => idx.to_s, "name" => name, "type" => "HasReports::Resource" }
+        end
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_all_resources)
+                .and_return(ReportsApiMock.query_all_resources_response(resources: resources))
+      end
+
+      it "returns an empty array and does not attempt to create resources" do
+        expect(described_class).not_to receive(:create_resources)
+        expect(Rails.logger).not_to receive(:info)
+
+        result = described_class.check_resources
+        expect(result).to eq([])
+      end
+    end
+
+    context "when a single flattener is missing (e.g., ProjectTeam)" do
+      let(:missing_name) { "ProjectTeam" }
+
+      before do
+        # Simulate a resource array where one flattener is missing
+        existing_names = flatteners_list - [missing_name]
+        resources = existing_names.map.with_index(155) do |name, idx|
+          { "id" => idx.to_s, "name" => name, "type" => "HasReports::Resource" }
+        end
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_all_resources)
+                .and_return(ReportsApiMock.query_all_resources_response(resources: resources))
+      end
+
+      it "returns the missing flattener class and triggers its creation" do
+        expect(described_class).to receive(:create_resources).with(missing_name).once
+
+        result = described_class.check_resources
+        expect(result).to match_array([Object.const_get("Flatteners::#{missing_name}")])
+      end
+    end
+
+    context "when some edges have nil nodes" do
+      before do
+        existing_names = flatteners_list.first(3)
+        resources = existing_names.map.with_index(155) do |name, idx|
+          { "id" => idx.to_s, "name" => name, "type" => "HasReports::Resource" }
+        end
+
+        # Inject a nil-node edge between valid ones
+        response = ReportsApiMock.query_all_resources_response(resources: resources)
+        response["data"]["resources"]["edges"].insert(1, { "node" => nil })
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_all_resources)
+                .and_return(response)
+      end
+
+      it "skips nil nodes without raising and processes the remaining edges" do
+        allow(described_class).to receive(:create_resources)
+        expect { described_class.check_resources }.not_to raise_error
+      end
+    end
+  end
+
+  #========================
+  # .generate_select_options
+  #========================
+  describe ".generate_select_options" do
+    let(:klass) { Class.new }
+    let(:resource_id) { 123 }
+    let(:options) { { any_opt: "value", another: 1 } }
+
+    it "delegates to each options module with proper arguments and concatenates in order" do
+      base_return     = [{ source: "base",     name: "base_opt" }]
+      constant_return = [{ source: "constant", name: "constant_opt" }]
+      belongs_return  = [{ source: "belongs",  name: "belongs_opt" }]
+      has_many_return = [{ source: "has_many", name: "has_many_opt" }]
+      nested_return   = [{ source: "nested",   name: "nested_opt" }]
+
+      expect(Reports::BaseOptions)
+        .to receive(:generate_select_options)
+              .with(klass, resource_id, hash_including(options))
+              .and_return(base_return)
+
+      expect(Reports::ConstantOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(constant_return)
+
+      expect(Reports::BelongsToOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(belongs_return)
+
+      expect(Reports::HasManyOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(has_many_return)
+
+      expect(Reports::NestedAttributeOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(nested_return)
+
+      result = described_class.generate_select_options(klass, resource_id, **options)
+
+      expect(result).to eq(
+                          base_return + constant_return + belongs_return + has_many_return + nested_return
+                        )
+    end
+
+    it "supports enumerables returned by generators (converted via to_a)" do
+      base_enum = Enumerator.new { |y| y << { source: "base" } }
+      constant_enum = Enumerator.new { |y| y << { source: "constant" } }
+      belongs_enum = Enumerator.new { |y| y << { source: "belongs" } }
+      has_many_enum = Enumerator.new { |y| y << { source: "has_many" } }
+      nested_enum = Enumerator.new { |y| y << { source: "nested" } }
+
+      allow(Reports::BaseOptions)
+        .to receive(:generate_select_options)
+              .with(klass, resource_id, hash_including(options))
+              .and_return(base_enum)
+
+      allow(Reports::ConstantOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(constant_enum)
+
+      allow(Reports::BelongsToOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(belongs_enum)
+
+      allow(Reports::HasManyOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(has_many_enum)
+
+      allow(Reports::NestedAttributeOptions)
+        .to receive(:generate_select_options)
+              .with(klass, hash_including(options))
+              .and_return(nested_enum)
+
+      result = described_class.generate_select_options(klass, resource_id, **options)
+
+      expect(result).to eq([
+                             { source: "base" },
+                             { source: "constant" },
+                             { source: "belongs" },
+                             { source: "has_many" },
+                             { source: "nested" }
+                           ])
+    end
+
+    it "returns an empty array when all generators return empty collections" do
+      allow(Reports::BaseOptions).to receive(:generate_select_options).and_return([])
+      allow(Reports::ConstantOptions).to receive(:generate_select_options).and_return([])
+      allow(Reports::BelongsToOptions).to receive(:generate_select_options).and_return([])
+      allow(Reports::HasManyOptions).to receive(:generate_select_options).and_return([])
+      allow(Reports::NestedAttributeOptions).to receive(:generate_select_options).and_return([])
+
+      result = described_class.generate_select_options(klass, resource_id)
+
+      expect(result).to eq([])
+    end
+
+    context "mirrors a real-world payload concatenation" do
+      let(:klass) { Class.new }
+      let(:resource_id) { "155" }
+
+      it "concatenates options in the same order as a real run" do
+        base_return = [
+          { name: "id",          columnType: "uuid",   associationColumnName: "id",          resourceId: "155" },
+          { name: "name",        columnType: "string", associationColumnName: "name",        resourceId: "155" },
+          { name: "header_row",  columnType: "text",   associationColumnName: "header_row",  resourceId: "155" }
+        ]
+
+        belongs_return = [
+          { name: "List",          selectOptionType: "BelongsTo", columnType: "uuid",    associationResourceId: 157, associationName: "list",         associationColumnName: "list_id",         joinType: "Inner" },
+          { name: "Created By",    selectOptionType: "BelongsTo", columnType: "uuid",    associationResourceId: 177, associationName: "created_by",   associationColumnName: "created_by_id",   joinType: "Left"  },
+          { name: "Organization",  selectOptionType: "BelongsTo", columnType: "integer", associationResourceId: 158, associationName: "organization", associationColumnName: "organization_id", joinType: "Inner" },
+          { name: "Organization",  selectOptionType: "BelongsTo", columnType: "integer", associationResourceId: 158, associationName: "organization", associationColumnName: "organization_id", joinType: "Inner" },
+          { name: "Updated By",    selectOptionType: "BelongsTo", columnType: "uuid",    associationResourceId: 177, associationName: "updated_by",   associationColumnName: "updated_by_id",   joinType: "Left"  },
+          { name: "Created At Date", selectOptionType: "BelongsTo", columnType: "datetime", associationResourceId: 164, associationName: "created_at", associationColumnName: "created_at", joinType: "Left" },
+          { name: "Updated At Date", selectOptionType: "BelongsTo", columnType: "datetime", associationResourceId: 164, associationName: "updated_at", associationColumnName: "updated_at", joinType: "Left" }
+        ]
+
+        has_many_return = [
+          { name: "Rows", associationResourceId: 161, associationName: "rows", columnType: "link", associationColumnName: "sheet_id", joinResourceId: 155, selectOptionType: "HasMany" }
+        ]
+
+        allow(Reports::ConstantOptions).to receive(:generate_select_options).and_return([])
+        allow(Reports::NestedAttributeOptions).to receive(:generate_select_options).and_return([])
+
+        expect(Reports::BaseOptions)
+          .to receive(:generate_select_options)
+                .with(klass, resource_id, any_args)
+                .and_return(base_return)
+
+        expect(Reports::BelongsToOptions)
+          .to receive(:generate_select_options)
+                .with(klass, any_args)
+                .and_return(belongs_return)
+
+        expect(Reports::HasManyOptions)
+          .to receive(:generate_select_options)
+                .with(klass, any_args)
+                .and_return(has_many_return)
+
+        result = described_class.generate_select_options(klass, resource_id)
+
+        expect(result).to eq(base_return + [] + belongs_return + has_many_return + [])
+      end
+    end
+  end
+
+  #========================
+  # .generate_filter_options
+  #========================
+  describe ".generate_filter_options" do
+    let(:klass) { Class.new }
+    let(:resource_id) { 123 }
+    let(:options) { { any_opt: "value", another: 1 } }
+
+    it "delegates to each options module with proper arguments and concatenates in order" do
+      base_return     = [{ source: "base",     name: "base_filter" }]
+      constant_return = [{ source: "constant", name: "constant_filter" }]
+      belongs_return  = [{ source: "belongs",  name: "belongs_filter" }]
+      has_many_return = [{ source: "has_many", name: "has_many_filter" }]
+      nested_return   = [{ source: "nested",   name: "nested_filter" }]
+
+      expect(Reports::BaseOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(base_return)
+
+      expect(Reports::ConstantOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(constant_return)
+
+      expect(Reports::BelongsToOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, resource_id, any_args)
+              .and_return(belongs_return)
+
+      expect(Reports::HasManyOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(has_many_return)
+
+      expect(Reports::NestedAttributeOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(nested_return)
+
+      result = described_class.generate_filter_options(klass, resource_id, **options)
+
+      expect(result).to eq(
+                          base_return + constant_return + belongs_return + has_many_return + nested_return
+                        )
+    end
+
+    it "supports enumerables returned by generators (converted via to_a)" do
+      base_enum = Enumerator.new { |y| y << { source: "base_f" } }
+      constant_enum = Enumerator.new { |y| y << { source: "constant_f" } }
+      belongs_enum = Enumerator.new { |y| y << { source: "belongs_f" } }
+      has_many_enum = Enumerator.new { |y| y << { source: "has_many_f" } }
+      nested_enum = Enumerator.new { |y| y << { source: "nested_f" } }
+
+      allow(Reports::BaseOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(base_enum)
+
+      allow(Reports::ConstantOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(constant_enum)
+
+      allow(Reports::BelongsToOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, resource_id, any_args)
+              .and_return(belongs_enum)
+
+      allow(Reports::HasManyOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(has_many_enum)
+
+      allow(Reports::NestedAttributeOptions)
+        .to receive(:generate_filter_options)
+              .with(klass, any_args)
+              .and_return(nested_enum)
+
+      result = described_class.generate_filter_options(klass, resource_id, **options)
+
+      expect(result).to eq([
+                             { source: "base_f" },
+                             { source: "constant_f" },
+                             { source: "belongs_f" },
+                             { source: "has_many_f" },
+                             { source: "nested_f" }
+                           ])
+    end
+
+    it "returns an empty array when all generators return empty collections" do
+      allow(Reports::BaseOptions).to receive(:generate_filter_options).and_return([])
+      allow(Reports::ConstantOptions).to receive(:generate_filter_options).and_return([])
+      allow(Reports::BelongsToOptions).to receive(:generate_filter_options).and_return([])
+      allow(Reports::HasManyOptions).to receive(:generate_filter_options).and_return([])
+      allow(Reports::NestedAttributeOptions).to receive(:generate_filter_options).and_return([])
+
+      result = described_class.generate_filter_options(klass, resource_id)
+
+      expect(result).to eq([])
+    end
+
+    context "mirrors a real-world payload concatenation" do
+      let(:klass) { Class.new }
+      let(:resource_id) { 155 }
+
+      it "concatenates options in the same order as a real run" do
+        base_return = [
+          { name: "ID",          associationColumnName: "id",          columnType: "uuid",  partialType: "Uuid",  operationType: "Equality" },
+          { name: "Name",        associationColumnName: "name",        columnType: "string", partialType: "Text",  operationType: "String"   },
+          { name: "Header Row",  associationColumnName: "header_row",  columnType: "text",   partialType: "Text",  operationType: "String"   }
+        ]
+
+        belongs_return = [
+          { name: "List",             filterOptionType: "BelongsTo", associationResourceId: 157, associationName: "list",         associationColumnName: "list_id",         joinType: "Inner" },
+          { name: "Created By",       filterOptionType: "BelongsTo", associationResourceId: 177, associationName: "created_by",   associationColumnName: "created_by_id",   joinType: "Left"  },
+          { name: "Organization",     filterOptionType: "BelongsTo", associationResourceId: 158, associationName: "organization", associationColumnName: "organization_id", joinType: "Inner" },
+          { name: "Organization",     filterOptionType: "BelongsTo", associationResourceId: 158, associationName: "organization", associationColumnName: "organization_id", joinType: "Inner" },
+          { name: "Updated By",       filterOptionType: "BelongsTo", associationResourceId: 177, associationName: "updated_by",   associationColumnName: "updated_by_id",   joinType: "Left"  },
+          { name: "Created At Date",  filterOptionType: "BelongsTo", columnType: "datetime", associationResourceId: 164, associationName: "created_at", associationColumnName: "created_at", joinType: "Left" },
+          { name: "Updated At Date",  filterOptionType: "BelongsTo", columnType: "datetime", associationResourceId: 164, associationName: "updated_at", associationColumnName: "updated_at", joinType: "Left" }
+        ]
+
+        has_many_return = [
+          { name: "Rows", associationResourceId: 161, associationName: "rows", columnType: "link", associationColumnName: "sheet_id", joinResourceId: 155, filterOptionType: "HasMany" }
+        ]
+
+        allow(Reports::ConstantOptions).to receive(:generate_filter_options).and_return([])
+        allow(Reports::NestedAttributeOptions).to receive(:generate_filter_options).and_return([])
+
+        expect(Reports::BaseOptions)
+          .to receive(:generate_filter_options)
+                .with(klass, any_args)
+                .and_return(base_return)
+
+        expect(Reports::BelongsToOptions)
+          .to receive(:generate_filter_options)
+                .with(klass, resource_id, any_args)
+                .and_return(belongs_return)
+
+        expect(Reports::HasManyOptions)
+          .to receive(:generate_filter_options)
+                .with(klass, any_args)
+                .and_return(has_many_return)
+
+        result = described_class.generate_filter_options(klass, resource_id)
+
+        expect(result).to eq(base_return + [] + belongs_return + has_many_return + [])
+      end
+    end
+  end
+
+  #========================
+  # .run
+  #========================
+  describe ".run" do
+    let(:klass_a) do
+      Class.new do
+        def self.name; "Sheet"; end
+      end
+    end
+    let(:klass_b) do
+      Class.new do
+        def self.name; "Text"; end
+      end
+    end
+
+    let(:resource_id_a) { "155" }
+    let(:resource_id_b) { "156" }
+
+    before do
+      # Stub check_resources (it is invoked once per klass in the loop)
+      allow(described_class).to receive(:check_resources).and_return([])
+
+      # GraphQL lookup for resource id by klass name
+      allow(Reports::ExternalGraphqlClient)
+        .to receive(:query_resource_by_name)
+              .with(name: "Sheet")
+              .and_return({ "data" => { "resourceName" => { "id" => resource_id_a } } })
+      allow(Reports::ExternalGraphqlClient)
+        .to receive(:query_resource_by_name)
+              .with(name: "Text")
+              .and_return({ "data" => { "resourceName" => { "id" => resource_id_b } } })
+
+      # Generators for select/filter options
+      allow(described_class)
+        .to receive(:generate_select_options)
+              .with(klass_a, resource_id_a, any_args)
+              .and_return([{ name: "s1" }])
+      allow(described_class)
+        .to receive(:generate_select_options)
+              .with(klass_b, resource_id_b, any_args)
+              .and_return([{ name: "s2" }])
+
+      allow(described_class)
+        .to receive(:generate_filter_options)
+              .with(klass_a, resource_id_a, any_args)
+              .and_return([{ name: "f1" }])
+      allow(described_class)
+        .to receive(:generate_filter_options)
+              .with(klass_b, resource_id_b, any_args)
+              .and_return([{ name: "f2" }])
+    end
+
+    context "happy path - no errors" do
+      it "imports select and filter options and returns an empty errors array" do
+        importer_double_a = instance_double(Reports::Importer)
+        importer_double_b = instance_double(Reports::Importer)
+
+        expect(Reports::Importer)
+          .to receive(:new).with(resource_id_a, any_args).twice.and_return(importer_double_a)
+        expect(Reports::Importer)
+          .to receive(:new).with(resource_id_b, any_args).twice.and_return(importer_double_b)
+
+        expect(importer_double_a)
+          .to receive(:import_select_options).with([{ name: "s1" }], resource_id_a, verbose: false).and_return([])
+        expect(importer_double_a)
+          .to receive(:import_filter_options).with([{ name: "f1" }], resource_id_a, verbose: false).and_return([])
+
+        expect(importer_double_b)
+          .to receive(:import_select_options).with([{ name: "s2" }], resource_id_b, verbose: false).and_return([])
+        expect(importer_double_b)
+          .to receive(:import_filter_options).with([{ name: "f2" }], resource_id_b, verbose: false).and_return([])
+
+        result = described_class.run([klass_a, klass_b])
+        expect(result).to eq([])
+
+        # check_resources is called once per klass
+        expect(described_class).to have_received(:check_resources).twice
+      end
+
+      it "passes resource_name: klass.name to Importer.new" do
+        importer_double = instance_double(Reports::Importer)
+        allow(importer_double).to receive(:import_select_options).and_return([])
+        allow(importer_double).to receive(:import_filter_options).and_return([])
+
+        expect(Reports::Importer)
+          .to receive(:new).with(resource_id_a, hash_including(resource_name: klass_a.name)).twice
+                .and_return(importer_double)
+
+        described_class.run(klass_a)
+      end
+    end
+
+    context "when importer returns errors for select or filter options" do
+      it "collects and returns those errors" do
+        importer_double = instance_double(Reports::Importer)
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name).with(name: "Text")
+                                              .and_return({ "data" => { "resourceName" => { "id" => resource_id_b } } })
+
+        allow(described_class)
+          .to receive(:generate_select_options)
+                .with(klass_b, resource_id_b, any_args)
+                .and_return([{ name: "s2" }])
+        allow(described_class)
+          .to receive(:generate_filter_options)
+                .with(klass_b, resource_id_b, any_args)
+                .and_return([{ name: "f2" }])
+
+        expect(Reports::Importer)
+          .to receive(:new).with(resource_id_b, any_args).twice.and_return(importer_double)
+
+        select_errors = [{ success: false, message: "select error" }]
+        filter_errors = [{ success: false, message: "filter error" }]
+
+        expect(importer_double)
+          .to receive(:import_select_options).with([{ name: "s2" }], resource_id_b, verbose: false).and_return(select_errors)
+        expect(importer_double)
+          .to receive(:import_filter_options).with([{ name: "f2" }], resource_id_b, verbose: false).and_return(filter_errors)
+
+        result = described_class.run(klass_b)
+        expect(result).to eq(select_errors + filter_errors)
+      end
+    end
+
+    context "when importer raises AuditError during select import" do
+      it "captures the error and returns an AUDIT error message" do
+        importer_double = instance_double(Reports::Importer)
+
+        expect(Reports::Importer)
+          .to receive(:new).with(resource_id_a, any_args).and_return(importer_double)
+        expect(Reports::Importer)
+          .to receive(:new).with(resource_id_a, any_args).and_return(importer_double)
+
+        expect(importer_double)
+          .to receive(:import_select_options)
+                .and_raise(Reports::Importer::AuditError.new("audit boom"))
+
+        expect(importer_double)
+          .to receive(:import_filter_options)
+                .with([{ name: "f1" }], resource_id_a, verbose: false)
+                .and_return([])
+
+        result = described_class.run(klass_a)
+        expect(result.any? { |e| e.include?("AUDIT ERROR (SelectOption - Sheet)") }).to be(true)
+      end
+    end
+
+    context "when an unexpected exception occurs inside the generation loop" do
+      it "captures and returns a FATAL EXCEPTION entry" do
+        allow(described_class)
+          .to receive(:generate_select_options)
+                .with(klass_a, resource_id_a, any_args)
+                .and_raise(StandardError.new("kaboom"))
+
+        result = described_class.run(klass_a)
+        expect(result.length).to eq(1)
+        expect(result.first).to include("FATAL EXCEPTION")
+      end
+    end
+  end
+
+  #========================
+  # .run_all
+  #========================
+  describe ".run_all" do
+    before do
+      # Define base flattener infra
+      stub_const("Flattener::Base", Class.new)
+      stub_const("Flatteners::Client", Class.new(Flattener::Base))
+      stub_const("Flatteners::HasHelpers::Organization", Class.new(Flattener::Base))
+      stub_const("Flatteners::UserOrganization", Class.new(Flattener::Base))
+
+      # Model classes needed for safe_constantize / constantize
+      stub_const("Client", Class.new)
+      stub_const("HasHelpers::Organization", Class.new)
+      stub_const("UserOrganization", Class.new)
+
+      # Stub filesystem scan — replaced by explicit list
+      allow(described_class).to receive(:all_flattener_classes).and_return([
+        Flatteners::Client, Flatteners::HasHelpers::Organization, Flatteners::UserOrganization
+      ])
+    end
+
+    context "when resources already exist remotely" do
+      before do
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name)
+                .with(name: "Client")
+                .and_return(ReportsApiMock.query_resource_by_name_found(id: "1", name: "Client"))
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name)
+                .with(name: "HasHelpers::Organization")
+                .and_return(ReportsApiMock.query_resource_by_name_found(id: "2", name: "HasHelpers::Organization"))
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name)
+                .with(name: "UserOrganization")
+                .and_return(ReportsApiMock.query_resource_by_name_found(id: "3", name: "UserOrganization"))
+      end
+
+      it "calls run for non-UserOrganization resources using constantize" do
+        expect(described_class).to receive(:run).with(Client).once
+        expect(described_class).to receive(:run).with(HasHelpers::Organization).once
+        expect(described_class).not_to receive(:run).with(UserOrganization)
+
+        described_class.run_all
+      end
+    end
+
+    context "when additional flatteners are present and are missing remotely" do
+      before do
+        # Add extra flatteners to match a real output (e.g. BrandConfiguration, UserView)
+        stub_const("Flatteners::BrandConfiguration", Class.new(Flattener::Base))
+        stub_const("Flatteners::UserView", Class.new(Flattener::Base))
+        stub_const("BrandConfiguration", Class.new)
+        stub_const("UserView", Class.new)
+
+        allow(described_class).to receive(:all_flattener_classes).and_return([
+          Flatteners::Client, Flatteners::HasHelpers::Organization, Flatteners::UserOrganization,
+          Flatteners::BrandConfiguration, Flatteners::UserView
+        ])
+
+        states = Hash.new(:first_nil)
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name) do |name:|
+          case name
+          when "Client"
+            ReportsApiMock.query_resource_by_name_found(id: "10", name: "Client")
+          when "HasHelpers::Organization"
+            ReportsApiMock.query_resource_by_name_found(id: "11", name: "HasHelpers::Organization")
+          when "UserOrganization"
+            ReportsApiMock.query_resource_by_name_found(id: "12", name: "UserOrganization")
+          when "BrandConfiguration", "UserView"
+            if states[name] == :first_nil
+              states[name] = :found
+              ReportsApiMock.query_resource_by_name_not_found
+            else
+              ReportsApiMock.query_resource_by_name_found(id: "999", name: name)
+            end
+          else
+            raise "Unexpected name in dynamic stub: #{name}"
+          end
+        end
+
+        # Creating a resource always succeeds here
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:create_resource)
+                .with(hash_including(mutation_name: "createResource",
+                                     input_name: "ReportResourceInput",
+                                     attributes: hash_including(:name, type: "HasReports::Resource")))
+                .and_return(ReportsApiMock.create_resource_success(id: "99"))
+      end
+
+      it "creates missing flatteners and calls run using safe_constantize on the returned name" do
+        expect(described_class).to receive(:run).with(Client).once
+        expect(described_class).to receive(:run).with(HasHelpers::Organization).once
+        expect(described_class).to receive(:run).with(BrandConfiguration).once
+        expect(described_class).to receive(:run).with(UserView).once
+        expect(described_class).not_to receive(:run).with(UserOrganization)
+
+        described_class.run_all
+
+        expect(Reports::ExternalGraphqlClient).to have_received(:create_resource)
+          .with(hash_including(attributes: hash_including(name: "BrandConfiguration"))).once
+        expect(Reports::ExternalGraphqlClient).to have_received(:create_resource)
+          .with(hash_including(attributes: hash_including(name: "UserView"))).once
+      end
+    end
+
+    context "when safe_constantize returns nil for an unknown resource name" do
+      before do
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name).with(name: "HasHelpers::Organization")
+                .and_return(ReportsApiMock.query_resource_by_name_found(id: "2", name: "HasHelpers::Organization"))
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:create_resource)
+                .and_return(ReportsApiMock.create_resource_success(id: "99"))
+
+        # Second query after creation returns an unresolvable constant name
+        call_count = Hash.new(0)
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name).with(name: "Client") do
+          call_count["Client"] += 1
+          call_count["Client"] == 1 ? ReportsApiMock.query_resource_by_name_not_found
+                                    : ReportsApiMock.query_resource_by_name_found(id: "1", name: "NonExistentConstant999")
+        end
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name).with(name: "UserOrganization") do
+          call_count["UserOrganization"] += 1
+          call_count["UserOrganization"] == 1 ? ReportsApiMock.query_resource_by_name_not_found
+                                              : ReportsApiMock.query_resource_by_name_found(id: "3", name: "NonExistentConstant999")
+        end
+      end
+
+      it "does not call run when safe_constantize returns nil" do
+        expect(described_class).to receive(:run).with(HasHelpers::Organization).once
+        expect(described_class).not_to receive(:run).with(nil)
+        described_class.run_all
+      end
+    end
+
+    it "returns an Array" do
+      allow(Reports::ExternalGraphqlClient)
+        .to receive(:query_resource_by_name)
+              .and_return(ReportsApiMock.query_resource_by_name_found(id: "1", name: "Client"))
+      allow(described_class).to receive(:run)
+      expect(described_class.run_all).to be_a(Array)
+    end
+
+    context "when creating a missing resource fails" do
+      before do
+        sequence = { "Client" => :nil, "HasHelpers::Organization" => :found, "UserOrganization" => :nil }
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:query_resource_by_name) do |name:|
+          case name
+          when "HasHelpers::Organization"
+            ReportsApiMock.query_resource_by_name_found(id: "2", name: "HasHelpers::Organization")
+          when "Client"
+            if sequence["Client"] == :nil
+              sequence["Client"] = :found
+              ReportsApiMock.query_resource_by_name_not_found
+            else
+              ReportsApiMock.query_resource_by_name_found(id: "101", name: "Client")
+            end
+          when "UserOrganization"
+            ReportsApiMock.query_resource_by_name_not_found
+          else
+            ReportsApiMock.query_resource_by_name_not_found
+          end
+        end
+
+        allow(Reports::ExternalGraphqlClient)
+          .to receive(:create_resource) do |mutation_name:, input_name:, attributes:|
+          if attributes[:name].to_s.include?("Client")
+            ReportsApiMock.create_resource_success(id: "101")
+          else
+            ReportsApiMock.create_resource_failure(errors: { "base" => ["boom"] })
+          end
+        end
+      end
+
+      it "does not call run for the failed creation and calls run for the successful one via safe_constantize" do
+        expect(described_class).to receive(:run).with(Client).once
+        expect(described_class).to receive(:run).with(HasHelpers::Organization).once
+        expect(described_class).not_to receive(:run).with(UserOrganization)
+
+        described_class.run_all
+
+        expect(Reports::ExternalGraphqlClient).to have_received(:create_resource)
+          .with(hash_including(attributes: hash_including(name: "Client"))).once
+        expect(Reports::ExternalGraphqlClient).to have_received(:create_resource)
+          .with(hash_including(attributes: hash_including(name: "UserOrganization"))).once
+      end
+    end
+  end
+
+  #========================
+  # .all_flattener_classes
+  #========================
+  describe ".all_flattener_classes" do
+    # Rails.root = "/" so that Rails.root.join("app/models/flatteners") = "/app/models/flatteners"
+    let(:fake_root) { Pathname.new("/") }
+    let(:base_path) { fake_root.join("app/models/flatteners") }
+
+    before do
+      stub_const("Flattener::Base", Class.new)
+      stub_const("Flatteners::Sheet", Class.new(Flattener::Base))
+      stub_const("Flatteners::Organization", Class.new(Flattener::Base))
+      stub_const("NonFlattenerClass", Class.new)
+
+      allow(Rails).to receive(:root).and_return(fake_root)
+      allow(Dir).to receive(:glob).with(base_path.join("**/*.rb")).and_return([
+        "/app/models/flatteners/sheet.rb",
+        "/app/models/flatteners/organization.rb"
+      ])
+    end
+
+    it "returns only classes that are subclasses of Flattener::Base" do
+      result = described_class.all_flattener_classes
+      expect(result).to include(Flatteners::Sheet, Flatteners::Organization)
+      expect(result).not_to include(NonFlattenerClass)
+    end
+
+    it "skips paths that do not resolve to a valid constant" do
+      allow(Dir).to receive(:glob).with(base_path.join("**/*.rb")).and_return([
+        "/app/models/flatteners/sheet.rb",
+        "/app/models/flatteners/unknown_constant_xyz.rb"
+      ])
+      expect { described_class.all_flattener_classes }.not_to raise_error
+    end
+
+    it "discovers flatteners nested in subdirectories" do
+      stub_const("Flatteners::Nested::DeepFlattener", Class.new(Flattener::Base))
+      allow(Dir).to receive(:glob).with(base_path.join("**/*.rb")).and_return([
+        "/app/models/flatteners/nested/deep_flattener.rb"
+      ])
+      result = described_class.all_flattener_classes
+      expect(result).to include(Flatteners::Nested::DeepFlattener)
+    end
+  end
+end