active_encode 0.4.1 → 0.8.0

data/spec/fixtures/pass_through/running-id/input_metadata

@@ -0,0 +1,90 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<MediaInfo
+    xmlns="https://mediaarea.net/mediainfo"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="https://mediaarea.net/mediainfo https://mediaarea.net/mediainfo/mediainfo_2_0.xsd"
+    version="2.0">
+<creatingLibrary version="18.05" url="https://mediaarea.net/MediaInfo">MediaInfoLib</creatingLibrary>
+<media ref="file:///Bars_512kb.mp4">
+<track type="General">
+<VideoCount>1</VideoCount>
+<AudioCount>1</AudioCount>
+<FileExtension>mp4</FileExtension>
+<Format>MPEG-4</Format>
+<Format_Profile>Base Media</Format_Profile>
+<CodecID>isom</CodecID>
+<FileSize>24876</FileSize>
+<Duration>4.928</Duration>
+<OverallBitRate_Mode>VBR</OverallBitRate_Mode>
+<OverallBitRate>40383</OverallBitRate>
+<FrameRate>1.000</FrameRate>
+<FrameCount>1</FrameCount>
+<StreamSize>3216</StreamSize>
+<HeaderSize>3208</HeaderSize>
+<DataSize>21668</DataSize>
+<FooterSize>0</FooterSize>
+<IsStreamable>Yes</IsStreamable>
+<Title>Bars - http://www.archive.org/details/ColorBarsWTone</Title>
+<Movie>Bars - http://www.archive.org/details/ColorBarsWTone</Movie>
+<Recorded_Date>2008</Recorded_Date>
+<Encoded_Date>UTC 1970-01-01 00:00:00</Encoded_Date>
+<Tagged_Date>UTC 2008-11-23 18:44:25</Tagged_Date>
+<Encoded_Application>Lavf51.10.0</Encoded_Application>
+<Comment>license:  http://creativecommons.org/licenses/publicdomain/</Comment>
+</track>
+<track type="Video">
+<StreamOrder>0</StreamOrder>
+<ID>1</ID>
+<Format>AVC</Format>
+<Format_Profile>Baseline</Format_Profile>
+<Format_Level>1.3</Format_Level>
+<Format_Settings_CABAC>No</Format_Settings_CABAC>
+<Format_Settings_RefFrames>1</Format_Settings_RefFrames>
+<CodecID>avc1</CodecID>
+<Duration>1.000</Duration>
+<BitRate>18504</BitRate>
+<Width>360</Width>
+<Height>240</Height>
+<Stored_Width>368</Stored_Width>
+<Sampled_Width>360</Sampled_Width>
+<Sampled_Height>240</Sampled_Height>
+<PixelAspectRatio>1.000</PixelAspectRatio>
+<DisplayAspectRatio>1.500</DisplayAspectRatio>
+<Rotation>0.000</Rotation>
+<FrameRate_Mode>CFR</FrameRate_Mode>
+<FrameRate>1.000</FrameRate>
+<FrameRate_Original>0.200</FrameRate_Original>
+<FrameCount>1</FrameCount>
+<ColorSpace>YUV</ColorSpace>
+<ChromaSubsampling>4:2:0</ChromaSubsampling>
+<BitDepth>8</BitDepth>
+<ScanType>Progressive</ScanType>
+<StreamSize>2313</StreamSize>
+<Encoded_Date>UTC 1970-01-01 00:00:00</Encoded_Date>
+<Tagged_Date>UTC 1970-01-01 00:00:00</Tagged_Date>
+</track>
+<track type="Audio">
+<StreamOrder>1</StreamOrder>
+<ID>2</ID>
+<Format>AAC</Format>
+<Format_Profile>LC</Format_Profile>
+<CodecID>mp4a-40-2</CodecID>
+<Duration>4.928</Duration>
+<BitRate_Mode>VBR</BitRate_Mode>
+<BitRate>31407</BitRate>
+<Channels>2</Channels>
+<ChannelPositions>Front: L R</ChannelPositions>
+<ChannelLayout>L R</ChannelLayout>
+<SamplesPerFrame>1024</SamplesPerFrame>
+<SamplingRate>48000</SamplingRate>
+<SamplingCount>236544</SamplingCount>
+<FrameRate>46.875</FrameRate>
+<FrameCount>231</FrameCount>
+<Compression_Mode>Lossy</Compression_Mode>
+<StreamSize>19347</StreamSize>
+<StreamSize_Proportion>0.77774</StreamSize_Proportion>
+<Encoded_Date>UTC 1970-01-01 00:00:00</Encoded_Date>
+<Tagged_Date>UTC 1970-01-01 00:00:00</Tagged_Date>
+</track>
+</media>
+</MediaInfo>

data/spec/integration/elastic_transcoder_adapter_spec.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require 'spec_helper'
-require 'aws-sdk'
+require 'aws-sdk-elastictranscoder'
 require 'json'
-require 'shared_specs/engine_adapter_specs'
+require 'active_encode/spec/shared_specs'
 
 describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
-  around(:example) do |example|
+  around do |example|
     # Setting this before each test works around a stubbing + memoization limitation
     ActiveEncode::Base.engine_adapter = :elastic_transcoder
     example.run
@@ -12,33 +13,37 @@ describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
   end
 
   let(:client) { Aws::ElasticTranscoder::Client.new(stub_responses: true) }
+  let(:s3client) { Aws::S3::Client.new(stub_responses: true) }
 
   before do
     allow(Aws::ElasticTranscoder::Client).to receive(:new).and_return(client)
+    allow(Aws::S3::Client).to receive(:new).and_return(s3client)
   end
 
   let(:created_job) do
     j = Aws::ElasticTranscoder::Types::Job.new JSON.parse(File.read('spec/fixtures/elastic_transcoder/job_created.json'))
     j.input = Aws::ElasticTranscoder::Types::JobInput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/input_generic.json')))
-    j.outputs = [ Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_submitted.json')))]
+    j.outputs = [Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_submitted.json')))]
 
     client.stub_responses(:create_job, Aws::ElasticTranscoder::Types::ReadJobResponse.new(job: j))
 
     ActiveEncode::Base.create(
-     "somefile.mp4",
-     pipeline_id: "1471963629141-kmcocm",
-       output_key_prefix: "elastic-transcoder-samples/output/hls/",
-       outputs: [{
-         key: 'hls0400k/' + "e8fe80f5b7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a",
-         preset_id: "1351620000001-200050",
-         segment_duration: "2"
-       }])
+      "spec/fixtures/fireworks.mp4",
+      pipeline_id: "1471963629141-kmcocm",
+      masterfile_bucket: "BucketName",
+      output_key_prefix: "elastic-transcoder-samples/output/hls/",
+      outputs: [{
+        key: 'hls0400k/' + "e8fe80f5bsomefilesource_bucket7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a",
+        preset_id: "1351620000001-200050",
+        segment_duration: "2"
+      }]
+    )
   end
 
   let(:running_job) do
     j = Aws::ElasticTranscoder::Types::Job.new JSON.parse(File.read('spec/fixtures/elastic_transcoder/job_progressing.json'))
     j.input = Aws::ElasticTranscoder::Types::JobInput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/input_progressing.json')))
-    j.outputs = [ Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_progressing.json')))]
+    j.outputs = [Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_progressing.json')))]
 
     client.stub_responses(:read_job, Aws::ElasticTranscoder::Types::ReadJobResponse.new(job: j))
     ActiveEncode::Base.find('running-id')
@@ -47,7 +52,7 @@ describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
   let(:canceled_job) do
     j = Aws::ElasticTranscoder::Types::Job.new JSON.parse(File.read('spec/fixtures/elastic_transcoder/job_canceled.json'))
     j.input = Aws::ElasticTranscoder::Types::JobInput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/input_generic.json')))
-    j.outputs = [ Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_canceled.json')))]
+    j.outputs = [Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_canceled.json')))]
 
     client.stub_responses(:read_job, Aws::ElasticTranscoder::Types::ReadJobResponse.new(job: j))
 
@@ -57,11 +62,11 @@ describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
   let(:cancelling_job) do
     j1 = Aws::ElasticTranscoder::Types::Job.new JSON.parse(File.read('spec/fixtures/elastic_transcoder/job_progressing.json'))
     j1.input = Aws::ElasticTranscoder::Types::JobInput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/input_progressing.json')))
-    j1.outputs = [ Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_progressing.json')))]
+    j1.outputs = [Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_progressing.json')))]
 
     j2 = Aws::ElasticTranscoder::Types::Job.new JSON.parse(File.read('spec/fixtures/elastic_transcoder/job_canceled.json'))
     j2.input = Aws::ElasticTranscoder::Types::JobInput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/input_generic.json')))
-    j2.outputs = [ Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_canceled.json')))]
+    j2.outputs = [Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_canceled.json')))]
 
     client.stub_responses(:read_job, [Aws::ElasticTranscoder::Types::ReadJobResponse.new(job: j1), Aws::ElasticTranscoder::Types::ReadJobResponse.new(job: j2)])
 
@@ -75,7 +80,7 @@ describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
   let(:completed_job) do
     j = Aws::ElasticTranscoder::Types::Job.new JSON.parse(File.read('spec/fixtures/elastic_transcoder/job_completed.json'))
     j.input = Aws::ElasticTranscoder::Types::JobInput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/input_completed.json')))
-    j.outputs = [ Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_completed.json')))]
+    j.outputs = [Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_completed.json')))]
 
     client.stub_responses(:read_job, Aws::ElasticTranscoder::Types::ReadJobResponse.new(job: j))
     ActiveEncode::Base.find('completed-id')
@@ -84,29 +89,28 @@ describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
   let(:failed_job) do
     j = Aws::ElasticTranscoder::Types::Job.new JSON.parse(File.read('spec/fixtures/elastic_transcoder/job_failed.json'))
     j.input = Aws::ElasticTranscoder::Types::JobInput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/input_generic.json')))
-    j.outputs = [ Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_failed.json')))]
+    j.outputs = [Aws::ElasticTranscoder::Types::JobOutput.new(JSON.parse(File.read('spec/fixtures/elastic_transcoder/output_failed.json')))]
 
     client.stub_responses(:read_job, Aws::ElasticTranscoder::Types::ReadJobResponse.new(job: j))
     ActiveEncode::Base.find('failed-id')
   end
 
-  let(:completed_output) { [{ id: "2", url: "elastic-transcoder-samples/output/hls/hls0400k/e8fe80f5b7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a", label: "hls0400k", :width=>400, :height=>224, :frame_rate=>25, :file_size=>6901104, :duration=>117353 }] }
-  let(:completed_tech_metadata) { { :width=>1280, :height=>720, :frame_rate=>25, :file_size=>21069678, :duration=>117312 } }
+  let(:completed_output) { [{ id: "2", url: "s3://BucketName/elastic-transcoder-samples/output/hls/hls0400k/e8fe80f5b7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a", label: "hls0400k", width: 400, height: 224, frame_rate: 25, file_size: 6_901_104, duration: 117_353 }] }
+  let(:completed_tech_metadata) { { width: 1280, height: 720, frame_rate: 25, file_size: 21_069_678, duration: 117_312 } }
   let(:failed_tech_metadata) { {} }
 
   it_behaves_like "an ActiveEncode::EngineAdapter"
 
   describe "#create" do
-    let(:create_output) { [{ id: "2", url: "elastic-transcoder-samples/output/hls/hls0400k/e8fe80f5b7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a", label: "hls0400k" }] }
-
     subject { created_job }
+    let(:create_output) { [{ id: "2", url: "s3://BucketName/elastic-transcoder-samples/output/hls/hls0400k/e8fe80f5b7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a", label: "hls0400k" }] }
 
     it { is_expected.to be_running }
-    its(:current_operations) { is_expected.to be_empty }
+    it { expect(subject.current_operations).to be_empty }
 
     it 'output has technical metadata' do
       subject.output.each do |output|
-        expected_output = create_output.find {|expected_out| expected_out[:id] == output.id }
+        expected_output = create_output.find { |expected_out| expected_out[:id] == output.id }
         expect(output.as_json.symbolize_keys).to include expected_output
       end
     end
@@ -114,12 +118,11 @@ describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
 
   describe "#find" do
     context "a running encode" do
-      let(:running_output) { [{ id: "2", url: "elastic-transcoder-samples/output/hls/hls0400k/e8fe80f5b7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a", label: "hls0400k" }] }
-      let(:running_tech_metadata) { {:width=>1280, :height=>720, :frame_rate=>25, :file_size=>21069678, :duration=>117312} }
-
       subject { running_job }
+      let(:running_output) { [{ id: "2", url: "s3://BucketName/elastic-transcoder-samples/output/hls/hls0400k/e8fe80f5b7063b12d567b90c0bdf6322116bba11ac458fe9d62921644159fe4a", label: "hls0400k" }] }
+      let(:running_tech_metadata) { { width: 1280, height: 720, frame_rate: 25, file_size: 21_069_678, duration: 117_312 } }
 
-      its(:current_operations) { is_expected.to be_empty }
+      it { expect(subject.current_operations).to be_empty }
 
       it 'input has technical metadata' do
         expect(subject.input.as_json.symbolize_keys).to include running_tech_metadata
@@ -127,10 +130,41 @@ describe ActiveEncode::EngineAdapters::ElasticTranscoderAdapter do
 
       it 'output has technical metadata' do
         subject.output.each do |output|
-          expected_output = running_output.find {|expected_out| expected_out[:id] == output.id }
+          expected_output = running_output.find { |expected_out| expected_out[:id] == output.id }
           expect(output.as_json.symbolize_keys).to include expected_output
         end
       end
     end
   end
+
+  describe "#check_s3_bucket" do
+    context "when file exists in masterfile_bucket" do
+      let(:input_url) { "s3://bucket1/file.mp4" }
+      let(:source_bucket) { "bucket1" }
+
+      it "just returns the key" do
+        # TODO: move these bucket helpers out to a service class so we don't have to test private methods
+        expect(described_class.new.send(:check_s3_bucket, input_url, source_bucket)).to eq "file.mp4"
+      end
+    end
+
+    context "when file is in another bucket" do
+      let(:input_url) { "s3://bucket1/file.mp4" }
+      let(:source_bucket) { "bucket2" }
+
+      it "copies to masterfile_bucket" do
+        # TODO: move these bucket helpers out to a service class so we don't have to test private methods
+        allow(SecureRandom).to receive(:uuid).and_return("randomstring")
+        expect(described_class.new.send(:check_s3_bucket, input_url, source_bucket)).to eq "randomstring/file.mp4"
+      end
+    end
+  end
+
+  describe "#output_percentage" do
+    let(:output) { double(ActiveEncode::Output, status: "Random status") }
+
+    it "returns 0 for any other status" do
+      expect(described_class.new.send(:output_percentage, output)).to eq 0
+    end
+  end
 end

data/spec/integration/ffmpeg_adapter_spec.rb

@@ -1,22 +1,27 @@
-require 'spec_helper'
-require 'shared_specs/engine_adapter_specs'
+# frozen_string_literal: true
+require 'rails_helper'
+require 'active_encode/spec/shared_specs'
 
 describe ActiveEncode::EngineAdapters::FfmpegAdapter do
-  around(:example) do |example|
+  around do |example|
     ActiveEncode::Base.engine_adapter = :ffmpeg
 
     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::FfmpegAdapter::WORK_DIR", @dir }
-  let(:file) { "file://#{File.absolute_path "spec/fixtures/fireworks.mp4"}" }
+  let(:file) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'fireworks.mp4').to_s }
   let(:created_job) do
-    ActiveEncode::Base.create(file, { outputs: [{ label: "low", ffmpeg_opt: "-s 640x480", extension: "mp4"}, { label: "high", ffmpeg_opt: "-s 1280x720", extension: "mp4"}] })
+    ActiveEncode::Base.create(file, outputs: [{ label: "low", ffmpeg_opt: "-s 640x480", extension: "mp4" }, { label: "high", ffmpeg_opt: "-s 1280x720", extension: "mp4" }])
   end
   let(:running_job) do
     allow(Process).to receive(:getpgid).and_return 8888
@@ -27,28 +32,33 @@ describe ActiveEncode::EngineAdapters::FfmpegAdapter do
   end
   let(:cancelling_job) do
     allow(Process).to receive(:kill).and_return(nil)
-    find_encode 'running-id'
+    encode = find_encode 'running-id'
+    File.write "#{work_dir}/running-id/cancelled", ""
+    encode
   end
   let(:completed_job) { find_encode "completed-id" }
   let(:failed_job) { find_encode 'failed-id' }
-  let(:completed_tech_metadata) { {:audio_bitrate => 171030,
-    :audio_codec => 'mp4a-40-2',
-    :duration => 6.315,
-    :file_size => 199160,
-    :frame_rate => 23.719,
-    :height => 110.0,
-    :id => "99999",
-    :url => "/home/pdinh/Downloads/videoshort.mp4",
-    :video_bitrate => 74477,
-    :video_codec => 'avc1',
-    :width => 200.0
-  } }
+  let(:completed_tech_metadata) do
+    {
+      audio_bitrate: 171_030,
+      audio_codec: 'mp4a-40-2',
+      duration: 6315,
+      file_size: 199_160,
+      frame_rate: 23.719,
+      height: 110.0,
+      id: "99999",
+      url: "/home/pdinh/Downloads/videoshort.mp4",
+      video_bitrate: 74_477,
+      video_codec: 'avc1',
+      width: 200.0
+    }
+  end
   let(:completed_output) { [{ id: "99999" }] }
-  let(:failed_tech_metadata) { { } }
+  let(:failed_tech_metadata) { {} }
 
   it_behaves_like "an ActiveEncode::EngineAdapter"
 
-  def find_encode id
+  def find_encode(id)
     # Precreate ffmpeg output directory and files
     FileUtils.copy_entry "spec/fixtures/ffmpeg/#{id}", "#{work_dir}/#{id}"
 
@@ -57,7 +67,7 @@ describe ActiveEncode::EngineAdapters::FfmpegAdapter do
     FileUtils.touch "#{work_dir}/#{id}/progress"
     FileUtils.touch Dir.glob("#{work_dir}/#{id}/*.mp4")
 
-    # # Stub out system calls
+    # Stub out system calls
     allow_any_instance_of(ActiveEncode::EngineAdapters::FfmpegAdapter).to receive(:`).and_return(1234)
 
     ActiveEncode::Base.find(id)
@@ -82,7 +92,7 @@ describe ActiveEncode::EngineAdapters::FfmpegAdapter do
 
     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", ffmpeg_opt: "-s 640x480", extension: 'mp4' }]}) }
+      let(:missing_job) { ActiveEncode::Base.create(missing_file, outputs: [{ label: "low", ffmpeg_opt: "-s 640x480", extension: 'mp4' }]) }
 
       it "returns the encode with correct error" do
         expect(missing_job.errors).to include("#{missing_file} does not exist or is not accessible")
@@ -91,14 +101,61 @@ describe ActiveEncode::EngineAdapters::FfmpegAdapter do
     end
 
     context "input file is not media" do
-      let(:nonmedia_file) { "file://#{File.absolute_path "spec/integration/ffmpeg_adapter_spec.rb"}" }
-      let(:nonmedia_job) { ActiveEncode::Base.create(nonmedia_file, { outputs: [{ label: "low", ffmpeg_opt: "-s 640x480", extension: 'mp4' }]}) }
+      let(:nonmedia_file) { "file://" + Rails.root.join('Gemfile').to_s }
+      let(:nonmedia_job) { ActiveEncode::Base.create(nonmedia_file, outputs: [{ label: "low", ffmpeg_opt: "-s 640x480", extension: 'mp4' }]) }
 
       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 filename with spaces" do
+      let(:file_with_space) { "file://" + Rails.root.join('..', 'spec', 'fixtures', 'file with space.mp4').to_s }
+      let!(:create_space_job) { ActiveEncode::Base.create(file_with_space, outputs: [{ label: "low", ffmpeg_opt: "-s 640x480", extension: 'mp4' }]) }
+      let(:find_space_job) { ActiveEncode::Base.find create_space_job.id }
+
+      it "does not have errors" do
+        sleep 2
+        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
+
+      it "has the pid in a file" do
+        expect(File.read("#{work_dir}/#{create_space_job.id}/pid")).not_to be_empty
+      end
+
+      context 'when uri encoded' do
+        let(:file_with_space) { URI.encode("file://" + Rails.root.join('..', 'spec', 'fixtures', 'file with space.mp4').to_s) }
+
+        it "does not have errors" do
+          sleep 2
+          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
+
+        it "has the pid in a file" do
+          expect(File.read("#{work_dir}/#{create_space_job.id}/pid")).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
 
   describe "#find" do
@@ -116,5 +173,20 @@ describe ActiveEncode::EngineAdapters::FfmpegAdapter do
       expect(Process).to receive(:kill).with('SIGTERM', running_job.input.id.to_i)
       running_job.cancel!
     end
+
+    it "does not attempt to stop a non-running encode" do
+      expect(Process).not_to receive(:kill).with('SIGTERM', completed_job.input.id.to_i)
+      completed_job.cancel!
+    end
+
+    it "raises an error if the process can not be found" do
+      expect(Process).to receive(:kill).with('SIGTERM', running_job.input.id.to_i).and_raise(Errno::ESRCH)
+      expect { running_job.cancel! }.to raise_error(ActiveEncode::NotRunningError)
+    end
+
+    it "raises an error" do
+      expect(Process).to receive(:kill).with('SIGTERM', running_job.input.id.to_i).and_raise(Errno::EPERM)
+      expect { running_job.cancel! }.to raise_error(ActiveEncode::CancelError)
+    end
   end
 end