leifcr-refile 0.6.3

data/spec/refile/backend/file_system_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe Refile::Backend::FileSystem do
+  let(:backend) { Refile::Backend::FileSystem.new(File.expand_path("tmp/store1", Dir.pwd), max_size: 100) }
+
+  it_behaves_like :backend
+end

data/spec/refile/backend_examples.rb

@@ -0,0 +1,228 @@
+RSpec.shared_examples_for :backend do
+  def uploadable(data = "hello")
+    Refile::FileDouble.new(data)
+  end
+
+  describe "#upload" do
+    it "raises ArgumentError when invalid object is uploaded" do
+      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
+      expect { backend.upload(uploadable("a" * 200)) }.to raise_error(Refile::Invalid)
+    end
+
+    it "stores file for later retrieval" do
+      file = backend.upload(uploadable)
+      retrieved = backend.get(file.id)
+
+      expect(retrieved.read).to eq("hello")
+      expect(retrieved.size).to eq(5)
+      expect(retrieved.exists?).to be_truthy
+    end
+
+    it "can store an uploaded file" do
+      file = backend.upload(uploadable)
+      file2 = backend.upload(file)
+
+      retrieved = backend.get(file2.id)
+
+      expect(retrieved.read).to eq("hello")
+      expect(retrieved.size).to eq(5)
+      expect(retrieved.exists?).to be_truthy
+    end
+  end
+
+  describe "#delete" do
+    it "removes a stored file" do
+      file = backend.upload(uploadable)
+
+      backend.delete(file.id)
+
+      expect(backend.get(file.id).exists?).to be_falsy
+    end
+
+    it "does not affect other files" do
+      file = backend.upload(uploadable)
+      other = backend.upload(uploadable)
+
+      backend.delete(file.id)
+
+      expect(backend.get(file.id).exists?).to be_falsy
+      expect(backend.get(other.id).exists?).to be_truthy
+    end
+
+    it "does nothing when file doesn't exist" do
+      file = backend.upload(uploadable)
+
+      backend.delete(file.id)
+      backend.delete(file.id)
+    end
+
+    it "can be called through file" do
+      file = backend.upload(uploadable)
+
+      file.delete
+
+      expect(backend.get(file.id).exists?).to be_falsy
+    end
+
+    it "raises error when called with invalid ID" do
+      expect { backend.delete("/evil") }.to raise_error(Refile::InvalidID)
+    end
+  end
+
+  describe "#read" do
+    it "returns file contents" do
+      file = backend.upload(uploadable)
+      expect(backend.read(file.id)).to eq("hello")
+    end
+
+    it "returns nil when file doesn't exist" do
+      expect(backend.read("nosuchfile")).to be_nil
+    end
+
+    it "can be called through file" do
+      file = backend.upload(uploadable)
+      expect(file.read).to eq("hello")
+    end
+
+    it "raises error when called with invalid ID" do
+      expect { backend.read("/evil") }.to raise_error(Refile::InvalidID)
+    end
+  end
+
+  describe "#size" do
+    it "returns file size" do
+      file = backend.upload(uploadable)
+      expect(backend.size(file.id)).to eq(5)
+    end
+
+    it "returns nil when file doesn't exist" do
+      expect(backend.size("nosuchfile")).to be_nil
+    end
+
+    it "can be called through file" do
+      file = backend.upload(uploadable)
+      expect(file.size).to eq(5)
+    end
+
+    it "raises error when called with invalid ID" do
+      expect { backend.size("/evil") }.to raise_error(Refile::InvalidID)
+    end
+  end
+
+  describe "#exists?" do
+    it "returns true when file exists" do
+      file = backend.upload(uploadable)
+      expect(backend.exists?(file.id)).to eq(true)
+    end
+
+    it "returns false when file doesn't exist" do
+      expect(backend.exists?("nosuchfile")).to eq(false)
+    end
+
+    it "can be called through file" do
+      expect(backend.upload(uploadable).exists?).to eq(true)
+      expect(backend.get("nosuchfile").exists?).to eq(false)
+    end
+
+    it "raises error when called with invalid ID" do
+      expect { backend.exists?("/evil") }.to raise_error(Refile::InvalidID)
+    end
+  end
+
+  describe "#clear!" do
+    it "removes files when called with :confirm" do
+      file = backend.upload(uploadable)
+
+      backend.clear!(:confirm)
+
+      expect(backend.get(file.id).exists?).to be_falsy
+    end
+
+    it "complains when called without confirm" do
+      file = backend.upload(uploadable)
+
+      expect { backend.clear! }.to raise_error(Refile::Confirm)
+
+      expect(backend.get(file.id).exists?).to be_truthy
+    end
+  end
+
+  describe "#max_size" do
+    it "returns the given max size" do
+      expect(backend.max_size).to eq(100)
+    end
+  end
+
+  describe "File" do
+    it "is an io-like object" do
+      file = backend.upload(uploadable)
+
+      buffer = ""
+      result = ""
+
+      until file.eof?
+        chunk = file.read(2, buffer)
+        result << chunk
+        expect("hello").to include(buffer)
+      end
+
+      expect(result).to eq("hello")
+
+      file.close
+
+      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)
+
+        expect(file.read).to eq("hello")
+      end
+
+      it "can read entire file contents into buffer" do
+        file = backend.upload(uploadable)
+
+        buffer = ""
+
+        file.read(nil, buffer)
+
+        expect(buffer).to eq("hello")
+      end
+    end
+
+    describe "#download" do
+      it "returns a downloaded tempfile" do
+        file = backend.upload(uploadable)
+        download = file.download
+
+        expect(download).to be_an_instance_of(Tempfile)
+        expect(File.read(download.path)).to eq("hello")
+      end
+    end
+
+    describe "#as_json" do
+      it "returns id and stringified backend as a Hash" do
+        file = backend.upload(uploadable)
+        hash = file.as_json
+
+        expect(hash.keys).to eq [:id, :backend]
+      end
+    end
+  end
+end

data/spec/refile/backend_macros_spec.rb

@@ -0,0 +1,83 @@
+RSpec.describe Refile::BackendMacros do
+  let(:klass) do
+    Class.new do
+      extend Refile::BackendMacros
+
+      attr_accessor :max_size
+
+      verify_uploadable def upload(uploadable)
+        uploadable
+      end
+
+      verify_id def get(id)
+        id
+      end
+    end
+  end
+  let(:instance) { klass.new }
+
+  describe "#verify_uploadable" 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, 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, 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, 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, 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, rewind: true, eof?: true)) }.to raise_error(Refile::InvalidFile)
+    end
+
+    it "returns true if size is respeced" do
+      instance.max_size = 8
+      expect(instance.upload(Refile::FileDouble.new("hello"))).to be_truthy
+    end
+
+    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::InvalidMaxSize)
+    end
+  end
+
+  describe "#verify_id" do
+    it "works if it has a valid ID" do
+      expect(instance.get("1234aBCde123aee")).to be_truthy
+    end
+
+    it "raises ArgumentError if argument does not respond to `size`" 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

@@ -0,0 +1,21 @@
+require "refile/custom_logger"
+
+describe Refile::CustomLogger do
+  let(:rack_app) do
+    ->(_) { [200, {}, ["Success"]] }
+  end
+  let(:io) { StringIO.new }
+  let(:env) do
+    { "QUERY_STRING" => "",
+      "REQUEST_METHOD" => "POST",
+      "PATH_INFO" => "/" }
+  end
+
+  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", -> { Logger.new(io) }).call(env)
+    body.close
+    expect(io.tap(&:rewind).read).to match(expected_format)
+  end
+end

data/spec/refile/features/direct_upload_spec.rb

@@ -0,0 +1,63 @@
+require "refile/test_app"
+
+feature "Direct HTTP post file uploads", :js do
+  scenario "Successfully upload a file" do
+    visit "/direct/posts/new"
+    fill_in "Title", with: "A cool post"
+    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")
+    expect(page).to have_content("All uploads complete")
+
+    click_button "Create"
+
+    expect(page).to have_selector("h1", text: "A cool post")
+    expect(page).to have_selector(".content-type", text: "text/plain")
+    expect(page).to have_selector(".size", text: "6")
+    expect(page).to have_selector(".filename", text: "hello.txt")
+    expect(download_link("Document")).to eq("hello")
+  end
+
+  scenario "Fail to upload a file that is too large" do
+    visit "/direct/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Document", path("large.txt")
+
+    expect(page).to have_content("Upload started")
+    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"
+    attach_file "Image", path("large.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(page).to have_selector(".field_with_errors")
+    expect(page).to have_content("You are not allowed to upload text/plain file format. Allowed types: image/jpeg, image/gif, and image/png.")
+  end
+end

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