active_encode 0.1.1 → 0.2

data/spec/integration/shingoncoder_adapter_spec.rb

@@ -7,7 +7,7 @@ describe ActiveEncode::EngineAdapters::ShingoncoderAdapter do
     ActiveEncode::Base.engine_adapter = :shingoncoder
   end
   after(:all) do
-    ActiveEncode::Base.engine_adapter = :inline
+    ActiveEncode::Base.engine_adapter = :test
   end
 
   let(:create_response) { Shingoncoder::Response.new(body: JSON.parse(File.read('spec/fixtures/zencoder/job_create.json'))) }

data/spec/integration/zencoder_adapter_spec.rb

@@ -7,7 +7,7 @@ describe ActiveEncode::EngineAdapters::ZencoderAdapter do
     ActiveEncode::Base.engine_adapter = :zencoder
   end
   after(:all) do
-    ActiveEncode::Base.engine_adapter = :inline
+    ActiveEncode::Base.engine_adapter = :test
   end
 
   let(:create_response) { Zencoder::Response.new(body: JSON.parse(File.read('spec/fixtures/zencoder/job_create.json'))) }

data/spec/rails_helper.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+require 'engine_cart'
+EngineCart.load_application!
+
+require 'rspec/rails'
+ActiveJob::Base.queue_adapter = :test
+
+require 'database_cleaner'
+
+RSpec.configure do |config|
+  config.before do |example|
+    if example.metadata[:db_clean]
+      DatabaseCleaner.clean_with(:truncation)
+      DatabaseCleaner.strategy = :truncation
+    end
+  end
+
+  config.after do |example|
+    DatabaseCleaner.clean if example.metadata[:db_clean]
+  end
+end

data/spec/shared_specs/engine_adapter_specs.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+RSpec.shared_examples 'an ActiveEncode::EngineAdapter' do |*_flags|
+  before do
+    raise 'adapter must be set with `let(:created_job)`' unless defined? created_job
+    raise 'adapter must be set with `let(:running_job)`' unless defined? running_job
+    raise 'adapter must be set with `let(:canceled_job)`' unless defined? canceled_job
+    raise 'adapter must be set with `let(:completed_job)`' unless defined? completed_job
+    raise 'adapter must be set with `let(:failed_job)`' unless defined? failed_job
+  end
+
+  it { is_expected.to respond_to :create }
+  it { is_expected.to respond_to :find }
+  it { is_expected.to respond_to :cancel }
+
+  describe "#create" do
+    subject { created_job }
+
+    it { is_expected.to be_a ActiveEncode::Base }
+    its(:id) { is_expected.not_to be_empty }
+    it { is_expected.to be_running }
+    its(:current_operations) { is_expected.to be_empty }
+    its(:percent_complete) { is_expected.to be < 100 }
+    its(:errors) { is_expected.to be_empty }
+    its(:created_at) { is_expected.to be_kind_of Time }
+    its(:updated_at) { is_expected.to be_nil }
+    its(:finished_at) { is_expected.to be_nil }
+    its(:tech_metadata) { is_expected.to be_empty }
+  end
+
+  describe "#find" do
+    context "a running encode" do
+      subject { running_job }
+
+      it 'returns an ActiveEncode::Base object' do
+        expect(subject.class).to be ActiveEncode::Base
+      end
+      its(:id) { is_expected.to eq 'running-id' }
+      it { is_expected.to be_running }
+      its(:percent_complete) { is_expected.to be > 0 }
+      its(:errors) { is_expected.to be_empty }
+      its(:created_at) { is_expected.to be_kind_of Time }
+      its(:updated_at) { is_expected.to be > subject.created_at }
+      its(:finished_at) { is_expected.to be_nil }
+    end
+
+    context "a cancelled encode" do
+      subject { canceled_job }
+
+      it 'returns an ActiveEncode::Base object' do
+        expect(subject.class).to be ActiveEncode::Base
+      end
+      its(:id) { is_expected.to eq 'cancelled-id' }
+      it { is_expected.to be_cancelled }
+      its(:percent_complete) { is_expected.to be > 0 }
+      its(:errors) { is_expected.to be_empty }
+      its(:created_at) { is_expected.to be_kind_of Time }
+      its(:finished_at) { is_expected.to be >= subject.created_at }
+      its(:tech_metadata) { is_expected.to be_empty }
+    end
+
+    context "a completed encode" do
+      subject { completed_job }
+
+      it 'returns an ActiveEncode::Base object' do
+        expect(subject.class).to be ActiveEncode::Base
+      end
+      its(:id) { is_expected.to eq 'completed-id' }
+      it { is_expected.to be_completed }
+      its(:output) { is_expected.to eq completed_output }
+      its(:percent_complete) { is_expected.to eq 100 }
+      its(:errors) { is_expected.to be_empty }
+      its(:created_at) { is_expected.to be_kind_of Time }
+      its(:updated_at) { is_expected.to be > subject.created_at }
+      its(:finished_at) { is_expected.to be >= subject.updated_at }
+      its(:tech_metadata) { is_expected.to include completed_tech_metadata }
+    end
+
+    context "a failed encode" do
+      subject { failed_job }
+
+      it 'returns an ActiveEncode::Base object' do
+        expect(subject.class).to be ActiveEncode::Base
+      end
+      its(:id) { is_expected.to eq 'failed-id' }
+      it { is_expected.to be_failed }
+      its(:percent_complete) { is_expected.to be > 0 }
+      its(:errors) { is_expected.not_to be_empty }
+      its(:created_at) { is_expected.to be_kind_of Time }
+      its(:updated_at) { is_expected.to be > subject.created_at }
+      its(:finished_at) { is_expected.to be >= subject.updated_at }
+      its(:tech_metadata) { is_expected.to include failed_tech_metadata }
+    end
+  end
+
+  describe "#cancel!" do
+    subject { cancelling_job.cancel! }
+
+    it 'returns an ActiveEncode::Base object' do
+      expect(subject.class).to be ActiveEncode::Base
+    end
+    its(:id) { is_expected.to eq 'cancelled-id' }
+    it { is_expected.to be_cancelled }
+    its(:percent_complete) { is_expected.to be > 0 }
+    its(:errors) { is_expected.to be_empty }
+    its(:created_at) { is_expected.to be_kind_of Time }
+    its(:finished_at) { is_expected.to be >= subject.created_at }
+    its(:tech_metadata) { is_expected.to be_empty }
+  end
+
+  describe "reload" do
+    subject { running_job.reload }
+
+    it 'returns an ActiveEncode::Base object' do
+      expect(subject.class).to be ActiveEncode::Base
+    end
+    its(:id) { is_expected.to eq 'running-id' }
+    it { is_expected.to be_running }
+    its(:percent_complete) { is_expected.to be > 0 }
+    its(:errors) { is_expected.to be_empty }
+    its(:created_at) { is_expected.to be_kind_of Time }
+    its(:updated_at) { is_expected.to be > subject.created_at }
+    its(:finished_at) { is_expected.to be_nil }
+  end
+end

data/spec/test_app_templates/lib/generators/test_app_generator.rb

@@ -0,0 +1,15 @@
+        require 'rails/generators'
+
+        class TestAppGenerator < Rails::Generators::Base
+          source_root "./spec/test_app_templates"
+
+          # if you need to generate any additional configuration
+          # into the test app, this generator will be run immediately
+          # after setting up the application
+
+          def install_engine
+            generate 'active_encode:install'
+            rake 'active_encode:install:migrations'
+          end
+        end
+

data/spec/units/callbacks_spec.rb

@@ -3,15 +3,16 @@ require 'spec_helper'
 describe ActiveEncode::Callbacks do
   before do
     class CallbackEncode < ActiveEncode::Base
+      after_find ->(encode) { encode.history << "CallbackEncode ran after_find" }
+
+      after_reload ->(encode) { encode.history << "CallbackEncode ran after_reload" }
+
       before_create ->(encode) { encode.history << "CallbackEncode ran before_create" }
       after_create ->(encode) { encode.history << "CallbackEncode ran after_create" }
 
       before_cancel ->(encode) { encode.history << "CallbackEncode ran before_cancel" }
       after_cancel ->(encode) { encode.history << "CallbackEncode ran after_cancel" }
 
-      before_purge ->(encode) { encode.history << "CallbackEncode ran before_purge" }
-      after_purge ->(encode) { encode.history << "CallbackEncode ran after_purge" }
-
       around_create do |encode, block|
         encode.history << "CallbackEncode ran around_create_start"
         block.call
@@ -24,12 +25,6 @@ describe ActiveEncode::Callbacks do
         encode.history << "CallbackEncode ran around_cancel_stop"
       end
 
-      around_purge do |encode, block|
-        encode.history << "CallbackEncode ran around_purge_start"
-        block.call
-        encode.history << "CallbackEncode ran around_purge_stop"
-      end
-
       def history
         @history ||= []
       end
@@ -40,6 +35,18 @@ describe ActiveEncode::Callbacks do
     Object.send(:remove_const, :CallbackEncode)
   end
 
+  describe 'find callback' do
+    let(:encode) { CallbackEncode.create("sample.mp4") }
+    subject { CallbackEncode.find(encode.id).history }
+    it { is_expected.to include("CallbackEncode ran after_find") }
+  end
+
+  describe 'reload callback' do
+    let(:encode) { CallbackEncode.create("sample.mp4") }
+    subject { encode.reload.history }
+    it { is_expected.to include("CallbackEncode ran after_reload") }
+  end
+
   describe 'create callbacks' do
     subject { CallbackEncode.create("sample.mp4").history }
     it { is_expected.to include("CallbackEncode ran before_create") }
@@ -55,12 +62,4 @@ describe ActiveEncode::Callbacks do
     it { is_expected.to include("CallbackEncode ran around_cancel_start") }
     it { is_expected.to include("CallbackEncode ran around_cancel_stop") }
   end
-
-  describe 'purge callbacks' do
-    subject { CallbackEncode.create("sample.mp4").purge!.history }
-    it { is_expected.to include("CallbackEncode ran before_purge") }
-    it { is_expected.to include("CallbackEncode ran after_purge") }
-    it { is_expected.to include("CallbackEncode ran around_purge_start") }
-    it { is_expected.to include("CallbackEncode ran around_purge_stop") }
-  end
 end

data/spec/units/core_spec.rb

@@ -1,9 +1,128 @@
 require 'spec_helper'
 
 describe ActiveEncode::Core do
+  before do
+    class CustomEncode < ActiveEncode::Base
+    end
+  end
+   after do
+    Object.send(:remove_const, :CustomEncode)
+  end
+
+  let(:encode_class) { ActiveEncode::Base }
+
+  describe 'attributes' do
+    subject { encode_class.new(nil) }
+
+    it { is_expected.to respond_to(:id, :input, :output, :options, :percent_complete, :current_operations) }
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+
+      it { is_expected.to respond_to(:id, :input, :output, :options, :percent_complete, :current_operations) }
+    end
+  end
+
   describe 'find' do
-    it "raises NotFound when no id is supplied" do
-      expect { ActiveEncode::Base.find(nil) }.to raise_error(ArgumentError)
+    let(:id) { encode_class.create(nil).id }
+    subject { encode_class.find(id) }
+
+    it { is_expected.to be_a encode_class }
+    its(:id) { is_expected.to eq id }
+
+    context 'with no id' do
+      let(:id) { nil }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+
+      it { is_expected.to be_a encode_class }
+      its(:id) { is_expected.to eq id }
+
+      context 'casting' do
+        let(:id) { ActiveEncode::Base.create(nil).id }
+
+        it { is_expected.to be_a encode_class }
+        its(:id) { is_expected.to eq id }
+      end
+    end
+  end
+
+  describe 'create' do
+    subject { encode_class.create(nil) }
+
+    it { is_expected.to be_a encode_class }
+    its(:id) { is_expected.not_to be nil }
+    its(:state) { is_expected.not_to be nil }
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+
+      it { is_expected.to be_a encode_class }
+      its(:id) { is_expected.not_to be nil }
+      its(:state) { is_expected.not_to be nil }
+    end
+  end
+
+  describe '#create!' do
+    let(:encode) { encode_class.new(nil) }
+    subject { encode.create! }
+
+    it { is_expected.to equal encode }
+    it { is_expected.to be_a encode_class }
+    its(:id) { is_expected.not_to be nil }
+    its(:state) { is_expected.not_to be nil }
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+
+      it { is_expected.to equal encode }
+      it { is_expected.to be_a encode_class }
+      its(:id) { is_expected.not_to be nil }
+      its(:state) { is_expected.not_to be nil }
+    end
+  end
+
+  describe '#cancel!' do
+    let(:encode) { encode_class.create(nil) }
+    subject { encode.cancel! }
+
+    it { is_expected.to equal encode }
+    it { is_expected.to be_a encode_class }
+    its(:id) { is_expected.not_to be nil }
+    it { is_expected.to be_cancelled }
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+
+      it { is_expected.to equal encode }
+      it { is_expected.to be_a encode_class }
+      its(:id) { is_expected.not_to be nil }
+      it { is_expected.to be_cancelled }
+    end
+  end
+
+  describe '#reload' do
+    let(:encode) { encode_class.create(nil) }
+    subject { encode.reload }
+
+    it { is_expected.to equal encode }
+    it { is_expected.to be_a encode_class }
+    its(:id) { is_expected.not_to be nil }
+    its(:state) { is_expected.not_to be nil }
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+
+      it { is_expected.to equal encode }
+      it { is_expected.to be_a encode_class }
+      its(:id) { is_expected.not_to be nil }
+      its(:state) { is_expected.not_to be nil }
     end
   end
 end

data/spec/units/engine_adapter_spec.rb

@@ -9,13 +9,7 @@ describe ActiveEncode::EngineAdapter do
 
           def find(_, _ = {}); end
 
-          def list(*); end
-
           def cancel(_encode); end
-
-          def purge(_encode); end
-
-          def remove_output(_encode, _output_id); end
         end
 
         class StubTwoAdapter
@@ -23,13 +17,7 @@ describe ActiveEncode::EngineAdapter do
 
           def find(_id, _opts = {}); end
 
-          def list(*); end
-
           def cancel(_encode); end
-
-          def purge(_encode); end
-
-          def remove_output(_encode, _output_id); end
         end
       end
     end

data/spec/units/global_id_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe ActiveEncode::GlobalID do
+  before do
+    class CustomEncode < ActiveEncode::Base
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :CustomEncode)
+  end
+
+  describe '#to_global_id' do
+    let(:encode_class) { ActiveEncode::Base }
+    let(:encode) { encode_class.create(nil) }
+    subject { encode.to_global_id }
+
+    it { is_expected.to be_a GlobalID }
+    its(:model_class) { is_expected.to eq encode_class }
+    its(:model_id) { is_expected.to eq encode.id }
+    its(:app) { is_expected.to eq 'ActiveEncode' }
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+
+      it { is_expected.to be_a GlobalID }
+      its(:model_class) { is_expected.to eq encode_class }
+      its(:model_id) { is_expected.to eq encode.id }
+      its(:app) { is_expected.to eq 'ActiveEncode' }
+    end
+  end
+
+  describe 'GlobalID::Locator#locate' do
+    let(:encode_class) { ActiveEncode::Base }
+    let(:encode) { encode_class.create(nil) }
+    let(:global_id) { encode.to_global_id }
+    subject { GlobalID::Locator.locate(global_id) }
+
+    it { is_expected.to be_a encode_class }
+    its(:id) { is_expected.to eq encode.id }
+
+    context 'with an ActiveEncode::Base subclass' do
+      let(:encode_class) { CustomEncode }
+      
+      it { is_expected.to be_a encode_class }
+      its(:id) { is_expected.to eq encode.id }
+    end
+  end
+end