saviour 0.2.0

data/spec/models/config_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Saviour::Config do
+  after { Saviour::Config.storage = nil }
+  
+  describe "#storage" do
+    it do
+      expect { Saviour::Config.storage }.to raise_error(RuntimeError)
+    end
+
+    it do
+      Saviour::Config.storage = :test
+      expect(Saviour::Config.storage).to eq :test
+    end
+  end
+end

data/spec/models/file_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe Saviour::File do
+  let(:mocked_storage) {
+    Class.new {
+      def write(content, filename)
+      end
+
+      def read(path)
+      end
+
+      def delete(path)
+      end
+
+      def exists?(path)
+      end
+    }.new
+  }
+
+  before { allow(Saviour::Config).to receive(:storage).and_return(mocked_storage) }
+
+  let(:uploader_klass) { Class.new(Saviour::BaseUploader) {
+    store_dir { "/store/dir" }
+  } }
+
+  let(:example_file) { double(read: "some file contents", path: "/my/path") }
+
+  describe "initialization" do
+    describe "derives persisted from the model" do
+      it do
+        file = Saviour::File.new(uploader_klass, Test.new, :file)
+        expect(file).not_to be_persisted
+      end
+
+      it do
+        file = Saviour::File.new(uploader_klass, Test.create!, :file)
+        expect(file).not_to be_persisted
+      end
+
+      it do
+        file = Saviour::File.new(uploader_klass, Test.create!(file: "/mocked/path"), :file)
+        expect(file).to be_persisted
+      end
+    end
+
+    describe "is not changed" do
+      it do
+        file = Saviour::File.new(uploader_klass, Test.new, :file)
+        expect(file).not_to be_changed
+      end
+
+      it do
+        file = Saviour::File.new(uploader_klass, Test.create!, :file)
+        expect(file).not_to be_changed
+      end
+
+      it do
+        file = Saviour::File.new(uploader_klass, Test.create!(file: "/mocked/path"), :file)
+        expect(file).not_to be_changed
+      end
+    end
+  end
+
+  describe "#assign" do
+    it "returns the assigned object" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      expect(file.assign(example_file)).to eq example_file
+    end
+
+    it "allows to reset the internal source" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      file.assign(example_file)
+      expect(file.assign(nil)).to be_nil
+    end
+
+    it "shows error if assigned object do not respond to :read" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      expect { file.assign(6) }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#write" do
+    it "fails without source" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      expect { file.write }.to raise_error(RuntimeError)
+    end
+
+    describe "filename used" do
+      it "is extracted from original_filename if possible" do
+        file = Saviour::File.new(uploader_klass, Test.new, :file)
+        file.assign(double(read: "contents", original_filename: 'original.jpg', path: "/my/path/my_file.zip"))
+        uploader = double
+        allow(file).to receive(:uploader).and_return(uploader)
+        expect(uploader).to receive(:write).with("contents", "original.jpg")
+        file.write
+      end
+
+      it "is extracted from path if possible" do
+        file = Saviour::File.new(uploader_klass, Test.new, :file)
+        file.assign(double(read: "contents", path: "/my/path/my_file.zip"))
+        uploader = double
+        allow(file).to receive(:uploader).and_return(uploader)
+        expect(uploader).to receive(:write).with("contents", "my_file.zip")
+        file.write
+      end
+
+      it "is random if cannot be guessed" do
+        file = Saviour::File.new(uploader_klass, Test.new, :file)
+        file.assign(double(read: "contents"))
+        allow(SecureRandom).to receive(:hex).and_return("stubbed-random")
+        uploader = double
+        allow(file).to receive(:uploader).and_return(uploader)
+        expect(uploader).to receive(:write).with("contents", "stubbed-random")
+        file.write
+      end
+    end
+
+    it "returns the path" do
+      object = Test.new
+      file = Saviour::File.new(uploader_klass, object, :file)
+      file.assign(double(read: "contents", path: "/my/path/my_file.zip"))
+      uploader = double
+      allow(file).to receive(:uploader).and_return(uploader)
+      expect(uploader).to receive(:write).with("contents", "my_file.zip").and_return("/store/dir/my_file.zip")
+      expect(file.write).to eq "/store/dir/my_file.zip"
+    end
+  end
+
+  describe "#changed?" do
+    it "is cleared after removing the assignation" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      expect(file).not_to be_changed
+      file.assign(example_file)
+      expect(file).to be_changed
+      file.assign(nil)
+      expect(file).not_to be_changed
+    end
+
+    it "is cleared after persisting" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      file.assign(double(read: "contents", path: "/my/path/my_file.zip"))
+      expect(file).to be_changed
+
+      uploader = double
+      allow(file).to receive(:uploader).and_return(uploader)
+      expect(uploader).to receive(:write)
+      file.write
+
+      expect(file).not_to be_changed
+    end
+  end
+
+  describe "#filename" do
+    it "returns the filename of the persisted file" do
+      file = Saviour::File.new(uploader_klass, Test.create!(file: "/mocked/path/file.rar"), :file)
+      expect(file.filename).to eq "file.rar"
+    end
+  end
+
+  describe "#with_copy" do
+    it "provides a copy of the stored file" do
+      file = Saviour::File.new(uploader_klass, Test.create!(file: "/mocked/path/file.rar"), :file)
+      allow(file).to receive(:read).and_return("some contents")
+
+      file.with_copy do |tmpfile|
+        expect(tmpfile.read).to eq "some contents"
+      end
+    end
+
+    it "deletes the copied file even on exception" do
+      file = Saviour::File.new(uploader_klass, Test.create!(file: "/mocked/path/file.rar"), :file)
+      allow(file).to receive(:read).and_return("some contents")
+      mocked_tmpfile = double(binmode: "", rewind: "", flush: "", write: "")
+      allow(Tempfile).to receive(:open).and_yield(mocked_tmpfile)
+
+      expect(mocked_tmpfile).to receive(:close)
+      expect(mocked_tmpfile).to receive(:delete)
+
+      test_exception = Class.new(Exception)
+
+      begin
+        file.with_copy {|_| raise(test_exception, "some exception within the block") }
+      rescue test_exception
+      end
+    end
+  end
+
+  describe "#blank?" do
+    it "it's true when not yet assigned nor persisted" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      expect(file).to be_blank
+    end
+
+    it "it's true when not yet assigned but persisted" do
+      file = Saviour::File.new(uploader_klass, Test.create!, :file)
+      expect(file).to be_blank
+    end
+
+    it "it's false when not persisted but assigned" do
+      file = Saviour::File.new(uploader_klass, Test.new, :file)
+      file.assign example_file
+      expect(file).not_to be_blank
+    end
+
+    it "it's false when persisted and assigned" do
+      file = Saviour::File.new(uploader_klass, Test.create!(file: example_file), :file)
+      expect(file).not_to be_blank
+    end
+  end
+end

data/spec/models/local_storage_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe Saviour::LocalStorage do
+  # operate only inside @tmpdir to not mess with test setup, Dir.mktmpdir
+  subject { Saviour::LocalStorage.new(local_prefix: @tmpdir) }
+
+  describe "#write" do
+    let(:filename) { "output.jpg" }
+    let(:destination_path) { File.join("/my/folder", filename) }
+
+    it "writting a new file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        file_destination = File.join(@tmpdir, destination_path)
+        expect(File.file?(file_destination)).to be_falsey
+
+        contents = file.read
+        subject.write(contents, destination_path)
+
+        expect(File.file?(file_destination)).to be_truthy
+        expect(File.read(file_destination)).to eq contents
+      end
+    end
+
+    describe "overwritting an existing file" do
+      context "with overwrite protection" do
+        it "raises an error" do
+          path = File.join(@tmpdir, destination_path)
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, "some dummy content")
+          expect(File.file?(path)).to be_truthy
+
+          with_test_file("camaloon.jpg") do |file, _|
+            contents = file.read
+            expect { subject.write(contents, destination_path) }.to raise_error(RuntimeError)
+          end
+        end
+      end
+
+      context "without overwrite protection" do
+        subject { Saviour::LocalStorage.new(local_prefix: @tmpdir, overwrite_protection: false) }
+
+        it do
+          path = File.join(@tmpdir, destination_path)
+
+          FileUtils.mkdir_p(File.dirname(path))
+          File.write(path, "some dummy content")
+          expect(File.file?(path)).to be_truthy
+
+          with_test_file("camaloon.jpg") do |file, _|
+            contents = file.read
+            subject.write(contents, destination_path)
+
+            expect(File.file?(path)).to be_truthy
+            expect(File.read(path)).to eq contents
+          end
+        end
+      end
+    end
+  end
+
+  describe "#read" do
+    it "reads an existing file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        expect(subject.read(File.basename(file.path))).to eq file.read
+      end
+    end
+
+    it "fails if the file do not exists" do
+      expect { subject.read("nope.rar") }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#delete" do
+    it "deletes an existing file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        expect(File.file?(file.path)).to be_truthy
+
+        subject.delete(File.basename(file.path))
+        expect(File.file?(file.path)).to be_falsey
+      end
+    end
+
+    it "fails if the file do not exists" do
+      expect { subject.delete("nope.rar") }.to raise_error(RuntimeError)
+    end
+
+    it "does not leave an empty dir behind" do
+      with_test_file("camaloon.jpg") do |file, _|
+        final_path = File.join(@tmpdir, "some/folder/dest.jpg")
+
+        FileUtils.mkdir_p(File.dirname(final_path))
+        FileUtils.cp file.path, final_path
+        expect(File.file?(final_path)).to be_truthy
+
+        subject.delete("/some/folder/dest.jpg")
+
+        expect(File.file?(final_path)).to be_falsey
+        expect(File.directory?(File.join(@tmpdir, "some/folder"))).to be_falsey
+        expect(File.directory?(File.join(@tmpdir, "some"))).to be_falsey
+      end
+    end
+  end
+
+  describe "#exists?" do
+    it "with existing file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        expect(subject.exists?(File.basename(file.path))).to be_truthy
+      end
+    end
+
+    it "with no file" do
+      expect(subject.exists?("unexisting_file.zip")).to be_falsey
+    end
+  end
+
+  describe "#public_url" do
+    let(:destination_path) { "dest/file.jpeg" }
+
+    context do
+      subject { Saviour::LocalStorage.new(local_prefix: @tmpdir) }
+
+      it "fails if not provided the prefix" do
+        with_test_file("camaloon.jpg") do |file, _|
+          expect {
+            subject.public_url(File.basename(file.path))
+          }.to raise_error(RuntimeError)
+        end
+      end
+    end
+
+    context do
+      subject { Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: -> { "http://mywebsite.com/#{Time.now.hour}/uploads" }) }
+
+      it do
+        allow(Time).to receive(:now).and_return(Time.new(2015, 1, 1, 13, 2, 1))
+
+        with_test_file("camaloon.jpg") do |file, filename|
+          expect(subject.public_url(File.basename(file.path))).to eq "http://mywebsite.com/13/uploads/#{filename}"
+        end
+      end
+    end
+
+    context do
+      subject { Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://mywebsite.com/uploads") }
+
+      it do
+        with_test_file("camaloon.jpg") do |file, filename|
+          expect(subject.public_url(File.basename(file.path))).to eq "http://mywebsite.com/uploads/#{filename}"
+        end
+      end
+    end
+  end
+end

data/spec/models/processors/digest_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Saviour::Processors::Digest do
+  describe "#digest_filename" do
+    subject {
+      Class.new { include Saviour::Processors::Digest }.new
+    }
+
+    let(:filename) { "name.jpg" }
+    let(:contents) { "bynary contents for a file" }
+
+    it do
+      _, new_name = subject.digest_filename(contents, filename)
+      expect(new_name).to eq "name-ab54d187b7909ff4bba34777073d4654.jpg"
+    end
+
+    it do
+      _, new_name = subject.digest_filename(contents, filename, separator: '/')
+      expect(new_name).to eq "name/ab54d187b7909ff4bba34777073d4654.jpg"
+    end
+  end
+end

data/spec/models/s3_storage_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Saviour::S3Storage do
+  subject { Saviour::S3Storage.new(bucket: "fake-bucket", aws_access_key_id: "stub", aws_secret_access_key: "stub", public_url_prefix: "https://fake-bucket.s3.amazonaws.com") }
+  let!(:mocked_s3) { MockedS3Helper.new }
+  before { mocked_s3.start!(bucket_name: "fake-bucket") }
+
+  context do
+    it "fails when no keys are provided" do
+      expect {
+        Saviour::S3Storage.new(bucket: "fake-bucket")
+      }.to raise_error(ArgumentError)
+    end
+
+    it "fails when the bucket doesn't exists" do
+      expect {
+        Saviour::S3Storage.new(bucket: "no-bucket", aws_access_key_id: "stub", aws_secret_access_key: "stub")
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#write" do
+    let(:destination_path) { "my/folder/file.jpeg" }
+
+    it "writting a new file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        expect(mocked_s3.exists?(destination_path)).to be_falsey
+
+        contents = file.read
+        subject.write(contents, destination_path)
+
+        expect(mocked_s3.read(destination_path)).to eq contents
+      end
+    end
+
+    describe "overwritting" do
+      context "without overwrite protection" do
+        subject {
+          Saviour::S3Storage.new(
+              bucket: "fake-bucket",
+              aws_access_key_id: "stub",
+              aws_secret_access_key: "stub",
+              public_url_prefix: "https://fake-bucket.s3.amazonaws.com",
+              overwrite_protection: false
+          )
+        }
+
+        it "overwrites the existing file" do
+          mocked_s3.write("some dummy contents", destination_path)
+          expect(mocked_s3.exists?(destination_path)).to be_truthy
+
+          with_test_file("camaloon.jpg") do |file, _|
+            contents = file.read
+            subject.write(contents, destination_path)
+            expect(mocked_s3.read(destination_path)).to eq contents
+          end
+        end
+      end
+
+      context "with overwrite protection" do
+        it "raises an exception" do
+          mocked_s3.write("some dummy contents", destination_path)
+          expect(mocked_s3.exists?(destination_path)).to be_truthy
+
+          with_test_file("camaloon.jpg") do |file, _|
+            contents = file.read
+            expect { subject.write(contents, destination_path) }.to raise_error(RuntimeError)
+          end
+        end
+      end
+    end
+
+    it "ignores leading slash" do
+      subject.write("trash contents", "/folder/file.out")
+      expect(subject.exists?("folder/file.out")).to be_truthy
+      expect(subject.exists?("/folder/file.out")).to be_truthy
+      expect(subject.exists?("////folder/file.out")).to be_truthy
+    end
+  end
+
+  describe "#read" do
+    let(:destination_path) { "dest/file.jpeg" }
+
+    it "reads an existing file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        contents = file.read
+
+        mocked_s3.write(contents, destination_path)
+        expect(subject.read(destination_path)).to eq contents
+      end
+    end
+
+    it "fails if the file do not exists" do
+      expect { subject.read("nope.rar") }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#delete" do
+    let(:destination_path) { "dest/file.jpeg" }
+
+    it "deletes an existing file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        contents = file.read
+        mocked_s3.write(contents, destination_path)
+
+        expect(mocked_s3.exists?(destination_path)).to be_truthy
+        subject.delete("/dest/file.jpeg")
+        expect(mocked_s3.exists?(destination_path)).to be_falsey
+      end
+    end
+
+    it "fails if the file do not exists" do
+      expect { subject.delete("nope.rar") }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "#exists?" do
+    let(:destination_path) { "dest/file.jpeg" }
+
+    it "with existing file" do
+      with_test_file("camaloon.jpg") do |file, _|
+        contents = file.read
+        mocked_s3.write(contents, destination_path)
+        expect(subject.exists?(destination_path)).to be_truthy
+      end
+    end
+
+    it "with no file" do
+      expect(subject.exists?("unexisting_file.zip")).to be_falsey
+    end
+  end
+
+  describe "#public_url" do
+    let(:destination_path) { "dest/file.jpeg" }
+
+    context do
+      subject { Saviour::S3Storage.new(bucket: "fake-bucket", aws_access_key_id: "stub", aws_secret_access_key: "stub") }
+
+      it "fails if not provided the prefix" do
+        with_test_file("camaloon.jpg") do |file, _|
+          contents = file.read
+          mocked_s3.write(contents, destination_path)
+          expect { subject.public_url(destination_path) }.to raise_error(RuntimeError)
+        end
+      end
+    end
+
+    context do
+      subject { Saviour::S3Storage.new(bucket: "fake-bucket", aws_access_key_id: "stub", aws_secret_access_key: "stub", public_url_prefix: -> { "https://#{Time.now.hour}.s3.amazonaws.com" }) }
+
+      it "allow to use a lambda for dynamic url prefixes" do
+        allow(Time).to receive(:now).and_return(Time.new(2015, 1, 1, 13, 2, 1))
+
+        with_test_file("camaloon.jpg") do |file, _|
+          contents = file.read
+          mocked_s3.write(contents, destination_path)
+          expect(subject.public_url(destination_path)).to eq "https://13.s3.amazonaws.com/dest/file.jpeg"
+        end
+      end
+    end
+
+    it do
+      with_test_file("camaloon.jpg") do |file, _|
+        contents = file.read
+        mocked_s3.write(contents, destination_path)
+        expect(subject.public_url(destination_path)).to eq "https://fake-bucket.s3.amazonaws.com/dest/file.jpeg"
+      end
+    end
+  end
+end