indexmap 0.6.0 → 0.7.0

data/test/indexmap/configuration_test.rb

@@ -8,41 +8,49 @@ class IndexmapConfigurationTest < Minitest::Test
   end
 
   def test_writer_builds_from_configured_callables
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-
-      Indexmap.configure do |config|
-        config.base_url = -> { "https://example.com" }
-        config.public_path = -> { public_path }
-        config.sections = -> do
-          [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [Indexmap::Entry.new(loc: "https://example.com/")])]
-        end
+    Indexmap.configure do |config|
+      config.base_url = -> { "https://example.com" }
+      config.sections = -> do
+        [Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [Indexmap::Entry.new(loc: "https://example.com/")])]
       end
+    end
+
+    files = Indexmap.configuration.writer.write
 
-      Indexmap.configuration.writer.write
+    assert_includes files.find { |file| file.filename == "sitemap.xml" }.body, "<loc>https://example.com/sitemap-pages.xml</loc>"
+    assert_includes files.find { |file| file.filename == "sitemap-pages.xml" }.body, "<loc>https://example.com/</loc>"
+  end
+
+  def test_create_writes_to_configured_storage
+    storage = Indexmap::Storage::Memory.new
 
-      assert_includes public_path.join("sitemap.xml").read, "<loc>https://example.com/sitemap-pages.xml</loc>"
-      assert_includes public_path.join("sitemap-pages.xml").read, "<loc>https://example.com/</loc>"
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      config.sections = [
+        Indexmap::Section.new(filename: "sitemap-pages.xml", entries: [Indexmap::Entry.new(loc: "https://example.com/")])
+      ]
     end
+
+    files = Indexmap.create
+
+    assert_equal ["sitemap-pages.xml", "sitemap.xml"], files
+    assert_includes storage.read("sitemap.xml"), "<loc>https://example.com/sitemap-pages.xml</loc>"
+    assert_includes storage.read("sitemap-pages.xml"), "<loc>https://example.com/</loc>"
   end
 
   def test_writer_builds_single_file_writer_from_configured_entries
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-
-      Indexmap.configure do |config|
-        config.base_url = "https://example.com"
-        config.public_path = public_path
-        config.format = :single_file
-        config.entries = -> { [Indexmap::Entry.new(loc: "https://example.com/")] }
-      end
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.format = :single_file
+      config.entries = -> { [Indexmap::Entry.new(loc: "https://example.com/")] }
+    end
 
-      Indexmap.configuration.writer.write
+    files = Indexmap.configuration.writer.write
 
-      assert_includes public_path.join("sitemap.xml").read, "<urlset"
-      assert_includes public_path.join("sitemap.xml").read, "<loc>https://example.com/</loc>"
-      refute public_path.join("sitemap-pages.xml").exist?
-    end
+    assert_equal ["sitemap.xml"], files.map(&:filename)
+    assert_includes files.fetch(0).body, "<urlset"
+    assert_includes files.fetch(0).body, "<loc>https://example.com/</loc>"
   end
 
   def test_writer_raises_without_base_url
@@ -83,141 +91,102 @@ class IndexmapConfigurationTest < Minitest::Test
       config.google.credentials = -> { "{\"type\":\"service_account\"}" }
       config.google.property = -> { "sc-domain:example.com" }
       config.index_now.key = -> { "example-key" }
+      config.index_now.key_filename = -> { "index-now-key.txt" }
       config.index_now.max_urls_per_request = -> { 250 }
+      config.index_now.write_key_file = -> { false }
     end
 
     assert_equal "{\"type\":\"service_account\"}", Indexmap.configuration.google.credentials
     assert_equal "sc-domain:example.com", Indexmap.configuration.google.property
     assert_equal "example-key", Indexmap.configuration.index_now.key
+    assert_equal "index-now-key.txt", Indexmap.configuration.index_now.key_filename
     assert_equal 250, Indexmap.configuration.index_now.max_urls_per_request
+    refute Indexmap.configuration.index_now.write_key_file?
   end
 
-  def test_named_outputs_inherit_configuration_defaults
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-
-      Indexmap.configure do |config|
-        config.base_url = "https://example.com"
-        config.public_path = public_path
-        config.output :reports do |output|
-          output.sections = [
-            Indexmap::Section.new(
-              filename: "sitemap-reports.xml",
-              entries: [Indexmap::Entry.new(loc: "https://example.com/reports")]
-            )
-          ]
-        end
-      end
+  def test_index_now_key_file_writing_defaults_to_configured_key_presence
+    config = Indexmap::Configuration.new
 
-      files = Indexmap.create(:reports)
+    refute config.index_now.write_key_file?
 
-      assert_equal [
-        public_path.join("sitemap-reports.xml"),
-        public_path.join("sitemap.xml")
-      ], files
-      assert_includes public_path.join("sitemap.xml").read, "https://example.com/sitemap-reports.xml"
-    end
-  end
+    config.index_now.key = "1234567890abcdef1234567890abcdef"
 
-  def test_create_writes_named_output_to_public_path
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-
-      Indexmap.configure do |config|
-        config.base_url = "https://example.com"
-        config.public_path = public_path
-        config.output :dynamic do |output|
-          output.sections = [
-            Indexmap::Section.new(
-              filename: "sitemap-dynamic.xml",
-              entries: [Indexmap::Entry.new(loc: "https://example.com/dynamic")]
-            )
-          ]
-        end
-      end
+    assert config.index_now.write_key_file?
+  end
 
-      files = Indexmap.create(:dynamic)
+  def test_index_now_key_file_writing_can_be_disabled_with_a_configured_key
+    config = Indexmap::Configuration.new
+    config.index_now.key = "1234567890abcdef1234567890abcdef"
+    config.index_now.write_key_file = false
 
-      assert_equal [
-        public_path.join("sitemap-dynamic.xml"),
-        public_path.join("sitemap.xml")
-      ], files
-      assert_includes public_path.join("sitemap-dynamic.xml").read, "https://example.com/dynamic"
-      assert_includes public_path.join("sitemap.xml").read, "https://example.com/sitemap-dynamic.xml"
-    end
+    refute config.index_now.write_key_file?
   end
 
-  def test_create_preserves_existing_files_when_validation_fails
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-      public_path.join("sitemap.xml").write("old index")
-      public_path.join("sitemap-pages.xml").write("old child")
-
-      Indexmap.configure do |config|
-        config.base_url = "https://example.com"
-        config.public_path = public_path
-        config.sections = [
+  def test_named_outputs_inherit_configuration_defaults
+    storage = Indexmap::Storage::Memory.new
+
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      config.output :reports do |output|
+        output.sections = [
           Indexmap::Section.new(
-            filename: "sitemap-pages.xml",
-            entries: [Indexmap::Entry.new(loc: "https://example.com/about?utm_source=test")]
+            filename: "sitemap-reports.xml",
+            entries: [Indexmap::Entry.new(loc: "https://example.com/reports")]
           )
         ]
       end
+    end
 
-      error = assert_raises(Indexmap::ValidationError) { Indexmap.create }
+    files = Indexmap.create(:reports)
 
-      assert_match "Parameterized sitemap URLs detected", error.message
-      assert_equal "old index", public_path.join("sitemap.xml").read
-      assert_equal "old child", public_path.join("sitemap-pages.xml").read
-    end
+    assert_equal ["sitemap-reports.xml", "sitemap.xml"], files
+    assert_includes storage.read("sitemap.xml"), "https://example.com/sitemap-reports.xml"
   end
 
   def test_create_writes_single_file_named_output_without_default_index
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-
-      Indexmap.configure do |config|
-        config.base_url = "https://example.com"
-        config.public_path = public_path
-        config.output :dynamic do |output|
-          output.format = :single_file
-          output.index_filename = "sitemap-dynamic.xml"
-          output.entries = [
-            Indexmap::Entry.new(loc: "https://example.com/dynamic")
-          ]
-        end
+    storage = Indexmap::Storage::Memory.new
+
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      config.output :dynamic do |output|
+        output.format = :single_file
+        output.index_filename = "sitemap-dynamic.xml"
+        output.entries = [
+          Indexmap::Entry.new(loc: "https://example.com/dynamic")
+        ]
       end
+    end
 
-      files = Indexmap.create(:dynamic)
+    files = Indexmap.create(:dynamic)
 
-      assert_equal [public_path.join("sitemap-dynamic.xml")], files
-      refute public_path.join("sitemap.xml").exist?
-      assert_includes public_path.join("sitemap-dynamic.xml").read, "https://example.com/dynamic"
-    end
+    assert_equal ["sitemap-dynamic.xml"], files
+    refute storage.exist?("sitemap.xml")
+    assert_includes storage.read("sitemap-dynamic.xml"), "https://example.com/dynamic"
   end
 
-  def test_create_preserves_existing_named_output_when_validation_fails
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-      public_path.join("sitemap-dynamic.xml").write("old dynamic")
-
-      Indexmap.configure do |config|
-        config.base_url = "https://example.com"
-        config.public_path = public_path
-        config.output :dynamic do |output|
-          output.format = :single_file
-          output.index_filename = "sitemap-dynamic.xml"
-          output.entries = [
-            Indexmap::Entry.new(loc: "https://example.com/dynamic?utm_source=test")
-          ]
-        end
-      end
-
-      error = assert_raises(Indexmap::ValidationError) { Indexmap.create(:dynamic) }
+  def test_create_preserves_existing_files_when_validation_fails
+    storage = Indexmap::Storage::Memory.new
+    storage.write("sitemap.xml", "old index")
+    storage.write("sitemap-pages.xml", "old child")
 
-      assert_match "Parameterized sitemap URLs detected", error.message
-      assert_equal "old dynamic", public_path.join("sitemap-dynamic.xml").read
+    Indexmap.configure do |config|
+      config.base_url = "https://example.com"
+      config.storage = storage
+      config.sections = [
+        Indexmap::Section.new(
+          filename: "sitemap-pages.xml",
+          entries: [Indexmap::Entry.new(loc: "https://example.com/about?utm_source=test")]
+        )
+      ]
     end
+
+    error = assert_raises(Indexmap::ValidationError) { Indexmap.create }
+
+    assert_match "Parameterized sitemap URLs detected", error.message
+    assert_equal "old index", storage.read("sitemap.xml")
+    assert_equal "old child", storage.read("sitemap-pages.xml")
   end
 
   def test_after_create_requires_a_block

data/test/indexmap/parser_test.rb

@@ -16,7 +16,7 @@ class IndexmapParserTest < Minitest::Test
         XML
       )
 
-    parser = Indexmap::Parser.new(path: "https://www.example.com/sitemap.xml")
+    parser = Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml")
 
     assert_equal ["/", "/pages/features"], parser.paths
   end
@@ -44,7 +44,7 @@ class IndexmapParserTest < Minitest::Test
         XML
       )
 
-    parser = Indexmap::Parser.new(path: "https://www.example.com/sitemap.xml")
+    parser = Indexmap::Parser.new(source: "https://www.example.com/sitemap.xml")
 
     assert_equal ["/tools/google-reviews-calculator"], parser.paths
     assert_equal ["https://www.reviato.com/tools/google-reviews-calculator"], parser.urls(base_url: "https://www.reviato.com")
@@ -73,9 +73,50 @@ class IndexmapParserTest < Minitest::Test
         XML
       )
 
-    parser = Indexmap::Parser.new(path: "http://localhost:3001/sitemap.xml", rebase_remote_children: true)
+    parser = Indexmap::Parser.new(source: "http://localhost:3001/sitemap.xml", rebase_remote_children: true)
 
     assert_equal ["/pages/pricing"], parser.paths
     assert_equal ["http://localhost:3001/pages/pricing"], parser.urls(base_url: "http://localhost:3001")
   end
+
+  def test_parses_storage_sitemap_index_with_directory_keys
+    storage = Indexmap::Storage::Memory.new
+    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/content.xml</loc></sitemap>
+      </sitemapindex>
+    XML
+    storage.write("sitemaps/content.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
+
+    parser = Indexmap::Parser.new(source: "sitemaps/sitemap.xml", storage: storage)
+
+    assert_equal ["/pages/features"], parser.paths
+    assert_equal ["sitemaps/content.xml"], parser.entries.map(&:source_sitemap)
+  end
+
+  def test_parses_relative_child_sitemaps_from_parent_directory
+    storage = Indexmap::Storage::Memory.new
+    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>content.xml</loc></sitemap>
+      </sitemapindex>
+    XML
+    storage.write("sitemaps/content.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/pricing</loc></url>
+      </urlset>
+    XML
+
+    parser = Indexmap::Parser.new(source: "sitemaps/sitemap.xml", storage: storage)
+
+    assert_equal ["/pages/pricing"], parser.paths
+  end
 end

data/test/indexmap/pinger/google_test.rb

@@ -28,167 +28,145 @@ class IndexmapPingerGoogleTest < Minitest::Test
   end
 
   def test_pings_google_for_each_sitemap_file
-    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:example.com"])
-      builder_calls = []
-      credentials_builder = lambda do |credentials:, scope:|
-        builder_calls << [credentials, scope]
-        :fake_authorizer
-      end
-
-      result = Indexmap::Pinger::Google.new(
-        configuration: configuration,
-        service: service,
-        credentials_builder: credentials_builder
-      ).ping
-
-      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 0, result[:url_count]
-      assert_equal 1, service.list_sites_calls
+    configuration = configuration_with(storage: storage_with("sitemap.xml" => "<sitemapindex/>"))
+    configuration.google.credentials = "{\"type\":\"service_account\"}"
+
+    service = FakeWebmastersService.new(site_urls: ["sc-domain:example.com"])
+    builder_calls = []
+    credentials_builder = lambda do |credentials:, scope:|
+      builder_calls << [credentials, scope]
+      :fake_authorizer
     end
+
+    result = Indexmap::Pinger::Google.new(
+      configuration: configuration,
+      service: service,
+      credentials_builder: credentials_builder
+    ).ping
+
+    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 0, result[:url_count]
+    assert_equal 1, service.list_sites_calls
   end
 
   def test_reports_unique_url_count_from_submitted_sitemaps
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-      public_path.join("sitemap.xml").write(<<~XML)
+    storage = storage_with(
+      "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-pages.xml</loc></sitemap>
           <sitemap><loc>https://www.example.com/sitemap-posts.xml</loc></sitemap>
         </sitemapindex>
       XML
-      public_path.join("sitemap-pages.xml").write(<<~XML)
+      "sitemap-pages.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/</loc></url>
           <url><loc>https://www.example.com/about</loc></url>
         </urlset>
       XML
-      public_path.join("sitemap-posts.xml").write(<<~XML)
+      "sitemap-posts.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/about</loc></url>
           <url><loc>https://www.example.com/blog</loc></url>
         </urlset>
       XML
-
-      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:example.com"])
-      result = Indexmap::Pinger::Google.new(
-        configuration: configuration,
-        service: service,
-        credentials_builder: ->(**) { :fake_authorizer }
-      ).ping
-
-      assert_equal :submitted, result[:status]
-      assert_equal 3, result[:sitemap_count]
-      assert_equal 3, result[:url_count]
-      assert_equal [
-        ["sc-domain:example.com", "https://www.example.com/sitemap-pages.xml"],
-        ["sc-domain:example.com", "https://www.example.com/sitemap-posts.xml"],
-        ["sc-domain:example.com", "https://www.example.com/sitemap.xml"]
-      ], service.submissions
-    end
+    )
+    configuration = configuration_with(storage: storage)
+    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 :submitted, result[:status]
+    assert_equal 3, result[:sitemap_count]
+    assert_equal 3, result[:url_count]
+    assert_equal [
+      ["sc-domain:example.com", "https://www.example.com/sitemap-pages.xml"],
+      ["sc-domain:example.com", "https://www.example.com/sitemap-posts.xml"],
+      ["sc-domain:example.com", "https://www.example.com/sitemap.xml"]
+    ], service.submissions
   end
 
   def test_skips_google_ping_when_credentials_are_missing
-    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 = configuration_with(storage: storage_with("sitemap.xml" => "<sitemapindex/>"))
+    service = FakeWebmastersService.new(site_urls: ["sc-domain:example.com"])
 
-      service = FakeWebmastersService.new(site_urls: ["sc-domain:example.com"])
+    result = 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
+    assert_nil service.submitted
+    assert_equal({status: :skipped, reason: :missing_credentials}, result)
   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
+    configuration = configuration_with
+    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
 
   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
+    configuration = configuration_with(storage: storage_with("sitemap.xml" => "<sitemapindex/>"))
+    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
 
   def test_google_authorization_requires_exact_property_match
-    Dir.mktmpdir do |dir|
-      public_path = Pathname(dir)
-      public_path.join("sitemap.xml").write("<sitemapindex/>")
+    configuration = configuration_with(storage: storage_with("sitemap.xml" => "<sitemapindex/>"))
+    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
+
+  private
 
-      configuration = Indexmap::Configuration.new
+  def configuration_with(storage: Indexmap::Storage::Memory.new(public_url: "https://www.example.com"))
+    Indexmap::Configuration.new.tap do |configuration|
       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
+      configuration.storage = storage
+    end
+  end
+
+  def storage_with(files)
+    Indexmap::Storage::Memory.new(public_url: "https://www.example.com").tap do |storage|
+      files.each { |filename, body| storage.write(filename, body) }
     end
   end
 end