active_encode 1.2.0 → 1.2.2

data/spec/units/core_spec.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-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
-    subject { encode_class.find(id) }
-    let(:id) { encode_class.create(nil).id }
-
-    it { is_expected.to be_a encode_class }
-    it { expect(subject.id).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 }
-      it { expect(subject.id).to eq id }
-
-      context 'casting' do
-        let(:id) { ActiveEncode::Base.create(nil).id }
-
-        it { is_expected.to be_a encode_class }
-        it { expect(subject.id).to eq id }
-      end
-    end
-  end
-
-  describe 'create' do
-    subject { encode_class.create(nil) }
-
-    it { is_expected.to be_a encode_class }
-    it { expect(subject.id).not_to be nil }
-    it { expect(subject.state).not_to be nil }
-
-    context 'with an ActiveEncode::Base subclass' do
-      let(:encode_class) { CustomEncode }
-
-      it { is_expected.to be_a encode_class }
-      it { expect(subject.id).not_to be nil }
-      it { expect(subject.state).not_to be nil }
-    end
-  end
-
-  describe '#create!' do
-    subject { encode.create! }
-    let(:encode) { encode_class.new(nil) }
-
-    it { is_expected.to equal encode }
-    it { is_expected.to be_a encode_class }
-    it { expect(subject.id).not_to be nil }
-    it { expect(subject.state).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 }
-      it { expect(subject.id).not_to be nil }
-      it { expect(subject.state).not_to be nil }
-    end
-  end
-
-  describe '#cancel!' do
-    subject { encode.cancel! }
-    let(:encode) { encode_class.create(nil) }
-
-    it { is_expected.to equal encode }
-    it { is_expected.to be_a encode_class }
-    it { expect(subject.id).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 }
-      it { expect(subject.id).not_to be nil }
-      it { is_expected.to be_cancelled }
-    end
-  end
-
-  describe '#reload' do
-    subject { encode.reload }
-    let(:encode) { encode_class.create(nil) }
-
-    it { is_expected.to equal encode }
-    it { is_expected.to be_a encode_class }
-    it { expect(subject.id).not_to be nil }
-    it { expect(subject.state).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 }
-      it { expect(subject.id).not_to be nil }
-      it { expect(subject.state).not_to be nil }
-    end
-  end
-
-  describe '#new' do
-    subject { encode.options }
-    before do
-      class DefaultOptionsEncode < ActiveEncode::Base
-        def self.default_options(_input_url)
-          { preset: 'video' }
-        end
-      end
-    end
-    after do
-      Object.send(:remove_const, :DefaultOptionsEncode)
-    end
-
-    let(:encode_class) { DefaultOptionsEncode }
-    let(:default_options) { { preset: 'video' } }
-    let(:options) { { output: [{ label: 'high', ffmpeg_opt: "640x480" }] } }
-    let(:encode) { encode_class.new(nil, options) }
-
-    it 'merges default options and options parameter' do
-      expect(subject).to include default_options
-      expect(subject).to include options
-    end
-
-    context 'with collisions' do
-      let(:options) { { preset: 'avalon' } }
-      it 'prefers options parameter' do
-        expect(subject[:preset]).to eq 'avalon'
-      end
-    end
-  end
-end

data/spec/units/engine_adapter_spec.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe ActiveEncode::EngineAdapter do
-  before do
-    module ActiveEncode
-      module EngineAdapters
-        class StubOneAdapter
-          def create(_); end
-
-          def find(_, _ = {}); end
-
-          def cancel(_encode); end
-        end
-
-        class StubTwoAdapter
-          def create(_encode); end
-
-          def find(_id, _opts = {}); end
-
-          def cancel(_encode); end
-        end
-      end
-    end
-  end
-
-  after do
-    ActiveEncode::EngineAdapters.send(:remove_const, :StubOneAdapter)
-    ActiveEncode::EngineAdapters.send(:remove_const, :StubTwoAdapter)
-  end
-
-  it 'does not allow classes as arguments' do
-    expect { ActiveEncode::Base.engine_adapter = ActiveEncode::EngineAdapters::StubOneAdapter }.to raise_error(ArgumentError)
-  end
-
-  it 'does not allow arguments that are not engine adapters' do
-    expect { ActiveEncode::Base.engine_adapter = Mutex.new }.to raise_error(ArgumentError)
-  end
-
-  context 'overriding' do
-    let(:base_engine_adapter) { ActiveEncode::Base.engine_adapter }
-
-    it 'does not affect the parent' do
-      child_encode_one = Class.new(ActiveEncode::Base)
-      child_encode_one.engine_adapter = :stub_one
-
-      expect(child_encode_one.engine_adapter).not_to eq base_engine_adapter
-      expect(child_encode_one.engine_adapter).to be_kind_of ActiveEncode::EngineAdapters::StubOneAdapter
-      expect(ActiveEncode::Base.engine_adapter).to eq base_engine_adapter
-    end
-
-    it 'does not affect its sibling' do
-      child_encode_one = Class.new(ActiveEncode::Base)
-      child_encode_one.engine_adapter = :stub_one
-      child_encode_two = Class.new(ActiveEncode::Base)
-      child_encode_two.engine_adapter = :stub_two
-
-      expect(child_encode_two.engine_adapter).not_to eq base_engine_adapter
-      expect(child_encode_two.engine_adapter).to be_kind_of ActiveEncode::EngineAdapters::StubTwoAdapter
-      # child_encode_one's engine adapter should remain unchanged
-      expect(child_encode_one.engine_adapter).to be_kind_of ActiveEncode::EngineAdapters::StubOneAdapter
-      expect(ActiveEncode::Base.engine_adapter).to eq base_engine_adapter
-      # new encodes should not be affected
-      expect(Class.new(ActiveEncode::Base).engine_adapter).to eq base_engine_adapter
-    end
-  end
-end

data/spec/units/file_locator_spec.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-# Copyright 2011-2018, The Trustees of Indiana University and Northwestern
-#   University.  Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed
-#   under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
-#   CONDITIONS OF ANY KIND, either express or implied. See the License for the
-#   specific language governing permissions and limitations under the License.
-# ---  END LICENSE_HEADER BLOCK  ---
-require 'aws-sdk-s3'
-require 'rails_helper'
-
-describe FileLocator, type: :service do
-  before do
-    Aws.config[:stub_responses] = true
-  end
-
-  describe 'S3File Class' do
-    let(:bucket) { "mybucket" }
-    let(:key) { "mykey.mp4" }
-    let(:s3file) { FileLocator::S3File.new("s3://#{bucket}/#{key}") }
-
-    it "is able to initialize from an S3 URI" do
-      expect(s3file.bucket).to eq bucket
-      expect(s3file.key).to eq key
-    end
-
-    it "returns an S3 Object" do
-      s3_object = s3file.object
-      expect(s3_object).to be_an Aws::S3::Object
-      expect(s3_object.bucket_name).to eq bucket
-      expect(s3_object.key).to eq key
-    end
-  end
-
-  describe "Local file" do
-    let(:path) { "/path/to/file.mp4" }
-    let(:source) { "file://#{path}" }
-    let(:locator) { described_class.new(source) }
-
-    it "returns the correct uri" do
-      expect(locator.uri).to eq Addressable::URI.parse(source)
-    end
-
-    it "returns the correct location" do
-      expect(locator.location).to eq path
-    end
-
-    it "tells if file exists" do
-      allow(File).to receive(:exist?).with(path) { true }
-      expect(locator.exist?).to be_truthy
-    end
-
-    context "return file" do
-      let(:file) { double(File) }
-      before do
-        allow(File).to receive(:open).and_return file
-      end
-
-      it "returns reader" do
-        expect(locator.reader).to eq file
-      end
-
-      it "returns attachment" do
-        expect(locator.attachment).to eq file
-      end
-    end
-  end
-
-  describe "s3 file" do
-    let(:bucket) { "mybucket" }
-    let(:key) { "mykey.mp4" }
-    let(:source) { "s3://#{bucket}/#{key}" }
-    let(:locator) { described_class.new(source) }
-
-    it "returns the correct uri" do
-      expect(locator.uri).to eq Addressable::URI.parse(source)
-    end
-
-    it "returns the correct location" do
-      expect(locator.location).to start_with "https://#{bucket}.s3.us-stubbed-1.amazonaws.com/#{key}"
-    end
-
-    it "tells if file exists" do
-      expect(locator.exist?).to be_truthy
-    end
-
-    it "returns reader" do
-      expect(locator.reader).to be_a StringIO
-    end
-
-    it "returns attachment" do
-      expect(locator.attachment).to eq Addressable::URI.parse(source)
-    end
-  end
-
-  describe "Other file" do
-    let(:path) { "/path/to/file.mp4" }
-    let(:source) { "bogus://#{path}" }
-    let(:locator) { described_class.new(source) }
-
-    it "returns the correct uri" do
-      expect(locator.uri).to eq Addressable::URI.parse(source)
-    end
-
-    it "returns the correct location" do
-      expect(locator.location).to eq source
-    end
-
-    it "tells if file exists" do
-      expect(locator.exist?).to be_falsy
-    end
-
-    it "returns reader" do
-      io = double(IO)
-      allow(Kernel).to receive(:open).and_return io
-      expect(locator.reader).to eq io
-    end
-
-    it "returns attachment" do
-      expect(locator.attachment).to eq locator.location
-    end
-  end
-end

data/spec/units/filename_sanitizer_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'addressable'
-
-describe ActiveEncode::FilenameSanitizer do
-  describe '#sanitize_uri' do
-    it 'removes file scheme' do
-      uri = "file:///path/to/file"
-      expect(ActiveEncode.sanitize_uri(uri)).to eq "/path/to/file"
-    end
-    it 'relativizes s3 uris' do
-      uri = "s3://mybucket/guitar.mp4"
-      expect(ActiveEncode.sanitize_uri(uri)).to eq "/guitar.mp4"
-    end
-    it 'does nothing for http(s) uris' do
-      uri = "https://www.googleapis.com/drive/v3/files/1WkWJ12WecI9hX-PmEbuKDGLPK_mN3kYP?alt=media"
-      expect(ActiveEncode.sanitize_uri(uri)).to eq uri
-    end
-  end
-end

data/spec/units/global_id_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-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
-    subject { encode.to_global_id }
-    let(:encode_class) { ActiveEncode::Base }
-    let(:encode) { encode_class.create(nil) }
-
-    it { is_expected.to be_a GlobalID }
-    it { expect(subject.model_class).to eq encode_class }
-    it { expect(subject.model_id).to eq encode.id }
-    it { expect(subject.app).to eq 'ActiveEncode' }
-
-    context 'with an ActiveEncode::Base subclass' do
-      let(:encode_class) { CustomEncode }
-
-      it { is_expected.to be_a GlobalID }
-      it { expect(subject.model_class).to eq encode_class }
-      it { expect(subject.model_id).to eq encode.id }
-      it { expect(subject.app).to eq 'ActiveEncode' }
-    end
-  end
-
-  describe 'GlobalID::Locator#locate' do
-    subject { GlobalID::Locator.locate(global_id) }
-    let(:encode_class) { ActiveEncode::Base }
-    let(:encode) { encode_class.create(nil) }
-    let(:global_id) { encode.to_global_id }
-
-    it { is_expected.to be_a encode_class }
-    it { expect(subject.id).to eq encode.id }
-
-    context 'with an ActiveEncode::Base subclass' do
-      let(:encode_class) { CustomEncode }
-
-      it { is_expected.to be_a encode_class }
-      it { expect(subject.id).to eq encode.id }
-    end
-  end
-end

data/spec/units/input_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe ActiveEncode::Input do
-  subject { described_class.new }
-
-  describe 'attributes' do
-    it { is_expected.to respond_to(:id, :url) }
-    it { is_expected.to respond_to(:state, :errors, :created_at, :updated_at) }
-    it {
-      is_expected.to respond_to(:width, :height, :frame_rate, :checksum,
-                                :audio_codec, :video_codec, :audio_bitrate, :video_bitrate)
-    }
-  end
-
-  describe '#valid?' do
-    let(:valid_input) do
-      described_class.new.tap do |obj|
-        obj.id = "1"
-        obj.url = "file:///tmp/video.mp4"
-        obj.created_at = Time.now.utc
-        obj.updated_at = Time.now.utc
-      end
-    end
-
-    it 'returns true when conditions met' do
-      expect(valid_input).to be_valid
-    end
-
-    it 'returns false when conditions not met' do
-      expect(valid_input.tap { |obj| obj.id = nil }).not_to be_valid
-      expect(valid_input.tap { |obj| obj.url = nil }).not_to be_valid
-      expect(valid_input.tap { |obj| obj.created_at = nil }).not_to be_valid
-      expect(valid_input.tap { |obj| obj.created_at = "today" }).not_to be_valid
-      expect(valid_input.tap { |obj| obj.updated_at = nil }).not_to be_valid
-      expect(valid_input.tap { |obj| obj.updated_at = "today" }).not_to be_valid
-      expect(valid_input.tap { |obj| obj.created_at = Time.now.utc }).not_to be_valid
-    end
-  end
-end

data/spec/units/output_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe ActiveEncode::Output do
-  subject { described_class.new }
-
-  describe 'attributes' do
-    it { is_expected.to respond_to(:id, :url, :label) }
-    it { is_expected.to respond_to(:state, :errors, :created_at, :updated_at) }
-    it {
-      is_expected.to respond_to(:width, :height, :frame_rate, :checksum,
-                                :audio_codec, :video_codec, :audio_bitrate, :video_bitrate)
-    }
-  end
-
-  describe '#valid?' do
-    let(:valid_output) do
-      described_class.new.tap do |obj|
-        obj.id = "1"
-        obj.url = "file:///tmp/video.mp4"
-        obj.label = "HD"
-        obj.created_at = Time.now.utc
-        obj.updated_at = Time.now.utc
-      end
-    end
-
-    it 'returns true when conditions met' do
-      expect(valid_output).to be_valid
-    end
-
-    it 'returns false when conditions not met' do
-      expect(valid_output.tap { |obj| obj.id = nil }).not_to be_valid
-      expect(valid_output.tap { |obj| obj.url = nil }).not_to be_valid
-      expect(valid_output.tap { |obj| obj.label = nil }).not_to be_valid
-      expect(valid_output.tap { |obj| obj.created_at = nil }).not_to be_valid
-      expect(valid_output.tap { |obj| obj.created_at = "today" }).not_to be_valid
-      expect(valid_output.tap { |obj| obj.updated_at = nil }).not_to be_valid
-      expect(valid_output.tap { |obj| obj.updated_at = "today" }).not_to be_valid
-      expect(valid_output.tap { |obj| obj.created_at = Time.now.utc }).not_to be_valid
-    end
-  end
-end

data/spec/units/persistence_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require 'rails_helper'
-
-describe ActiveEncode::Persistence, db_clean: true do
-  before do
-    class CustomEncode < ActiveEncode::Base
-      include ActiveEncode::Persistence
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :CustomEncode)
-  end
-
-  describe 'find' do
-    subject { ActiveEncode::EncodeRecord.find_by(global_id: encode.to_global_id.to_s) }
-    let(:encode) { CustomEncode.create(nil) }
-
-    it 'persists changes on find' do
-      expect { CustomEncode.find(encode.id) }.to change { subject.reload.updated_at }
-    end
-  end
-
-  describe 'create' do
-    subject { ActiveEncode::EncodeRecord.find_by(global_id: encode.to_global_id.to_s) }
-    let(:create_options) { { option: 'value' } }
-    let(:encode) { CustomEncode.create(nil, create_options) }
-
-    it 'creates a record' do
-      expect { encode }.to change { ActiveEncode::EncodeRecord.count }.by(1)
-    end
-
-    it { expect(subject.global_id).to eq encode.to_global_id.to_s }
-    it { expect(subject.state).to eq encode.state.to_s }
-    it { expect(subject.adapter).to eq encode.class.engine_adapter.class.name }
-    it { expect(subject.title).to eq encode.input.url.to_s }
-    it { expect(subject.raw_object).to eq encode.to_json }
-    it { expect(subject.created_at).to be_within(1.second).of encode.created_at }
-    it { expect(subject.updated_at).to be_within(1.second).of encode.updated_at }
-    it { expect(subject.create_options).to eq create_options.to_json }
-    it { expect(subject.progress).to eq encode.percent_complete }
-  end
-
-  describe 'cancel' do
-    subject { ActiveEncode::EncodeRecord.find_by(global_id: encode.to_global_id.to_s) }
-    let(:encode) { CustomEncode.create(nil) }
-
-    it 'persists changes on cancel' do
-      expect { encode.cancel! }.to change { subject.reload.state }.from("running").to("cancelled")
-    end
-  end
-
-  describe 'reload' do
-    subject { ActiveEncode::EncodeRecord.find_by(global_id: encode.to_global_id.to_s) }
-    let(:encode) { CustomEncode.create(nil) }
-
-    it 'persists changes on reload' do
-      expect { encode.reload }.to change { subject.reload.updated_at }
-    end
-  end
-end

data/spec/units/polling_job_spec.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-require 'rails_helper'
-
-describe ActiveEncode::PollingJob do
-  include ActiveJob::TestHelper
-
-  before do
-    class PollingEncode < ActiveEncode::Base
-      include ActiveEncode::Polling
-      after_status_update ->(encode) { encode.history << "PollingEncode ran after_status_update" }
-      after_failed ->(encode) { encode.history << "PollingEncode ran after_failed" }
-      after_cancelled ->(encode) { encode.history << "PollingEncode ran after_cancelled" }
-      after_completed ->(encode) { encode.history << "PollingEncode ran after_completed" }
-
-      def history
-        @history ||= []
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :PollingEncode)
-  end
-
-  describe '#perform' do
-    subject { encode.history }
-    let(:encode) { PollingEncode.create("sample.mp4").tap { |encode| encode.state = state } }
-    let(:poll) { described_class.new }
-
-    before do
-      encode
-      clear_enqueued_jobs
-      poll.perform(encode)
-    end
-
-    context "with job failed" do
-      let(:state) { :failed }
-
-      it "runs after_failed" do
-        is_expected.to include("PollingEncode ran after_status_update")
-        is_expected.to include("PollingEncode ran after_failed")
-      end
-
-      it "does not re-enqueue itself" do
-        expect(described_class).not_to have_been_enqueued
-      end
-    end
-
-    context "with job cancelled" do
-      let(:state) { :cancelled }
-
-      it "runs after_cancelled" do
-        is_expected.to include("PollingEncode ran after_status_update")
-        is_expected.to include("PollingEncode ran after_cancelled")
-      end
-
-      it "does not re-enqueue itself" do
-        expect(described_class).not_to have_been_enqueued
-      end
-    end
-
-    context "with job completed" do
-      let(:state) { :completed }
-
-      it "runs after_completed" do
-        is_expected.to include("PollingEncode ran after_status_update")
-        is_expected.to include("PollingEncode ran after_completed")
-      end
-
-      it "does not re-enqueue itself" do
-        expect(described_class).not_to have_been_enqueued
-      end
-    end
-
-    context "with job running" do
-      let(:state) { :running }
-
-      it "runs after_status_update" do
-        is_expected.to include("PollingEncode ran after_status_update")
-      end
-
-      it "re-enqueues itself" do
-        expect(described_class).to have_been_enqueued.with(encode)
-      end
-    end
-  end
-end

data/spec/units/polling_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require 'rails_helper'
-
-describe ActiveEncode::Polling do
-  before do
-    class PollingEncode < ActiveEncode::Base
-      include ActiveEncode::Polling
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :PollingEncode)
-  end
-
-  describe 'after_create' do
-    subject { PollingEncode.create("sample.mp4") }
-
-    it "enqueues a PollingJob" do
-      subject
-      expect(ActiveEncode::PollingJob).to have_been_enqueued.with(subject)
-    end
-  end
-end