indexmap 0.5.0 → 0.7.0

data/test/indexmap/pinger/index_now_test.rb

@@ -6,243 +6,198 @@ 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 = VALID_KEY
+    storage = Indexmap::Storage::Memory.new
+    configuration = configuration_with(storage: storage)
+    configuration.index_now.key = VALID_KEY
 
-      path = Indexmap::Pinger::IndexNow.new(configuration: configuration).write_key_file
+    filename = Indexmap::Pinger::IndexNow.new(configuration: configuration).write_key_file
 
-      assert_equal Pathname(dir).join("#{VALID_KEY}.txt"), path
-      assert_equal VALID_KEY, path.read
-    end
+    assert_equal "#{VALID_KEY}.txt", filename
+    assert_equal VALID_KEY, storage.read(filename)
+  end
+
+  def test_does_not_rewrite_existing_valid_key_file
+    storage = Indexmap::Storage::Memory.new
+    storage.write("#{VALID_KEY}.txt", VALID_KEY, content_type: "text/plain")
+    configuration = configuration_with(storage: storage)
+    configuration.index_now.key = VALID_KEY
+
+    result = Indexmap::Pinger::IndexNow.new(configuration: configuration).write_key_file
+
+    assert_equal "#{VALID_KEY}.txt", result
+    assert_equal VALID_KEY, storage.read(result)
   end
 
   def test_ensure_key_file_generates_a_key_when_configuration_is_missing
-    Dir.mktmpdir do |dir|
-      configuration = Indexmap::Configuration.new
-      configuration.base_url = "https://www.example.com"
-      configuration.public_path = Pathname(dir)
+    storage = Indexmap::Storage::Memory.new
+    configuration = configuration_with(storage: storage)
 
-      path = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
+    filename = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
 
-      assert_match(/\A[a-f0-9]{32}\.txt\z/, path.basename.to_s)
-      assert_equal path.basename(".txt").to_s, path.read
-    end
+    assert_match(/\A[a-f0-9]{32}\.txt\z/, filename)
+    assert_equal filename.delete_suffix(".txt"), storage.read(filename)
   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("#{VALID_KEY}.txt")
-      key_path.write(VALID_KEY)
-      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
+    storage = sitemap_storage
+    storage.write("#{VALID_KEY}.txt", VALID_KEY, content_type: "text/plain")
+    configuration = configuration_with(storage: storage)
 
-      indexnow_url = "https://api.indexnow.org/indexnow"
-      stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
+    indexnow_url = "https://api.indexnow.org/indexnow"
+    stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
 
-      result = 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 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]
+    assert_requested(:post, indexnow_url, times: 1) do |request|
+      payload = JSON.parse(request.body)
+      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
 
   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")
+    storage = Indexmap::Storage::Memory.new
+    storage.write("#{VALID_KEY}.txt", "#{VALID_KEY}\n", content_type: "text/plain")
+    configuration = configuration_with(storage: storage)
 
-      configuration = Indexmap::Configuration.new
-      configuration.base_url = "https://www.example.com"
-      configuration.public_path = public_path
+    filename = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
 
-      path = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
+    refute_equal "#{VALID_KEY}.txt", filename
+    assert_match(/\A[a-f0-9]{32}\.txt\z/, filename)
+    assert_equal filename.delete_suffix(".txt"), storage.read(filename)
+  end
 
-      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
+  def test_pings_all_sitemap_urls_when_no_cutoff_is_provided
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
+
+    indexnow_url = "https://api.indexnow.org/indexnow"
+    stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
+
+    result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+
+    assert_requested(:post, indexnow_url, times: 1) do |request|
+      payload = JSON.parse(request.body)
+      assert_equal [
+        "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
 
-  def test_pings_all_sitemap_urls_when_no_cutoff_is_provided
-    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
+  def test_pings_sitemap_urls_from_directory_storage_keys
+    storage = Indexmap::Storage::Memory.new(public_url: "https://www.example.com")
+    storage.write("sitemaps/sitemap.xml", <<~XML)
+      <?xml version="1.0" encoding="UTF-8"?>
+      <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        <sitemap><loc>https://www.example.com/sitemaps/sitemap-marketing.xml</loc></sitemap>
+      </sitemapindex>
+    XML
+    storage.write("sitemaps/sitemap-marketing.xml", <<~XML)
+      <?xml version="1.0" encoding="UTF-8"?>
+      <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        <url><loc>https://www.example.com/pages/features</loc></url>
+      </urlset>
+    XML
+    configuration = configuration_with(storage: storage, index_filename: "sitemaps/sitemap.xml")
+    configuration.index_now.key = VALID_KEY
 
-      indexnow_url = "https://api.indexnow.org/indexnow"
-      stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
+    indexnow_url = "https://api.indexnow.org/indexnow"
+    stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
 
-      result = 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 [
-          "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]
+    assert_requested(:post, indexnow_url, times: 1) do |request|
+      payload = JSON.parse(request.body)
+      assert_equal ["https://www.example.com/pages/features"], payload.fetch("urlList")
     end
+    assert_equal :submitted, result[:status]
+    assert_equal 1, result[:url_count]
   end
 
   def test_pings_only_sitemap_urls_newer_than_since
-    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
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
 
-      indexnow_url = "https://api.indexnow.org/indexnow"
-      stub_request(:post, indexnow_url).to_return(status: 200, body: "", headers: {})
+    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
-        result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+    with_env("SINCE" => "2026-04-15T00:00:00Z") do
+      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_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|
-        payload = JSON.parse(request.body)
-        assert_equal ["https://www.example.com/pages/features"], payload.fetch("urlList")
-      end
+    assert_requested(:post, indexnow_url, times: 1) do |request|
+      payload = JSON.parse(request.body)
+      assert_equal ["https://www.example.com/pages/features"], payload.fetch("urlList")
     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
+    configuration = configuration_with(storage: sitemap_storage)
 
-      result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+    result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
 
-      assert_equal({status: :skipped, reason: :missing_key}, result)
-    end
+    assert_equal({status: :skipped, reason: :missing_key}, result)
   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
+    configuration = configuration_with(storage: sitemap_storage)
+    configuration.index_now.key = VALID_KEY
 
-      with_env("INDEXNOW_DRY_RUN" => "1") do
-        result = Indexmap::Pinger::IndexNow.new(configuration: configuration).ping
+    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
+      assert_equal :dry_run, result[:status]
+      assert_equal 2, result[:url_count]
+      assert_equal 1, result[:batch_count]
     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
+    configuration = configuration_with(storage: sitemap_storage)
+    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: {})
+    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
+    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
+    assert_equal :failed, result[:status]
+    assert_equal 1, result[:failures].count
+    assert_equal 500, result[:failures].first[:status_code]
   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
+    configuration = configuration_with
+    configuration.index_now.key = "test-key"
 
-      assert_equal "IndexNow key must be a 32-character lowercase hexadecimal string", error.message
+    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
 
   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
+    storage = Indexmap::Storage::Memory.new
+    storage.write("ffffffffffffffffffffffffffffffff.txt", "ffffffffffffffffffffffffffffffff")
+    storage.write("00000000000000000000000000000000.txt", "00000000000000000000000000000000")
+    configuration = configuration_with(storage: storage)
 
-      path = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
+    filename = Indexmap::Pinger::IndexNow.new(configuration: configuration).ensure_key_file
 
-      assert_equal public_path.join("00000000000000000000000000000000.txt"), path
-    end
+    assert_equal "00000000000000000000000000000000.txt", filename
   end
 
   private
@@ -257,8 +212,22 @@ class IndexmapPingerIndexNowTest < Minitest::Test
     end
   end
 
-  def write_sitemap_files(public_path, marketing_lastmod:, insights_lastmod:)
-    public_path.join("sitemap.xml").write(<<~XML)
+  def configuration_with(storage: Indexmap::Storage::Memory.new(public_url: "https://www.example.com"), index_filename: "sitemap.xml")
+    Indexmap::Configuration.new.tap do |configuration|
+      configuration.base_url = "https://www.example.com"
+      configuration.index_filename = index_filename
+      configuration.storage = storage
+    end
+  end
+
+  def sitemap_storage(marketing_lastmod: "2026-04-18T00:00:00Z", insights_lastmod: "2026-04-10T00:00:00Z")
+    Indexmap::Storage::Memory.new(public_url: "https://www.example.com").tap do |storage|
+      write_sitemap_files(storage, marketing_lastmod: marketing_lastmod, insights_lastmod: insights_lastmod)
+    end
+  end
+
+  def write_sitemap_files(storage, marketing_lastmod:, insights_lastmod:)
+    storage.write("sitemap.xml", <<~XML)
       <?xml version="1.0" encoding="UTF-8"?>
       <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
         <sitemap><loc>https://www.example.com/sitemap-marketing.xml</loc></sitemap>
@@ -266,7 +235,7 @@ class IndexmapPingerIndexNowTest < Minitest::Test
       </sitemapindex>
     XML
 
-    public_path.join("sitemap-marketing.xml").write(<<~XML)
+    storage.write("sitemap-marketing.xml", <<~XML)
       <?xml version="1.0" encoding="UTF-8"?>
       <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
         <url>
@@ -276,7 +245,7 @@ class IndexmapPingerIndexNowTest < Minitest::Test
       </urlset>
     XML
 
-    public_path.join("sitemap-insights.xml").write(<<~XML)
+    storage.write("sitemap-insights.xml", <<~XML)
       <?xml version="1.0" encoding="UTF-8"?>
       <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
         <url>

data/test/indexmap/storage_test.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class IndexmapStorageTest < Minitest::Test
+  class FakeAttachment
+    attr_reader :body, :content_type
+
+    def attach(io:, filename:, content_type:)
+      @filename = filename
+      @body = io.read
+      @content_type = content_type
+    end
+
+    def attached?
+      !!@filename
+    end
+
+    def download
+      body
+    end
+
+    def purge
+      @filename = nil
+      @body = nil
+      @content_type = nil
+    end
+  end
+
+  class FakeRecord
+    attr_reader :file
+    attr_accessor :filename
+
+    def initialize(filename:)
+      @filename = filename
+      @file = FakeAttachment.new
+      @persisted = false
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def save!
+      @persisted = true
+    end
+  end
+
+  class FakeRelation
+    include Enumerable
+
+    def initialize(records)
+      @records = records
+    end
+
+    def each(&block)
+      @records.each(&block)
+    end
+  end
+
+  class FakeModel
+    def initialize
+      @records = {}
+    end
+
+    def find_or_initialize_by(filename:)
+      @records[filename] ||= FakeRecord.new(filename: filename)
+    end
+
+    def find_by(filename:)
+      @records[filename]
+    end
+
+    def all
+      FakeRelation.new(@records.values)
+    end
+  end
+
+  def test_filesystem_storage_writes_reads_lists_and_builds_public_urls
+    Dir.mktmpdir do |dir|
+      storage = Indexmap::Storage::Filesystem.new(path: dir, public_url: "https://example.com")
+
+      storage.write("sitemap.xml", "<xml/>")
+      storage.write("sitemaps/sitemap-pages.xml", "<xml/>")
+      storage.write("robots.txt", "robots", content_type: "text/plain")
+
+      assert storage.exist?("sitemap.xml")
+      assert storage.exist?("sitemaps/sitemap-pages.xml")
+      assert_equal "<xml/>", storage.read("sitemap.xml")
+      assert_equal "<xml/>", storage.read("sitemaps/sitemap-pages.xml")
+      assert_equal ["sitemap.xml", "sitemaps/sitemap-pages.xml"], storage.list(prefix: "sitemap", suffix: ".xml")
+      assert_equal "https://example.com/sitemap.xml", storage.public_url("sitemap.xml")
+      assert_equal "https://example.com/sitemaps/sitemap-pages.xml", storage.public_url("sitemaps/sitemap-pages.xml")
+    end
+  end
+
+  def test_filesystem_storage_rejects_absolute_filenames
+    Dir.mktmpdir do |dir|
+      storage = Indexmap::Storage::Filesystem.new(path: dir)
+
+      assert_raises(ArgumentError) { storage.write("/tmp/sitemap.xml", "") }
+    end
+  end
+
+  def test_active_storage_adapter_does_not_require_active_storage_to_load
+    assert Indexmap::Storage::ActiveStorage
+  end
+
+  def test_active_storage_adapter_uses_supplied_model_and_attachment
+    model = FakeModel.new
+    storage = Indexmap::Storage::ActiveStorage.new(
+      model: model,
+      public_url: "https://example.com"
+    )
+
+    storage.write("sitemap.xml", "<xml/>")
+
+    assert storage.exist?("sitemap.xml")
+    assert_equal "<xml/>", storage.read("sitemap.xml")
+    assert_equal ["sitemap.xml"], storage.list(prefix: "sitemap", suffix: ".xml")
+    assert_equal "https://example.com/sitemap.xml", storage.public_url("sitemap.xml")
+  end
+end