saviour 0.2.0

data/spec/feature/persisted_path_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "persisted path" do
+  before { Saviour::Config.storage = Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com") }
+  after { Saviour::Config.storage = nil }
+
+  context "can change the default_path on the uploader and previous instances are not affected" do
+    it do
+      uploader = Class.new(Saviour::BaseUploader) { store_dir { "/store/dir" } }
+      klass = Class.new(Test) { include Saviour }
+      klass.attach_file :file, uploader
+
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+        expect(File.dirname(a[:file])).to eq "/store/dir"
+
+
+        uploader.class_eval { store_dir { "/another/dir" } }
+
+        with_test_file("camaloon.jpg") do |example_2|
+          b = klass.create!
+          expect(b.update_attributes(file: example_2)).to be_truthy
+
+          expect(Saviour::Config.storage.exists?(b[:file])).to be_truthy
+          expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+
+          expect(File.dirname(b[:file])).to eq "/another/dir"
+          expect(File.dirname(a[:file])).to eq "/store/dir"
+        end
+      end
+    end
+  end
+end

data/spec/feature/reload_model_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "reload model" do
+  before { Saviour::Config.storage = Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com") }
+  after { Saviour::Config.storage = nil }
+
+  context "updates the Saviour::File instance" do
+    it do
+      uploader = Class.new(Saviour::BaseUploader) { store_dir { "/store/dir" } }
+      klass = Class.new(Test) { include Saviour }
+      klass.attach_file :file, uploader
+      a = klass.create!
+      b = klass.find(a.id)
+
+      with_test_file("example.xml") do |example|
+        a.update_attributes! file: example
+        expect(a.file.exists?).to be_truthy
+        expect(b.file.exists?).to be_falsey
+
+        b.reload
+        expect(b.file.exists?).to be_truthy
+      end
+    end
+  end
+end

data/spec/feature/validations_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe "validations saving a new file" do
+  before { Saviour::Config.storage = Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com") }
+  after { Saviour::Config.storage = nil }
+
+  let(:uploader) {
+    Class.new(Saviour::BaseUploader) {
+      store_dir { "/store/dir" }
+    }
+  }
+
+  let(:base_klass) {
+    a = Class.new(Test) { include Saviour }
+    a.attach_file :file, uploader
+    a
+  }
+
+  it "fails at block validation" do
+    klass = Class.new(base_klass) do
+      attach_validation(:file) do |contents, _|
+        errors.add(:file, "Cannot start with X") if contents[0] == 'X'
+      end
+    end
+
+    with_test_file("example.xml") do |example|
+      allow(example).to receive(:read).and_return("X-Extra contents for the file")
+      a = klass.new
+      a.file = example
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Cannot start with X"
+    end
+
+    with_test_file("example.xml") do |example|
+      a = klass.new
+      a.file = example
+      expect(a).to be_valid
+      expect(a.save).to be_truthy
+    end
+  end
+
+
+  it "fails at method validation" do
+    klass = Class.new(base_klass) do
+      attach_validation :file, :check_filesize
+
+      def check_filesize(contents, _)
+        errors.add(:file, "Filesize must be less than 10 bytes") if contents.bytesize >= 10
+      end
+    end
+
+    with_test_file("example.xml") do |example|
+      allow(example).to receive(:read).and_return("1234567890")
+      a = klass.new
+      a.file = example
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Filesize must be less than 10 bytes"
+    end
+
+    with_test_file("example.xml") do |example|
+      allow(example).to receive(:read).and_return("123456789")
+      a = klass.new
+      a.file = example
+      expect(a).to be_valid
+    end
+  end
+
+  it "combined validatinos" do
+    klass = Class.new(base_klass) do
+      attach_validation :file, :check_filesize
+      attach_validation(:file) do |contents, _|
+        errors.add(:file, "Cannot start with X") if contents[0] == 'X'
+      end
+
+      def check_filesize(contents, _)
+        errors.add(:file, "Filesize must be less than 10 bytes") if contents.bytesize >= 10
+      end
+    end
+
+    with_test_file("example.xml") do |example|
+      allow(example).to receive(:read).and_return("X-Ex")
+      a = klass.new
+      a.file = example
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Cannot start with X"
+    end
+
+    with_test_file("example.xml") do |example|
+      allow(example).to receive(:read).and_return("Ex too long content")
+      a = klass.new
+      a.file = example
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Filesize must be less than 10 bytes"
+    end
+
+    # Consistent order
+    with_test_file("example.xml") do |example|
+      allow(example).to receive(:read).and_return("X-Ex too long content")
+      a = klass.new
+      a.file = example
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Filesize must be less than 10 bytes"
+      expect(a.errors[:file][1]).to eq "Cannot start with X"
+    end
+  end
+
+  it "validates by filename" do
+    klass = Class.new(base_klass) do
+      attach_validation :file, :check_filename
+
+      def check_filename(_, filename)
+        errors.add(:file, "Only .jpg files") unless filename =~ /\.jpg/
+      end
+    end
+
+    with_test_file("example.xml") do |example|
+      allow(example).to receive(:read).and_return("X-Ex")
+      a = klass.new
+      a.file = example
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Only .jpg files"
+    end
+
+    with_test_file("camaloon.jpg") do |example|
+      allow(example).to receive(:read).and_return("X-Ex")
+      a = klass.new
+      a.file = example
+      expect(a).to be_valid
+    end
+  end
+
+  it "receives the attached_as information" do
+    klass = Class.new(base_klass) do
+      attach_validation :file, :check_filename
+
+      def check_filename(_, _, opts)
+        errors.add(:file, "Received error in #{opts[:attached_as]}")
+      end
+    end
+
+    with_test_file("example.xml") do |example|
+      a = klass.new file: example
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Received error in file"
+    end
+  end
+
+  context "versions are validated" do
+    let(:uploader) {
+      Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+        version(:thumb)
+      }
+    }
+    let(:klass) {
+      Class.new(base_klass) do
+        attach_validation(:file) do |contents, _, opts|
+          errors.add(:file, "Cannot start with X in version #{opts[:version]}") if contents[0] == 'X'
+        end
+      end
+    }
+
+    it do
+      a = klass.create!
+      a.file.assign Saviour::StringSource.new("correct contents")
+      a.file(:thumb).assign Saviour::StringSource.new("X Incorrect contents")
+
+      expect(a).not_to be_valid
+      expect(a.errors[:file][0]).to eq "Cannot start with X in version thumb"
+    end
+  end
+end

data/spec/feature/versions_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe "saving a new file" do
+  before { Saviour::Config.storage = Saviour::LocalStorage.new(local_prefix: @tmpdir, public_url_prefix: "http://domain.com") }
+  after { Saviour::Config.storage = nil }
+
+  let(:uploader) {
+    Class.new(Saviour::BaseUploader) do
+      store_dir { "/store/dir" }
+
+      version(:thumb) do
+        store_dir { "/versions/store/dir" }
+      end
+    end
+  }
+
+  let(:klass) {
+    a = Class.new(Test) { include Saviour }
+    a.attach_file :file, uploader
+    a
+  }
+
+  describe "creation following main file" do
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+      end
+    end
+  end
+
+  describe "deletion" do
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        a.update_attributes(file: example)
+        expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+
+        a.destroy
+        expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_falsey
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_falsey
+      end
+    end
+  end
+
+  describe "changes following main file" do
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+
+        with_test_file("camaloon.jpg") do |file|
+          a.update_attributes(file: file)
+          expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+          file.rewind
+          expect(a.file(:thumb).read).to eq file.read
+        end
+      end
+    end
+  end
+
+  describe "accessing file features directly" do
+    let(:uploader) {
+      Class.new(Saviour::BaseUploader) do
+        store_dir { "/store/dir" }
+
+        version(:thumb) do
+          store_dir { "/versions/store/dir" }
+          process { |contents, name| ["#{contents}_for_version_thumb", name] }
+        end
+      end
+    }
+
+    it "#url" do
+      with_test_file("example.xml") do |example, name|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+
+        versioned_name = "#{File.basename(name, ".*")}_thumb#{File.extname(name)}"
+        expect(a.file(:thumb).url).to eq "http://domain.com/versions/store/dir/#{versioned_name}"
+      end
+    end
+
+    it "#read" do
+      with_test_file("text.txt") do |example|
+        a = klass.create!
+        a.update_attributes(file: example)
+
+        expect(a.file(:thumb).read).to eq "Hello world\n_for_version_thumb"
+      end
+    end
+
+    it "#delete" do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+
+        a.file(:thumb).delete
+        expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_falsey
+        expect(Saviour::Config.storage.exists?(a[:file])).to be_truthy
+      end
+    end
+
+    it "#exists?" do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+        expect(a.file(:thumb).exists?).to be_truthy
+      end
+    end
+  end
+
+  describe "assign specific version after first creation" do
+    it do
+      with_test_file("example.xml") do |example|
+        a = klass.create!
+        expect(a.update_attributes(file: example)).to be_truthy
+        expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+        expect(a[:file_thumb]).to eq "/versions/store/dir/#{File.basename(example, ".*")}_thumb.xml"
+
+        with_test_file("camaloon.jpg") do |ex2, filename|
+          a.file(:thumb).assign(ex2)
+
+          expect(a.save!).to be_truthy
+
+          expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+          expect(a[:file_thumb]).to eq "/versions/store/dir/#{File.basename(filename, ".*")}.jpg"
+        end
+      end
+    end
+
+    context do
+      let(:uploader) {
+        Class.new(Saviour::BaseUploader) do
+          store_dir { "/store/dir" }
+
+          version(:thumb) do
+            store_dir { "/versions/store/dir" }
+            process { |_, filename| ["modified_content", filename] }
+          end
+        end
+      }
+
+      it "runs the processors for that version only" do
+        with_test_file("example.xml") do |example|
+          a = klass.create!
+          expect(a.update_attributes(file: example)).to be_truthy
+          expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+          expect(a[:file_thumb]).to eq "/versions/store/dir/#{File.basename(example, ".*")}_thumb.xml"
+
+          with_test_file("camaloon.jpg") do |ex2, filename|
+            a.file(:thumb).assign(ex2)
+
+            expect(a.save!).to be_truthy
+
+            expect(Saviour::Config.storage.exists?(a[:file_thumb])).to be_truthy
+            expect(a[:file_thumb]).to eq "/versions/store/dir/#{File.basename(filename, ".*")}.jpg"
+            expect(Saviour::Config.storage.read(a[:file_thumb])).to eq "modified_content"
+          end
+        end
+      end
+    end
+  end
+
+  describe "respects version assignation vs main file assignation on conflict" do
+    it do
+      a = klass.create!
+
+      with_test_file("example.xml") do |file1, fname1|
+        with_test_file("camaloon.jpg") do |file2, fname2|
+          a.file.assign(file1)
+          a.file(:thumb).assign(file2)
+          a.save!
+
+          expect(a[:file]).to eq "/store/dir/#{fname1}"
+          expect(a[:file_thumb]).to eq "/versions/store/dir/#{fname2}"
+        end
+      end
+    end
+  end
+end

data/spec/models/base_uploader_spec.rb

@@ -0,0 +1,396 @@
+require 'spec_helper'
+
+describe Saviour::BaseUploader do
+  let(:mocked_storage) {
+    Class.new {
+      def write(content, filename)
+        # pass
+      end
+    }.new
+  }
+  before { allow(Saviour::Config).to receive(:storage).and_return(mocked_storage) }
+
+
+  describe "DSL" do
+    subject { Class.new(Saviour::BaseUploader) }
+
+    it do
+      subject.process :hola
+      expect(subject.processors[0][:element].method_or_block).to eq :hola
+      expect(subject.processors[0][:opts]).to eq({})
+    end
+
+    it do
+      subject.process :a
+      subject.process :resize, width: 50
+
+      expect(subject.processors[0][:element].method_or_block).to eq :a
+      expect(subject.processors[0][:opts]).to eq({})
+
+      expect(subject.processors[1][:element].method_or_block).to eq :resize
+      expect(subject.processors[1][:opts]).to eq({width: 50})
+    end
+
+    it do
+      subject.process { 5 }
+      expect(subject.processors[0][:element].method_or_block).to respond_to :call
+      expect(subject.processors[0][:element].method_or_block.call).to eq 5
+    end
+
+    it do
+      subject.store_dir { "/my/dir" }
+      expect(subject.store_dirs[0].method_or_block.call).to eq "/my/dir"
+    end
+
+    it do
+      subject.store_dir :method_to_return_the_dir
+      expect(subject.store_dirs[0].method_or_block).to eq :method_to_return_the_dir
+    end
+
+    it "can use store_dir twice and last prevails" do
+      subject.store_dir { "/my/dir" }
+      subject.store_dir { "/my/dir/4" }
+      expect(subject.store_dirs[0].method_or_block.call).to eq "/my/dir"
+      expect(subject.store_dirs[1].method_or_block.call).to eq "/my/dir/4"
+    end
+
+    it "is not accessible from subclasses, works in isolation" do
+      subject.process :hola
+      expect(subject.processors[0][:element].method_or_block).to eq :hola
+      expect(subject.processors[0][:opts]).to eq({})
+
+      subclass = Class.new(subject)
+      expect(subclass.processors).to eq []
+    end
+
+    describe "version" do
+      it "stores as elements with the given version" do
+        subject.process :hola
+        subject.version(:thumb) do
+          process :resize_to_thumb
+        end
+
+        expect(subject.processors[0][:element].method_or_block).to eq :hola
+        expect(subject.processors[0][:element].version).to eq nil
+        expect(subject.processors[0][:opts]).to eq({})
+
+        expect(subject.processors[1][:element].method_or_block).to eq :resize_to_thumb
+        expect(subject.processors[1][:element].version).to eq :thumb
+        expect(subject.processors[1][:opts]).to eq({})
+      end
+
+      it "respects ordering" do
+        subject.process :hola
+        subject.version(:thumb) { process :resize_to_thumb }
+        subject.process :top_level
+        subject.version(:another) { process(:foo) }
+
+        expect(subject.processors[0][:element].method_or_block).to eq :hola
+        expect(subject.processors[0][:element].version).to eq nil
+        expect(subject.processors[1][:element].method_or_block).to eq :resize_to_thumb
+        expect(subject.processors[1][:element].version).to eq :thumb
+        expect(subject.processors[2][:element].method_or_block).to eq :top_level
+        expect(subject.processors[2][:element].version).to eq nil
+        expect(subject.processors[3][:element].method_or_block).to eq :foo
+        expect(subject.processors[3][:element].version).to eq :another
+      end
+    end
+  end
+
+  describe "initialization with data" do
+    it "can declare wathever" do
+      uploader = Class.new(Saviour::BaseUploader).new(data: {a: "2", data: "my file"})
+      expect(uploader).to respond_to :a
+      expect(uploader).to respond_to :data
+      expect(uploader.a).to eq "2"
+    end
+
+    it do
+      uploader = Class.new(Saviour::BaseUploader).new(data: {a: "2", data: "my file"})
+      expect(uploader).to respond_to :a
+
+      uploader = Class.new(Saviour::BaseUploader).new(data: {name: "johny"})
+      expect(uploader).not_to respond_to :a
+    end
+  end
+
+  describe "#write" do
+    subject { uploader.new(data: {model: "model", attached_as: "attached_as"}) }
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) }
+
+      it "error if no store_dir" do
+        expect { subject.write("contents", "filename.jpg") }.to raise_error(RuntimeError)
+      end
+    end
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+      } }
+
+      it "calls storage write" do
+        expect(Saviour::Config.storage).to receive(:write).with("contents", "/store/dir/file.jpg")
+        subject.write("contents", "file.jpg")
+      end
+
+      it "returns the fullpath" do
+        expect(subject.write("contents", "file.jpg")).to eq '/store/dir/file.jpg'
+      end
+    end
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+
+        def resize(contents, filename)
+          ["#{contents}-x2", filename]
+        end
+
+        process :resize
+      } }
+
+      it "calls the processors" do
+        expect(subject).to receive(:resize).with("content", "output.png").and_call_original
+        expect(Saviour::Config.storage).to receive(:write).with("content-x2", "/store/dir/output.png")
+        subject.write("content", "output.png")
+      end
+    end
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+
+        def resize(contents, filename)
+          ["#{contents}-x2", filename]
+        end
+
+        process :resize
+        process { |content, filename| ["#{content}_x9", "prefix-#{filename}"] }
+      } }
+
+      it "respects ordering on processor calling" do
+        expect(Saviour::Config.storage).to receive(:write).with("content-x2_x9", "/store/dir/prefix-output.png")
+        subject.write("content", "output.png")
+      end
+    end
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+
+        def resize(contents, filename, opts = {})
+          ["#{contents}-#{opts[:width]}-#{opts[:height]}", filename]
+        end
+
+        process :resize, width: 50, height: 10
+      } }
+
+      it "calls the method using the stored arguments" do
+        expect(Saviour::Config.storage).to receive(:write).with("content-50-10", "/store/dir/output.png")
+        subject.write("content", "output.png")
+      end
+    end
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+
+        def rename(contents, filename)
+          [contents, "#{model.id}_#{filename}"]
+        end
+
+        process :rename
+        process { |content, filename| [content, "#{model.name}_#{filename}"] }
+      } }
+
+      let(:model) { double(id: 8, name: "Robert") }
+      subject { uploader.new(data: {model: model, attached_as: "attached_as"}) }
+
+      it "can access model from processors" do
+        expect(Saviour::Config.storage).to receive(:write).with("content", "/store/dir/Robert_8_output.png")
+        subject.write("content", "output.png")
+      end
+    end
+  end
+
+  describe "version" do
+    subject { uploader.new(version: :thumb) }
+
+    describe "store_dir" do
+      context "is the last one defined for the given version" do
+        let(:uploader) { Class.new(Saviour::BaseUploader) {
+          store_dir { "/store/dir" }
+          version(:thumb) do
+            store_dir { "/thumb/store/dir" }
+          end
+          store_dir { "/store/dir/second" }
+        } }
+
+        it do
+          expect(Saviour::Uploader::StoreDirExtractor.new(subject).store_dir).to eq "/thumb/store/dir"
+        end
+      end
+
+      context "is the last one defined without version if not specified per version" do
+        let(:uploader) { Class.new(Saviour::BaseUploader) {
+          store_dir { "/store/dir" }
+          version(:thumb) { process(:whatever) }
+          store_dir { "/store/dir/second" }
+        } }
+
+        it do
+          expect(Saviour::Uploader::StoreDirExtractor.new(subject).store_dir).to eq "/store/dir/second"
+        end
+      end
+
+    end
+
+    describe "processing behaviour on write" do
+      context "fails if no store_dir defined for root version" do
+        let(:uploader) { Class.new(Saviour::BaseUploader) {
+          version(:thumb) { store_dir { "/store/dir" } }
+        } }
+
+        it do
+          a = uploader.new(data: {model: "model", attached_as: "attached_as"})
+          expect { a.write('1', '2') }.to raise_error(RuntimeError)
+        end
+      end
+
+      context "with only one version" do
+        let(:uploader) { Class.new(Saviour::BaseUploader) {
+          store_dir { "/store/dir" }
+
+          version(:thumb) do
+            store_dir { "/versions/store/dir" }
+            process { |contents, name| [contents, "2_#{name}"] }
+          end
+        } }
+
+        it do
+          a = uploader.new(version: :thumb)
+          expect(Saviour::Config.storage).to receive(:write).with("content", "/versions/store/dir/2_output.png")
+          a.write("content", "output.png")
+        end
+
+        it do
+          a = uploader.new
+          expect(Saviour::Config.storage).to receive(:write).with("content", "/store/dir/output.png")
+          a.write("content", "output.png")
+        end
+      end
+
+      context "multiple definitions" do
+        let(:uploader) { Class.new(Saviour::BaseUploader) {
+          store_dir { "/store/dir" }
+          process { |contents, name| ["#{contents}_altered", name] }
+
+          version(:thumb) do
+            store_dir { "/versions/store/dir" }
+            process { |contents, name| [contents, "2_#{name}"] }
+          end
+        } }
+
+        it do
+          a = uploader.new(version: :thumb)
+          expect(Saviour::Config.storage).to receive(:write).with("content_altered", "/versions/store/dir/2_output.png")
+          a.write("content", "output.png")
+        end
+
+        it do
+          a = uploader.new
+          expect(Saviour::Config.storage).to receive(:write).with("content_altered", "/store/dir/output.png")
+          a.write("content", "output.png")
+        end
+      end
+
+      context "consecutive versions" do
+        let(:uploader) { Class.new(Saviour::BaseUploader) {
+          store_dir { "/store/dir" }
+          process { |contents, name| ["#{contents}_altered", name] }
+
+          version(:thumb) do
+            store_dir { "/versions/store/dir" }
+            process { |contents, name| ["thumb_#{contents}", "2_#{name}"] }
+          end
+
+          version(:thumb_2) do
+            store_dir { "/versions/store/dir" }
+            process { |contents, name| ["thumb_2_#{contents}", "3_#{name}"] }
+          end
+
+          process { |contents, name| ["last_transform_#{contents}", name] }
+        } }
+
+        it do
+          a = uploader.new
+          expect(Saviour::Config.storage).to receive(:write).with("last_transform_content_altered", "/store/dir/output.png")
+          a.write("content", "output.png")
+        end
+
+        it do
+          a = uploader.new(version: :thumb)
+          expect(Saviour::Config.storage).to receive(:write).with("last_transform_thumb_content_altered", "/versions/store/dir/2_output.png")
+          a.write("content", "output.png")
+        end
+
+        it do
+          a = uploader.new(version: :thumb_2)
+          expect(Saviour::Config.storage).to receive(:write).with("last_transform_thumb_2_content_altered", "/versions/store/dir/3_output.png")
+          a.write("content", "output.png")
+        end
+      end
+    end
+  end
+
+  describe "#process_with_file" do
+    subject { uploader.new(data: {model: "model", attached_as: "attached_as"}) }
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+
+        def foo(file, filename)
+          ::File.write(file.path, "modified-contents")
+          [file, filename]
+        end
+
+        process_with_file :foo
+      } }
+
+      it "calls the processors" do
+        expect(subject).to receive(:foo).with(an_instance_of(Tempfile), "output.png").and_call_original
+        expect(Saviour::Config.storage).to receive(:write).with("modified-contents", "/store/dir/output.png")
+        subject.write("contents", "output.png")
+      end
+    end
+
+    context do
+      let(:uploader) { Class.new(Saviour::BaseUploader) {
+        store_dir { "/store/dir" }
+
+        process do |contents, filename|
+          ["#{contents}_first_run", filename]
+        end
+
+        process_with_file do |file, filename|
+          ::File.write(file.path, "#{::File.read(file.path)}-modified-contents")
+          [file, filename]
+        end
+
+        process :last_run
+
+        def last_run(contents, filename)
+          ["pre-#{contents}", "pre-#{filename}"]
+        end
+      } }
+
+      it "can mix types of runs between file and contents" do
+        expect(Saviour::Config.storage).to receive(:write).with("pre-contents_first_run-modified-contents", "/store/dir/pre-aaa.png")
+        subject.write("contents", "aaa.png")
+      end
+    end
+  end
+end