indexmap 0.8.2 → 0.9.0

data/test/indexmap/correctness_test.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class IndexmapCorrectnessTest < Minitest::Test
+  def test_resolves_only_the_selected_source_once_per_generation
+    %i[index single_file].each do |format|
+      calls = Hash.new(0)
+      configuration = configuration_with
+      configuration.format = format
+      configuration.entries = -> do
+        calls[:entries] += 1
+        [Indexmap::Entry.new(loc: "https://example.com/page")]
+      end
+      configuration.sections = -> do
+        calls[:sections] += 1
+        [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [{loc: "https://example.com/page"}])]
+      end
+
+      2.times { Indexmap.create(configuration: configuration) }
+
+      assert_equal((format == :index) ? {sections: 2} : {entries: 2}, calls)
+    end
+  end
+
+  def test_url_count_boundary
+    body = urlset((1..50_000).map { |id| "<url><loc>https://example.com/#{id}</loc></url>" }.join)
+    assert validate(body)
+
+    error = assert_raises(Indexmap::ValidationError) do
+      validate(body.sub("</urlset>", "<url><loc>https://example.com/extra</loc></url></urlset>"))
+    end
+    assert_match "50,000", error.message
+  end
+
+  def test_index_count_limit_precedes_child_reads
+    body = index((1..50_001).map { |id| "https://example.com/sitemap-#{id}.xml" })
+    error = assert_raises(Indexmap::ValidationError) { validate(body) }
+    assert_match "50,000", error.message
+  end
+
+  def test_uncompressed_utf8_byte_boundary
+    body = urlset("<url><loc>https://example.com/page</loc></url>")
+    padding = 52_428_800 - body.bytesize
+    comments = []
+    while padding > 1_000_007
+      comments << "<!--#{"x" * 1_000_000}-->"
+      padding -= 1_000_007
+    end
+    comments << "<!--#{"x" * (padding - 7)}-->"
+    body = body.sub("</urlset>", "#{comments.join}</urlset>")
+    assert_equal 52_428_800, body.bytesize
+    assert validate(body)
+
+    error = assert_raises(Indexmap::ValidationError) { validate(body.sub("page", "pagé")) }
+    assert_match "52,428,800", error.message
+  end
+
+  def test_rejects_foreign_child_origins_even_when_the_local_file_exists
+    %w[https://other.example/sitemap-child.xml http://example.com/sitemap-child.xml https://example.com:444/sitemap-child.xml //other.example/sitemap-child.xml].each do |location|
+      configuration = configuration_with
+      configuration.storage.write("sitemap.xml", index([location]))
+      configuration.storage.write("sitemap-child.xml", urlset("<url><loc>https://example.com/page</loc></url>"))
+
+      assert_raises(Indexmap::ValidationError) { Indexmap::Validator.new(configuration: configuration).validate! }
+    end
+  end
+
+  def test_rejects_self_and_multi_file_cycles
+    configuration = configuration_with
+    configuration.storage.write("sitemap.xml", index(["https://example.com/sitemap.xml"]))
+    error = assert_raises(Indexmap::ValidationError) { Indexmap::Validator.new(configuration: configuration).validate! }
+    assert_match "cycle", error.message
+
+    configuration.storage.write("sitemap.xml", index(["https://example.com/sitemap-child.xml"]))
+    configuration.storage.write("sitemap-child.xml", index(["https://example.com/sitemap.xml"]))
+    assert_raises(Indexmap::ValidationError) { Indexmap::Validator.new(configuration: configuration).validate! }
+  end
+
+  def test_rejects_dtds_and_unsafe_child_paths
+    assert_raises(Indexmap::ValidationError) do
+      validate('<!DOCTYPE urlset [<!ENTITY example "https://example.com/page">]>' + urlset("<url><loc>&example;</loc></url>"))
+    end
+    %w[../outside.xml https://example.com/sitemap.xml?query=1 https://example.com/sitemap.xml#fragment].each do |location|
+      assert_raises(Indexmap::ValidationError) { validate(index([location])) }
+    end
+  end
+
+  def test_rejects_missing_locations_and_incorrect_namespaces
+    [urlset("<url/>"), urlset("<url><loc/></url>"), index(["", "https://example.com/child.xml"]),
+      '<urlset xmlns="https://other.example/schema"><url><loc>https://example.com/page</loc></url></urlset>'].each do |body|
+      assert_raises(Indexmap::ValidationError) { validate(body) }
+    end
+    assert_raises(Indexmap::ValidationError) do
+      validate(urlset("<url><loc>https://user:password@example.com/page</loc></url>"))
+    end
+  end
+
+  def test_validates_deep_indexes_without_recursion_or_repeated_reads
+    configuration = configuration_with
+    storage = configuration.storage
+    reads = Hash.new(0)
+    storage.define_singleton_method(:read) do |name|
+      reads[name] += 1
+      super(name)
+    end
+    names = ["sitemap.xml", *(1..1200).map { |id| "sitemap-#{id}.xml" }]
+    names.each_cons(2) { |parent, child| storage.write(parent, index(["https://example.com/#{child}"])) }
+    storage.write(names.last, urlset("<url><loc>https://example.com/page</loc></url>"))
+
+    validator = Indexmap::Validator.new(configuration: configuration)
+    assert validator.validate!
+    assert_equal ["https://example.com/page"], validator.entries.map(&:loc)
+    assert_equal names.size, reads.size
+    assert reads.values.all? { |count| count == 1 }
+  end
+
+  def test_location_length_and_repeated_fields_are_bounded
+    prefix = "https://example.com/"
+    location = prefix + "a" * (2047 - prefix.length)
+    assert validate(urlset("<url><loc>#{location}</loc></url>"))
+    assert_raises(Indexmap::ValidationError) { validate(urlset("<url><loc>#{location}x</loc></url>")) }
+    assert_raises(Indexmap::ValidationError) do
+      validate(urlset("<url><loc>https://example.com/</loc><loc>https://example.com/other</loc></url>"))
+    end
+    assert_raises(Indexmap::ValidationError) do
+      validate(urlset("<url><loc>https://example.com/</loc><lastmod/><lastmod/></url>"))
+    end
+  end
+
+  private
+
+  def configuration_with
+    Indexmap::Configuration.new.tap do |configuration|
+      configuration.base_url = "https://example.com"
+      configuration.storage = Indexmap::Storage::Memory.new
+    end
+  end
+
+  def validate(body)
+    configuration = configuration_with
+    configuration.storage.write("sitemap.xml", body)
+    Indexmap::Validator.new(configuration: configuration).validate!
+  end
+
+  def urlset(body)
+    %(<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">#{body}</urlset>)
+  end
+
+  def index(locations)
+    %(<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">#{locations.map { |loc| "<sitemap><loc>#{loc}</loc></sitemap>" }.join}</sitemapindex>)
+  end
+end

data/test/indexmap/install_generator_test.rb

@@ -19,8 +19,8 @@ class IndexmapInstallGeneratorTest < Minitest::Test
       rakefile = File.read(File.join(destination, "Rakefile"))
 
       assert File.exist?(initializer)
-      assert_includes File.read(initializer), "module IndexmapConfiguration"
-      assert_includes File.read(initializer), "IndexmapConfiguration.apply if defined?(Indexmap)"
+      assert_includes File.read(initializer), "module HostConfiguration"
+      assert_includes File.read(initializer), "Indexmap::HostConfiguration.apply if defined?(Indexmap::Configuration)"
       assert_includes File.read(initializer), "Search-engine pings start from config.index_filename"
       assert_includes rakefile, 'require "indexmap/tasks"'
       assert_operator rakefile.index('require "indexmap/tasks"'), :<, rakefile.index('require_relative "config/application"')
@@ -33,7 +33,7 @@ class IndexmapInstallGeneratorTest < Minitest::Test
 
         module Rails
           def self.public_path
-            Pathname.new("public")
+            Pathname.new(ENV.fetch("INDEXMAP_TEST_PUBLIC_PATH"))
           end
         end
 
@@ -41,12 +41,14 @@ class IndexmapInstallGeneratorTest < Minitest::Test
         load ARGV.fetch(0)
 
         configuration = Indexmap.configuration
-        IndexmapConfiguration.apply
+        Indexmap::HostConfiguration.apply
         abort "configuration replaced" unless Indexmap.configuration.equal?(configuration)
         abort "base URL missing" unless configuration.base_url == "http://localhost:3000"
         abort "index filename missing" unless configuration.index_filename == "sitemap.xml"
+        abort "storage rebuilt" unless configuration.storage.equal?(configuration.storage)
       RUBY
       _stdout, stderr, status = Open3.capture3(
+        {"INDEXMAP_TEST_PUBLIC_PATH" => File.join(destination, "public")},
         RbConfig.ruby,
         "-I#{File.expand_path("../../lib", __dir__)}",
         "-e",
@@ -56,4 +58,34 @@ class IndexmapInstallGeneratorTest < Minitest::Test
       assert status.success?, stderr
     end
   end
+
+  def test_loads_tasks_after_rails_has_removed_the_command_from_argv
+    Dir.mktmpdir do |destination|
+      File.write(File.join(destination, "Rakefile"), <<~RUBY)
+        require_relative "config/application"
+        Rails.application.load_tasks
+      RUBY
+      Indexmap::Generators::InstallGenerator.start([], destination_root: destination)
+      FileUtils.mkdir_p(File.join(destination, "config"))
+      File.write(File.join(destination, "config/application.rb"), <<~RUBY)
+        abort "Indexmap loaded too late" unless defined?(Indexmap::Configuration)
+        module Rails
+          def self.application = self
+          def self.load_tasks = nil
+        end
+      RUBY
+      script = <<~RUBY
+        require "rake"
+        Rake.application.init("rake", ["indexmap:sitemap:create"])
+        ARGV.clear
+        load ARGV_FILE
+        abort "task missing" unless Rake::Task.task_defined?("indexmap:sitemap:create")
+      RUBY
+      script = script.sub("ARGV_FILE", File.join(destination, "Rakefile").dump)
+      _stdout, stderr, status = Open3.capture3(
+        RbConfig.ruby, "-I#{File.expand_path("../../lib", __dir__)}", "-e", script
+      )
+      assert status.success?, stderr
+    end
+  end
 end

data/test/indexmap/parser_test.rb

@@ -119,4 +119,81 @@ class IndexmapParserTest < Minitest::Test
 
     assert_equal ["/pages/pricing"], parser.paths
   end
+
+  def test_rejects_cross_origin_children_including_scheme_relative_urls
+    ["https://other.example/child.xml", "//other.example/child.xml", "http://www.example.com/child.xml",
+      "https://www.example.com:444/child.xml", "https://user@www.example.com/child.xml"].each do |child|
+      stub_request(:get, "https://www.example.com/sitemap.xml").to_return(
+        body: "<sitemapindex><sitemap><loc>#{child}</loc></sitemap></sitemapindex>"
+      )
+      error = assert_raises(Indexmap::ValidationError) do
+        Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml").entries
+      end
+      assert_match(/source origin/, error.message)
+    end
+    assert_requested :get, "https://www.example.com/sitemap.xml", times: 5
+  end
+
+  def test_redirects_are_limited_to_the_source_origin
+    stub_request(:get, "https://www.example.com/sitemap.xml")
+      .to_return(status: 302, headers: {"Location" => "/current.xml"})
+    stub_request(:get, "https://www.example.com/current.xml")
+      .to_return(body: "<urlset><url><loc>https://www.example.com/page</loc></url></urlset>")
+    assert_equal ["/page"], Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml").paths
+
+    stub_request(:get, "https://www.example.com/current.xml")
+      .to_return(status: 302, headers: {"Location" => "http://169.254.169.254/metadata"})
+    assert_raises(Indexmap::ValidationError) do
+      Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml").entries
+    end
+    assert_not_requested :get, "http://169.254.169.254/metadata"
+  end
+
+  def test_redirect_loops_stop
+    stub_request(:get, "https://www.example.com/sitemap.xml")
+      .to_return(status: 302, headers: {"Location" => "/sitemap.xml"})
+    assert_empty Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml").entries
+    assert_requested :get, "https://www.example.com/sitemap.xml", times: 4
+  end
+
+  def test_rejects_oversized_remote_responses_with_and_without_content_length
+    [{}, {"Content-Length" => (Indexmap::Validator::MAX_BYTES + 1).to_s}].each do |headers|
+      stub_request(:get, "https://www.example.com/sitemap.xml")
+        .to_return(body: "x" * (Indexmap::Validator::MAX_BYTES + 1), headers: headers)
+      assert_raises(Indexmap::ValidationError) do
+        Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml").entries
+      end
+    end
+  end
+
+  def test_rejects_oversized_redirect_and_error_bodies
+    [302, 500].each do |status|
+      stub_request(:get, "https://www.example.com/sitemap.xml")
+        .to_return(status: status, body: "x" * (Indexmap::Validator::MAX_BYTES + 1))
+      assert_raises(Indexmap::ValidationError) do
+        Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml").entries
+      end
+    end
+  end
+
+  def test_enumerates_storage_without_whole_file_reads_and_handles_cycles
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemap.xml", "<sitemapindex><sitemap><loc>sitemap.xml</loc></sitemap><sitemap><loc>child.xml</loc></sitemap></sitemapindex>")
+    storage.write("child.xml", "<urlset><url><loc>https://example.com/a</loc><lastmod>2026-04-21</lastmod></url><url><loc>https://example.com/b</loc></url></urlset>")
+    storage.define_singleton_method(:metadata) { |name| {bytes: files.fetch(name).body.bytesize} }
+    storage.define_singleton_method(:open) { |name, &block| block.call(StringIO.new(files.fetch(name).body)) }
+    storage.define_singleton_method(:read) { |*| raise "whole-file read" }
+    parser = Indexmap::Parser.new(storage: storage)
+    entries = parser.each_entry.to_a
+    assert_equal ["https://example.com/a", "https://example.com/b"], entries.map(&:loc)
+    assert_equal ["2026-04-21", nil], entries.map(&:lastmod)
+    refute parser.instance_variable_defined?(:@entries)
+  end
+
+  def test_rejects_dtds_without_fetching_entities
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemap.xml", '<!DOCTYPE urlset [<!ENTITY x SYSTEM "http://example.com/secret">]><urlset><url><loc>&x;</loc></url></urlset>')
+    assert_raises(Indexmap::ValidationError) { Indexmap::Parser.new(storage: storage).entries }
+    assert_not_requested :get, "http://example.com/secret"
+  end
 end

data/test/indexmap/pinger/google_test.rb

@@ -159,6 +159,28 @@ class IndexmapPingerGoogleTest < Minitest::Test
     assert_nil service.submitted
   end
 
+  def test_counts_unique_urls_across_disk_sort_runs_without_whole_file_reads
+    storage = Indexmap::Storage::Memory.new(public_url: "https://www.example.com")
+    rows = (1..10_001).map { |id| "<url><loc>https://www.example.com/#{id}</loc></url>" }.join
+    storage.write("sitemap.xml", "<urlset>#{rows}#{rows}</urlset>")
+    storage.define_singleton_method(:metadata) { |name| {bytes: files.fetch(name).body.bytesize} }
+    storage.define_singleton_method(:open) { |name, &block| block.call(StringIO.new(files.fetch(name).body)) }
+    storage.define_singleton_method(:read) { |*| raise "whole-file read" }
+    configuration = configuration_with(storage: storage)
+    configuration.google.credentials = '{"type":"service_account"}'
+    calls = 0
+    configuration.storage = -> {
+      calls += 1
+      storage
+    }
+    service = FakeWebmastersService.new(site_urls: ["sc-domain:example.com"])
+    result = Indexmap::Pinger::Google.new(
+      configuration: configuration, service: service, credentials_builder: ->(**) { :fake_authorizer }
+    ).ping
+    assert_equal 10_001, result[:url_count]
+    assert_equal 1, calls
+  end
+
   private
 
   def configuration_with(storage: Indexmap::Storage::Memory.new(public_url: "https://www.example.com"))

data/test/indexmap/pinger/index_now_test.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "test_helper"
+require "indexmap/tasks"
 
 class IndexmapPingerIndexNowTest < Minitest::Test
   VALID_KEY = "1234567890abcdef1234567890abcdef"
@@ -207,6 +208,173 @@ class IndexmapPingerIndexNowTest < Minitest::Test
     assert_equal "00000000000000000000000000000000.txt", filename
   end
 
+  def test_date_only_lastmods_include_the_cutoff_day
+    configuration = configuration_with(storage: sitemap_storage(
+      marketing_lastmod: "2026-04-18", insights_lastmod: "2026-04-17"
+    ))
+    configuration.index_now.key = VALID_KEY
+    configuration.index_now.dry_run = true
+
+    with_env("SINCE" => "2026-04-18T23:59:59Z") do
+      assert_equal 1, Indexmap::Pinger::IndexNow.new(configuration: configuration).ping.fetch(:url_count)
+    end
+  end
+
+  def test_rejects_invalid_batch_sizes_before_sending
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
+    %w[0 -1 invalid 1.5 10001].each do |value|
+      with_env("INDEXNOW_MAX_URLS_PER_REQUEST" => value) do
+        assert_raises(Indexmap::ConfigurationError) do
+          Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+        end
+      end
+    end
+    assert_not_requested(:post, "https://api.indexnow.org/indexnow")
+  end
+
+  def test_invalid_since_does_not_fall_back_to_recent_hours
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
+    with_env("SINCE" => "invalid", "INDEXNOW_RECENT_HOURS" => "24") do
+      assert_raises(ArgumentError) { Indexmap::Pinger::IndexNow.new(configuration: configuration).ping }
+    end
+  end
+
+  def test_plan_without_a_key_reports_exact_selection_and_exclusions
+    configuration = configuration_with(storage: sitemap_storage)
+    with_env("SINCE" => "2026-04-15T00:00:00Z") do
+      rows = Indexmap::Pinger::IndexNow.new(configuration: configuration).plan.to_a
+      assert_equal 2, rows.size
+      selected = rows.find { |row| row.fetch(:selected) }
+      assert_equal "https://www.example.com/pages/features", selected.fetch(:loc)
+      assert_equal "sitemap-marketing.xml", selected.fetch(:source_sitemap)
+      assert_equal :recent, selected.fetch(:reason)
+      assert_equal 1, selected.fetch(:batch)
+      assert selected.fetch(:missing_key)
+      assert_equal :before_cutoff, rows.find { |row| !row.fetch(:selected) }.fetch(:reason)
+    end
+    assert_not_requested(:post, "https://api.indexnow.org/indexnow")
+  end
+
+  def test_plan_matches_submitted_batches_and_explains_undated_entries
+    configuration = configuration_with(storage: sitemap_storage(marketing_lastmod: ""))
+    configuration.index_now.key = VALID_KEY
+    configuration.index_now.max_urls_per_request = 1
+    stub_request(:post, "https://api.indexnow.org/indexnow").to_return(status: 200)
+    with_env("SINCE" => "2026-04-15T00:00:00Z") do
+      pinger = Indexmap::Pinger::IndexNow.new(configuration: configuration)
+      rows = pinger.plan.select { |row| row.fetch(:selected) }
+      assert_equal :missing_lastmod, rows.first.fetch(:reason)
+      events = []
+      pinger.ping { |event| events << event }
+      assert_equal rows.map { |row| row.fetch(:loc) }, events.select { |event| event[:event] == :attempt_started }.flat_map { |event| event[:urls] }
+      refute_includes JSON.generate(events), VALID_KEY
+    end
+  end
+
+  def test_transport_failure_preserves_earlier_receipts_and_reports_uncertainty
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
+    configuration.index_now.max_urls_per_request = 1
+    stub_request(:post, "https://api.indexnow.org/indexnow")
+      .to_return(status: 202).then.to_timeout
+    events = []
+    result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping { |event| events << event }
+    assert_equal :partial, result.fetch(:status)
+    assert_equal 1, result.fetch(:url_count)
+    assert_equal :unknown_delivery, result.fetch(:failures).first.fetch(:reason)
+    receipts = events.select { |event| event[:event] == :attempt_finished }
+    assert_equal 202, receipts.first.fetch(:status_code)
+    assert_equal :validation_pending, receipts.first.fetch(:receipt)
+    assert_equal :unknown_delivery, receipts.last.fetch(:reason)
+  end
+
+  def test_plan_task_exports_json_lines_without_sending
+    configuration = configuration_with(storage: sitemap_storage)
+    Rake::Task.define_task(:environment)
+    task = Rake::Task["indexmap:index_now:plan"]
+    task.reenable
+    output, = Indexmap.stub(:configuration, configuration) { capture_io { task.invoke } }
+    rows = output.lines.map { |line| JSON.parse(line) }
+    assert_equal 2, rows.size
+    assert rows.all? { |row| row.fetch("selected") && row.fetch("missing_key") }
+    assert_not_requested(:post, "https://api.indexnow.org/indexnow")
+  end
+
+  def test_ping_task_report_contains_exact_attempts_and_a_summary
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
+    stub_request(:post, "https://api.indexnow.org/indexnow").to_return(status: 200)
+    Rake::Task.define_task(:environment)
+    task = Rake::Task["indexmap:index_now:ping"]
+    task.reenable
+    with_env("INDEXNOW_REPORT" => "1") do
+      output, = Indexmap.stub(:configuration, configuration) { capture_io { task.invoke } }
+      events = output.lines.map { |line| JSON.parse(line) }
+      assert_equal %w[attempt_started attempt_finished summary], events.map { |event| event.fetch("event") }
+      assert_equal 2, events.first.fetch("urls").size
+      assert_equal "received", events[1].fetch("receipt")
+      assert_equal "submitted", events.last.fetch("status")
+      refute_includes output, VALID_KEY
+    end
+  end
+
+  def test_invalid_sitemap_fails_before_any_submission
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
+    configuration.storage.write("sitemap-insights.xml", '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"><url><loc>https://private.example/secret</loc></url></urlset>')
+    assert_raises(Indexmap::ValidationError) { Indexmap::Pinger::IndexNow.new(configuration: configuration).ping }
+    assert_not_requested(:post, "https://api.indexnow.org/indexnow")
+  end
+
+  def test_retries_only_a_transient_failed_batch_and_reports_every_attempt
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
+    configuration.index_now.max_attempts = 3
+    configuration.index_now.max_wait = 0
+    configuration.index_now.max_urls_per_request = 1
+    request = stub_request(:post, "https://api.indexnow.org/indexnow")
+      .to_return(status: 200).then.to_return(status: 503).then.to_return(status: 200)
+    events = []
+    result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping { |event| events << event }
+    assert_equal :submitted, result.fetch(:status)
+    assert_equal 2, result.fetch(:url_count)
+    assert_requested request, times: 3
+    started = events.select { |event| event[:event] == :attempt_started }
+    assert_equal [1, 2, 2], started.map { |event| event.fetch(:batch) }
+    assert_equal [1, 1, 2], started.map { |event| event.fetch(:attempt) }
+  end
+
+  def test_does_not_retry_permanent_errors_or_shortcut_long_retry_after
+    [403, 429].each do |status|
+      configuration = configuration_with(storage: sitemap_storage)
+      configuration.index_now.key = VALID_KEY
+      configuration.index_now.max_attempts = 3
+      configuration.index_now.max_wait = 1
+      request = stub_request(:post, "https://api.indexnow.org/indexnow")
+        .to_return(status: status, headers: {"Retry-After" => "120"})
+      assert_equal :failed, Indexmap::Pinger::IndexNow.new(configuration: configuration).ping.fetch(:status)
+      assert_requested request, times: 1
+      WebMock.reset!
+    end
+  end
+
+  def test_selection_and_sending_share_one_resolved_storage
+    config = configuration_with(storage: sitemap_storage)
+    config.index_now.key = VALID_KEY
+    storage = config.storage
+    calls = 0
+    config.storage = -> {
+      calls += 1
+      storage
+    }
+    stub_request(:post, "https://api.indexnow.org/indexnow").to_return(status: 200)
+    result = Indexmap::Pinger::IndexNow.new(configuration: config).ping
+    assert_equal :submitted, result.fetch(:status)
+    assert_equal 1, calls
+  end
+
   private
 
   def with_env(overrides)