active_encode 1.2.0 → 1.2.2

data/spec/integration/media_convert_adapter_spec.rb

@@ -1,321 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'aws-sdk-cloudwatchevents'
-require 'aws-sdk-cloudwatchlogs'
-require 'aws-sdk-mediaconvert'
-require 'aws-sdk-s3'
-require 'json'
-require 'active_encode/spec/shared_specs'
-require 'active_support/json'
-require 'active_support/time'
-
-def with_json_parsing
-  old_settings = { parse_json_times: ActiveSupport.parse_json_times, time_zone: Time.zone }
-  ActiveSupport.parse_json_times = true
-  Time.zone = 'America/Chicago'
-  yield
-ensure
-  ActiveSupport.parse_json_times = old_settings[:parse_json_times]
-  Time.zone = old_settings[:time_zone]
-end
-
-def reconstitute_response(fixture_path)
-  with_json_parsing do
-    HashWithIndifferentAccess.new(ActiveSupport::JSON.decode(File.read(File.join("spec/fixtures", fixture_path))))
-  end
-end
-
-describe ActiveEncode::EngineAdapters::MediaConvertAdapter do
-  around do |example|
-    # Setting this before each test works around a stubbing + memoization limitation
-    ActiveEncode::Base.engine_adapter = :media_convert
-    ActiveEncode::Base.engine_adapter.role = 'arn:aws:iam::123456789012:role/service-role/MediaConvert_Default_Role'
-    ActiveEncode::Base.engine_adapter.output_bucket = 'output-bucket'
-    example.run
-    ActiveEncode::Base.engine_adapter = :test
-  end
-
-  let(:job_id) { "1625859001514-vvqfwj" }
-  let(:mediaconvert) { Aws::MediaConvert::Client.new(stub_responses: true) }
-  let(:cloudwatch_events) { Aws::CloudWatchEvents::Client.new(stub_responses: true) }
-  let(:cloudwatch_logs) { Aws::CloudWatchLogs::Client.new(stub_responses: true) }
-
-  let(:s3client) { Aws::S3::Client.new(stub_responses: true) }
-
-  before do
-    mediaconvert.stub_responses(:describe_endpoints, reconstitute_response("media_convert/endpoints.json"))
-
-    allow(Aws::MediaConvert::Client).to receive(:new).and_return(mediaconvert)
-    allow(Aws::CloudWatchEvents::Client).to receive(:new).and_return(cloudwatch_events)
-    allow(Aws::CloudWatchLogs::Client).to receive(:new).and_return(cloudwatch_logs)
-    allow(Aws::S3::Client).to receive(:new).and_return(s3client)
-  end
-
-  let(:created_job) do
-    mediaconvert.stub_responses(:create_job, reconstitute_response("media_convert/job_created.json"))
-
-    ActiveEncode::Base.create(
-      "s3://input-bucket/test_files/source_file.mp4",
-      output_prefix: "active-encode-test/output",
-      outputs: [
-        { preset: "System-Avc_16x9_1080p_29_97fps_8500kbps", modifier: "-1080" },
-        { preset: "System-Avc_16x9_720p_29_97fps_5000kbps", modifier: "-720" },
-        { preset: "System-Avc_16x9_540p_29_97fps_3500kbps", modifier: "-540" }
-      ],
-      use_original_url: true
-    )
-  end
-
-  let(:running_job) do
-    mediaconvert.stub_responses(:get_job, reconstitute_response("media_convert/job_progressing.json"))
-    ActiveEncode::Base.find(job_id)
-  end
-
-  let(:canceled_job) do
-    mediaconvert.stub_responses(:get_job, reconstitute_response("media_convert/job_canceled.json"))
-    ActiveEncode::Base.find(job_id)
-  end
-
-  let(:cancelling_job) do
-    mediaconvert.stub_responses(:cancel_job, reconstitute_response("media_convert/job_canceling.json"))
-    mediaconvert.stub_responses(:get_job, reconstitute_response("media_convert/job_canceled.json"))
-    ActiveEncode::Base.find(job_id)
-  end
-
-  let(:completed_job) do
-    mediaconvert.stub_responses(:get_job, reconstitute_response("media_convert/job_completed.json"))
-    cloudwatch_logs.stub_responses(:start_query, reconstitute_response("media_convert/job_completed_detail_query.json"))
-    cloudwatch_logs.stub_responses(:get_query_results, reconstitute_response("media_convert/job_completed_detail.json"))
-
-    ActiveEncode::Base.find(job_id)
-  end
-
-  let(:recent_completed_job_without_results) do
-    job_response = reconstitute_response("media_convert/job_completed.json")
-    job_response["job"]["timing"]["finish_time"] = 5.minutes.ago
-    mediaconvert.stub_responses(:get_job, job_response)
-    cloudwatch_logs.stub_responses(:start_query, reconstitute_response("media_convert/job_completed_detail_query.json"))
-    cloudwatch_logs.stub_responses(:get_query_results, reconstitute_response("media_convert/job_completed_empty_detail.json"))
-
-    ActiveEncode::Base.find(job_id)
-  end
-
-  let(:failed_job) do
-    mediaconvert.stub_responses(:get_job, reconstitute_response("media_convert/job_failed.json"))
-
-    ActiveEncode::Base.find(job_id)
-  end
-
-  let(:completed_output) do
-    [
-      { id: "1625859001514-vvqfwj-output-auto", url: "s3://output-bucket/active-encode-test/output.m3u8",
-        label: "output.m3u8", audio_codec: "AAC", duration: 888_020, video_codec: "H_264" },
-      { id: "1625859001514-vvqfwj-output-1080", url: "s3://output-bucket/active-encode-test/output-1080.m3u8",
-        label: "output-1080.m3u8", audio_bitrate: 128_000, audio_codec: "AAC", duration: 888_020,
-        video_bitrate: 8_500_000, height: 1080, width: 1920, video_codec: "H_264", frame_rate: 29.97 },
-      { id: "1625859001514-vvqfwj-output-720", url: "s3://output-bucket/active-encode-test/output-720.m3u8",
-        label: "output-720.m3u8", audio_bitrate: 96_000, audio_codec: "AAC", duration: 888_020,
-        video_bitrate: 5_000_000, height: 720, width: 1280, video_codec: "H_264", frame_rate: 29.97 },
-      { id: "1625859001514-vvqfwj-output-540", url: "s3://output-bucket/active-encode-test/output-540.m3u8",
-        label: "output-540.m3u8", audio_bitrate: 96_000, audio_codec: "AAC", duration: 888_020,
-        video_bitrate: 3_500_000, height: 540, width: 960, video_codec: "H_264", frame_rate: 29.97 }
-    ]
-  end
-  let(:completed_tech_metadata) { {} }
-  let(:failed_tech_metadata) { {} }
-
-  it_behaves_like "an ActiveEncode::EngineAdapter"
-
-  describe "output location specification" do
-    let(:operations) { mediaconvert.api_requests(exclude_presign: true) }
-    before do
-      mediaconvert.stub_responses(:create_job, reconstitute_response("media_convert/job_created.json"))
-    end
-
-    it "can use output_bucket and output_prefix" do
-      ActiveEncode::Base.create(
-        "s3://input-bucket/test_files/source_file.mp4",
-        output_prefix: "active-encode-test/output",
-        outputs: [],
-        use_original_url: true
-      )
-      create_job_operation = operations.find { |o| o[:operation_name] == :create_job }
-      expect(create_job_operation).to be_present
-
-      destination = create_job_operation.dig(:params, :settings, :output_groups, 0,
-        :output_group_settings, :hls_group_settings, :destination)
-
-      expect(destination).to eq("s3://output-bucket/active-encode-test/output")
-    end
-
-    it "can use destination arg" do
-      ActiveEncode::Base.create(
-        "s3://input-bucket/test_files/source_file.mp4",
-        destination: "s3://alternate-output-bucket/my-path/output",
-        outputs: [],
-        use_original_url: true
-      )
-      create_job_operation = operations.find { |o| o[:operation_name] == :create_job }
-      expect(create_job_operation).to be_present
-
-      destination = create_job_operation.dig(:params, :settings, :output_groups, 0,
-        :output_group_settings, :hls_group_settings, :destination)
-
-      expect(destination).to eq("s3://alternate-output-bucket/my-path/output")
-    end
-  end
-
-  describe "output_group_destination_settings" do
-    let(:operations) { mediaconvert.api_requests(exclude_presign: true) }
-    before do
-      mediaconvert.stub_responses(:create_job, reconstitute_response("media_convert/job_created.json"))
-    end
-
-    it "are sent to MediaConvert" do
-      ActiveEncode::Base.create(
-        "s3://input-bucket/test_files/source_file.mp4",
-        destination: "s3://alternate-output-bucket/my-path/output",
-        outputs: [],
-        use_original_url: true,
-        output_group_destination_settings: {
-          s3_settings: {
-            access_control: {
-              canned_acl: "PUBLIC_READ"
-            }
-          }
-        }
-      )
-
-      create_job_operation = operations.find { |o| o[:operation_name] == :create_job }
-      expect(create_job_operation).to be_present
-
-      destination_settings = create_job_operation.dig(:params, :settings, :output_groups, 0,
-        :output_group_settings, :hls_group_settings, :destination_settings)
-      expect(destination_settings).to eq({ s3_settings: { access_control: { canned_acl: "PUBLIC_READ" } } })
-    end
-  end
-
-  describe "queue" do
-    let(:operations) { mediaconvert.api_requests(exclude_presign: true) }
-
-    it "uses the default queue" do
-      mediaconvert.stub_responses(:create_job, reconstitute_response("media_convert/job_created.json"))
-      ActiveEncode::Base.create(
-        "s3://input-bucket/test_files/source_file.mp4",
-        output_prefix: "active-encode-test/output",
-        outputs: [],
-        use_original_url: true
-      )
-      expect(operations).to include(include(operation_name: :create_job, params: include(queue: 'Default')))
-    end
-
-    it "uses a specific queue" do
-      mediaconvert.stub_responses(:create_job, reconstitute_response("media_convert/job_created.json"))
-      ActiveEncode::Base.engine_adapter.queue = 'test-queue'
-      ActiveEncode::Base.create(
-        "s3://input-bucket/test_files/source_file.mp4",
-        output_prefix: "active-encode-test/output",
-        outputs: [],
-        use_original_url: true
-      )
-      expect(operations).to include(include(operation_name: :create_job, params: include(queue: 'test-queue')))
-    end
-  end
-
-  describe "output" do
-    it "contains all expected outputs" do
-      completed_output.each do |expected_output|
-        found_output = completed_job.output.find { |output| output.id == expected_output[:id] }
-        expected_output.each_pair do |key, value|
-          expect(found_output.send(key)).to eq(value)
-        end
-      end
-    end
-
-    it "has no logging entries but finished within the last 10 minutes" do
-      expect(recent_completed_job_without_results.state).to eq(:running)
-    end
-
-    it "finished more than 10 minutes ago but has no logging entries" do
-      mediaconvert.stub_responses(:get_job, reconstitute_response("media_convert/job_completed.json"))
-      cloudwatch_logs.stub_responses(:start_query, reconstitute_response("media_convert/job_completed_detail_query.json"))
-      cloudwatch_logs.stub_responses(:get_query_results, reconstitute_response("media_convert/job_completed_empty_detail.json"))
-
-      expect { ActiveEncode::Base.find(job_id) }.to raise_error do |error|
-        expect(error).to be_a(ActiveEncode::EngineAdapters::MediaConvertAdapter::ResultsNotAvailable)
-        expect(error.encode).to be_a(ActiveEncode::Base)
-        expect(error.encode.state).to eq(:completed)
-      end
-    end
-  end
-
-  describe "direct_output_lookup" do
-    before do
-      ActiveEncode::Base.engine_adapter.direct_output_lookup = true
-    end
-
-    it "contains all expected outputs" do
-      completed_output.each do |expected_output|
-        found_output = completed_job.output.find { |output| output.id == expected_output[:id] }
-        expected_output.each_pair do |key, value|
-          expect(found_output.send(key)).to eq(value)
-        end
-      end
-    end
-
-    it "does not make cloudwatch queries" do
-      expect(cloudwatch_logs).not_to receive(:start_query)
-      expect(cloudwatch_logs).not_to receive(:get_query_results)
-
-      completed_job
-    end
-  end
-
-  describe "#s3_uri" do
-    context "when filename has no special characters" do
-      context "non-s3 file" do
-        let(:input_url) { "spec/fixtures/fireworks.mp4" }
-        let(:source_bucket) { "bucket1" }
-
-        it "calls the #upload_to_s3 method" do
-          allow(SecureRandom).to receive(:uuid).and_return("randomstring")
-          expect(described_class.new.send(:s3_uri, input_url, { masterfile_bucket: source_bucket })).to eq "randomstring/fireworks.mp4"
-        end
-      end
-      context "s3 file" do
-        let(:input_url) { "s3://bucket1/file.mp4" }
-        let(:source_bucket) { "bucket1" }
-
-        it "calls the #check_s3_bucket method" do
-          expect(described_class.new.send(:s3_uri, input_url, { masterfile_bucket: source_bucket })).to eq "file.mp4"
-        end
-      end
-    end
-    context "when filename has special characters" do
-      context "non-s3 file" do
-        let(:input) { ["'file_with_single_quote'.mp4", '"file_with_double_quote".mp4', "file with space.mp4", "file.with...periods.mp4", "file.with :=+%sp3c!l-ch4cts().mp4", '@ወዳጅህ ማር ቢ. ሆን ጨርስ. ህ አትላሰ!@#$^^&$%&.mov'] }
-        let(:clean) { ["_file_with_single_quote_.mp4", "_file_with_double_quote_.mp4", "file_with_space.mp4", "filewithperiods.mp4", "filewith_____sp3c_l-ch4cts__.mp4", '__________________________________.mov'] }
-        let(:source_bucket) { "bucket1" }
-
-        it "calls the #upload_to_s3 method" do
-          allow(SecureRandom).to receive(:uuid).and_return("randomstring")
-          input.each_with_index do |url, index|
-            expect(described_class.new.send(:s3_uri, "spec/fixtures/#{url}", { masterfile_bucket: source_bucket })).to eq "randomstring/#{clean[index]}"
-          end
-        end
-      end
-      context "s3 file" do
-        let(:input_urls) { ["s3://bucket1/'file_with_single_quote'.mp4", 's3://bucket1/"file_with_double_quote".mp4', "s3://bucket1/file with space.mp4", "s3://bucket1/file.with...periods.mp4", "s3://bucket1/file.with :=+%sp3c!l-ch4cts().mp4", 's3://bucket1/@ወዳጅህ ማር ቢ. ሆን ጨርስ. ህ አትላሰ!@#$^^&$%&.mov'] }
-        let(:clean) { ["_file_with_single_quote_.mp4", "_file_with_double_quote_.mp4", "file_with_space.mp4", "filewithperiods.mp4", "filewith_____sp3c_l-ch4cts__.mp4", '__________________________________.mov'] }
-        let(:source_bucket) { "bucket2" }
-
-        it "calls the #check_s3_bucket method" do
-          allow(SecureRandom).to receive(:uuid).and_return("randomstring")
-          input_urls.each_with_index do |url, index|
-            expect(described_class.new.send(:s3_uri, url, { masterfile_bucket: source_bucket })).to eq "randomstring/#{clean[index]}"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/pass_through_adapter_spec.rb

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-require 'rails_helper'
-require 'active_encode/spec/shared_specs'
-
-describe ActiveEncode::EngineAdapters::PassThroughAdapter do
-  around do |example|
-    ActiveEncode::Base.engine_adapter = :pass_through
-
-    Dir.mktmpdir do |dir|
-      @dir = dir
-      example.run
-      Dir.foreach(dir) do |e|
-        next if e == "." || e == ".."
-        FileUtils.rm_rf(File.join(dir, e))
-      end
-    end
-
-    ActiveEncode::Base.engine_adapter = :test
-  end
-
-  let!(:work_dir) { stub_const "ActiveEncode::EngineAdapters::PassThroughAdapter::WORK_DIR", @dir }
-  let(:file) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'fireworks.mp4').to_s }
-  let(:low_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'fireworks.low.mp4').to_s }
-  let(:created_job) do
-    ActiveEncode::Base.create(file, outputs: [{ label: 'low', url: low_derivative }])
-  end
-  let(:running_job) do
-    created_job
-  end
-  let(:canceled_job) do
-    find_encode 'cancelled-id'
-  end
-  let(:cancelling_job) do
-    find_encode 'running-id'
-  end
-  let(:completed_job) { find_encode "completed-id" }
-  let(:failed_job) { find_encode 'failed-id' }
-  let(:completed_tech_metadata) do
-    {
-      audio_bitrate: 171_030,
-      audio_codec: 'mp4a-40-2',
-      duration: 6315.0,
-      file_size: 199_160,
-      frame_rate: 23.719,
-      height: 110.0,
-      id: "completed-id",
-      url: "/home/pdinh/Downloads/videoshort.mp4",
-      video_bitrate: 74_477,
-      video_codec: 'avc1',
-      width: 200.0
-    }
-  end
-  let(:completed_output) { [{ id: "completed-id" }] }
-  let(:failed_tech_metadata) { {} }
-
-  it_behaves_like "an ActiveEncode::EngineAdapter"
-
-  def find_encode(id)
-    # Precreate ffmpeg output directory and files
-    FileUtils.copy_entry "spec/fixtures/pass_through/#{id}", "#{work_dir}/#{id}"
-
-    # Simulate that progress is modified later than other files
-    sleep 0.1
-    FileUtils.touch Dir.glob("#{work_dir}/#{id}/*.mp4")
-    touch_fixture(id, "completed")
-    touch_fixture(id, "cancelled")
-    touch_fixture(id, "error.log")
-
-    # Stub out system calls
-    allow_any_instance_of(ActiveEncode::EngineAdapters::PassThroughAdapter).to receive(:`).and_return(1234)
-
-    ActiveEncode::Base.find(id)
-  end
-
-  def touch_fixture(id, filename)
-    FileUtils.touch("#{work_dir}/#{id}/#{filename}") if File.exist? "#{work_dir}/#{id}/#{filename}"
-  end
-
-  describe "#create" do
-    subject { created_job }
-
-    it "creates a directory whose name is the encode id" do
-      expect(File).to exist("#{work_dir}/#{subject.id}")
-    end
-
-    context "input file exists" do
-      it "has the input technical metadata in a file" do
-        expect(File.read("#{work_dir}/#{subject.id}/input_metadata")).not_to be_empty
-      end
-    end
-
-    context "input file doesn't exist" do
-      let(:missing_file) { "file:///a_bogus_file.mp4" }
-      let(:missing_job) { ActiveEncode::Base.create(missing_file, outputs: [{ label: "low", url: 'mp4' }]) }
-
-      it "returns the encode with correct error" do
-        expect(missing_job.errors).to include("#{missing_file} does not exist or is not accessible")
-        expect(missing_job.percent_complete).to be 1
-      end
-    end
-
-    context "input file is not media" do
-      let(:nonmedia_file) { "file://" + Rails.root.join('Gemfile').to_s }
-      let(:nonmedia_job) { ActiveEncode::Base.create(nonmedia_file, outputs: [{ label: "low", url: nonmedia_file }]) }
-
-      it "returns the encode with correct error" do
-        expect(nonmedia_job.errors).to include("Error inspecting input: #{nonmedia_file}")
-        expect(nonmedia_job.percent_complete).to be 1
-      end
-    end
-
-    context "input file format does not match extension" do
-      let(:improper_format_file) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file_without_metadata.mp4').to_s }
-      let(:improper_format_job) { ActiveEncode::Base.create(improper_format_file, outputs: [{ label: "low", url: improper_format_file }]) }
-
-      it "returns the encode with correct error" do
-        expect(improper_format_job.errors).to include("Error inspecting input: #{improper_format_file}")
-        expect(improper_format_job.percent_complete).to be 1
-      end
-    end
-
-    context "input file without metadata" do
-      let(:file_without_metadata) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file_without_metadata.webm').to_s }
-      let(:file_without_metadata_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file_without_metadata.low.webm').to_s }
-      let(:create_without_metadata_job) { ActiveEncode::Base.create(file_without_metadata, outputs: [{ label: "low", url: file_without_metadata_derivative }]) }
-      let(:find_without_metadata_job) { ActiveEncode::Base.find create_without_metadata_job.id }
-
-      it "does not have errors" do
-        expect(find_without_metadata_job.errors).to be_empty
-      end
-
-      it "has the input technical metadata in a file" do
-        expect(File.read("#{work_dir}/#{create_without_metadata_job.id}/input_metadata")).not_to be_empty
-      end
-
-      it "assigns the correct duration to the encode" do
-        expect(create_without_metadata_job.input.duration).to eq 68_653
-        expect(find_without_metadata_job.input.duration).to eq 68_653
-      end
-
-      context 'when uri encoded' do
-        let(:file_without_metadata) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', 'file_without_metadata.webm').to_s) }
-        let(:file_without_metadata_derivative) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', 'file_without_metadata.low.webm').to_s) }
-
-        it "does not have errors" do
-          expect(find_without_metadata_job.errors).to be_empty
-        end
-
-        it "has the input technical metadata in a file" do
-          expect(File.read("#{work_dir}/#{create_without_metadata_job.id}/input_metadata")).not_to be_empty
-        end
-
-        it "assigns the correct duration to the encode" do
-          expect(create_without_metadata_job.input.duration).to eq 68_653
-          expect(find_without_metadata_job.input.duration).to eq 68_653
-        end
-      end
-    end
-
-    context "input filename with spaces" do
-      let(:file_with_space) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file with space.mp4').to_s }
-      let(:file_with_space_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file with space.low.mp4').to_s }
-      let!(:create_space_job) { ActiveEncode::Base.create(file_with_space, outputs: [{ label: "low", url: file_with_space_derivative }]) }
-      let(:find_space_job) { ActiveEncode::Base.find create_space_job.id }
-
-      it "does not have errors" do
-        expect(find_space_job.errors).to be_empty
-      end
-
-      it "has the input technical metadata in a file" do
-        expect(File.read("#{work_dir}/#{create_space_job.id}/input_metadata")).not_to be_empty
-      end
-
-      context 'when uri encoded' do
-        let(:file_with_space) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', 'file with space.mp4').to_s) }
-        let(:file_with_space_derivative) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', 'file with space.low.mp4').to_s) }
-
-        it "does not have errors" do
-          expect(find_space_job.errors).to be_empty
-        end
-
-        it "has the input technical metadata in a file" do
-          expect(File.read("#{work_dir}/#{create_space_job.id}/input_metadata")).not_to be_empty
-        end
-      end
-    end
-
-    context "input filename with single quotes" do
-      let(:file_with_single_quote) { "file://" + Rails.root.join('..', 'spec', 'fixtures', "'file_with_single_quote'.mp4").to_s }
-      let(:file_with_single_quote_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', "'file_with_single_quote'.low.mp4").to_s }
-      let!(:create_single_quote_job) { ActiveEncode::Base.create(file_with_single_quote, outputs: [{ label: "low", url: file_with_single_quote_derivative }]) }
-      let(:find_single_quote_job) { ActiveEncode::Base.find create_single_quote_job.id }
-
-      it "does not have errors" do
-        expect(find_single_quote_job.errors).to be_empty
-      end
-
-      it "has the input technical metadata in a file" do
-        expect(File.read("#{work_dir}/#{create_single_quote_job.id}/input_metadata")).not_to be_empty
-      end
-
-      context 'when uri encoded' do
-        let(:file_with_single_quote) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', "'file_with_single_quote'.mp4").to_s) }
-        let(:file_with_single_quote_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', "'file_with_single_quote'.low.mp4").to_s }
-
-        it "does not have errors" do
-          expect(find_single_quote_job.errors).to be_empty
-        end
-
-        it "has the input technical metadata in a file" do
-          expect(File.read("#{work_dir}/#{create_single_quote_job.id}/input_metadata")).not_to be_empty
-        end
-      end
-    end
-
-    context "input filename with double quotes" do
-      let(:file_with_double_quote) { "file://" + Rails.root.join('..', 'spec', 'fixtures', '"file_with_double_quote".mp4').to_s }
-      let(:file_with_double_quote_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', '"file_with_double_quote".mp4').to_s }
-      let!(:create_double_quote_job) { ActiveEncode::Base.create(file_with_double_quote, outputs: [{ label: "low", url: file_with_double_quote_derivative }]) }
-      let(:find_double_quote_job) { ActiveEncode::Base.find create_double_quote_job.id }
-
-      it "does not have errors" do
-        expect(find_double_quote_job.errors).to be_empty
-      end
-
-      it "has the input technical metadata in a file" do
-        expect(File.read("#{work_dir}/#{create_double_quote_job.id}/input_metadata")).not_to be_empty
-      end
-
-      context 'when uri encoded' do
-        let(:file_with_double_quote) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', '"file_with_double_quote".mp4').to_s) }
-        let(:file_with_double_quote_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', '"file_with_double_quote".mp4').to_s }
-
-        it "does not have errors" do
-          expect(find_double_quote_job.errors).to be_empty
-        end
-
-        it "has the input technical metadata in a file" do
-          expect(File.read("#{work_dir}/#{create_double_quote_job.id}/input_metadata")).not_to be_empty
-        end
-      end
-    end
-
-    context "input filename with other special characters" do
-      let(:file_with_special_characters) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file.with :=+%sp3c!l-ch4cts().mp4').to_s }
-      let(:file_with_special_characters_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file.with :=+%sp3c!l-ch4cts().mp4').to_s }
-      let!(:create_special_characters_job) { ActiveEncode::Base.create(file_with_special_characters, outputs: [{ label: "low", url: file_with_special_characters_derivative }]) }
-      let(:find_special_characters_job) { ActiveEncode::Base.find create_special_characters_job.id }
-      let(:file_with_more_special_characters) { "file://" + Rails.root.join('..', 'spec', 'fixtures', '@ወዳጅህ ማር ቢ. ሆን ጨርስ. ህ አትላሰ!@#$^^&$%&.mov').to_s }
-      let(:file_with_more_special_characters_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', '@ወዳጅህ ማር ቢ. ሆን ጨርስ. ህ አትላሰ!@#$^^&$%&.mov').to_s }
-      let!(:create_more_special_characters_job) { ActiveEncode::Base.create(file_with_more_special_characters, outputs: [{ label: "low", url: file_with_more_special_characters_derivative }]) }
-      let(:find_more_special_characters_job) { ActiveEncode::Base.find create_more_special_characters_job.id }
-
-      it "does not have errors" do
-        expect(find_special_characters_job.errors).to be_empty
-        expect(find_more_special_characters_job.errors).to be_empty
-      end
-
-      it "has the input technical metadata in a file" do
-        expect(File.read("#{work_dir}/#{create_special_characters_job.id}/input_metadata")).not_to be_empty
-        expect(File.read("#{work_dir}/#{create_more_special_characters_job.id}/input_metadata")).not_to be_empty
-      end
-
-      context 'when uri encoded' do
-        let(:file_with_special_characters) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', 'file.with :=+%sp3c!l-ch4cts().mp4').to_s) }
-        let(:file_with_special_characters_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file.with :=+%sp3c!l-ch4cts().mp4').to_s }
-        let(:file_with_more_special_characters) { Addressable::URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', '@ወዳጅህ ማር ቢ. ሆን ጨርስ. ህ አትላሰ!@#$^^&$%&.mov').to_s) }
-        let(:file_with_more_special_characters_derivative) { "file://" + Rails.root.join('..', 'spec', 'fixtures', '@ወዳጅህ ማር ቢ. ሆን ጨርስ. ህ አትላሰ!@#$^^&$%&.mov').to_s }
-
-        it "does not have errors" do
-          expect(find_special_characters_job.errors).to be_empty
-          expect(find_more_special_characters_job.errors).to be_empty
-        end
-
-        it "has the input technical metadata in a file" do
-          expect(File.read("#{work_dir}/#{create_special_characters_job.id}/input_metadata")).not_to be_empty
-          expect(File.read("#{work_dir}/#{create_more_special_characters_job.id}/input_metadata")).not_to be_empty
-        end
-      end
-    end
-
-    context 'when failed' do
-      subject { created_job }
-
-      before do
-        allow_any_instance_of(Object).to receive(:`).and_raise Errno::ENOENT
-      end
-
-      it { is_expected.to be_failed }
-      it { expect(subject.errors).to be_present }
-    end
-  end
-end