neocities-red 1.1.2 → 1.2.0

data/lib/neocities_red/services/site/exporter.rb

@@ -2,41 +2,154 @@
 
 require "whirly"
 require "pastel"
+require "uri"
+require "time"
+require "fileutils"
 
 module NeocitiesRed
   module Services
     module Site
+      # Downloads all files from the remote Neocities site to the local filesystem.
+      #
+      # Supports incremental pulls — files that haven't been updated since the
+      # last pull (and exist locally) are skipped. Progress is displayed per-file,
+      # or via a Whirly spinner in quiet mode. Pull metadata (timestamp and
+      # working directory) is persisted in the config file for future incremental
+      # pulls.
+      #
+      # @example Full pull
+      #   exporter = NeocitiesRed::Services::Site::Exporter.new(
+      #     client, "my-site", config_data, config_path, display: display
+      #   )
+      #   exporter.export
+      #
+      # @example Quiet pull with incremental support
+      #   exporter.export(quiet: true, last_pull_time: "2024-01-01", last_pull_loc: "/path/to/site")
+      #
+      # @see NeocitiesRed::Client#list Fetches remote file list
+      # @see NeocitiesRed::Client#download Downloads individual files
       class Exporter
-        attr_accessor :client, :sitename, :data, :app_config_path
+        # @return [NeocitiesRed::Client] the authenticated API client
+        attr_reader :client
 
-        def initialize(client, sitename, data, app_config_path)
+        # @return [String] the site name being exported
+        attr_reader :sitename
+
+        # @return [Hash] the current config data (modified in-place with last pull info)
+        attr_reader :data
+
+        # @return [String] path to the config file for persisting pull metadata
+        attr_reader :app_config_path
+
+        # @param client [NeocitiesRed::Client] authenticated API client
+        # @param sitename [String] the Neocities site name
+        # @param data [Hash] current application config data
+        # @param app_config_path [String] path to the config file
+        # @param display [NeocitiesRed::CliDisplay] output helper
+        def initialize(client, sitename, data, app_config_path, display:)
           @client = client
           @sitename = sitename
           @data = data
           @app_config_path = app_config_path
+          @display = display
           @pastel = Pastel.new(eachline: "\n")
         end
 
+        # Downloads all site files to the current working directory.
+        #
+        # After the download, persists the current timestamp and working
+        # directory to the config file for future incremental pulls.
+        #
+        # @param quiet [Boolean] when true, shows a spinner instead of per-file output
+        # @param last_pull_time [String, nil] ISO timestamp of the last pull
+        # @param last_pull_loc [String, nil] working directory of the last pull
+        # @return [void]
         def export(quiet: false, last_pull_time: nil, last_pull_loc: nil)
           if quiet
             Whirly.start spinner: ["😺", "😸", "😹", "😻", "😼", "😽", "🙀", "😿", "😾"],
                          status: "Retrieving files for #{@pastel.bold @sitename}"
           end
 
-          @client.pull(@sitename, last_pull_time, last_pull_loc, quiet: quiet)
+          fetch_files(last_pull_time, last_pull_loc, quiet)
 
-          # write last pull data to file (not necessarily the best way to do this, but better than cloning every time)
           data["LAST_PULL"] = {
             time: Time.now,
             loc: Dir.pwd
           }
 
-          File.write(app_config_path, data.to_json)
-        rescue StandardError => e
-          e
+          ::File.write(app_config_path, data.to_json)
         ensure
           Whirly.stop if quiet
         end
+
+        private
+
+        # Fetches each file from the remote site and writes it locally.
+        #
+        # Skips files that haven't changed since the last pull when
+        # incremental data is available.
+        #
+        # @param last_pull_time [String, nil] ISO timestamp of the last pull
+        # @param last_pull_loc [String, nil] working directory of the last pull
+        # @param quiet [Boolean] suppresses per-file output when true
+        # @return [void]
+        # @raise [NeocitiesRed::APIError] if the site info or file list API fails
+        def fetch_files(last_pull_time, last_pull_loc, quiet)
+          site_info = @client.info(@sitename)
+
+          raise NeocitiesRed::APIError, site_info[:message] if site_info[:result] == "error"
+
+          info_data = site_info[:info]
+
+          domain =
+            if info_data[:domain].to_s.empty?
+              "https://#{@sitename}.neocities.org/"
+            else
+              "https://#{info_data[:domain]}/"
+            end
+
+          success_loaded = 0
+          start_time = Time.now
+          curr_dir = Dir.pwd
+
+          resp = @client.list
+
+          raise NeocitiesRed::APIError, resp[:message] if resp[:result] == "error"
+
+          uri_parser = URI::Parser.new
+          resp[:files].each do |file|
+            if file[:is_directory]
+              FileUtils.mkdir_p file[:path].to_s
+            else
+              @display.display_pull_progress(file[:path]) unless quiet
+
+              if last_pull_time &&
+                 last_pull_loc &&
+                 Time.parse(file[:updated_at]) <= Time.parse(last_pull_time) &&
+                 last_pull_loc == curr_dir &&
+                 ::File.exist?(file[:path])
+
+                @display.display_pull_no_updates unless quiet
+
+                next
+              end
+
+              pathtotry = uri_parser.escape(domain + file[:path])
+              fileconts = @client.download(pathtotry)
+
+              if fileconts.status == 200
+                @display.display_pull_success unless quiet
+                success_loaded += 1
+
+                ::File.write(file[:path].to_s, fileconts.body)
+              elsif !quiet
+                @display.display_pull_failure
+              end
+            end
+          end
+
+          @display.display_pull_stats(success_loaded, Time.now - start_time)
+        end
       end
     end
   end

data/lib/neocities_red/services/site/informer.rb

@@ -5,12 +5,27 @@ require "pastel"
 
 module NeocitiesRed
   module Services
-    class ClientError < StandardError; end
-
     module Site
+      # Retrieves and formats site information for the Neocities site.
+      #
+      # Queries the Neocities API for site metadata (domain, bandwidth,
+      # created_at, last_updated, etc.) and formats it as rows suitable
+      # for display in a TTY::Table.
+      #
+      # @example
+      #   informer = NeocitiesRed::Services::Site::Informer.new(client, ["my-site"], "my-site")
+      #   rows = informer.pretty_print
+      #   puts TTY::Table.new(rows)
+      #
+      # @see NeocitiesRed::Client#info Underlying API call
       class Informer
-        attr_accessor :client
+        # @return [NeocitiesRed::Client] the authenticated API client
+        attr_reader :client
 
+        # @param client [NeocitiesRed::Client] authenticated API client
+        # @param subargs [Array<String>] CLI subarguments; the first element
+        #   may be a sitename to query
+        # @param sitename [String, nil] default sitename (used when subargs is empty)
         def initialize(client, subargs = [], sitename = nil)
           @client = client
           @subargs = subargs
@@ -18,14 +33,24 @@ module NeocitiesRed
           @pastel = Pastel.new(eachline: "\n")
         end
 
+        # Fetches site information from the Neocities API.
+        #
+        # @return [Hash] parsed API response containing +:info+ with site metadata
+        # @raise [NeocitiesRed::APIError] if the API returns an error
         def stats
           response = @client.info(@subargs[0] || @sitename)
 
-          raise NeocitiesRed::Services::ClientError, response if response[:result] == "error"
+          raise NeocitiesRed::APIError, response[:message] if response[:result] == "error"
 
           response
         end
 
+        # Formats the site stats as bold-labeled rows.
+        #
+        # Timestamp fields (+created_at+, +last_updated+) are converted
+        # to local time for readability.
+        #
+        # @return [Array<Array(String, Object)>] array of +[label, value]+ pairs
         def pretty_print
           out = []
 

data/lib/neocities_red/services/site/pusher.rb

@@ -5,12 +5,45 @@ require "digest"
 
 module NeocitiesRed
   module Services
+    # Site-level operations: push, diff, info, and export.
     module Site
+      # Recursively uploads a local directory to the Neocities site.
+      #
+      # Orchestrates the full push workflow:
+      # 1. Validates the root path
+      # 2. Optionally prunes remote files not present locally
+      # 3. Collects all files via glob
+      # 4. Applies .gitignore rules, dotfile filtering, exclusions, and
+      #    optimized (hash-based) filtering
+      # 5. Uploads remaining files in parallel via a worker pool
+      #
+      # @example Basic push
+      #   pusher = NeocitiesRed::Services::Site::Pusher.new(
+      #     client, display,
+      #     root: ".", no_gitignore: false, ignore_dotfiles: false,
+      #     exclude: [], dry_run: false, prune: false, optimized: false
+      #   )
+      #   pusher.push
+      #
+      # @see NeocitiesRed::Services::File::Uploader Individual file upload
+      # @see NeocitiesRed::Services::Common::Exclusions Exclusion builder
+      # @see NeocitiesRed::Services::Common::WorkerPool Thread pool
       class Pusher
-        # warning - the big quantity of working threads could be considered like-a DDOS.
-        # Your ip-address could get banned on neocities for a few days.
+        # @return [Integer] maximum concurrent upload threads.
+        #
+        # Warning: a high thread count may be flagged as DDOS-like traffic
+        # by Neocities, potentially resulting in a temporary IP ban.
         MAX_THREADS = 5
 
+        # @param client [NeocitiesRed::Client] authenticated API client
+        # @param display [NeocitiesRed::CliDisplay] output helper
+        # @param root [String] local directory path to push
+        # @param no_gitignore [Boolean] when true, ignores .gitignore rules
+        # @param ignore_dotfiles [Boolean] when true, skips files starting with "."
+        # @param exclude [Array<String>] additional paths to exclude from upload
+        # @param dry_run [Boolean] when true, simulates the push without uploading
+        # @param prune [Boolean] when true, deletes remote files not present locally
+        # @param optimized [Boolean] when true, skips files whose SHA1 matches the server
         def initialize(client, display, root:, no_gitignore:, ignore_dotfiles:, exclude:, dry_run:, prune:, optimized:)
           @client = client
           @display = display
@@ -23,6 +56,10 @@ module NeocitiesRed
           @optimized = optimized
         end
 
+        # Executes the full push workflow.
+        #
+        # @return [void]
+        # @raise [ArgumentError] if the root path does not exist or is not a directory
         def push
           root_path = Pathname(@root)
           validate_root_path!(root_path)
@@ -30,7 +67,7 @@ module NeocitiesRed
           @display.display_dry_run_notice if @dry_run
           prune_remote_files if @prune
 
-          excluded_files = build_push_exclusions(@exclude)
+          excluded_files = Services::Common::Exclusions.build(@exclude)
 
           Dir.chdir(root_path) do
             paths = Dir.glob(::File.join("**", "*"), ::File::FNM_DOTMATCH)
@@ -46,27 +83,22 @@ module NeocitiesRed
 
         private
 
+        # Validates that the root path exists and is a directory.
+        #
+        # @param root_path [Pathname] the local root directory
+        # @raise [ArgumentError] if validation fails
         def validate_root_path!(root_path)
           raise ArgumentError, "path #{root_path} does not exist" unless root_path.exist?
           raise ArgumentError, "provided path is not a directory" unless root_path.directory?
         end
 
-        def build_push_exclusions(excluded_entries)
-          excluded_files = []
-
-          excluded_entries.each do |entry|
-            filepath = Pathname.new(entry).cleanpath.to_s
-
-            if ::File.file?(filepath)
-              excluded_files << filepath
-            elsif ::File.directory?(filepath)
-              excluded_files.concat(Dir.glob(::File.join(filepath, "**", "*"), ::File::FNM_DOTMATCH).push(filepath))
-            end
-          end
-
-          excluded_files
-        end
-
+        # Filters file paths based on .gitignore rules.
+        #
+        # Reads the local .gitignore and removes matching paths using
+        # +File.fnmatch+ for glob pattern support.
+        #
+        # @param paths [Array<String>] all file paths in the root
+        # @return [Array<String>> filtered paths not matched by .gitignore
         def apply_gitignore(paths)
           return paths unless ::File.exist?(".gitignore")
 
@@ -82,6 +114,14 @@ module NeocitiesRed
           filtered
         end
 
+        # Computes which files can be skipped because their SHA1 hash
+        # matches the server version.
+        #
+        # Fetches the remote file list, computes local SHA1 hashes, and
+        # returns paths that don't need re-uploading.
+        #
+        # @param paths [Array<String>] all local file paths
+        # @return [Array<String>] file paths to exclude (already up to date)
         def optimized_exclusions(paths)
           hex = paths.select { |path| ::File.file?(path) }
                      .map { |file| { filepath: file, sha1_hash: Digest::SHA1.file(file).hexdigest } }
@@ -97,31 +137,27 @@ module NeocitiesRed
              .map { |entry| entry[:filepath] }
         end
 
+        # Uploads all filtered paths in parallel using a worker pool.
+        #
+        # @param paths [Array<Pathname>] local files to upload
+        # @return [void]
         def upload_files(paths)
-          task_queue = Queue.new
-          paths.each { |path| task_queue.push(path) }
-
-          threads = []
-          MAX_THREADS.times do
-            threads << Thread.new do
-              until task_queue.empty?
-                path = begin
-                  task_queue.pop(true)
-                rescue StandardError
-                  nil
-                end
-
-                next if path.nil? || path.directory?
-
-                Services::File::Uploader.new(@client, path, path).upload
-              end
-            end
+          worker_pool = Services::Common::WorkerPool.new(MAX_THREADS) do |path|
+            next if path.directory?
+
+            Services::File::Uploader.new(@client, path, path, display: @display).upload
           end
 
-          threads.each(&:join)
+          worker_pool.process(paths)
           @display.display_upload_complete
         end
 
+        # Deletes remote files that no longer exist in the local directory.
+        #
+        # Skips directories that have already been pruned. Respects the
+        # +@dry_run+ flag.
+        #
+        # @return [void]
         def prune_remote_files
           pruned_dirs = []
           resp = @client.list

data/lib/neocities_red/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module NeocitiesRed
-  VERSION = "1.1.2"
+  # The current version of the NeocitiesRed gem.
+  VERSION = "1.2.0"
 end

data/lib/neocities_red.rb

@@ -1,17 +1,36 @@
 # frozen_string_literal: true
 
-require File.join(File.dirname(__FILE__), "neocities_red", "version")
-require File.join(File.dirname(__FILE__), "neocities_red", "client")
-require File.join(File.dirname(__FILE__), "neocities_red", "cli_display")
-require File.join(File.dirname(__FILE__), "neocities_red", "cli")
+# Top-level namespace for the NeocitiesRed gem.
+#
+# Provides a CLI tool and Ruby API client for managing static sites
+# hosted on {https://neocities.org Neocities.org}.
+#
+# @see NeocitiesRed::Client HTTP API client
+# @see NeocitiesRed::CLI Command-line interface
+module NeocitiesRed
+  # Service layer organized by domain.
+  #
+  # - {Services::File} — single-file and folder-level operations (upload, delete, list)
+  # - {Services::Site} — site-level operations (push, diff, info, export)
+  # - {Services::Common} — shared utilities (exclusions, worker pool)
+  module Services; end
 
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "uploader")
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "folder_uploader")
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "remover")
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "list")
+  require File.join(File.dirname(__FILE__), "neocities_red", "version")
+  require File.join(File.dirname(__FILE__), "neocities_red", "errors")
+  require File.join(File.dirname(__FILE__), "neocities_red", "client")
+  require File.join(File.dirname(__FILE__), "neocities_red", "cli_display")
+  require File.join(File.dirname(__FILE__), "neocities_red", "cli")
 
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "differencer")
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "informer")
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "exporter")
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "pusher")
-require File.join(File.dirname(__FILE__), "neocities_red", "services", "common", "pizza")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "uploader")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "folder_uploader")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "remover")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "file", "list")
+
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "differencer")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "informer")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "exporter")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "site", "pusher")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "common", "exclusions")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "common", "worker_pool")
+  require File.join(File.dirname(__FILE__), "neocities_red", "services", "common", "pizza")
+end

data/neocities-red.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     files = begin
       if system("git", "rev-parse", "--is-inside-work-tree", out: File::NULL, err: File::NULL)
-        `git ls-files -z`.split("\x0")
+        `git ls-files -z`.split("\x0").reject { |f| f == ".yardopts" }
       else
         []
       end
@@ -26,7 +26,8 @@ Gem::Specification.new do |spec|
     if files.empty?
       files = Dir.glob("**/*", File::FNM_DOTMATCH).select do |path|
         File.file?(path) &&
-          !path.start_with?("test/", "spec/", "features/", ".git/", ".github/", ".rubocop_cache/")
+          !path.start_with?("test/", "spec/", "features/", ".git/", ".github/", ".rubocop_cache/") &&
+          path != ".yardopts"
       end
     end
 
@@ -43,12 +44,16 @@ Gem::Specification.new do |spec|
   spec.add_dependency "faraday-multipart"
   spec.add_dependency "faraday-retry"
   spec.add_dependency "fiddle"
-  spec.add_dependency "pastel", "~> 0.8", "= 0.8.0"
-  spec.add_dependency "rake", "~> 13", ">= 13.3.0"
+  spec.add_dependency "pastel", "= 0.8.0"
+  spec.add_dependency "rake", "~> 13"
   spec.add_dependency "thor", "~> 1.5.0", ">= 1.5.0"
-  spec.add_dependency "tty-prompt", "~> 0.23", "= 0.23.1"
-  spec.add_dependency "tty-table", "~> 0.12", "= 0.12.0"
+  spec.add_dependency "tty-prompt", "= 0.23.1"
+  spec.add_dependency "tty-table", "= 0.12.0"
   spec.add_dependency "whirly", "~> 0.3", ">= 0.3.0"
 
   spec.metadata["rubygems_mfa_required"] = "true"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/o-200/neocities-red"
+  spec.metadata["changelog_uri"] = "https://github.com/o-200/neocities-red/blob/main/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "https://github.com/o-200/neocities-red#readme"
 end

data/spec/neocities_red/cli_display_spec.rb

@@ -81,12 +81,6 @@ RSpec.describe NeocitiesRed::CliDisplay do
   end
 
   describe "status helpers" do
-    it "prints unknown option" do
-      display.display_unknown_option("--wat")
-
-      expect(text_output).to include('Unknown option: "--wat"')
-    end
-
     it "prints delete progress and success on the same line" do
       display.display_delete_progress("foo.txt")
       display.display_delete_success

data/spec/neocities_red/cli_spec.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "tmpdir"
+require "fileutils"
+require "json"
+require "stringio"
 
 RSpec.describe NeocitiesRed::CLI do
   describe ".app_config_path" do
@@ -65,4 +69,85 @@ RSpec.describe NeocitiesRed::CLI do
       expect(path).to eq(File.join("/home/alice", ".#{app_name}"))
     end
   end
+
+  describe "#persist_config" do
+    let(:tmp_dir) { Dir.mktmpdir }
+    let(:config_path) { File.join(tmp_dir, "config.json") }
+    let(:cli) { described_class.new }
+
+    before do
+      allow(cli).to receive(:app_config_path).and_return(config_path)
+    end
+
+    after do
+      FileUtils.rm_rf(tmp_dir)
+    end
+
+    it "writes the config with 0600 permissions" do
+      cli.send(:persist_config, API_KEY: "secret", SITENAME: "test-site")
+
+      expect(File.read(config_path)).to eq('{"API_KEY":"secret","SITENAME":"test-site"}')
+      expect(File.stat(config_path).mode & 0o777).to eq(0o600)
+    end
+  end
+
+  describe "purge" do
+    around do |example|
+      # rubocop:disable RSpec/ExpectOutput
+      original_stdout = $stdout
+      $stdout = StringIO.new
+      example.run
+    ensure
+      $stdout = original_stdout
+    end
+    # rubocop:enable RSpec/ExpectOutput
+
+    let(:tmp_dir) { Dir.mktmpdir }
+    let(:config_path) { File.join(tmp_dir, "config.json") }
+
+    before do
+      allow(described_class).to receive(:app_config_path).and_return(tmp_dir)
+      File.write(config_path, JSON.generate(API_KEY: "test-key", SITENAME: "test-site"))
+
+      stub_request(:get, %r{https://neocities\.org/api/list})
+        .to_return(body: {
+          result: "success",
+          files: [
+            { path: "index.html", is_directory: false },
+            { path: "gone_dir", is_directory: true }
+          ]
+        }.to_json)
+    end
+
+    after do
+      WebMock.reset!
+      FileUtils.rm_rf(tmp_dir)
+    end
+
+    it "deletes listed files when confirmed" do
+      stub_request(:post, %r{https://neocities\.org/api/delete})
+        .to_return(body: { result: "success" }.to_json)
+
+      described_class.start(%w[purge -y])
+
+      expect(a_request(:post, %r{https://neocities\.org/api/delete}))
+        .to have_been_made.twice
+    end
+
+    it "does not delete anything with --dry-run" do
+      described_class.start(%w[purge -y --dry-run])
+
+      expect(a_request(:post, %r{https://neocities\.org/api/delete}))
+        .not_to have_been_made
+    end
+
+    it "shows help when -y is missing" do
+      expect { described_class.start(%w[purge]) }.to raise_error(SystemExit)
+
+      expect(a_request(:post, %r{https://neocities\.org/api/delete}))
+        .not_to have_been_made
+      expect(a_request(:get, %r{https://neocities\.org/api/list}))
+        .not_to have_been_made
+    end
+  end
 end

data/spec/neocities_red/client_spec.rb

@@ -191,7 +191,7 @@ RSpec.describe NeocitiesRed::Client do
       end
 
       context "when file already exists on server with same hash" do
-        let(:mock_hash_response) { { result: "success", files: { "test_upload.txt" => true } } }
+        let(:mock_hash_response) { { result: "success", files: { "test_upload.txt": true } } }
 
         before do
           allow(client).to receive(:upload_hash).and_return(mock_hash_response)
@@ -247,60 +247,17 @@ RSpec.describe NeocitiesRed::Client do
     end
   end
 
-  describe "#pull" do
+  describe "#download" do
     let(:client) { described_class.new(api_key: api_key) }
-    let(:temp_dir) { Dir.mktmpdir }
-    let(:mock_list_response) { { result: "success", files: [] } }
-    let(:mock_info_response) { { result: "success", info: { domain: nil } } }
-
-    around do |example|
-      original_dir = Dir.pwd
-      Dir.chdir(temp_dir)
-      example.run
-    ensure
-      Dir.chdir(original_dir)
-      FileUtils.rm_rf(temp_dir)
-    end
+    let(:mock_conn_response) { instance_double(Faraday::Response, status: 200, body: "raw content") }
 
     before do
-      allow(client).to receive_messages(list: mock_list_response, info: mock_info_response)
-      allow(client.instance_variable_get(:@conn)).to receive(:get).and_return(
-        instance_double(Faraday::Response, status: 200, body: "")
-      )
-    end
-
-    it "pulls files from the site" do
-      expect { client.pull(sitename, nil, nil, quiet: true) }.not_to raise_error
-    end
-
-    it "supports last_pull_time and last_pull_loc parameters" do
-      last_pull_time = Time.now - 86_400
-      last_pull_loc = Dir.pwd
-      expect { client.pull(sitename, last_pull_time, last_pull_loc, quiet: true) }.not_to raise_error
-    end
-
-    context "when site has custom domain" do
-      let(:mock_info_response) { { result: "success", info: { domain: "example.com" } } }
-
-      it "uses the custom domain for fetching files" do
-        expect { client.pull(sitename, nil, nil, quiet: true) }.not_to raise_error
-      end
-    end
-
-    context "when API returns error for info" do
-      let(:mock_info_response) { { result: "error", message: "Site not found" } }
-
-      it "raises an error" do
-        expect { client.pull(sitename, nil, nil, quiet: true) }.to raise_error(ArgumentError, /Site not found/)
-      end
+      allow(client.instance_variable_get(:@conn)).to receive(:get).and_return(mock_conn_response)
     end
 
-    context "when API returns error for list" do
-      let(:mock_list_response) { { result: "error", message: "List failed" } }
-
-      it "raises an error" do
-        expect { client.pull(sitename, nil, nil, quiet: true) }.to raise_error(ArgumentError, /List failed/)
-      end
+    it "returns the raw Faraday response for a url" do
+      response = client.download("https://example.com/index.html")
+      expect(response).to eq(mock_conn_response)
     end
   end
 end