tessa 2.0 → 6.0.0.rc2

data/spec/tessa/asset_spec.rb

@@ -1,196 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::Asset do
-  subject(:asset) { described_class.new(args) }
-  let(:args) {
-    {
-      id: 123,
-      status: 'completed',
-      strategy: 'default',
-      meta: { name: "foo" },
-      public_url: "http://example.com/public",
-      private_url: "http://example.com/private",
-      private_download_url: "http://example.com/private?download",
-      delete_url: "http://example.com/delete",
-    }
-  }
-
-  describe "#initialize" do
-    context "with all arguments" do
-      it "sets id to attribute" do
-        expect(asset.id).to eq(args[:id])
-      end
-
-      it "sets status to attribute" do
-        expect(asset.status).to eq(args[:status])
-      end
-
-      it "sets strategy to attribute" do
-        expect(asset.strategy).to eq(args[:strategy])
-      end
-
-      it "sets meta to attribute" do
-        expect(asset.meta).to eq(args[:meta])
-      end
-
-      it "sets public_url to attribute" do
-        expect(asset.public_url).to eq(args[:public_url])
-      end
-
-      it "sets private_url to attribute" do
-        expect(asset.private_url).to eq(args[:private_url])
-      end
-
-      it "sets private_download_url to attribute" do
-        expect(asset.private_download_url).to eq(args[:private_download_url])
-      end
-
-      it "sets delete_url to attribute" do
-        expect(asset.delete_url).to eq(args[:delete_url])
-      end
-
-    end
-  end
-
-  describe "#complete!" do
-    subject(:call) { asset.complete!(call_args) }
-
-    include_examples "remote call macro", :patch, "/assets/123/completed", Tessa::Asset
-  end
-
-  describe "#cancel!" do
-    subject(:call) { asset.cancel!(call_args) }
-
-    include_examples "remote call macro", :patch, "/assets/123/cancelled", Tessa::Asset
-  end
-
-  describe "#delete!" do
-    subject(:call) { asset.delete!(call_args) }
-
-    include_examples "remote call macro", :delete, "/assets/123", Tessa::Asset
-  end
-
-  describe "#failure?" do
-    it "returns false" do
-      expect(asset.failure?).to be(false)
-    end
-  end
-
-  describe ".find" do
-    let(:faraday_stubs) {
-      Faraday::Adapter::Test::Stubs.new do |stub|
-        stub.get("/assets/#{id_query}") { |env| [200, {}, remote_response.to_json] }
-      end
-    }
-    let(:connection) { Faraday.new { |f| f.adapter :test, faraday_stubs } }
-
-    context "with a single id" do
-      let(:id_query) { "ID" }
-      let(:remote_response) { {} }
-
-      it "calls get('/assets/ID') on connection" do
-        expect(connection).to receive(:get).with("/assets/ID").and_call_original
-        described_class.find("ID", connection: connection)
-      end
-
-      it "returns an instance of Asset" do
-        response = described_class.find("ID", connection: connection)
-        expect(response).to be_a(described_class)
-      end
-
-      it "defaults connection to Tessa.config.connection" do
-        expect(Tessa.config).to receive(:connection).and_return(connection)
-        expect(connection).to receive(:get).and_call_original
-        described_class.find("ID")
-      end
-
-      context "with attributes in response" do
-        subject(:response) { described_class.find("ID", connection: connection) }
-        let(:remote_response) { args }
-
-        it "sets attributes on models" do
-          expect(response.id).to eq(args[:id])
-          expect(response.status).to eq(args[:status])
-          expect(response.meta).to eq(args[:meta])
-        end
-      end
-    end
-
-    context "with multiple ids" do
-      subject(:response) {
-        described_class.find("ID1", "ID2", connection: connection)
-      }
-      let(:remote_response) { [{}] }
-      let(:id_query) { "ID1,ID2" }
-
-      it "calls get('/assets/ID1,ID2') on connection" do
-        expect(connection).to receive(:get).with("/assets/ID1,ID2").and_call_original
-        response
-      end
-
-      it "returns instances of Asset" do
-        expect(response).to all(be_a(described_class))
-      end
-
-      context "with attributes in response" do
-        let(:remote_response) { [args, args] }
-
-        it "sets attributes on models" do
-          expect(response[0].id).to eq(args[:id])
-          expect(response[1].id).to eq(args[:id])
-        end
-      end
-    end
-  end
-
-  describe ".create" do
-    let(:upload) { instance_double(Tessa::Upload) }
-
-    before :each do
-      allow(Tessa::Upload).to receive(:create).and_return(upload)
-      allow(upload).to receive(:upload_file)
-    end
-
-    it "requires a file param" do
-      expect { described_class.create }.to raise_error(ArgumentError)
-      expect { described_class.create(file: __FILE__) }.to_not raise_error
-    end
-
-    it "creates a new upload" do
-      expect(Tessa::Upload)
-        .to receive(:create).with(hash_including(foo: :bar, baz: :boom)).and_return(upload)
-      described_class.create(file: __FILE__, foo: :bar, baz: :boom)
-    end
-
-    it "uploads the passed file to the upload's URL" do
-      expect(Tessa::Upload).to receive(:create).and_return(upload)
-      expect(upload).to receive(:upload_file).with(__FILE__)
-      described_class.create(file: __FILE__)
-    end
-
-    it "infers the file size, name, and date" do
-      file = Tempfile.new("test")
-      file.write "abc"
-      file.close
-      expected_values = {
-        size: 3,
-        name: File.basename(file.path),
-        date: File.mtime(file.path),
-      }
-      expect(Tessa::Upload)
-        .to receive(:create).with(hash_including(expected_values)).and_return(upload)
-      described_class.create(file: file.path)
-    end
-
-    it "allows overriding inferred values" do
-      expected_values = {
-        size: 1,
-        name: "my-file",
-        date: "123",
-      }
-      expect(Tessa::Upload)
-        .to receive(:create).with(hash_including(expected_values)).and_return(upload)
-      described_class.create(file: __FILE__, **expected_values)
-    end
-  end
-end

data/spec/tessa/config_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::Config do
-  let(:cfg) { Tessa::Config.new }
-
-  shared_examples_for "defaults to environment variable" do
-    around { |ex| swap_environment_var(variable_name, 'from-env') { ex.run } }
-
-    it { is_expected.to eq("from-env") }
-
-    def swap_environment_var(var, new_val)
-      old_val = ENV[var]
-      ENV[var] = new_val
-      yield
-      ENV[var] = old_val
-    end
-  end
-
-  describe "#username" do
-    it_behaves_like "defaults to environment variable" do
-      let(:variable_name) { 'TESSA_USERNAME' }
-      subject { cfg.username }
-    end
-
-    it "behaves like a normal accessor" do
-      cfg.username = "my-new-value"
-      expect(cfg.username).to eq("my-new-value")
-    end
-  end
-
-  describe "#password" do
-    it_behaves_like "defaults to environment variable" do
-      let(:variable_name) { 'TESSA_PASSWORD' }
-      subject { cfg.password }
-    end
-
-    it "behaves like a normal accessor" do
-      cfg.password = "my-new-value"
-      expect(cfg.password).to eq("my-new-value")
-    end
-  end
-
-  describe "#url" do
-    it_behaves_like "defaults to environment variable" do
-      let(:variable_name) { 'TESSA_URL' }
-      subject { cfg.url }
-    end
-
-    it "behaves like a normal accessor" do
-      cfg.url = "my-new-value"
-      expect(cfg.url).to eq("my-new-value")
-    end
-  end
-
-  describe "#strategy" do
-    it_behaves_like "defaults to environment variable" do
-      let(:variable_name) { 'TESSA_STRATEGY' }
-      subject { cfg.strategy }
-    end
-
-    it "uses the string 'default' when no envvar passed" do
-      expect(cfg.strategy).to eq("default")
-    end
-
-    it "behaves like a normal accessor" do
-      cfg.strategy = "my-new-value"
-      expect(cfg.strategy).to eq("my-new-value")
-    end
-  end
-end

data/spec/tessa/controller_helpers_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::ControllerHelpers do
-  let(:controller) {
-    Class.new do
-      attr_writer :session
-
-      def session
-        @session ||= {}
-      end
-
-    end.tap { |c| c.send :include, described_class }
-  }
-  subject(:instance) { controller.new }
-
-  describe "#tessa_upload_asset_ids" do
-    it "returns the value of session[:tessa_upload_asset_ids]" do
-      instance.session = { tessa_upload_asset_ids: :value }
-      expect(instance.tessa_upload_asset_ids).to eq(:value)
-    end
-
-    it "sets and returns session[:tessa_upload_asset_ids] to an empty array if nil" do
-      array = instance.tessa_upload_asset_ids
-      expect(array).to eq([])
-      array << 123
-      expect(instance.tessa_upload_asset_ids).to eq(array)
-    end
-  end
-
-  describe "#params_for_asset" do
-    it "returns a Tessa::AssetChangeSet" do
-      expect(instance.params_for_asset({})).to be_a(Tessa::AssetChangeSet)
-    end
-
-    it "sets the value of changes to the argument passed" do
-      changes = [Tessa::AssetChange.new(id: 1)]
-      expect(instance.params_for_asset(changes).changes).to eq(changes)
-    end
-
-    it "sets the scoped_ids to the value of tessa_upload_asset_ids" do
-      scoped_ids = [1, 2, 3]
-      instance.session[:tessa_upload_asset_ids] = scoped_ids
-      expect(instance.params_for_asset([]).scoped_ids).to eq(scoped_ids)
-    end
-
-    it "ensures a unique array" do
-      scoped_ids = [1]
-      instance.session[:tessa_upload_asset_ids] = scoped_ids
-      set = instance.params_for_asset([])
-      set.scoped_ids << 2
-      expect(scoped_ids).to eq([1])
-    end
-  end
-
-end

data/spec/tessa/jobs/migrate_assets_job_spec.rb

@@ -1,247 +0,0 @@
-require 'rails_helper'
-
-require 'tessa/jobs/migrate_assets_job'
-
-RSpec.describe Tessa::MigrateAssetsJob do
-  it 'does nothing if no db rows' do
-    
-    expect {
-      subject.perform
-    }.to_not change { ActiveStorage::Attachment.count }
-  end
-
-  it 'creates attachments for old tessa assets' do
-    allow(Tessa::Asset).to receive(:find)
-      .with(1)
-      .and_return(
-        Tessa::Asset.new(id: 1,
-          meta: { name: 'README.md' },
-          private_download_url: 'https://test.com/README.md')
-      )
-    
-    allow(Tessa::Asset).to receive(:find)
-      .with(2)
-      .and_return(
-        Tessa::Asset.new(id: 2,
-          meta: { name: 'LICENSE.txt' },
-          private_download_url: 'https://test.com/LICENSE.txt'),
-      )
-
-    stub_request(:get, 'https://test.com/README.md')
-      .to_return(body: File.new('README.md'))
-    stub_request(:get, 'https://test.com/LICENSE.txt')
-      .to_return(body: File.new('LICENSE.txt'))
-
-      # DB models with those
-    models = [
-      SingleAssetModel.create!(avatar_id: 1),
-      SingleAssetModel.create!(avatar_id: 2)
-    ]
-
-    expect {
-      subject.perform
-    }.to change { ActiveStorage::Attachment.count }.by(2)
-
-    models.each do |m|
-      expect(m.reload.avatar_id).to eq(m.avatar.key)
-      # Now it's in activestorage
-      expect(m.avatar.public_url).to start_with(
-        'https://www.example.com/rails/active_storage/blobs/')
-    end
-
-    expect(SingleAssetModel.where.not('avatar_id' => nil).count)
-      .to eq(0)
-  end
-
-  it 'preserves ActiveStorage blobs' do
-    allow(Tessa::Asset).to receive(:find)
-      .with([1, 2])
-      .and_return([
-        Tessa::Asset.new(id: 1,
-          meta: { name: 'README.md' },
-          private_download_url: 'https://test.com/README.md'),
-        Tessa::Asset.new(id: 2,
-          meta: { name: 'LICENSE.txt' },
-          private_download_url: 'https://test.com/LICENSE.txt'),
-      ])
-    stub_request(:get, 'https://test.com/README.md')
-      .to_return(body: File.new('README.md'))
-    stub_request(:get, 'https://test.com/LICENSE.txt')
-      .to_return(body: File.new('LICENSE.txt'))
-
-    file2 = Rack::Test::UploadedFile.new("LICENSE.txt")
-
-    model = MultipleAssetModel.create!(
-      # The Tessa DB column has the one asset
-      another_place: [1, 2]
-    )
-    # But has already attached a second ActiveStorage blob
-    ::ActiveStorage::Attached::Many.new("multiple_field", model, dependent: :purge_later)
-      .attach(file2)
-    model.save!
-    attachment = model.multiple_field_attachments.first
-
-    expect {
-      subject.perform
-    }.to change { ActiveStorage::Attachment.count }.by(2)
-
-    model = model.reload
-    # The IDs are now the keys of ActiveStorage objects
-    expect(model.another_place).to eq(
-      model.multiple_field.map(&:key))
-    # preserves the existing attachment
-    expect(model.multiple_field_attachments).to include(attachment)
-    expect(model.another_place).to include(attachment.key)
-
-    # all assets are in activestorage
-    model.multiple_field.each do |blob|
-      expect(blob.public_url).to start_with(
-        'https://www.example.com/rails/active_storage/blobs/')
-    end
-
-    # DB column is reset to nil
-    expect(MultipleAssetModel.where.not('another_place' => nil).count)
-      .to eq(0)
-  end
-
-  it 'Stops after hitting the batch size' do
-    1.upto(11).each do |i|
-      asset = Tessa::Asset.new(id: i,
-        meta: { name: 'README.md' },
-        private_download_url: 'https://test.com/README.md')
-      allow(Tessa::Asset).to receive(:find)
-        .with(i)
-        .and_return(asset)
-      allow(Tessa::Asset).to receive(:find)
-        .with([i])
-        .and_return([asset])
-    end
-    stub_request(:get, 'https://test.com/README.md')
-      .to_return(body: File.new('README.md'))
-
-    # Mix of the two models...
-    models =
-      1.upto(11).map do |i|
-        if i % 2 == 0
-          MultipleAssetModel.create!(another_place: [i])
-        else
-          SingleAssetModel.create!(avatar_id: i)
-        end
-      end
-
-    final_state = nil
-    final_options = nil
-    dbl = double('set')
-    expect(dbl).to receive(:perform_later) do |state, options|
-      final_state = Marshal.load(state)
-      final_options = options
-    end
-    expect(Tessa::MigrateAssetsJob).to receive(:set)
-      .with(wait: 10.minutes)
-      .and_return(dbl) 
-    
-    expect {
-      subject.perform
-    }.to change { ActiveStorage::Attachment.count }.by(10)
-
-    expect(final_state.fully_processed?).to be false
-    expect(final_options).to eq({
-      batch_size: 10,
-      interval: 10.minutes.to_i
-    })
-    # One of the two models was fully processed
-    expect(final_state.model_queue.count(&:fully_processed?))
-      .to eq(1)
-  end
-
-  it 'Skips over Tessa errors' do
-    1.upto(11).each do |i|
-      if i % 2 == 0
-        allow(Tessa::Asset).to receive(:find)
-          .with(i)
-          .and_raise(Tessa::RequestFailed)
-        next
-      end
-
-      allow(Tessa::Asset).to receive(:find)
-        .with(i)
-        .and_return(
-          Tessa::Asset.new(id: i,
-            meta: { name: 'README.md' },
-            private_download_url: 'https://test.com/README.md')
-        )
-    end
-    stub_request(:get, 'https://test.com/README.md')
-      .to_return(body: File.new('README.md'))
-
-    # Mix of the two models...
-    models =
-      1.upto(11).map do |i|
-        SingleAssetModel.create!(avatar_id: i)
-      end
-
-    final_state = nil
-    final_options = nil
-    dbl = double('set')
-    expect(dbl).to receive(:perform_later) do |state, options|
-      final_state = Marshal.load(state)
-      final_options = options
-    end
-    expect(Tessa::MigrateAssetsJob).to receive(:set)
-      .with(wait: 10.minutes)
-      .and_return(dbl) 
-    
-    expect {
-      subject.perform
-    }.to change { ActiveStorage::Attachment.count }.by(5)
-
-    expect(final_state.fully_processed?).to be false
-    field_state = final_state.next_model.next_field
-    expect(field_state.offset).to eq(5)
-  end
-
-  it 'Resumes from marshalled state' do
-
-    file = Rack::Test::UploadedFile.new('README.md')
-
-    state = Tessa::MigrateAssetsJob::ProcessingState.initialize_from_models(
-      [SingleAssetModel])
-    field_state = state.model_queue
-      .detect { |m| m.class_name == 'SingleAssetModel' }
-      .field_queue
-      .detect { |m| m.field_name == :avatar }
-    
-    1.upto(10).each do |i|
-      if i % 2 == 0
-        # This one failed
-        SingleAssetModel.create!(avatar_id: i).tap do |r|
-          field_state.offset += 1
-        end
-      else
-        # This one succeeded and is in ActiveStorage
-        SingleAssetModel.create!(avatar: file).tap do |r|
-          field_state.success_count += 1
-        end
-      end
-    end
-    
-    # This one still needs to transition
-    model = SingleAssetModel.create!(avatar_id: 11)
-
-    asset = Tessa::Asset.new(id: 11,
-      meta: { name: 'README.md' },
-      private_download_url: 'https://test.com/README.md')
-    allow(Tessa::Asset).to receive(:find)
-      .with(11)
-      .and_return(asset)
-    stub_request(:get, 'https://test.com/README.md')
-      .to_return(body: File.new('README.md'))
-
-    # Doesn't reenqueue since we finished processing
-    expect(Tessa::MigrateAssetsJob).to_not receive(:set)
-
-    expect {
-      subject.perform(Marshal.dump(state), { batch_size: 2, interval: 3 })
-    }.to change { ActiveStorage::Attachment.count }.by(1)
-  end
-end

data/spec/tessa/model_field_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tessa::Model::Field do
-  subject(:field) { described_class.new(attrs) }
-  let(:attrs) { {} }
-
-  describe "#initialize" do
-    context "with all fields set" do
-      let(:attrs) {
-        {
-          model: :model,
-          name: "name",
-          multiple: true,
-          id_field: "my_field",
-        }
-      }
-
-      it "sets :model to attribute" do
-        expect(field.model).to eq(:model)
-      end
-
-      it "sets :name to attribute" do
-        expect(field.name).to eq("name")
-      end
-
-      it "sets :multiple to attribute" do
-        expect(field.multiple).to eq(true)
-      end
-
-      it "sets :id_field to attribute" do
-        expect(field.id_field).to eq("my_field")
-      end
-    end
-
-    context "with no fields set" do
-      it "defaults model to nil" do
-        expect(field.model).to be_nil
-      end
-
-      it "defaults name to nil" do
-        expect(field.name).to be_nil
-      end
-
-      it "defaults multiple to false" do
-        expect(field.multiple).to eq(false)
-      end
-
-      context "when multiple true" do
-        before do
-          attrs[:name] = "my_name"
-          attrs[:multiple] = false
-        end
-
-        it "defaults id_field to name + '_id'" do
-          expect(field.id_field).to eq("my_name_id")
-        end
-      end
-
-      context "when multiple false" do
-        before do
-          attrs[:name] = "my_name"
-          attrs[:multiple] = true
-        end
-
-        it "defaults id_field to name + '_ids'" do
-          expect(field.id_field).to eq("my_name_ids")
-        end
-      end
-    end
-  end
-
-end