refile 0.5.5 → 0.6.0

data/spec/refile/backend_examples.rb

@@ -5,8 +5,8 @@ RSpec.shared_examples_for :backend do
 
   describe "#upload" do
     it "raises ArgumentError when invalid object is uploaded" do
-      expect { backend.upload(double(size: 123)) }.to raise_error(ArgumentError)
-      expect { backend.upload("hello") }.to raise_error(ArgumentError)
+      expect { backend.upload(double(size: 123)) }.to raise_error(Refile::InvalidFile)
+      expect { backend.upload("hello") }.to raise_error(Refile::InvalidFile)
     end
 
     it "raises Refile::Invalid when object is too large" do
@@ -177,6 +177,17 @@ RSpec.shared_examples_for :backend do
       expect { file.read(1, buffer) }.to raise_error
     end
 
+    describe "#rewind" do
+      it "rewinds file to beginning" do
+        file = backend.upload(uploadable)
+
+        expect(file.read(2)).to eq("he")
+        expect(file.read(2)).to eq("ll")
+        file.rewind
+        expect(file.read(2)).to eq("he")
+      end
+    end
+
     describe "#read" do
       it "can read file contents" do
         file = backend.upload(uploadable)

data/spec/refile/backend_macros_spec.rb

@@ -20,23 +20,27 @@ RSpec.describe Refile::BackendMacros do
     let(:io) { StringIO.new("hello") }
 
     it "works if it conforms to required API" do
-      expect(instance.upload(double(size: 444, read: io, eof?: true, close: nil))).to be_truthy
+      expect(instance.upload(double(size: 444, read: io, eof?: true, rewind: true, close: nil))).to be_truthy
     end
 
     it "raises ArgumentError if argument does not respond to `size`" do
-      expect { instance.upload(double(read: io, eof?: true, close: nil)) }.to raise_error(ArgumentError)
+      expect { instance.upload(double(read: io, eof?: true, rewind: true, close: nil)) }.to raise_error(Refile::InvalidFile)
     end
 
     it "raises ArgumentError if argument does not respond to `read`" do
-      expect { instance.upload(double(size: 444, eof?: true, close: nil)) }.to raise_error(ArgumentError)
+      expect { instance.upload(double(size: 444, eof?: true, rewind: true, close: nil)) }.to raise_error(Refile::InvalidFile)
     end
 
     it "raises ArgumentError if argument does not respond to `eof?`" do
-      expect { instance.upload(double(size: 444, read: true, close: nil)) }.to raise_error(ArgumentError)
+      expect { instance.upload(double(size: 444, read: true, rewind: true, close: nil)) }.to raise_error(Refile::InvalidFile)
+    end
+
+    it "raises ArgumentError if argument does not respond to `rewind`" do
+      expect { instance.upload(double(size: 444, read: true, eof?: true, close: nil)) }.to raise_error(Refile::InvalidFile)
     end
 
     it "raises ArgumentError if argument does not respond to `close`" do
-      expect { instance.upload(double(size: 444, read: true, eof?: true)) }.to raise_error(ArgumentError)
+      expect { instance.upload(double(size: 444, read: true, rewind: true, eof?: true)) }.to raise_error(Refile::InvalidFile)
     end
 
     it "returns true if size is respeced" do
@@ -46,7 +50,7 @@ RSpec.describe Refile::BackendMacros do
 
     it "raises Refile::Invalid if size is exceeded" do
       instance.max_size = 8
-      expect { instance.upload(Refile::FileDouble.new("hello world")) }.to raise_error(Refile::Invalid)
+      expect { instance.upload(Refile::FileDouble.new("hello world")) }.to raise_error(Refile::InvalidMaxSize)
     end
   end
 
@@ -59,4 +63,21 @@ RSpec.describe Refile::BackendMacros do
       expect { instance.get("ev/il") }.to raise_error(Refile::InvalidID)
     end
   end
+
+  describe "#valid_id?" do
+    it "returns true for valid ID" do
+      expect(klass.valid_id?("1234aBCde123aee")).to be_truthy
+    end
+
+    it "returns false for invalid ID" do
+      expect(klass.valid_id?("ev/il")).to be_falsey
+    end
+  end
+
+  describe "#decode_id" do
+    it "returns to_s" do
+      expect(klass.decode_id("1234aBCde123aee")).to eq "1234aBCde123aee"
+      expect(klass.decode_id(1234)).to eq "1234"
+    end
+  end
 end

data/spec/refile/custom_logger_spec.rb

@@ -1,4 +1,3 @@
-require "active_support/logger"
 require "refile/custom_logger"
 
 describe Refile::CustomLogger do
@@ -12,10 +11,10 @@ describe Refile::CustomLogger do
       "PATH_INFO" => "/" }
   end
 
-  let(:expected_format) { /^Prefix: \[[^\]]+\] POST "\/" 200 \d+\.\d+ms\n\n$/ }
+  let(:expected_format) { %r{Prefix: \[[^\]]+\] POST "/" 200 \d+\.\d+ms\n\n$} }
 
   it "uses a dynamic logger" do
-    _, _, body = described_class.new(rack_app, "Prefix", -> { ActiveSupport::Logger.new(io) }).call(env)
+    _, _, body = described_class.new(rack_app, "Prefix", -> { Logger.new(io) }).call(env)
     body.close
     expect(io.tap(&:rewind).read).to match(expected_format)
   end

data/spec/refile/features/direct_upload_spec.rb

@@ -9,6 +9,7 @@ feature "Direct HTTP post file uploads", :js do
     expect(page).to have_content("Upload started")
     expect(page).to have_content("Upload success")
     expect(page).to have_content("Upload complete")
+    expect(page).to have_content("All uploads complete")
 
     click_button "Create"
 
@@ -28,6 +29,23 @@ feature "Direct HTTP post file uploads", :js do
     expect(page).to have_content("Upload failure error")
   end
 
+  scenario "Upload a file after validation failure" do
+    visit "/direct/posts/new"
+    fill_in "Title", with: "A cool post"
+    check "Requires document"
+    click_button "Create"
+
+    attach_file "Document", path("hello.txt")
+
+    expect(page).to have_content("Upload started")
+    expect(page).to have_content("Upload success")
+    expect(page).to have_content("Upload complete")
+
+    click_button "Create"
+
+    expect(download_link("Document")).to eq("hello")
+  end
+
   scenario "Fail to upload a file that has wrong format" do
     visit "/direct/posts/new"
     fill_in "Title", with: "A cool post"

data/spec/refile/features/multiple_upload_spec.rb

@@ -0,0 +1,122 @@
+require "refile/test_app"
+
+feature "Multiple file uploads", :js do
+  scenario "Upload multiple files" do
+    visit "/multiple/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", [path("hello.txt"), path("world.txt")]
+    click_button "Create"
+
+    expect(download_link("Document: hello.txt")).to eq("hello")
+    expect(download_link("Document: world.txt")).to eq("world")
+  end
+
+  scenario "Fail to upload a file that is too large" do
+    visit "/multiple/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", [path("hello.txt"), path("large.txt")]
+    click_button "Create"
+
+    expect(page).to have_content("Documents is invalid")
+  end
+
+  scenario "Fail to upload a file that has the wrong format then submit" do
+    visit "/multiple/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", [path("hello.txt"), path("image.jpg")]
+    click_button "Create"
+
+    expect(page).to have_content("Documents is invalid")
+    click_button "Create"
+    expect(page).to have_selector("h1", text: "A cool post")
+    expect(page).not_to have_link("Document")
+  end
+
+  scenario "Upload files via form redisplay", js: true do
+    visit "/multiple/posts/new"
+    attach_file "Documents", [path("hello.txt"), path("world.txt")]
+    click_button "Create"
+    fill_in "Title", with: "A cool post"
+    click_button "Create"
+
+    expect(download_link("Document: hello.txt")).to eq("hello")
+    expect(download_link("Document: world.txt")).to eq("world")
+  end
+
+  scenario "Edit with changes" do
+    visit "/multiple/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", [path("hello.txt"), path("world.txt")]
+    click_button "Create"
+
+    click_link "Edit multiple"
+    attach_file "Documents", [path("monkey.txt")]
+    click_button "Update"
+
+    expect(download_link("Document: monkey.txt")).to eq("monkey")
+    expect(page).not_to have_link("Document: hello.txt")
+    expect(page).not_to have_link("Document: world.txt")
+  end
+
+  scenario "Edit without changes" do
+    visit "/multiple/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", [path("hello.txt"), path("world.txt")]
+    click_button "Create"
+
+    click_link "Edit multiple"
+    click_button "Update"
+
+    expect(download_link("Document: hello.txt")).to eq("hello")
+    expect(download_link("Document: world.txt")).to eq("world")
+  end
+
+  describe "with direct upload" do
+    scenario "Successfully upload a file" do
+      visit "/direct/posts/new"
+      fill_in "Title", with: "A cool post"
+      attach_file "Documents", [path("hello.txt"), path("world.txt")]
+
+      expect(page).to have_content("Upload started")
+      expect(page).to have_content("Upload success")
+      expect(page).to have_content("Upload complete")
+      expect(page).to have_content("All uploads complete")
+
+      click_button "Create"
+
+      expect(download_link("Document: hello.txt")).to eq("hello")
+      expect(download_link("Document: world.txt")).to eq("world")
+    end
+  end
+
+  describe "with presigned upload" do
+    scenario "Successfully upload a file" do
+      visit "/presigned/posts/new"
+      fill_in "Title", with: "A cool post"
+      attach_file "Documents", [path("hello.txt"), path("world.txt")]
+
+      expect(page).to have_content("Presign start")
+      expect(page).to have_content("Presign complete")
+      expect(page).to have_content("Upload started")
+      expect(page).to have_content("Upload complete token accepted")
+      expect(page).to have_content("Upload success token accepted")
+
+      click_button "Create"
+
+      expect(page).to have_selector("h1", text: "A cool post")
+      expect(download_link("Document: hello.txt")).to eq("hello")
+      expect(download_link("Document: world.txt")).to eq("world")
+    end
+
+    scenario "Fail to upload a file that is too large" do
+      visit "/presigned/posts/new"
+      fill_in "Title", with: "A cool post"
+      attach_file "Documents", [path("large.txt"), path("world.txt")]
+
+      expect(page).to have_content("Presign start")
+      expect(page).to have_content("Presign complete")
+      expect(page).to have_content("Upload started")
+      expect(page).to have_content("Upload failure too large")
+    end
+  end
+end

data/spec/refile/features/normal_upload_spec.rb

@@ -119,7 +119,9 @@ feature "Normal HTTP Post file uploads" do
   end
 
   scenario "Upload a file from a remote URL" do
-    stub_request(:get, "http://www.example.com/some_file").to_return(
+    url = "http://www.example.com/foo/bar/some_file.png?some-query-string=true"
+
+    stub_request(:get, url).to_return(
       status: 200,
       body: "abc",
       headers: {
@@ -130,13 +132,13 @@ feature "Normal HTTP Post file uploads" do
 
     visit "/normal/posts/new"
     fill_in "Title", with: "A cool post"
-    fill_in "Remote document url", with: "http://www.example.com/some_file"
+    fill_in "Remote document url", with: url
     click_button "Create"
 
     expect(page).to have_selector("h1", text: "A cool post")
     expect(download_link("Document")).to eq("abc")
     expect(page).to have_selector(".content-type", text: "image/png")
     expect(page).to have_selector(".size", text: "3")
-    expect(page).to have_selector(".filename", text: "some_file")
+    expect(page).to have_selector(".filename", text: "some_file.png", exact: true)
   end
 end

data/spec/refile/features/presigned_upload_spec.rb

@@ -6,6 +6,8 @@ feature "Direct HTTP post file uploads", :js do
     fill_in "Title", with: "A cool post"
     attach_file "Document", path("hello.txt")
 
+    expect(page).to have_content("Presign start")
+    expect(page).to have_content("Presign complete")
     expect(page).to have_content("Upload started")
     expect(page).to have_content("Upload complete token accepted")
     expect(page).to have_content("Upload success token accepted")
@@ -21,6 +23,8 @@ feature "Direct HTTP post file uploads", :js do
     fill_in "Title", with: "A cool post"
     attach_file "Document", path("large.txt")
 
+    expect(page).to have_content("Presign start")
+    expect(page).to have_content("Presign complete")
     expect(page).to have_content("Upload started")
     expect(page).to have_content("Upload failure too large")
   end

data/spec/refile/features/simple_form_spec.rb

@@ -0,0 +1,8 @@
+require "refile/test_app"
+
+feature "simple form upload" do
+  scenario "renders a normal input" do
+    visit "/simple_form/posts/new"
+    attach_file "Document", path("hello.txt")
+  end
+end

data/spec/refile/fixtures/monkey.txt

@@ -0,0 +1 @@
+monkey

data/spec/refile/fixtures/world.txt

@@ -0,0 +1 @@
+world

data/spec/refile/spec_helper.rb

@@ -1,9 +1,13 @@
+ENV["RACK_ENV"] = "test"
+
 require "refile"
 require "refile/backend_examples"
 require "webmock/rspec"
 
 tmp_path = Dir.mktmpdir
 
+WebMock.disable_net_connect!(allow_localhost: true)
+
 at_exit do
   FileUtils.remove_entry_secure(tmp_path)
 end
@@ -18,9 +22,15 @@ class FakePresignBackend < Refile::Backend::FileSystem
   end
 end
 
+Refile.secret_key = "144c82de680afe5e8e91fc7cf13c22b2f8d2d4b1a4a0e92531979b12e2fa8b6dd6239c65be28517f27f442bfba11572a8bef80acf44a11f465ba85dde85488d5"
+
 Refile.backends["limited_cache"] = FakePresignBackend.new(File.expand_path("default_cache", tmp_path), max_size: 100)
 
-Refile.direct_upload = %w[cache limited_cache]
+Refile.allow_uploads_to = %w[cache limited_cache]
+
+Refile.allow_origin = "*"
+
+Refile.app_host = "http://localhost:56120"
 
 Refile.processor(:reverse) do |file|
   StringIO.new(file.read.reverse)
@@ -28,6 +38,8 @@ end
 
 Refile.processor(:upcase, proc { |file| StringIO.new(file.read.upcase) })
 
+Refile.logger = Logger.new(nil)
+
 Refile.processor(:concat) do |file, *words|
   tempfile = Tempfile.new("concat")
   tempfile.write(file.read)
@@ -38,8 +50,8 @@ Refile.processor(:concat) do |file, *words|
   File.open(tempfile.path, "r")
 end
 
-Refile.processor(:convert_case) do |file, format:|
-  case format
+Refile.processor(:convert_case) do |file, options = {}|
+  case options[:format]
     when "up" then StringIO.new(file.read.upcase)
     when "down" then StringIO.new(file.read.downcase)
     else file
@@ -59,6 +71,10 @@ module Refile
       @io.read(*args)
     end
 
+    def rewind
+      @io.rewind
+    end
+
     def size
       @io.size
     end
@@ -81,12 +97,6 @@ end
 
 RSpec.configure do |config|
   config.include PathHelper
-  config.before(:all) do
-    Refile.logger = Logger.new(nil)
-    if ENV["S3"]
-      WebMock.allow_net_connect!
-    else
-      WebMock.disable_net_connect!(allow_localhost: true)
-    end
-  end
 end
+
+RSpec::Expectations.configuration.warn_about_potential_false_positives = false

data/spec/refile_spec.rb

@@ -1,6 +1,21 @@
 require "refile"
 
 RSpec.describe Refile do
+  before do
+    allow(Refile).to receive(:token).and_return("token")
+    allow(Refile).to receive(:app_host).and_return(nil)
+    allow(Refile).to receive(:mount_point).and_return(nil)
+  end
+
+  let(:klass) do
+    Class.new do
+      extend Refile::Attachment
+      attr_accessor :document_id
+      attachment :document
+    end
+  end
+  let(:instance) { klass.new }
+
   describe ".extract_filename" do
     it "extracts filename from original_filename" do
       name = Refile.extract_filename(double(original_filename: "/foo/bar/baz.png"))
@@ -40,56 +55,126 @@ RSpec.describe Refile do
     end
   end
 
-  describe ".attachment_url" do
-    let(:klass) do
-      Class.new do
-        extend Refile::Attachment
-        attachment :document
-      end
+  describe ".app_url" do
+    it "generates a root url when all options unset" do
+      expect(Refile.app_url).to eq("/")
     end
-    let(:instance) { klass.new }
-    let(:id) { instance.document_attacher.cache_id }
 
-    before do
-      allow(Refile).to receive(:host).and_return(nil)
-      allow(Refile).to receive(:mount_point).and_return(nil)
+    it "uses supplied host option" do
+      expect(Refile.app_url(host: "http://example.org")).to eq("http://example.org/")
+    end
+
+    it "falls back to Refile.app_host" do
+      allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+      expect(Refile.app_url).to eq("http://elabs.se/")
+    end
+
+    it "adds a prefix" do
+      expect(Refile.app_url(prefix: "/moo")).to eq("/moo")
+    end
+
+    it "takes prefix from Refile.mount_point" do
+      allow(Refile).to receive(:mount_point).and_return("/attachments")
+      expect(Refile.app_url).to eq("/attachments")
+    end
+  end
+
+  describe ".file_url" do
+    let(:file) { Refile.cache.upload(Refile::FileDouble.new("hello")) }
+    let(:id) { file.id }
+
+    it "generates a url from an attachment" do
+      expect(Refile.file_url(file, filename: "document")).to eq("/token/cache/#{id}/document")
+    end
+
+    it "uses supplied host option" do
+      expect(Refile.file_url(file, host: "http://example.org", filename: "document")).to eq("http://example.org/token/cache/#{id}/document")
+    end
+
+    it "falls back to Refile.app_host" do
+      allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+      expect(Refile.file_url(file, filename: "document")).to eq("http://elabs.se/token/cache/#{id}/document")
+    end
+
+    it "falls back to Refile.cdn_host" do
+      allow(Refile).to receive(:cdn_host).and_return("http://foo.cloudfront.com")
+      allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+      expect(Refile.file_url(file, filename: "document")).to eq("http://foo.cloudfront.com/token/cache/#{id}/document")
+    end
+
+    it "adds a prefix" do
+      expect(Refile.file_url(file, prefix: "/moo", filename: "document")).to eq("/moo/token/cache/#{id}/document")
     end
 
+    it "takes prefix from Refile.mount_point" do
+      allow(Refile).to receive(:mount_point).and_return("/attachments")
+      expect(Refile.file_url(file, filename: "document")).to eq("/attachments/token/cache/#{id}/document")
+    end
+
+    it "adds an escaped filename" do
+      expect(Refile.file_url(file, filename: "test.png")).to eq("/token/cache/#{id}/test.png")
+      expect(Refile.file_url(file, filename: "tes/t.png")).to eq("/token/cache/#{id}/tes%2Ft.png")
+    end
+
+    it "adds a format" do
+      expect(Refile.file_url(file, format: "png", filename: "document")).to eq("/token/cache/#{id}/document.png")
+    end
+
+    context "with no file" do
+      it "returns nil" do
+        expect(Refile.file_url(nil, filename: "document")).to be_nil
+      end
+    end
+  end
+
+  describe ".attachment_url" do
+    let(:id) { instance.document_attacher.cache_id }
+
     context "with file" do
       before do
         instance.document = Refile::FileDouble.new("hello")
       end
 
       it "generates a url from an attachment" do
-        expect(Refile.attachment_url(instance, :document)).to eq("/cache/#{id}/document")
+        expect(Refile.attachment_url(instance, :document)).to eq("/token/cache/#{id}/document")
       end
 
       it "uses supplied host option" do
-        expect(Refile.attachment_url(instance, :document, host: "http://example.org")).to eq("http://example.org/cache/#{id}/document")
+        expect(Refile.attachment_url(instance, :document, host: "http://example.org")).to eq("http://example.org/token/cache/#{id}/document")
       end
 
-      it "falls back to Refile.host" do
-        allow(Refile).to receive(:host).and_return("http://elabs.se")
+      it "falls back to Refile.app_host" do
+        allow(Refile).to receive(:app_host).and_return("http://elabs.se")
 
-        expect(Refile.attachment_url(instance, :document)).to eq("http://elabs.se/cache/#{id}/document")
+        expect(Refile.attachment_url(instance, :document)).to eq("http://elabs.se/token/cache/#{id}/document")
+      end
+
+      it "falls back to Refile.cdn_host" do
+        allow(Refile).to receive(:cdn_host).and_return("http://foo.cloudfront.com")
+        allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+        expect(Refile.attachment_url(instance, :document)).to eq("http://foo.cloudfront.com/token/cache/#{id}/document")
       end
 
       it "adds a prefix" do
-        expect(Refile.attachment_url(instance, :document, prefix: "moo")).to eq("/moo/cache/#{id}/document")
+        expect(Refile.attachment_url(instance, :document, prefix: "/moo")).to eq("/moo/token/cache/#{id}/document")
       end
 
       it "takes prefix from Refile.mount_point" do
-        allow(Refile).to receive(:mount_point).and_return("attachments")
-        expect(Refile.attachment_url(instance, :document)).to eq("/attachments/cache/#{id}/document")
+        allow(Refile).to receive(:mount_point).and_return("/attachments")
+        expect(Refile.attachment_url(instance, :document)).to eq("/attachments/token/cache/#{id}/document")
       end
 
       it "adds an escaped filename" do
-        expect(Refile.attachment_url(instance, :document, filename: "test.png")).to eq("/cache/#{id}/test.png")
-        expect(Refile.attachment_url(instance, :document, filename: "tes/t.png")).to eq("/cache/#{id}/tes%2Ft.png")
+        expect(Refile.attachment_url(instance, :document, filename: "test.png")).to eq("/token/cache/#{id}/test.png")
+        expect(Refile.attachment_url(instance, :document, filename: "tes/t.png")).to eq("/token/cache/#{id}/tes%2Ft.png")
       end
 
       it "adds a format" do
-        expect(Refile.attachment_url(instance, :document, format: "png")).to eq("/cache/#{id}/document.png")
+        expect(Refile.attachment_url(instance, :document, format: "png")).to eq("/token/cache/#{id}/document.png")
       end
     end
 
@@ -99,7 +184,7 @@ RSpec.describe Refile do
       end
 
       it "adds format inferred from content type" do
-        expect(Refile.attachment_url(instance, :document)).to eq("/cache/#{id}/document.png")
+        expect(Refile.attachment_url(instance, :document)).to eq("/token/cache/#{id}/document.png")
       end
     end
 
@@ -109,7 +194,7 @@ RSpec.describe Refile do
       end
 
       it "adds filename" do
-        expect(Refile.attachment_url(instance, :document)).to eq("/cache/#{id}/hello.html")
+        expect(Refile.attachment_url(instance, :document)).to eq("/token/cache/#{id}/hello.html")
       end
     end
 
@@ -119,4 +204,148 @@ RSpec.describe Refile do
       end
     end
   end
+
+  describe ".upload_url" do
+    it "generates an upload url" do
+      expect(Refile.upload_url(Refile.cache)).to eq("/cache")
+    end
+
+    it "uses supplied host option" do
+      expect(Refile.upload_url(Refile.cache, host: "http://example.org")).to eq("http://example.org/cache")
+    end
+
+    it "falls back to Refile.app_host" do
+      allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+      expect(Refile.upload_url(Refile.cache)).to eq("http://elabs.se/cache")
+    end
+
+    it "does not fall back to Refile.cdn_host" do
+      allow(Refile).to receive(:cdn_host).and_return("http://foo.cloudfront.com")
+
+      expect(Refile.upload_url(Refile.cache)).to eq("/cache")
+    end
+
+    it "adds a prefix" do
+      expect(Refile.upload_url(Refile.cache, prefix: "/moo")).to eq("/moo/cache")
+    end
+
+    it "takes prefix from Refile.mount_point" do
+      allow(Refile).to receive(:mount_point).and_return("/attachments")
+      expect(Refile.upload_url(Refile.cache)).to eq("/attachments/cache")
+    end
+  end
+
+  describe ".presign_url" do
+    it "generates an upload url" do
+      expect(Refile.presign_url(Refile.cache)).to eq("/cache/presign")
+    end
+
+    it "uses supplied host option" do
+      expect(Refile.presign_url(Refile.cache, host: "http://example.org")).to eq("http://example.org/cache/presign")
+    end
+
+    it "falls back to Refile.app_host" do
+      allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+      expect(Refile.presign_url(Refile.cache)).to eq("http://elabs.se/cache/presign")
+    end
+
+    it "does not fall back to Refile.cdn_host" do
+      allow(Refile).to receive(:cdn_host).and_return("http://foo.cloudfront.com")
+
+      expect(Refile.presign_url(Refile.cache)).to eq("/cache/presign")
+    end
+
+    it "adds a prefix" do
+      expect(Refile.presign_url(Refile.cache, prefix: "/moo")).to eq("/moo/cache/presign")
+    end
+
+    it "takes prefix from Refile.mount_point" do
+      allow(Refile).to receive(:mount_point).and_return("/attachments")
+      expect(Refile.presign_url(Refile.cache)).to eq("/attachments/cache/presign")
+    end
+  end
+
+  describe ".attachment_upload_url" do
+    it "generates an upload url" do
+      expect(Refile.attachment_upload_url(instance, :document)).to eq("/cache")
+    end
+
+    it "uses supplied host option" do
+      expect(Refile.attachment_upload_url(instance, :document, host: "http://example.org")).to eq("http://example.org/cache")
+    end
+
+    it "falls back to Refile.app_host" do
+      allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+      expect(Refile.attachment_upload_url(instance, :document)).to eq("http://elabs.se/cache")
+    end
+
+    it "does not fall back to Refile.cdn_host" do
+      allow(Refile).to receive(:cdn_host).and_return("http://foo.cloudfront.com")
+
+      expect(Refile.attachment_upload_url(instance, :document)).to eq("/cache")
+    end
+
+    it "adds a prefix" do
+      expect(Refile.attachment_upload_url(instance, :document, prefix: "/moo")).to eq("/moo/cache")
+    end
+
+    it "takes prefix from Refile.mount_point" do
+      allow(Refile).to receive(:mount_point).and_return("/attachments")
+      expect(Refile.attachment_upload_url(instance, :document)).to eq("/attachments/cache")
+    end
+  end
+
+  describe ".attachment_presign_url" do
+    it "generates an upload url" do
+      expect(Refile.attachment_presign_url(instance, :document)).to eq("/cache/presign")
+    end
+
+    it "uses supplied host option" do
+      expect(Refile.attachment_presign_url(instance, :document, host: "http://example.org")).to eq("http://example.org/cache/presign")
+    end
+
+    it "falls back to Refile.app_host" do
+      allow(Refile).to receive(:app_host).and_return("http://elabs.se")
+
+      expect(Refile.attachment_presign_url(instance, :document)).to eq("http://elabs.se/cache/presign")
+    end
+
+    it "does not fall back to Refile.cdn_host" do
+      allow(Refile).to receive(:cdn_host).and_return("http://foo.cloudfront.com")
+
+      expect(Refile.attachment_presign_url(instance, :document)).to eq("/cache/presign")
+    end
+
+    it "adds a prefix" do
+      expect(Refile.attachment_presign_url(instance, :document, prefix: "/moo")).to eq("/moo/cache/presign")
+    end
+
+    it "takes prefix from Refile.mount_point" do
+      allow(Refile).to receive(:mount_point).and_return("/attachments")
+      expect(Refile.attachment_presign_url(instance, :document)).to eq("/attachments/cache/presign")
+    end
+  end
+
+  describe ".token" do
+    before do
+      allow(Refile).to receive(:token).and_call_original
+    end
+
+    it "returns digest of given path and secret token" do
+      allow(Refile).to receive(:secret_key).and_return("abcd1234")
+
+      path = "/store/f5f2e4/document.pdf"
+      token = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha1"), "abcd1234", path)
+      expect(Refile.token(path)).to eq(token)
+    end
+
+    it "returns raise error when secret token is nil" do
+      allow(Refile).to receive(:secret_key).and_return(nil)
+
+      expect { Refile.token("/store/f5f2e4/document.pdf") }.to raise_error(RuntimeError, /Refile\.secret_key was not set/)
+    end
+  end
 end