tessa 2.0 → 6.0.0.rc2

data/spec/tessa/model_spec.rb

@@ -1,325 +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 "No longer calls Tessa::Asset#find" do
-        instance.another_place = [1, 2, 3]
-        expect(Tessa::Asset).to_not receive(:find)
-        expect(getter).to eq([])
-      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 "No longer calls Tessa::Asset#find" do
-        instance.avatar_id = 1
-        expect(Tessa::Asset).to_not receive(:find)
-        expect(getter).to eq(nil)
-      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
-    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

data/spec/tessa/upload/uploads_file_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::Upload::UploadsFile do
-  describe "#initialize" do
-    it "requires an upload and sets it to attribute" do
-      expect { described_class.new }.to raise_error(ArgumentError)
-      obj = described_class.new(upload: :upload)
-      expect(obj.upload).to eq(:upload)
-    end
-
-    it "optionally takes a connection" do
-      obj = described_class.new(upload: :upload, connection: :conn)
-      expect(obj.connection).to eq(:conn)
-    end
-
-    it "defaults connection to empty Faraday connection" do
-      expect(described_class).to receive(:connection_factory).and_return(:foo)
-      obj = described_class.new(upload: :upload)
-      expect(obj.connection).to eq(:foo)
-    end
-  end
-
-  describe "#call" do
-    let(:upload) {
-      instance_double(
-        Tessa::Upload,
-        upload_url: "http://upload/path?arg=1",
-        upload_method: "post"
-      )
-    }
-    let(:connection) {
-      Faraday.new { |f| f.adapter :test, stubs }
-    }
-    subject(:task) { described_class.new(upload: upload, connection: connection) }
-
-    context "uploads file successfully" do
-      let(:stubs) {
-        Faraday::Adapter::Test::Stubs.new do |stub|
-          stub.post("http://upload/path?arg=1") { |env|
-            [200, {}, '']
-          }
-        end
-      }
-
-      it "calls the upload_url with upload_method HTTP method" do
-        file = Tempfile.new("test")
-        file.write "hello there"
-        file.close
-        expect(connection).to receive(:post).with("http://upload/path?arg=1", "hello there").and_call_original
-        expect(task.call(file.path)).to be_truthy
-      end
-    end
-
-    context "uploads file successfully" do
-      let(:stubs) {
-        Faraday::Adapter::Test::Stubs.new do |stub|
-          stub.post("http://upload/path?arg=1") { |env|
-            [500, {}, '']
-          }
-        end
-      }
-
-      it "calls the upload_url with upload_method HTTP method" do
-        file = Tempfile.new("test")
-        file.write "hello there"
-        file.close
-        expect(connection).to receive(:post).with("http://upload/path?arg=1", "hello there").and_call_original
-        expect(task.call(file.path)).to be_falsey
-      end
-    end
-  end
-end

data/spec/tessa/upload_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::Upload do
-  subject(:upload) { described_class.new(args) }
-  let(:args) {
-    {
-      upload_url: "/upload",
-      upload_method: "put",
-      asset_id: 123,
-    }
-  }
-
-  describe "#initialize" do
-    context "with all arguments" do
-      it "sets upload_url to attribute" do
-        expect(upload.upload_url).to eq(args[:upload_url])
-      end
-
-      it "sets upload_method to attribute" do
-        expect(upload.upload_method).to eq(args[:upload_method])
-      end
-
-      it "sets asset_id to attribute" do
-        expect(upload.asset_id).to eq(args[:asset_id])
-      end
-    end
-  end
-
-  describe "#upload_file" do
-    subject(:upload) { described_class.new }
-    let(:task) { instance_double(described_class::UploadsFile) }
-
-    before :each do
-      allow(described_class::UploadsFile).to receive(:new).and_return(task)
-      allow(task).to receive(:call)
-      allow(Tessa::Asset).to receive(:new).and_return(instance_spy(Tessa::Asset))
-    end
-
-    it "initializes UploadsFile with self and passes argument to call" do
-      expect(task).to receive(:call).with(:file)
-      expect(described_class::UploadsFile).to receive(:new).with(upload: upload).and_return(task)
-      upload.upload_file(:file)
-    end
-
-    context "with a successful upload" do
-      before :each do
-        allow(task).to receive(:call).and_return(true)
-      end
-
-      it "updates the asset to complete state and returns asset" do
-        upload.asset_id = 123
-        asset = Tessa::Asset.new(id: 123)
-        expect(Tessa::Asset).to receive(:new).with(id: 123).and_return(asset)
-        expect(asset).to receive(:complete!).and_return(:asset)
-        expect(upload.upload_file(:file)).to eq(:asset)
-      end
-    end
-
-    context "with a failed upload" do
-      before :each do
-        allow(task).to receive(:call).and_return(false)
-      end
-
-      it "updates the asset to canceled state and returns false" do
-        upload.asset_id = 123
-        asset = Tessa::Asset.new(id: 123)
-        expect(Tessa::Asset).to receive(:new).with(id: 123).and_return(asset)
-        expect(asset).to receive(:cancel!).and_return(:asset)
-        expect(upload.upload_file(:file)).to eq(false)
-      end
-    end
-  end
-
-  describe ".create" do
-    subject(:call) { described_class.create(call_args) }
-
-    include_examples "remote call macro", :post, "/uploads", Tessa::Upload
-
-    context "with a full response" do
-      let(:remote_response) { args }
-
-      it "returns a new object initialized with the response" do
-        upload = described_class.create(connection: connection)
-        expect(upload.asset_id).to eq(args[:asset_id])
-        expect(upload.upload_url).to eq(args[:upload_url])
-        expect(upload.upload_method).to eq(args[:upload_method])
-      end
-    end
-
-    describe ":strategy param" do
-      it "defaults to config.strategy" do
-        expect(Tessa.config).to receive(:strategy).and_return(:my_default)
-        expect_post_with_hash_including(strategy: :my_default)
-        described_class.create(connection: connection)
-      end
-
-      it "overrides with :strategy argument" do
-        expect_post_with_hash_including(strategy: :my_default)
-        described_class.create(connection: connection, strategy: :my_default)
-      end
-    end
-
-    it "sets :name param from argument" do
-      expect_post_with_hash_including(name: "my-file.txt")
-      described_class.create(connection: connection, name: "my-file.txt")
-    end
-
-    it "sets :size param from argument" do
-      expect_post_with_hash_including(size: 12345)
-      described_class.create(connection: connection, size: 12345)
-    end
-
-    it "sets :mime_type param from argument" do
-      expect_post_with_hash_including(mime_type: "text/plain")
-      described_class.create(connection: connection, mime_type: "text/plain")
-    end
-
-    def expect_post_with_hash_including(expected)
-      expect(connection).to receive(:post)
-        .with("/uploads", hash_including(expected))
-        .and_call_original
-    end
-  end
-
-end

data/spec/tessa_spec.rb

@@ -1,23 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Tessa do
-
-  describe '#find_assets' do
-    it 'returns AssetFailure for singular asset' do
-      result = Tessa.find_assets(1)
-
-      expect(result).to be_a(Tessa::Asset::Failure)
-      expect(result.message).to eq("The service is unavailable at this time.")
-    end
-
-    it 'returns AssetFailure array for multiple assets' do
-      result = Tessa.find_assets([1, 2, 3])
-
-      expect(result.count).to eq(3)
-      result.each do |r|
-        expect(r).to be_a(Tessa::Asset::Failure)
-        expect(r.message).to eq("The service is unavailable at this time.")
-      end
-    end
-  end
-end