tessa 1.2.3 → 6.0.0.rc1

data/spec/tessa/model_spec.rb

@@ -1,578 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Tessa::Model do
-  subject(:described_module) { described_class }
-  let(:model) {
-    SingleAssetModel
-  }
-
-  it { is_expected.to be_a(Module) }
-
-  describe "::asset" do
-    it "creates ModelField and sets it by name to @tessa_fields" do
-      expect(model.tessa_fields[:avatar]).to be_a(Tessa::Model::Field)
-    end
-
-    context "with a field named :avatar" do
-      subject(:instance) { model.new }
-
-      it "creates an #avatar method" do
-        expect(instance).to respond_to(:avatar)
-      end
-
-      it "creates an #avatar= method" do
-        expect(instance).to respond_to(:avatar=)
-      end
-
-      it "allows overriding and calling super" do
-        model.class_eval do
-          def avatar
-            @override_test = true
-            super
-          end
-        end
-
-        instance.avatar
-        expect(instance.instance_variable_get(:@override_test)).to eq(true)
-      end
-    end
-
-    context "with customized field" do
-      let(:model) {
-        MultipleAssetModel
-      }
-      let(:instance) { model.new(another_place: []) }
-
-      it "sets all attributes on ModelField properly" do
-        field = model.tessa_fields[:multiple_field]
-        expect(field.name).to eq("multiple_field")
-        expect(field.multiple).to eq(true)
-        expect(field.id_field).to eq("another_place")
-      end
-    end
-
-    context "with inheritance hierarchy" do
-      let(:submodel) {
-        Class.new(model) do
-          asset :field2
-        end
-      }
-
-      it "submodel has its own list of fields" do
-        expect(submodel.tessa_fields.keys).to eq([:avatar, :field2])
-      end
-
-      it "does not alter parent class fields" do
-        expect(model.tessa_fields.keys).to eq([:avatar])
-      end
-    end
-
-    context "on a form object" do
-      let(:model) {
-        SingleAssetModelForm
-      }
-      subject(:instance) { model.new }
-
-      it "creates an #avatar method" do
-        expect(instance).to respond_to(:avatar)
-      end
-
-      it "creates an #avatar= method" do
-        expect(instance).to respond_to(:avatar=)
-      end
-    end
-  end
-
-  describe "#asset_getter" do
-    let(:instance) { model.new }
-
-    context "with a multiple typed field" do
-      let(:model) {
-        MultipleAssetModel
-      }
-      let(:instance) { model.new(another_place: []) }
-      subject(:getter) { instance.multiple_field }
-
-      it "calls find for each of the file_ids and returns result" do
-        instance.another_place = [1, 2, 3]
-        expect(Tessa::Asset).to receive(:find).with([1, 2, 3]).and_return([:a1, :a2, :a3])
-        expect(getter).to eq([:a1, :a2, :a3])
-      end
-
-      it "caches the result" do
-        instance.another_place = [1]
-        expect(Tessa::Asset).to receive(:find).and_return(:val).once
-        instance.multiple_field
-        instance.multiple_field
-      end
-
-      context "with no values" do
-        it "does not call find" do
-          instance.another_place = []
-          expect(Tessa::Asset).not_to receive(:find)
-          expect(instance.multiple_field).to eq([])
-        end
-      end
-    end
-
-    context "with a singular typed field" do
-      let(:model) {
-        SingleAssetModel
-      }
-      subject(:getter) { instance.avatar }
-
-      it "calls find for file_id and returns result" do
-        instance.avatar_id = 1
-        expect(Tessa::Asset).to receive(:find).with(1).and_return(:a1)
-        expect(getter).to eq(:a1)
-      end
-
-      it "caches the result" do
-        instance.avatar_id = 1
-        expect(Tessa::Asset).to receive(:find).and_return(:val).once
-        instance.avatar
-        instance.avatar
-      end
-
-      it "wraps ActiveStorage uploads with AssetWrapper" do
-        file = Rack::Test::UploadedFile.new("README.md")
-        instance.avatar = file
-        
-        asset = instance.avatar
-        expect(asset).to be_a(Tessa::ActiveStorage::AssetWrapper)
-        # This goes to the blobs URL, which then redirects to the backend service URL
-        expect(asset.public_url).to start_with('https://www.example.com/rails/active_storage/blobs/')
-        # This is a direct download to the service URL (in test mode that is "disk")
-        expect(asset.private_url).to start_with('https://www.example.com/rails/active_storage/disk/')
-        expect(asset.private_download_url).to start_with('https://www.example.com/rails/active_storage/disk/')
-        expect(asset.private_download_url).to include('&disposition=attachment')
-      end
-
-      context "with nil value" do
-        it "does not call find" do
-          instance.avatar_id = nil
-          expect(Tessa::Asset).not_to receive(:find)
-          expect(instance.avatar).to be_nil
-        end
-      end
-    end
-
-    context "on a form object" do
-      let(:model) {
-        SingleAssetModelForm
-      }
-      subject(:getter) { instance.avatar }
-      
-      it 'returns nil when empty' do
-        expect(getter).to be_nil
-      end
-
-      it 'returns assigned upload object' do
-        file = Rack::Test::UploadedFile.new("README.md")
-        instance.avatar = file
-        expect(getter).to eq(file)
-      end
-    end
-  end
-
-  describe "#asset_setter" do
-    let(:instance) { model.new }
-
-    context "with a singular typed field" do
-      let(:model) {
-        SingleAssetModel
-      }
-      subject(:getter) { instance.avatar }
-      let(:file) {
-        Rack::Test::UploadedFile.new("README.md")
-      }
-
-      it 'attaches uploaded file' do
-        instance.avatar = file
-
-        expect(getter.name).to eq('avatar')
-        expect(getter.filename).to eq('README.md')
-        expect(getter.content_type).to eq('text/plain')
-        expect(getter.service_url)
-          .to start_with('https://www.example.com/rails/active_storage/disk/')
-      end
-
-      it 'sets the ID to be the ActiveStorage key' do
-        instance.avatar = file
-
-        expect(instance.avatar_id).to eq(instance.avatar_attachment.key)
-      end
-
-      it 'sets the ID in the attributes' do
-        instance.avatar = file
-        
-        expect(instance.attributes['avatar_id']).to eq(instance.avatar_attachment.key)
-      end
-
-      it 'attaches signed ID from Tessa::AssetChangeSet' do
-        blob = ::ActiveStorage::Blob.create_before_direct_upload!({
-          filename: 'README.md',
-          byte_size: file.size,
-          content_type: file.content_type,
-          checksum: '1234'
-        })
-
-        changeset = Tessa::AssetChangeSet.new(
-          changes: [{ 'id' => blob.signed_id, 'action' => 'add' }]
-        )
-        instance.avatar = changeset
-
-        expect(instance.avatar_id).to eq(instance.avatar_attachment.key)
-      end
-
-      it 'does nothing when "add"ing an existing blob' do
-        # Before this HTTP POST, we've previously uploaded this file
-        instance.avatar = file
-
-        # In this HTTP POST, we re-upload the 'add' action with the same ID
-        changeset = Tessa::AssetChangeSet.new(
-          changes: [{ 'id' => instance.avatar_attachment.key, 'action' => 'add' }]
-        )
-
-        # We expect that we're not going to detatch the existing attachment
-        expect(instance.avatar_attachment).to_not receive(:destroy)
-
-        # act
-        instance.avatar = changeset
-
-        expect(instance.avatar_id).to eq(instance.avatar_attachment.key)
-      end
-    end
-
-    context "with a multiple typed field" do
-      let(:model) {
-        MultipleAssetModel
-      }
-      let(:instance) { model.new(another_place: []) }
-      let(:file) {
-        Rack::Test::UploadedFile.new("README.md")
-      }
-      let(:file2) {
-        Rack::Test::UploadedFile.new("LICENSE.txt")
-      }
-
-      it 'attaches uploaded files' do
-        instance.multiple_field = [file, file2]
-
-        expect(instance.multiple_field[0].name).to eq('multiple_field')
-        expect(instance.multiple_field[0].filename).to eq('README.md')
-        expect(instance.multiple_field[0].content_type).to eq('text/plain')
-        expect(instance.multiple_field[0].service_url)
-          .to start_with('https://www.example.com/rails/active_storage/disk/')
-        expect(instance.multiple_field[1].name).to eq('multiple_field')
-        expect(instance.multiple_field[1].filename).to eq('LICENSE.txt')
-        expect(instance.multiple_field[1].content_type).to eq('text/plain')
-        expect(instance.multiple_field[1].service_url)
-          .to start_with('https://www.example.com/rails/active_storage/disk/')
-      end
-
-      it 'sets the ID to be the ActiveStorage key' do
-        instance.multiple_field = [file, file2]
-
-        expect(instance.another_place).to eq(instance.multiple_field_attachments.map(&:key))
-      end
-
-      it 'sets the ID in the attributes' do
-        instance.multiple_field = [file, file2]
-        
-        expect(instance.attributes['another_place']).to eq(instance.multiple_field_attachments.map(&:key))
-      end
-
-      it 'attaches signed ID from Tessa::AssetChangeSet' do
-        blob = ::ActiveStorage::Blob.create_before_direct_upload!({
-          filename: 'README.md',
-          byte_size: file.size,
-          content_type: file.content_type,
-          checksum: '1234'
-        })
-        blob2 = ::ActiveStorage::Blob.create_before_direct_upload!({
-          filename: "LICENSE.txt",
-          byte_size: file2.size,
-          content_type: file2.content_type,
-          checksum: '5678'
-        })
-
-        changeset = Tessa::AssetChangeSet.new(
-          changes: [
-            { 'id' => blob.signed_id, 'action' => 'add' },
-            { 'id' => blob2.signed_id, 'action' => 'add' },
-          ]
-        )
-        instance.multiple_field = changeset
-
-        expect(instance.another_place).to eq([
-          blob.key,
-          blob2.key
-        ])
-      end
-
-      it 'does nothing when "add"ing an existing blob' do
-        # Before this HTTP POST, we've previously uploaded these files
-        instance.multiple_field = [file, file2]
-        keys = instance.multiple_field_attachments.map(&:key)
-
-        # In this HTTP POST, we re-upload the 'add' action with the same ID
-        changeset = Tessa::AssetChangeSet.new(
-          changes: [
-            { 'id' => keys[0], 'action' => 'add' },
-            { 'id' => keys[1], 'action' => 'add' },
-          ]
-        )
-
-        # We expect that we're not going to detatch the existing attachment
-        instance.multiple_field_attachments.each do |a|
-          expect(a).to_not receive(:destroy)
-        end
-
-        # act
-        instance.multiple_field = changeset
-
-        expect(instance.another_place).to eq(keys)
-      end
-
-      it 'replaces Tessa assets with ActiveStorage assets' do
-        # Before deploying this code, we previously had DB records with Tessa IDs
-        instance.update!(another_place: [1, 2, 3])
-
-        # In this HTTP POST, we removed one of the tessa assets and uploaded a
-        # new ActiveStorage asset
-        blob = ::ActiveStorage::Blob.create_before_direct_upload!({
-          filename: 'README.md',
-          byte_size: file.size,
-          content_type: file.content_type,
-          checksum: '1234'
-        })
-        changeset = Tessa::AssetChangeSet.new(
-          changes: [
-            { 'id' => 1, 'action' => 'add' },
-            { 'id' => 2, 'action' => 'remove' },
-            { 'id' => 3, 'action' => 'add' },
-            { 'id' => blob.signed_id, 'action' => 'add' },
-          ]
-        )
-
-        # We'll download these assets when we access #multiple_field
-        allow(Tessa.config.connection).to receive(:get)
-          .with("/assets/1,3")
-          .and_return(double("response",
-            success?: true,
-            body: [
-              { 'id' => 1, 'public_url' => 'test1' },
-              { 'id' => 2, 'public_url' => 'test2' }
-            ].to_json))
-
-        blob.upload(file)
-
-        # act
-        instance.multiple_field = changeset
-
-        expect(instance.another_place).to eq([
-          blob.key, 1, 3
-        ])
-
-        assets = instance.multiple_field
-        expect(assets[0].key).to eq(blob.key)
-        expect(assets[0].service_url)
-          .to start_with('https://www.example.com/rails/active_storage/disk/')
-
-        expect(assets[1].id).to eq(1)
-        expect(assets[1].public_url).to eq('test1')
-        expect(assets[2].id).to eq(2)
-        expect(assets[2].public_url).to eq('test2')
-      end
-    end
-  end
-
-  describe "#apply_tessa_change_sets" do
-    let(:instance) { model.new }
-    let(:sets) { [ instance_spy(Tessa::AssetChangeSet) ] }
-
-    before do
-      instance.instance_variable_set(
-        :@pending_tessa_change_sets,
-        {
-          avatar: sets[0],
-        }
-      )
-    end
-
-    it "iterates over all pending changesets calling apply" do
-      instance.apply_tessa_change_sets
-      expect(sets[0]).to have_received(:apply)
-    end
-
-    it "removes all changesets from list" do
-      instance.apply_tessa_change_sets
-      expect(instance.pending_tessa_change_sets).to be_empty
-    end
-
-    context "no @pending_tessa_change_sets ivar" do
-      before do
-        instance.instance_variable_set(
-          :@pending_tessa_change_sets,
-          nil
-        )
-      end
-
-      it "doesn't raise error" do
-        expect { instance.apply_tessa_change_sets }.to_not raise_error
-      end
-    end
-  end
-
-  describe "#fetch_tessa_remote_assets" do
-    subject(:result) { model.new.fetch_tessa_remote_assets(arg) }
-
-    context "argument is `nil`" do
-      let(:arg) { nil }
-
-      it "returns nil" do
-        expect(result).to be_nil
-      end
-    end
-
-    context "argument is `[]`" do
-      let(:arg) { [] }
-
-      it "returns []" do
-        expect(result).to be_a(Array)
-        expect(result).to be_empty
-      end
-    end
-
-    context "when argument is not blank" do
-      let(:id) { rand(100) }
-      let(:arg) { id }
-
-      it "calls Tessa::Asset.find with arguments" do
-        expect(Tessa::Asset).to receive(:find).with(arg)
-        result
-      end
-
-      context "when Tessa::Asset.find raises RequestFailed exception" do
-        let(:error) {
-          Tessa::RequestFailed.new("test exception", double(status: '500'))
-        }
-
-        before do
-          allow(Tessa::Asset).to receive(:find).and_raise(error)
-        end
-
-        context "argument is single id" do
-          let(:arg) { id }
-
-          it "returns Failure" do
-            expect(result).to be_a(Tessa::Asset::Failure)
-          end
-
-          it "returns asset with proper data" do
-            expect(result.id).to eq(arg)
-          end
-        end
-
-        context "argument is array" do
-          let(:arg) { [ id, id * 2 ] }
-
-          it "returns array" do
-            expect(result).to be_a(Array)
-          end
-
-          it "returns instances of Failure" do
-            expect(result).to all( be_a(Tessa::Asset::Failure) )
-          end
-
-          it "returns array with an asset for each id passed" do
-            arg.zip(result) do |a, r|
-              expect(r.id).to eq(a)
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe "#remove_all_tessa_assets" do
-    let(:instance) { model.new }
-
-    context "with a single typed field" do
-      let(:model) {
-        SingleAssetModel
-      }
-
-      before do
-        instance.avatar_id = 1
-      end
-
-      it "adds pending change sets for each field removing all current assets" do
-        instance.remove_all_tessa_assets
-        changes = instance.pending_tessa_change_sets.values
-          .reduce(Tessa::AssetChangeSet.new, :+)
-          .changes
-          .map { |change| [change.id, change.action.to_sym] }
-          expect(changes).to eq([
-            [1, :remove]
-          ])
-      end
-    end
-
-
-    context "with a multiple typed field" do
-      let(:model) {
-        MultipleAssetModel
-      }
-      let(:instance) { model.new(another_place: []) }
-      
-      before do
-        instance.another_place = [2, 3]
-      end
-
-      it "adds pending change sets for each field removing all current assets" do
-        instance.remove_all_tessa_assets
-        changes = instance.pending_tessa_change_sets.values
-          .reduce(Tessa::AssetChangeSet.new, :+)
-          .changes
-          .map { |change| [change.id, change.action.to_sym] }
-          expect(changes).to eq([
-            [2, :remove],
-            [3, :remove],
-          ])
-      end
-    end
-  end
-
-  describe "adds callbacks" do
-    context "model responds to after_commit" do
-      let(:model) {
-        Class.new do
-          def self.after_commit(arg=nil)
-            @after_commit ||= arg
-          end
-        end.tap { |c| c.send(:include, described_module) }
-      }
-
-      it "calls it with :apply_tessa_change_sets" do
-        expect(model.after_commit).to eq(:apply_tessa_change_sets)
-      end
-    end
-
-    context "model responds to before_destroy" do
-      let(:model) {
-        Class.new do
-          def self.before_destroy(arg=nil)
-            @before_destroy ||= arg
-          end
-        end.tap { |c| c.send(:include, described_module) }
-      }
-
-      it "calls it with :remove_all_tessa_assets" do
-        expect(model.before_destroy).to eq(:remove_all_tessa_assets)
-      end
-    end
-  end
-
-end

data/spec/tessa/rack_upload_proxy_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::RackUploadProxy do
-  Result = Struct.new(:status, :headers, :body) do
-    def json
-      JSON.parse body.first
-    end
-  end
-
-  subject(:result) { Result.new *described_class.call(env) }
-  let(:env) {
-    {
-      "rack.request.form_hash" => params,
-      "rack.session" => session,
-    }
-  }
-  let(:params) { {} }
-  let(:session) { {} }
-
-  let(:blob) { ActiveStorage::Blob.last }
-
-  before do
-    allow(ActiveStorage.verifier).to receive(:generate)
-      .and_return('some-consistent-token')
-  end
-
-  shared_examples_for "proper json return" do
-    it "returns asset_id" do
-      expect(result.json['asset_id']).to eq(blob.signed_id)
-    end
-
-    it "returns upload_url" do
-      expect(result.json['upload_url']).to eq('https://www.example.com/rails/active_storage/disk/some-consistent-token')
-    end
-
-    it "returns upload_method" do
-      expect(result.json['upload_method']).to eq('PUT')
-    end
-
-    it "returns upload_method" do
-      expect(result.json['upload_headers']).to eq(blob.service_headers_for_direct_upload)
-    end
-
-    it "returns a 200 response" do
-      expect(result.status).to eq(200)
-    end
-
-    it "sets the mime type to application/json" do
-      expect(result.headers).to include("Content-Type" => "application/json")
-    end
-  end
-
-  context "with no params and no session" do
-    it "raises a bad request error" do
-      expect(result.status).to eq(400)
-    end
-  end
-
-  context "with params" do
-    let(:params) {
-      {
-        "name" => "my-name",
-        "size" => 456,
-        "mime_type" => "plain/text",
-        "checksum" => '1234'
-      }
-    }
-
-    it "creates the ActiveStorage blob" do
-      expect {
-        described_class.call(env)
-      }.to change { ActiveStorage::Blob.count }.by(1)
-
-      expect(blob.filename).to eq('my-name')
-      expect(blob.byte_size).to eq(456)
-      expect(blob.content_type).to eq('plain/text')
-      expect(blob.checksum).to eq('1234')
-    end
-
-    it_behaves_like "proper json return"
-  end
-
-end