admin_suite 0.3.0 → 0.4.0

data/test/lib/builtin_renderers_test.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class BuiltinRenderersTest < ActionView::TestCase
+    include ::ERB::Util
+    include AdminSuite::BaseHelper
+
+    Record = Struct.new(:id, :config, :rows, :snippet) do
+      def attributes = { "id" => id }
+    end
+
+    def record
+      Record.new(
+        3,
+        { "mode" => "fast" },
+        [ { name: "alpha", count: 2 }, { name: "beta", count: 5 } ],
+        "puts :hi"
+      )
+    end
+
+    def build(key, **options)
+      # The four built-ins (and their aliases) are gem defaults now (Finding
+      # 2 of the whole-branch review: `register_default`, not `register`,
+      # so a host's own explicit registration or renderer class can beat
+      # them) -- fall back to the default store the same way
+      # `render_custom_section` does.
+      klass = AdminSuite::RendererRegistry.lookup(key) || AdminSuite::RendererRegistry.lookup_default(key)
+      klass.new(record, self, options).render
+    end
+
+    # A minimal double for the shape TableFromRenderer/KeyValueRenderer must
+    # keep supporting: something relation-like — not an Array, not a Hash,
+    # but Enumerable/#to_a-able, the way a real ActiveRecord::Relation or
+    # CollectionProxy is. Deliberately not ActiveRecord itself: the dummy
+    # app is database-free (see test/test_helper.rb).
+    class FakeRelation
+      include Enumerable
+
+      def initialize(records) = @records = records
+      def each(&block) = @records.each(&block)
+    end
+
+    test "json renderer prints the source hash" do
+      assert_includes build(:json, source: ->(r) { r.config }), "mode"
+    end
+
+    test "json renderer defaults to record attributes" do
+      # json_block HTML-escapes the pretty-printed JSON (see
+      # RendererTest#"json_block renders pretty-printed JSON..." for the
+      # same &quot; pattern), so a literal `"id"` never appears verbatim.
+      assert_includes build(:json), "&quot;id&quot;"
+    end
+
+    test "key_value renderer renders each pair" do
+      # KeyValueRenderer humanizes keys (`k.to_s.humanize`), so "mode"
+      # renders as "Mode".
+      html = build(:key_value, source: ->(r) { r.config })
+      assert_includes html, "Mode"
+      assert_includes html, "fast"
+    end
+
+    test "table_from renderer renders rows and infers columns" do
+      html = build(:table_from, source: ->(r) { r.rows })
+      assert_includes html, "alpha"
+      assert_includes html, "beta"
+      assert_includes html, "Count"
+    end
+
+    test "table_from renderer honours explicit columns and empty message" do
+      html = build(:table_from, source: ->(_r) { [] }, columns: %i[name], empty: "no data")
+      assert_includes html, "no data"
+    end
+
+    # Regression: Rails deserializes JSONB columns to String-keyed Hashes —
+    # exactly what trust_growth's organic_results/metadata/SERP arrays are.
+    # TableFromRenderer infers Symbol columns from `rows.first.keys.to_sym`,
+    # but `data_table`'s cell lookup (`row[c]`) previously looked those
+    # Symbols up against the original String-keyed rows and silently found
+    # nothing — headers rendered, every <td> came back blank, and
+    # `rows.blank?` never caught it because the rows themselves were present.
+    test "table_from renderer renders cell values (not just headers) for String-keyed rows" do
+      html = build(:table_from, source: ->(_r) { [ { "name" => "alpha", "count" => 2 } ] })
+
+      assert_includes html, "Name"
+      assert_includes html, "Count"
+      # The values, not just the headers, must survive the String/Symbol
+      # key mismatch — this is the assertion whose absence let the bug
+      # through originally.
+      assert_includes html, "alpha"
+      assert_includes html, "2"
+    end
+
+    test "table_from renderer raises a clear error for a non-Array source" do
+      error = assert_raises(ArgumentError) { build(:table_from, source: ->(_r) { { name: "alpha" } }) }
+      assert_match(/table_from expects an Array of Hashes, got Hash/, error.message)
+    end
+
+    # Regression: the Array-only guard above must not narrow what worked
+    # before it existed. `Array(source_value([]))` used to coerce any
+    # #to_a-able Enumerable — most importantly an ActiveRecord relation,
+    # the single most likely `source:` shape in the real migration — into a
+    # real Array. Only a bare Hash is the actual contract violation.
+    test "table_from renderer accepts a non-Array Enumerable source (e.g. an AR relation)" do
+      relation = FakeRelation.new([ { name: "alpha", count: 2 } ])
+      html = build(:table_from, source: ->(_r) { relation })
+
+      assert_includes html, "alpha"
+      assert_includes html, "2"
+    end
+
+    test "code renderer renders the snippet" do
+      assert_includes build(:code, source: ->(r) { r.snippet }, language: :ruby), "puts"
+    end
+
+    test "a symbol source resolves a method on the record" do
+      assert_includes build(:json, source: :config), "mode"
+    end
+
+    test "json_preview and code_preview are registered aliases to the same classes" do
+      assert_equal AdminSuite::Renderers::JsonRenderer, AdminSuite::RendererRegistry.lookup_default(:json_preview)
+      assert_equal AdminSuite::Renderers::CodeRenderer, AdminSuite::RendererRegistry.lookup_default(:code_preview)
+    end
+
+    test "key_value renderer shows an empty state for a blank source" do
+      html = build(:key_value, source: ->(_r) { {} })
+      assert_includes html, "Nothing to display."
+    end
+
+    test "key_value renderer raises a clear error for a flat non-pair Array" do
+      error = assert_raises(ArgumentError) { build(:key_value, source: ->(_r) { [ 1, 2, 3 ] }) }
+      assert_match(/key_value expects a Hash or an Array of \[key, value\] pairs/, error.message)
+    end
+
+    # Same narrowing risk as table_from's Enumerable regression test above:
+    # a non-Array Enumerable of pairs must still coerce, not raise.
+    test "key_value renderer accepts a non-Array Enumerable of pairs" do
+      relation = FakeRelation.new([ [ "mode", "fast" ] ])
+      html = build(:key_value, source: ->(_r) { relation })
+
+      assert_includes html, "Mode"
+      assert_includes html, "fast"
+    end
+
+    # data_table is a public primitive hosts may call directly from their own
+    # Renderer subclasses (not just through TableFromRenderer), so the
+    # String-keyed-rows fix belongs on the primitive itself.
+    test "data_table renders cell values for String-keyed rows" do
+      html = AdminSuite::Renderer.new(record, self).send(
+        :data_table, [ { "name" => "alpha", "count" => 2 } ], columns: %i[name count]
+      )
+
+      assert_includes html, "alpha"
+      assert_includes html, "2"
+    end
+
+    test "table_from renderer's :columns option reaches the renderer through render_custom_section" do
+      section = Admin::Base::Resource::ShowSectionDefinition.new(
+        name: :costs,
+        render: :table_from,
+        options: { source: ->(r) { r.rows }, columns: %i[name] }
+      )
+
+      html = render_custom_section(record, section.render, section.options)
+
+      assert_includes html, "alpha"
+      refute_includes html, "Count"
+    end
+
+    # Full DSL path: a host resource's `show { panel ... }` block, through
+    # ShowConfig#build_section, to render_show_section, to render_custom_section,
+    # to the registered renderer. No prior test in this suite exercised
+    # build_section at all, so this pins the plumbing this task added:
+    # ShowSectionDefinition#options is populated from the panel's leftover
+    # DSL keys (source:, columns:, empty:), including `columns:` a second
+    # time even though it also has its own dedicated `section.columns` slot.
+    class DslProbeResource < Admin::Base::Resource
+      show do
+        panel :costs, title: "Provider Costs",
+          render: :table_from,
+          source: ->(r) { r.rows },
+          columns: %i[name],
+          empty: "No spend"
+      end
+    end
+
+    test "panel DSL options reach the renderer end-to-end" do
+      section = DslProbeResource.show_config.sections_list.find { |s| s.name == :costs }
+
+      assert_equal :table_from, section.render
+      assert_equal %i[name], section.columns
+      assert_equal({ source: section.options[:source], columns: %i[name], empty: "No spend" }, section.options)
+
+      html = render_show_section(record, section, :main)
+
+      assert_includes html, "alpha"
+      assert_includes html, "beta"
+      refute_includes html, "Count"
+    end
+  end
+end

data/test/lib/definition_loader_test.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class DefinitionLoaderTest < ActiveSupport::TestCase
+    def with_globs(kind, paths)
+      key = { resources: :resource_globs, portals: :portal_globs,
+              dashboards: :dashboard_globs, actions: :action_globs }.fetch(kind)
+      saved = AdminSuite.config.public_send(key)
+      AdminSuite.config.public_send("#{key}=", paths)
+      restore_registry = snapshot_registry(kind)
+      AdminSuite::DefinitionLoader.reset!(kind)
+      yield
+    ensure
+      AdminSuite.config.public_send("#{key}=", saved)
+      restore_registry.call
+    end
+
+    # `DefinitionLoader.reset!` clears shared global state (the resource
+    # registry, the portal registry) that accumulates real fixtures
+    # registered by *other* tests at file-load time -- e.g.
+    # `test/integration/read_only_resource_test.rb`'s `ReadOnlyWidgetResource`
+    # and `test_helper.rb`'s fixture resources are registered once, forever,
+    # before any test runs. An earlier version of this helper called
+    # `reset!` bare and broke `navigation_sections_test.rb` whenever it ran
+    # afterward. Snapshot what's there before resetting and restore exactly
+    # that afterward, rather than trusting it to come back on its own.
+    def snapshot_registry(kind)
+      case kind
+      when :resources
+        before = Admin::Base::Resource.registered_resources.dup
+        lambda do
+          Admin::Base::Resource.reset_registry!
+          before.each { |r| Admin::Base::Resource.registered_resources << r }
+        end
+      when :portals
+        before = AdminSuite::PortalRegistry.all.dup
+        lambda do
+          AdminSuite::PortalRegistry.reset!
+          before.each_value { |definition| AdminSuite::PortalRegistry.register(definition) }
+        end
+      else
+        -> { AdminSuite::DefinitionLoader.reset!(kind) }
+      end
+    end
+
+    # Stubs Rails.env for the duration of the block, restoring it afterward.
+    # Used to exercise DefinitionLoader's `load` (vs `require`) file-loading
+    # mode, which never runs under the dummy app's normal (test-env) CI
+    # suite.
+    def with_rails_env(name)
+      original = Rails.env
+      Rails.env = ActiveSupport::EnvironmentInquirer.new(name.to_s)
+      yield
+    ensure
+      Rails.env = original
+    end
+
+    test "loads each matching file once in non-development environments" do
+      Dir.mktmpdir do |dir|
+        marker = File.join(dir, "count.txt")
+        File.write(File.join(dir, "thing.rb"), "File.write(#{marker.inspect}, File.exist?(#{marker.inspect}) ? File.read(#{marker.inspect}).to_i + 1 : 1)")
+        with_globs(:dashboards, [ File.join(dir, "*.rb") ]) do
+          2.times { AdminSuite::DefinitionLoader.load!(:dashboards) }
+          assert_equal 1, File.read(marker).to_i
+        end
+      end
+    end
+
+    test "empty globs are a no-op and do not re-scan" do
+      with_globs(:dashboards, []) do
+        assert_nothing_raised { 2.times { AdminSuite::DefinitionLoader.load!(:dashboards) } }
+      end
+    end
+
+    test "a raising definition file surfaces the error in test env" do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, "bad.rb"), "raise 'boom'")
+        with_globs(:dashboards, [ File.join(dir, "*.rb") ]) do
+          error = assert_raises(RuntimeError) { AdminSuite::DefinitionLoader.load!(:dashboards) }
+          assert_equal "boom", error.message
+        end
+      end
+    end
+
+    test "an unknown kind is rejected" do
+      assert_raises(ArgumentError) { AdminSuite::DefinitionLoader.load!(:nonsense) }
+    end
+
+    # --- Development-mode reload coverage ---
+    #
+    # Per the Task 9 erratum: `load!` itself must NEVER reset a kind's
+    # registry automatically (in development or otherwise) -- only
+    # `reset_for_new_request!` (wired into Rails' `to_prepare` by the
+    # engine, simulating "a new request began") or a test's explicit
+    # `reset!`/`with_globs` may do that. These tests simulate the request
+    # boundary explicitly rather than assuming `load!` reloads on every call.
+
+    test "in development, load! does not reload on repeated calls (bounded to the request boundary)" do
+      Dir.mktmpdir do |dir|
+        marker = File.join(dir, "count.txt")
+        File.write(File.join(dir, "thing.rb"), "File.write(#{marker.inspect}, File.exist?(#{marker.inspect}) ? File.read(#{marker.inspect}).to_i + 1 : 1)")
+        with_globs(:dashboards, [ File.join(dir, "*.rb") ]) do
+          # reset_for_new_request! resets *every* dev_resettable kind, not
+          # just :dashboards -- it also touches PortalRegistry and
+          # handlers_loaded, which is exactly the shared global state
+          # Finding 3 established a snapshot/restore discipline for. Wrap
+          # it here too, or this test becomes seed-dependent the day some
+          # other test registers a portal at file-load time.
+          restore_portals = snapshot_registry(:portals)
+          restore_actions = snapshot_registry(:actions)
+
+          with_rails_env(:development) do
+            3.times { AdminSuite::DefinitionLoader.load!(:dashboards) }
+            assert_equal 1, File.read(marker).to_i,
+                         "expected load! to load the file once, not once per call, without an intervening reset"
+            assert AdminSuite.config.root_dashboard_loaded,
+                   "expected load! to mark the kind loaded in development too, not only outside it"
+
+            AdminSuite::DefinitionLoader.reset_for_new_request!
+            AdminSuite::DefinitionLoader.load!(:dashboards)
+            assert_equal 2, File.read(marker).to_i,
+                         "expected reset_for_new_request! to make the next load! call reload"
+          end
+        ensure
+          restore_portals.call
+          restore_actions.call
+        end
+      end
+    end
+
+    test "in development, a portal removed from disk only disappears after reset_for_new_request!, not on a bare repeated load!" do
+      Dir.mktmpdir do |dir|
+        portal_file = File.join(dir, "temp_portal.rb")
+        File.write(portal_file, "AdminSuite.portal(:definition_loader_dev_test) {}")
+
+        with_globs(:portals, [ File.join(dir, "*.rb") ]) do
+          with_rails_env(:development) do
+            AdminSuite::DefinitionLoader.load!(:portals)
+            assert AdminSuite::PortalRegistry.all.key?(:definition_loader_dev_test),
+                   "expected the portal defined by the glob'd file to be registered"
+
+            File.delete(portal_file)
+
+            # No reset happened -- load! alone must not touch the registry.
+            AdminSuite::DefinitionLoader.load!(:portals)
+            assert AdminSuite::PortalRegistry.all.key?(:definition_loader_dev_test),
+                   "expected the portal to remain registered without an intervening reset_for_new_request!"
+
+            AdminSuite::DefinitionLoader.reset_for_new_request!
+            AdminSuite::DefinitionLoader.load!(:portals)
+            assert_not AdminSuite::PortalRegistry.all.key?(:definition_loader_dev_test),
+                       "expected the removed portal to disappear once reset_for_new_request! ran"
+          end
+        end
+      end
+    end
+
+    test "reset_for_new_request! resets portals, dashboards and actions, but never resources" do
+      # This is the regression this task's erratum exists for: resource
+      # registration happens only via Class#inherited, which never refires
+      # on a reopened (already-defined) class, so resetting the resource
+      # registry between requests would empty it permanently after the
+      # first reset+reload cycle. See the :resources KINDS entry.
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, "resource.rb"), <<~RUBY)
+          module Admin
+            module Resources
+              class ResetForNewRequestResource < Admin::Base::Resource
+              end
+            end
+          end
+        RUBY
+
+        with_globs(:resources, [ File.join(dir, "*.rb") ]) do
+          with_globs(:portals, []) do
+            with_globs(:dashboards, []) do
+              with_globs(:actions, []) do
+                AdminSuite.portal(:reset_for_new_request_test) {}
+                AdminSuite::DefinitionLoader.load!(:resources)
+                Admin::Base::ActionExecutor.handlers_loaded = true
+                AdminSuite.config.root_dashboard_loaded = true
+
+                AdminSuite::DefinitionLoader.reset_for_new_request!
+
+                assert_not AdminSuite::PortalRegistry.all.key?(:reset_for_new_request_test),
+                           "expected portals to be reset"
+                assert_not AdminSuite.config.root_dashboard_loaded, "expected dashboards to be reset"
+                assert_not Admin::Base::ActionExecutor.handlers_loaded, "expected actions to be reset"
+                assert Admin::Base::Resource.registered_resources.any? { |r| r.name == "Admin::Resources::ResetForNewRequestResource" },
+                       "expected resources to survive reset_for_new_request! untouched"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # The assertion whose absence let the erratum's bug through: the
+    # dev-mode resources test that existed before this fix only ever loaded
+    # a brand-new constant exactly once -- the one case where Class#inherited
+    # actually fires. Calling load! twice against the *same* file, with no
+    # reset in between, is what a single request actually does (base_helper's
+    # `portal_color`/`portal_icon` both re-enter `navigation_items`, which
+    # calls `ensure_resources_loaded!` again).
+    test "load!(:resources) called twice against the same file leaves the registry populated after the second call" do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, "definition_loader_dev_resource.rb"), <<~RUBY)
+          module Admin
+            module Resources
+              class DefinitionLoaderDevResource < Admin::Base::Resource
+              end
+            end
+          end
+        RUBY
+
+        with_globs(:resources, [ File.join(dir, "*.rb") ]) do
+          with_rails_env(:development) do
+            2.times { AdminSuite::DefinitionLoader.load!(:resources) }
+
+            assert Admin::Base::Resource.registered_resources.any? { |r| r.name == "Admin::Resources::DefinitionLoaderDevResource" },
+                   "expected the resource to still be registered after a second load! call"
+          end
+        end
+      end
+    end
+
+    # --- Per-kind wiring sanity (guards against a kind pointed at the wrong globals) ---
+
+    test "resources kind is backed by Admin::Base::Resource's registry" do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, "definition_loader_dev_resource.rb"), <<~RUBY)
+          module Admin
+            module Resources
+              class DefinitionLoaderDevResource2 < Admin::Base::Resource
+              end
+            end
+          end
+        RUBY
+
+        with_globs(:resources, [ File.join(dir, "*.rb") ]) do
+          AdminSuite::DefinitionLoader.load!(:resources)
+          assert Admin::Base::Resource.registered_resources.any? { |r| r.name == "Admin::Resources::DefinitionLoaderDevResource2" }
+        end
+      end
+    end
+
+    test "actions kind is backed by ActionExecutor.handlers_loaded" do
+      with_globs(:actions, []) do
+        Admin::Base::ActionExecutor.handlers_loaded = false
+        AdminSuite::DefinitionLoader.load!(:actions)
+        assert Admin::Base::ActionExecutor.handlers_loaded
+      end
+    end
+
+    test "dashboards kind is backed by AdminSuite.config.root_dashboard_loaded" do
+      with_globs(:dashboards, []) do
+        AdminSuite::DefinitionLoader.load!(:dashboards)
+        assert AdminSuite.config.root_dashboard_loaded
+      end
+    end
+  end
+end

data/test/lib/engine_defaults_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class EngineDefaultsTest < ActiveSupport::TestCase
+    def with_fresh_config
+      saved = AdminSuite.instance_variable_get(:@config)
+      AdminSuite.instance_variable_set(:@config, AdminSuite::Configuration.new)
+      yield AdminSuite.config
+    ensure
+      AdminSuite.instance_variable_set(:@config, saved)
+    end
+
+    test "an explicit empty portals hash suppresses the built-in defaults" do
+      with_fresh_config do |config|
+        config.portals = {}
+        assert config.portals_configured?, "assigning portals must mark them configured"
+        AdminSuite::Engine.apply_default_portals!(config)
+        assert_empty config.portals
+      end
+    end
+
+    test "untouched portals receive the built-in defaults" do
+      with_fresh_config do |config|
+        refute config.portals_configured?
+        AdminSuite::Engine.apply_default_portals!(config)
+        assert_includes config.portals.keys, :ops
+      end
+    end
+
+    test "dead configuration and DSL members are gone" do
+      refute AdminSuite::Configuration.new.respond_to?(:tailwind_cdn)
+      assert Admin::Base::Resource.respond_to?(:exportable),
+        "exportable is a deprecated no-op, not removed -- see ResourceExportableDeprecationTest"
+      refute Admin::Base::Resource::ColumnDefinition.members.include?(:render)
+    end
+  end
+end

data/test/lib/form_field_renderer_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class FormFieldRendererTest < ActionView::TestCase
+    include AdminSuite::BaseHelper
+
+    Record = Struct.new(:name, :body, :enabled) do
+      def to_model = self
+      def model_name = ActiveModel::Name.new(self.class, nil, "Record")
+      def persisted? = false
+      def to_key = nil
+
+      # render_form_field unconditionally calls `resource.errors[field.name]`
+      # for every field type (to add the error border class / message), so
+      # the double needs an `errors` object supporting `[]` -> Array-like
+      # (`.any?`, `.first`). No test here exercises an actual validation
+      # error, so a Hash defaulting to `[]` is sufficient.
+      def errors = Hash.new([])
+    end
+
+    def field(name, type)
+      Admin::Base::Resource::FieldDefinition.new(
+        name: name, type: type, required: false, label: name.to_s.humanize,
+        readonly: false, multiple: false, creatable: false, preview: true
+      )
+    end
+
+    def render_field(type, name: :name)
+      record = Record.new("x", "y", true)
+      html = nil
+      form_with(model: record, url: "/", scope: :record) { |f| html = render_form_field(f, field(name, type), record) }
+      html.to_s
+    end
+
+    test "textarea type renders a textarea" do
+      assert_includes render_field(:textarea, name: :body), "<textarea"
+    end
+
+    test "email and url types render matching inputs" do
+      assert_includes render_field(:email), 'type="email"'
+      assert_includes render_field(:url), 'type="url"'
+    end
+
+    test "date and datetime types render matching inputs" do
+      assert_includes render_field(:date), 'type="date"'
+      assert_includes render_field(:datetime), 'type="datetime-local"'
+    end
+
+    test "markdown type wires the markdown editor controller" do
+      assert_includes render_field(:markdown, name: :body), "admin-suite--markdown-editor"
+    end
+
+    test "an unregistered type falls back to a text field" do
+      html = render_field(:totally_unknown_type)
+      assert_includes html, 'type="text"'
+    end
+
+    test "the label is rendered for every field" do
+      assert_includes render_field(:text), "Name"
+    end
+  end
+end

data/test/lib/legacy_renderer_deprecation_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class LegacyRendererDeprecationTest < ActionView::TestCase
+    include ::ERB::Util
+    include AdminSuite::BaseHelper
+
+    Prompt = Struct.new(:prompt_template)
+
+    setup { AdminSuite::Renderers::LegacyGleania.reset_deprecation_notices! }
+
+    test "the legacy prompt renderer still renders its template" do
+      html = render_custom_section(Prompt.new("Hello {{name}}"), :prompt_template_preview)
+      assert_includes html, "Hello"
+      assert_includes html, "name"
+    end
+
+    test "using a legacy renderer logs a deprecation once per key" do
+      logged = []
+      AdminSuite::Renderers::LegacyGleania.stub(:warn_once_sink, ->(msg) { logged << msg }) do
+        2.times { render_custom_section(Prompt.new("x"), :prompt_template_preview) }
+      end
+      assert_equal 1, logged.size
+      assert_includes logged.first, "deprecated"
+      assert_includes logged.first, "0.5.0"
+    end
+
+    test "the gem no longer includes the host CustomRenderersHelper constant" do
+      source = AdminSuite::Engine.root.join("app/helpers/admin_suite/base_helper.rb").read
+      refute_includes source, "Internal::Developer::CustomRenderersHelper"
+    end
+  end
+end