indexmap 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a655a2fa64beda7c2724d6fb4f283a13a5baf47519863c489e982efa86f2c32
-  data.tar.gz: 42dac8a1312d05bba81df9534bba52eaa69d55c236688473757252a1038dae06
+  metadata.gz: 9b0f3c8b9175d0c18c39e52b61b3934129dfa8b8b637d06ad3d0d9adc30eb995
+  data.tar.gz: 3baf06c566ce17d63e189aabfdd7f3e7b4047d5908fc6a58f3e017da5ecef1de
 SHA512:
-  metadata.gz: d0615154aef9cf51613b73c46f834efb16c53b77dfb3611f8f980a8ae5c1e8eedaa653ca84ca5610a27b58377717e7c3acbd0fc1cdb162df90fd84d660912ed6
-  data.tar.gz: 796aeed197f26684ebbd74bb7b47d37c878fea855c02c4ec0636cd7ce28c44f32fb73a3c2a911955d194d175c8c80ce351c8b2f955e03707543a88e4ab740763
+  metadata.gz: 700e0cd5485cd433ceaa520a2d634eb4e5ccf93d4d8993224fae61acdf7dacd73c91029e24ff750cc58ce8704a5b00bb4ed66eff113d0693c46df75fc5aea4df
+  data.tar.gz: aa51396dad778e50b18a53606d316d5f9008ed358cecb7b75c0f7dc72f24d47a3959750102fdddafe50fbb31688256e16b07ec9c9c0ae53cb9431148593bb250

data/CHANGELOG.md

@@ -5,12 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.4.0] - 2026-04-22
+## [0.4.2] - 2026-04-23
 
 
-### Documentation
+### Fixed
 
-- improve the task messages (#4)
+- harden sitemap pinging and indexnow key handling (#7)
 
 
 

data/lib/indexmap/pinger/google.rb

@@ -17,10 +17,13 @@ module Indexmap
       def ping
         if google_configuration.credentials.to_s.strip.empty?
           logger.debug("Google sitemap credentials not configured.")
-          return
+          return {status: :skipped, reason: :missing_credentials}
         end
 
-        super
+        results = sitemap_files.map { |sitemap_file| ping_sitemap(sitemap_file) }
+        return {status: :skipped, reason: :no_sitemaps} if results.empty?
+
+        summarize_results(results)
       end
 
       private
@@ -35,18 +38,31 @@ module Indexmap
         sitemap_url = URI.join(host, File.basename(sitemap_file)).to_s
 
         unless authorized?
-          logger.error("Google Search Console does not have access to the site: #{root_domain}")
-          return
+          logger.debug("Google Search Console does not have access to the site: #{root_domain}")
+          return {
+            status: :failed,
+            reason: :unauthorized,
+            property: property_identifier,
+            root_domain: root_domain
+          }
         end
 
         webmasters_service.submit_sitemap(property_identifier, sitemap_url)
         logger.debug { "Successfully pinged Google with sitemap: #{sitemap_url}" }
+        {status: :submitted, sitemap_url: sitemap_url}
       rescue ::Google::Apis::ClientError => e
         logger.debug { "Failed to ping Google for #{sitemap_url}. Status: #{e.status_code}, Body: #{e.body}" }
+        {
+          status: :failed,
+          reason: :client_error,
+          sitemap_url: sitemap_url,
+          status_code: e.status_code,
+          body: e.body
+        }
       end
 
       def authorized?
-        webmasters_service.list_sites.site_entry.any? { |site| site.site_url.include?(root_domain) }
+        @authorized ||= accessible_site_urls.include?(property_identifier)
       end
 
       def property_identifier
@@ -73,6 +89,25 @@ module Indexmap
           scope: scope
         )
       end
+
+      def summarize_results(results)
+        submitted = results.select { |result| result[:status] == :submitted }
+        failures = results.select { |result| result[:status] == :failed }
+
+        return {status: :submitted, sitemap_count: submitted.count, submitted: submitted} if failures.empty?
+        return {status: :failed, sitemap_count: 0, failures: failures} if submitted.empty?
+
+        {
+          status: :partial,
+          sitemap_count: submitted.count,
+          submitted: submitted,
+          failures: failures
+        }
+      end
+
+      def accessible_site_urls
+        @accessible_site_urls ||= Array(webmasters_service.list_sites.site_entry).map(&:site_url)
+      end
     end
   end
 end

data/lib/indexmap/pinger/index_now.rb

@@ -8,6 +8,8 @@ require "time"
 module Indexmap
   module Pinger
     class IndexNow < Base
+      KEY_FORMAT = /\A[a-f0-9]{32}\z/
+
       def initialize(configuration: Indexmap.configuration, connection: nil)
         super(configuration: configuration)
         @connection = connection
@@ -17,42 +19,45 @@ module Indexmap
         api_key = read_api_key
         unless api_key
           logger.debug("IndexNow API key is not configured.")
-          return
+          return {status: :skipped, reason: :missing_key}
         end
 
         entries = entries_to_ping
         if entries.empty?
           logger.debug("IndexNow: no URLs matched the current filter.")
-          return
+          return {status: :skipped, reason: :no_urls}
         end
 
-        entries.each_slice(max_urls_per_request) do |batch|
+        results = entries.each_slice(max_urls_per_request).map do |batch|
           urls = batch.map(&:loc)
 
           if dry_run?
             logger.debug { "IndexNow dry-run: would ping #{urls.count} URLs." }
-            next
+            next({status: :dry_run, url_count: urls.count})
           end
 
           submit_batch(api_key: api_key, urls: urls)
         end
+
+        summarize_results(results)
       end
 
       def write_key_file(key: index_now_configuration.key, path: nil)
-        key = key.to_s.strip
+        key = normalized_configured_key(key)
         return if key.empty?
 
         path ||= index_now_configuration.key_path(public_path: configuration.public_path, key: key)
         FileUtils.mkdir_p(path.dirname)
-        File.write(path, "#{key}\n")
+        File.write(path, key)
         path
       end
 
       def ensure_key_file
-        configured_key = index_now_configuration.key.to_s.strip
+        configured_key = normalized_configured_key(index_now_configuration.key)
         return write_key_file(key: configured_key) unless configured_key.empty?
 
-        return existing_key_file if existing_key_file
+        existing_path = existing_key_file
+        return existing_path if existing_path
 
         key = generated_key
         write_key_file(key: key, path: configuration.public_path.join("#{key}.txt"))
@@ -141,6 +146,9 @@ module Indexmap
 
       def submit_batch(api_key:, urls:)
         payload = {host: hostname, key: api_key, urlList: urls}
+        location = key_location(api_key: api_key)
+        payload[:keyLocation] = location if location
+
         response = index_now_connection.post("/indexnow") do |request|
           request.headers["Content-Type"] = "application/json"
           request.body = payload.to_json
@@ -148,10 +156,10 @@ module Indexmap
 
         if response.success?
           logger.debug { "Successfully pinged IndexNow with #{urls.count} URLs." }
-          true
+          {status: :submitted, url_count: urls.count}
         else
           logger.debug { "Failed to ping IndexNow. Status: #{response.status}, Body: #{response.body}" }
-          false
+          {status: :failed, url_count: urls.count, status_code: response.status, body: response.body}
         end
       end
 
@@ -166,30 +174,88 @@ module Indexmap
       end
 
       def read_api_key
-        configured_key = index_now_configuration.key.to_s.strip
+        configured_key = normalized_configured_key(index_now_configuration.key)
         return configured_key unless configured_key.empty?
 
-        existing_key_file&.read&.strip
+        existing_key_file&.read
       end
 
       def existing_key_file
         configured_path = index_now_configuration.key_path(public_path: configuration.public_path)
         return configured_path if valid_key_file?(configured_path)
 
-        configuration.public_path.glob("*.txt").find { |file| valid_key_file?(file) }
+        configuration.public_path.glob("*.txt").sort.find { |file| valid_key_file?(file) }
+      end
+
+      def key_location(api_key:)
+        path = index_now_configuration.key_path(public_path: configuration.public_path, key: api_key) || existing_key_file
+        return unless path
+
+        public_path = configuration.public_path.expand_path
+        key_path = path.expand_path
+        relative_path = key_path.relative_path_from(public_path)
+
+        URI.join("#{host}/", relative_path.to_s).to_s
+      rescue ArgumentError
+        nil
       end
 
       def valid_key_file?(path)
         return false unless path&.file?
 
         filename = path.basename(".txt").to_s
-        return false unless filename.match?(/\A[a-zA-Z0-9-]{8,128}\z/)
+        return false unless filename.match?(KEY_FORMAT)
 
-        path.read.strip == filename
+        path.read == filename
       end
 
       def generated_key
-        SecureRandom.uuid
+        SecureRandom.hex(16)
+      end
+
+      def normalized_configured_key(value)
+        key = value.to_s.strip
+        return key if key.empty? || key.match?(KEY_FORMAT)
+
+        raise ConfigurationError, "IndexNow key must be a 32-character lowercase hexadecimal string"
+      end
+
+      def summarize_results(results)
+        dry_runs = results.select { |result| result[:status] == :dry_run }
+        submitted = results.select { |result| result[:status] == :submitted }
+        failures = results.select { |result| result[:status] == :failed }
+
+        if dry_runs.any?
+          return {
+            status: :dry_run,
+            url_count: dry_runs.sum { |result| result[:url_count] },
+            batch_count: dry_runs.count
+          }
+        end
+
+        if failures.empty?
+          return {
+            status: :submitted,
+            url_count: submitted.sum { |result| result[:url_count] },
+            batch_count: submitted.count
+          }
+        end
+
+        if submitted.empty?
+          return {
+            status: :failed,
+            url_count: 0,
+            batch_count: 0,
+            failures: failures
+          }
+        end
+
+        {
+          status: :partial,
+          url_count: submitted.sum { |result| result[:url_count] },
+          batch_count: submitted.count,
+          failures: failures
+        }
       end
     end
   end

data/lib/indexmap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Indexmap
-  VERSION = "0.4.0"
+  VERSION = "0.4.2"
 end

data/lib/indexmap/writer.rb

@@ -82,7 +82,8 @@ module Indexmap
       sitemap_sections.each do |section|
         lines << "  <sitemap>"
         lines << "    <loc>#{escape(index_loc(section.filename))}</loc>"
-        lines << "    <lastmod>#{format_lastmod(section_lastmod(section))}</lastmod>"
+        lastmod = section_lastmod(section)
+        lines << "    <lastmod>#{format_lastmod(lastmod)}</lastmod>" if lastmod
         lines << "  </sitemap>"
       end
 
@@ -102,7 +103,7 @@ module Indexmap
 
     def section_lastmod(section)
       timestamps = Array(section.entries).map { |entry| comparable_lastmod(normalize_entry(entry).lastmod) }.compact
-      timestamps.max || Time.now.utc
+      timestamps.max
     end
 
     def format_lastmod(value)

data/lib/tasks/indexmap_tasks.rake

@@ -35,14 +35,40 @@ namespace :sitemap do
   namespace :google do
     desc "Ping Google Search Console"
     task ping: :environment do
-      Indexmap::Pinger::Google.new.ping
+      result = Indexmap::Pinger::Google.new.ping
+
+      case result[:status]
+      when :submitted
+        puts "Submitted #{result[:sitemap_count]} sitemap #{(result[:sitemap_count] == 1) ? "file" : "files"} to Google Search Console."
+      when :partial
+        puts "Submitted #{result[:sitemap_count]} sitemap #{(result[:sitemap_count] == 1) ? "file" : "files"} to Google Search Console, with #{result[:failures].count} failure#{"s" unless result[:failures].count == 1}."
+        result[:failures].each { |failure| puts format_google_ping_failure(failure) }
+      when :failed
+        result[:failures].each { |failure| puts format_google_ping_failure(failure) }
+      when :skipped
+        puts format_google_ping_skip(result)
+      end
     end
   end
 
   namespace :index_now do
     desc "Ping IndexNow. ENV: SINCE=2026-04-18T10:30:00Z or INDEXNOW_RECENT_HOURS=24"
     task ping: :environment do
-      Indexmap::Pinger::IndexNow.new.ping
+      result = Indexmap::Pinger::IndexNow.new.ping
+
+      case result[:status]
+      when :submitted
+        puts "Submitted #{result[:url_count]} URL#{"s" unless result[:url_count] == 1} to IndexNow in #{result[:batch_count]} request#{"s" unless result[:batch_count] == 1}."
+      when :partial
+        puts "Submitted #{result[:url_count]} URL#{"s" unless result[:url_count] == 1} to IndexNow in #{result[:batch_count]} request#{"s" unless result[:batch_count] == 1}, with #{result[:failures].count} failure#{"s" unless result[:failures].count == 1}."
+        result[:failures].each { |failure| puts format_index_now_ping_failure(failure) }
+      when :failed
+        result[:failures].each { |failure| puts format_index_now_ping_failure(failure) }
+      when :dry_run
+        puts "IndexNow dry-run: would submit #{result[:url_count]} URL#{"s" unless result[:url_count] == 1} in #{result[:batch_count]} request#{"s" unless result[:batch_count] == 1}."
+      when :skipped
+        puts format_index_now_ping_skip(result)
+      end
     end
 
     desc "Ensure the IndexNow key file exists in public/"
@@ -64,4 +90,46 @@ namespace :sitemap do
   def public_directory(runner)
     runner.public_path
   end
+
+  def format_google_ping_failure(failure)
+    case failure[:reason]
+    when :unauthorized
+      "Google Search Console does not have access to #{failure[:property]}."
+    when :client_error
+      "Google ping failed for #{failure[:sitemap_url]} (status #{failure[:status_code]})."
+    else
+      "Google ping failed."
+    end
+  end
+
+  def format_google_ping_skip(result)
+    case result[:reason]
+    when :missing_credentials
+      "Google sitemap credentials are not configured; skipped Google submission."
+    when :no_sitemaps
+      "No sitemap files found; skipped Google submission."
+    else
+      "Skipped Google submission."
+    end
+  end
+
+  def format_index_now_ping_failure(failure)
+    case failure[:status_code]
+    when nil
+      "IndexNow submission failed."
+    else
+      "IndexNow submission failed for #{failure[:url_count]} URL#{"s" unless failure[:url_count] == 1} (status #{failure[:status_code]})."
+    end
+  end
+
+  def format_index_now_ping_skip(result)
+    case result[:reason]
+    when :missing_key
+      "IndexNow key is not configured and no valid key file was found; skipped IndexNow submission."
+    when :no_urls
+      "No sitemap URLs matched the current IndexNow filter; skipped IndexNow submission."
+    else
+      "Skipped IndexNow submission."
+    end
+  end
 end

data/test/indexmap/pinger/google_test.rb

@@ -8,13 +8,15 @@ class IndexmapPingerGoogleTest < Minitest::Test
 
   class FakeWebmastersService
     attr_accessor :authorization
-    attr_reader :submitted
+    attr_reader :submitted, :list_sites_calls
 
     def initialize(site_urls:)
       @site_urls = site_urls
+      @list_sites_calls = 0
     end
 
     def list_sites
+      @list_sites_calls += 1
       SiteList.new(@site_urls.map { |site_url| SiteEntry.new(site_url) })
     end
 
@@ -40,7 +42,7 @@ class IndexmapPingerGoogleTest < Minitest::Test
         :fake_authorizer
       end
 
-      Indexmap::Pinger::Google.new(
+      result = Indexmap::Pinger::Google.new(
         configuration: configuration,
         service: service,
         credentials_builder: credentials_builder
@@ -49,6 +51,9 @@ class IndexmapPingerGoogleTest < Minitest::Test
       assert_equal [["{\"type\":\"service_account\"}", "https://www.googleapis.com/auth/webmasters"]], builder_calls
       assert_equal :fake_authorizer, service.authorization
       assert_equal ["sc-domain:example.com", "https://www.example.com/sitemap.xml"], service.submitted
+      assert_equal :submitted, result[:status]
+      assert_equal 1, result[:sitemap_count]
+      assert_equal 1, service.list_sites_calls
     end
   end
 
@@ -63,9 +68,76 @@ class IndexmapPingerGoogleTest < Minitest::Test
 
       service = FakeWebmastersService.new(site_urls: ["sc-domain:example.com"])
 
-      Indexmap::Pinger::Google.new(configuration: configuration, service: service).ping
+      result = Indexmap::Pinger::Google.new(configuration: configuration, service: service).ping
 
       assert_nil service.submitted
+      assert_equal({status: :skipped, reason: :missing_credentials}, result)
+    end
+  end
+
+  def test_reports_missing_sitemap_files
+    Dir.mktmpdir do |dir|
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = Pathname(dir)
+      configuration.google.credentials = "{\"type\":\"service_account\"}"
+
+      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({status: :skipped, reason: :no_sitemaps}, result)
+      assert_nil service.submitted
+    end
+  end
+
+  def test_reports_google_authorization_failure
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      public_path.join("sitemap.xml").write("<sitemapindex/>")
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+      configuration.google.credentials = "{\"type\":\"service_account\"}"
+
+      service = FakeWebmastersService.new(site_urls: ["sc-domain:not-example.org"])
+      result = Indexmap::Pinger::Google.new(
+        configuration: configuration,
+        service: service,
+        credentials_builder: ->(**) { :fake_authorizer }
+      ).ping
+
+      assert_equal :failed, result[:status]
+      assert_equal 1, result[:failures].count
+      assert_equal :unauthorized, result[:failures].first[:reason]
+      assert_nil service.submitted
+    end
+  end
+
+  def test_google_authorization_requires_exact_property_match
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      public_path.join("sitemap.xml").write("<sitemapindex/>")
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+      configuration.google.credentials = "{\"type\":\"service_account\"}"
+
+      service = FakeWebmastersService.new(site_urls: ["sc-domain:myexample.com"])
+      result = Indexmap::Pinger::Google.new(
+        configuration: configuration,
+        service: service,
+        credentials_builder: ->(**) { :fake_authorizer }
+      ).ping
+
+      assert_equal :failed, result[:status]
+      assert_equal :unauthorized, result[:failures].first[:reason]
+      assert_nil service.submitted
     end
   end
 end

data/test/indexmap/pinger/index_now_test.rb

@@ -3,17 +3,19 @@
 require "test_helper"
 
 class IndexmapPingerIndexNowTest < Minitest::Test
+  VALID_KEY = "1234567890abcdef1234567890abcdef"
+
   def test_writes_key_file_from_configuration
     Dir.mktmpdir do |dir|
       configuration = Indexmap::Configuration.new
       configuration.base_url = "https://www.example.com"
       configuration.public_path = Pathname(dir)
-      configuration.index_now.key = "test-key"
+      configuration.index_now.key = VALID_KEY
 
       path = Indexmap::Pinger::IndexNow.new(configuration: configuration).write_key_file
 
-      assert_equal Pathname(dir).join("test-key.txt"), path
-      assert_equal "test-key\n", path.read
+      assert_equal Pathname(dir).join("#{VALID_KEY}.txt"), path
+      assert_equal VALID_KEY, path.read
     end
   end
 
@@ -25,16 +27,16 @@ class IndexmapPingerIndexNowTest < Minitest::Test
 
       path = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
 
-      assert_match(/\A[a-z0-9-]{8,128}\.txt\z/, path.basename.to_s)
-      assert_equal "#{path.basename(".txt")}\n", path.read
+      assert_match(/\A[a-f0-9]{32}\.txt\z/, path.basename.to_s)
+      assert_equal path.basename(".txt").to_s, path.read
     end
   end
 
   def test_pings_using_existing_key_file_when_key_is_not_configured
     Dir.mktmpdir do |dir|
       public_path = Pathname(dir)
-      key_path = public_path.join("test-key-123.txt")
-      key_path.write("test-key-123\n")
+      key_path = public_path.join("#{VALID_KEY}.txt")
+      key_path.write(VALID_KEY)
       write_sitemap_files(
         public_path,
         marketing_lastmod: "2026-04-18T00:00:00Z",
@@ -48,12 +50,34 @@ class IndexmapPingerIndexNowTest < Minitest::Test
       indexnow_url = "https://api.indexnow.org/indexnow"
       stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
 
-      Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+      result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
 
       assert_requested(:post, indexnow_url, times: 1) do |request|
         payload = JSON.parse(request.body)
-        assert_equal "test-key-123", payload.fetch("key")
+        assert_equal VALID_KEY, payload.fetch("key")
+        assert_equal "https://www.example.com/#{VALID_KEY}.txt", payload.fetch("keyLocation")
       end
+      assert_equal :submitted, result[:status]
+      assert_equal 2, result[:url_count]
+      assert_equal 1, result[:batch_count]
+    end
+  end
+
+  def test_ignores_existing_key_file_with_trailing_newline
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      invalid_key_path = public_path.join("1234567890abcdef1234567890abcdef.txt")
+      invalid_key_path.write("#{VALID_KEY}\n")
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+
+      path = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
+
+      refute_equal invalid_key_path, path
+      assert_match(/\A[a-f0-9]{32}\.txt\z/, path.basename.to_s)
+      assert_equal path.basename(".txt").to_s, path.read
     end
   end
 
@@ -69,12 +93,12 @@ class IndexmapPingerIndexNowTest < Minitest::Test
       configuration = Indexmap::Configuration.new
       configuration.base_url = "https://www.example.com"
       configuration.public_path = public_path
-      configuration.index_now.key = "test-key"
+      configuration.index_now.key = VALID_KEY
 
       indexnow_url = "https://api.indexnow.org/indexnow"
       stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
 
-      Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+      result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
 
       assert_requested(:post, indexnow_url, times: 1) do |request|
         payload = JSON.parse(request.body)
@@ -82,7 +106,11 @@ class IndexmapPingerIndexNowTest < Minitest::Test
           "https://www.example.com/pages/features",
           "https://www.example.com/insights/us/restaurants/overview"
         ].sort, payload.fetch("urlList").sort
+        assert_equal "https://www.example.com/#{VALID_KEY}.txt", payload.fetch("keyLocation")
       end
+      assert_equal :submitted, result[:status]
+      assert_equal 2, result[:url_count]
+      assert_equal 1, result[:batch_count]
     end
   end
 
@@ -98,13 +126,17 @@ class IndexmapPingerIndexNowTest < Minitest::Test
       configuration = Indexmap::Configuration.new
       configuration.base_url = "https://www.example.com"
       configuration.public_path = public_path
-      configuration.index_now.key = "test-key"
+      configuration.index_now.key = VALID_KEY
 
       indexnow_url = "https://api.indexnow.org/indexnow"
       stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
 
       with_env("SINCE" => "2026-04-15T00:00:00Z") do
-        Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+        result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+
+        assert_equal :submitted, result[:status]
+        assert_equal 1, result[:url_count]
+        assert_equal 1, result[:batch_count]
       end
 
       assert_requested(:post, indexnow_url, times: 1) do |request|
@@ -114,6 +146,105 @@ class IndexmapPingerIndexNowTest < Minitest::Test
     end
   end
 
+  def test_skips_indexnow_ping_when_key_is_missing
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      write_sitemap_files(
+        public_path,
+        marketing_lastmod: "2026-04-18T00:00:00Z",
+        insights_lastmod: "2026-04-10T00:00:00Z"
+      )
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+
+      result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+
+      assert_equal({status: :skipped, reason: :missing_key}, result)
+    end
+  end
+
+  def test_reports_indexnow_dry_run
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      write_sitemap_files(
+        public_path,
+        marketing_lastmod: "2026-04-18T00:00:00Z",
+        insights_lastmod: "2026-04-10T00:00:00Z"
+      )
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+      configuration.index_now.key = VALID_KEY
+
+      with_env("INDEXNOW_DRY_RUN" => "1") do
+        result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+
+        assert_equal :dry_run, result[:status]
+        assert_equal 2, result[:url_count]
+        assert_equal 1, result[:batch_count]
+      end
+    end
+  end
+
+  def test_reports_failed_indexnow_submission
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      write_sitemap_files(
+        public_path,
+        marketing_lastmod: "2026-04-18T00:00:00Z",
+        insights_lastmod: "2026-04-10T00:00:00Z"
+      )
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+      configuration.index_now.key = VALID_KEY
+
+      indexnow_url = "https://api.indexnow.org/indexnow"
+      stub_request(:post, indexnow_url).to_return(status: 500, body: "boom", headers: {})
+
+      result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+
+      assert_equal :failed, result[:status]
+      assert_equal 1, result[:failures].count
+      assert_equal 500, result[:failures].first[:status_code]
+    end
+  end
+
+  def test_rejects_invalid_configured_key
+    Dir.mktmpdir do |dir|
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = Pathname(dir)
+      configuration.index_now.key = "test-key"
+
+      error = assert_raises(Indexmap::ConfigurationError) do
+        Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+      end
+
+      assert_equal "IndexNow key must be a 32-character lowercase hexadecimal string", error.message
+    end
+  end
+
+  def test_reuses_existing_key_file_deterministically
+    Dir.mktmpdir do |dir|
+      public_path = Pathname(dir)
+      public_path.join("ffffffffffffffffffffffffffffffff.txt").write("ffffffffffffffffffffffffffffffff")
+      public_path.join("00000000000000000000000000000000.txt").write("00000000000000000000000000000000")
+
+      configuration = Indexmap::Configuration.new
+      configuration.base_url = "https://www.example.com"
+      configuration.public_path = public_path
+
+      path = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
+
+      assert_equal public_path.join("00000000000000000000000000000000.txt"), path
+    end
+  end
+
   private
 
   def with_env(overrides)

data/test/indexmap/task_runner_test.rb

@@ -3,6 +3,8 @@
 require "test_helper"
 
 class IndexmapTaskRunnerTest < Minitest::Test
+  VALID_KEY = "1234567890abcdef1234567890abcdef"
+
   def test_create_removes_existing_sitemap_files_writes_new_sitemap_and_key_file
     Dir.mktmpdir do |dir|
       public_path = Pathname(dir)
@@ -18,15 +20,15 @@ class IndexmapTaskRunnerTest < Minitest::Test
           entries: [Indexmap::Entry.new(loc: "https://example.com/about")]
         )
       ]
-      configuration.index_now.key = "test-key"
+      configuration.index_now.key = VALID_KEY
 
       result = Indexmap::TaskRunner.new(configuration: configuration).create
 
       assert_equal false, public_path.join("sitemap-pages.xml.gz").exist?
       assert_includes public_path.join("sitemap.xml").read, "<sitemapindex"
-      assert_equal "test-key\n", public_path.join("test-key.txt").read
+      assert_equal VALID_KEY, public_path.join("#{VALID_KEY}.txt").read
       assert_equal [public_path.join("sitemap-pages.xml").to_s, public_path.join("sitemap.xml").to_s], result[:files]
-      assert_equal public_path.join("test-key.txt"), result[:index_now_key_path]
+      assert_equal public_path.join("#{VALID_KEY}.txt"), result[:index_now_key_path]
     end
   end
 
@@ -56,8 +58,8 @@ class IndexmapTaskRunnerTest < Minitest::Test
 
       result = Indexmap::TaskRunner.new(configuration: configuration).write_index_now_key(generate_if_missing: true)
 
-      assert_match(/\A[a-z0-9-]{8,128}\.txt\z/, result.basename.to_s)
-      assert_equal "#{result.basename(".txt")}\n", result.read
+      assert_match(/\A[a-f0-9]{32}\.txt\z/, result.basename.to_s)
+      assert_equal result.basename(".txt").to_s, result.read
     end
   end
 end

data/test/indexmap/writer_test.rb

@@ -77,4 +77,23 @@ class IndexmapWriterTest < Minitest::Test
       refute File.exist?(File.join(directory, "sitemap-pages.xml"))
     end
   end
+
+  def test_omits_sitemap_index_lastmod_when_sections_have_no_lastmod
+    Dir.mktmpdir do |directory|
+      Indexmap::Writer.new(
+        sections: [
+          Indexmap::Section.new(
+            filename: "sitemap-pages.xml",
+            entries: [Indexmap::Entry.new(loc: "https://example.com/about")]
+          )
+        ],
+        public_path: directory,
+        base_url: "https://example.com"
+      ).write
+
+      index_xml = File.read(File.join(directory, "sitemap.xml"))
+
+      refute_includes index_xml, "<lastmod>"
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: indexmap
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Paulo Fidalgo