refile 0.2.2

data/spec/refile/attachment_spec.rb

@@ -0,0 +1,141 @@
+describe Refile::Attachment do
+  let(:options) { { } }
+  let(:post) { Post.new }
+  let(:klass) do
+    opts = options
+    Class.new do
+      extend Refile::Attachment
+
+      attr_accessor :document_id, :document_name, :document_size
+
+      attachment :document, **opts
+    end
+  end
+  let(:instance) { klass.new }
+
+  describe ":name=" do
+    it "receives a file, caches it and sets the _id parameter" do
+      instance.document = Refile::FileDouble.new("hello")
+
+      expect(Refile.cache.get(instance.document.id).read).to eq("hello")
+      expect(Refile.cache.get(instance.document_cache_id).read).to eq("hello")
+    end
+  end
+
+  describe ":name" do
+    it "gets a file from the store" do
+      file = Refile.store.upload(Refile::FileDouble.new("hello"))
+      instance.document_id = file.id
+
+      expect(instance.document.id).to eq(file.id)
+    end
+  end
+
+  describe ":name_cache_id" do
+    it "doesn't overwrite a cached file" do
+      instance.document = Refile::FileDouble.new("hello")
+      instance.document_cache_id = "xyz"
+
+      expect(instance.document.read).to eq("hello")
+    end
+  end
+
+  describe ":name_attachment.store!" do
+    it "puts a cached file into the store" do
+      instance.document = Refile::FileDouble.new("hello")
+      cache = instance.document
+
+      instance.document_attachment.store!
+
+      expect(Refile.store.get(instance.document_id).read).to eq("hello")
+      expect(Refile.store.get(instance.document.id).read).to eq("hello")
+
+      expect(instance.document_cache_id).to be_nil
+      expect(Refile.cache.get(cache.id).exists?).to be_falsy
+    end
+
+    it "does nothing when not cached" do
+      file = Refile.store.upload(Refile::FileDouble.new("hello"))
+      instance.document_id = file.id
+
+      instance.document_attachment.store!
+
+      expect(Refile.store.get(instance.document_id).read).to eq("hello")
+      expect(Refile.store.get(instance.document.id).read).to eq("hello")
+    end
+
+    it "overwrites previously stored file" do
+      file = Refile.store.upload(Refile::FileDouble.new("hello"))
+      instance.document_id = file.id
+
+      instance.document = Refile::FileDouble.new("world")
+      cache = instance.document
+
+      instance.document_attachment.store!
+
+      expect(Refile.store.get(instance.document_id).read).to eq("world")
+      expect(Refile.store.get(instance.document.id).read).to eq("world")
+
+      expect(instance.document_cache_id).to be_nil
+      expect(Refile.cache.get(cache.id).exists?).to be_falsy
+      expect(Refile.store.get(file.id).exists?).to be_falsy
+    end
+  end
+
+  describe ":name_attachment.error" do
+    let(:options) { { cache: :limited_cache, raise_errors: false } }
+
+    it "is blank when valid file uploaded" do
+      file = Refile::FileDouble.new("hello")
+      instance.document = file
+
+      expect(instance.document_attachment.errors).to be_empty
+      expect(Refile.cache.get(instance.document.id).exists?).to be_truthy
+    end
+
+    it "contains a list of errors when invalid file uploaded" do
+      file = Refile::FileDouble.new("a"*120)
+      instance.document = file
+
+      expect(instance.document_attachment.errors).to eq([:too_large])
+      expect(instance.document).to be_nil
+    end
+
+    it "is reset when valid file uploaded" do
+      file = Refile::FileDouble.new("a"*120)
+      instance.document = file
+
+      file = Refile::FileDouble.new("hello")
+      instance.document = file
+
+      expect(instance.document_attachment.errors).to be_empty
+      expect(Refile.cache.get(instance.document.id).exists?).to be_truthy
+    end
+  end
+
+  describe "with option `raise_errors: true" do
+    let(:options) { { cache: :limited_cache, raise_errors: true } }
+
+    it "raises an error when invalid file assigned" do
+      file = Refile::FileDouble.new("a"*120)
+      expect do
+        instance.document = file
+      end.to raise_error(Refile::Invalid)
+
+      expect(instance.document_attachment.errors).to eq([:too_large])
+      expect(instance.document).to be_nil
+    end
+  end
+
+  describe "with option `raise_errors: false" do
+    let(:options) { { cache: :limited_cache, raise_errors: false } }
+
+    it "does not raise an error when invalid file assigned" do
+      file = Refile::FileDouble.new("a"*120)
+      instance.document = file
+
+      expect(instance.document_attachment.errors).to eq([:too_large])
+      expect(instance.document).to be_nil
+    end
+  end
+end

data/spec/refile/backend/file_system_spec.rb

@@ -0,0 +1,30 @@
+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
+
+  describe "#upload" do
+    it "efficiently copies a file if it has a path" do
+      path = File.expand_path("tmp/test.txt", Dir.pwd)
+      File.write(path, "hello")
+
+      uploadable = Refile::FileDouble.new("wrong")
+      allow(uploadable).to receive(:path).and_return(path)
+
+      file = backend.upload(uploadable)
+
+      expect(backend.get(file.id).read).to eq("hello")
+    end
+
+    it "ignores path if it doesn't exist" do
+      path = File.expand_path("tmp/doesnotexist.txt", Dir.pwd)
+
+      uploadable = Refile::FileDouble.new("yes")
+      allow(uploadable).to receive(:path).and_return(path)
+
+      file = backend.upload(uploadable)
+
+      expect(backend.get(file.id).read).to eq("yes")
+    end
+  end
+end

data/spec/refile/backend/s3_spec.rb

@@ -0,0 +1,11 @@
+if ENV["S3"]
+  require "refile/backend/s3"
+
+  config = YAML.load_file("s3.yml").map { |k, v| [k.to_sym, v] }.to_h
+
+  RSpec.describe Refile::Backend::S3 do
+    let(:backend) { Refile::Backend::S3.new(max_size: 100, **config) }
+
+    it_behaves_like :backend
+  end
+end

data/spec/refile/backend_examples.rb

@@ -0,0 +1,215 @@
+RSpec.shared_examples_for :backend do
+  def uploadable(data = "hello")
+    Refile::FileDouble.new(data)
+  end
+
+  def open_files
+    ObjectSpace.each_object(File).reject { |f| f.closed? } if defined?(ObjectSpace)
+  end
+
+  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)
+    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
+  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
+  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
+  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
+  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(ArgumentError)
+
+      expect(backend.get(file.id).exists?).to be_truthy
+    end
+  end
+
+  describe "File" do
+    it "is an io-like object" do
+      before = open_files
+
+      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
+
+      expect(open_files).to eq(before)
+    end
+
+    describe "#read" do
+      it "can read file contents" do
+        file = backend.upload(uploadable)
+
+        buffer = ""
+
+        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 "#each" do
+      it "can read file contents" do
+        file = backend.upload(uploadable)
+
+        buffer = ""
+        file.each do |chunk|
+          buffer << chunk
+        end
+
+        expect(buffer).to eq("hello")
+      end
+
+      it "returns an enumerator when no block given" do
+        file = backend.upload(uploadable)
+
+        expect(file.each.to_a.join).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
+  end
+end

data/spec/refile/features/direct_upload_spec.rb

@@ -0,0 +1,29 @@
+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")
+
+    click_button "Create"
+
+    expect(page).to have_selector("h1", text: "A cool post")
+    result = Net::HTTP.get_response(URI(find_link("Document")[:href])).body.chomp
+    expect(result).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
+end
+

data/spec/refile/features/normal_upload_spec.rb

@@ -0,0 +1,36 @@
+require "refile/test_app"
+
+feature "Normal HTTP Post file uploads" do
+  scenario "Successfully upload a file" do
+    visit "/normal/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Document", path("hello.txt")
+    click_button "Create"
+
+    expect(page).to have_selector("h1", text: "A cool post")
+    click_link("Document")
+    expect(page.source.chomp).to eq("hello")
+  end
+
+  scenario "Fail to upload a file that is too large" do
+    visit "/normal/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Document", path("large.txt")
+    click_button "Create"
+
+    expect(page).to have_selector(".field_with_errors")
+    expect(page).to have_content("Document is too large")
+  end
+
+  scenario "Upload a file via form redisplay" do
+    visit "/normal/posts/new"
+    attach_file "Document", path("hello.txt")
+    click_button "Create"
+    fill_in "Title", with: "A cool post"
+    click_button "Create"
+
+    expect(page).to have_selector("h1", text: "A cool post")
+    click_link("Document")
+    expect(page.source.chomp).to eq("hello")
+  end
+end