vzaar_api 2.0.0

data/spec/vzaar_api/encoding_preset_spec.rb

@@ -0,0 +1,92 @@
+module VzaarApi
+  describe EncodingPreset do
+
+    before do
+      setup_auth!
+    end
+
+    describe '.find' do
+      context 'when the encoding preset can be found' do
+        it 'finds the encoding preset' do
+          VCR.use_cassette('encoding_presets/find') do
+            preset = described_class.find(4)
+            expect(preset.id).to eq 4
+            expect(preset.name).to eq "LD"
+            expect(preset.description).to eq "270p"
+            expect(preset.output_format).to eq "mp4"
+            expect(preset.bitrate_kbps).to eq 365
+            expect(preset.max_bitrate_kbps).to eq 500
+            expect(preset.long_dimension).to eq 480
+            expect(preset.video_codec).to eq "libx264"
+            expect(preset.profile).to eq "baseline"
+            expect(preset.frame_rate_upper_threshold).to eq "29.97"
+            expect(preset.keyframe_upper_threshold).to eq 60
+            expect(preset.audio_bitrate_kbps).to eq 128
+            expect(preset.audio_channels).to eq 2
+            expect(preset.audio_sample_rate).to eq 44100
+            expect(preset.created_at).to eq "2016-10-24T12:36:47.000Z"
+            expect(preset.updated_at).to eq "2016-10-24T12:36:47.000Z"
+          end
+        end
+      end
+
+      context 'when the encoding preset cannot be found' do
+        it 'raises an error' do
+          VCR.use_cassette('encoding_presets/find_404') do
+            expect { described_class.find(-1) }.
+              to raise_error(Error, 'Not found: Resource cannot be found')
+          end
+        end
+      end
+    end
+
+    describe '.each_item' do
+      it 'loads the category collection' do
+        VCR.use_cassette('encoding_presets/each_item') do
+          enum = described_class.each_item(per_page: 2)
+          ids = enum.map { |preset| preset.id }
+          expect(ids).to match_array [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+        end
+      end
+    end
+
+    describe '.paginate' do
+      it 'loads the preset collection' do
+        VCR.use_cassette('encoding_presets/paginate_first') do
+          pager = described_class.paginate(per_page: 1)
+          pager.first
+          ids = pager.collection.map { |preset| preset.id }
+          expect(ids).to match_array [9]
+        end
+      end
+
+      it 'loads the preset collection' do
+        VCR.use_cassette('encoding_presets/paginate_next') do
+          pager = described_class.paginate(per_page: 1)
+          pager.next
+          ids = pager.collection.map { |preset| preset.id }
+          expect(ids).to match_array [2]
+        end
+      end
+
+      it 'loads the preset collection' do
+        VCR.use_cassette('encoding_presets/paginate_last') do
+          pager = described_class.paginate(per_page: 1)
+          pager.last
+          ids = pager.collection.map { |preset| preset.id }
+          expect(ids).to match_array [11]
+        end
+      end
+
+      it 'loads the preset collection' do
+        VCR.use_cassette('encoding_presets/paginate_previous') do
+          pager = described_class.paginate(page: 4, per_page: 1)
+          pager.previous
+          ids = pager.collection.map { |preset| preset.id }
+          expect(ids).to match_array [3]
+        end
+      end
+    end
+
+  end
+end

data/spec/vzaar_api/ingest_recipe_spec.rb

@@ -0,0 +1,197 @@
+module VzaarApi
+  describe IngestRecipe do
+
+    before do
+      setup_auth!
+    end
+
+    describe '.find' do
+      context 'when the recipe can be found' do
+        it 'finds the recipe' do
+          VCR.use_cassette('ingest_recipes/find') do
+            recipe = described_class.find(1)
+            expect(recipe.id).to eq 1
+            expect(recipe.name).to eq "new-video"
+            expect(recipe.recipe_type).to eq "new_video"
+            expect(recipe.description).to be_nil
+            expect(recipe.account_id).to eq 79357
+            expect(recipe.user_id).to eq 79357
+            expect(recipe.default).to eq true
+            expect(recipe.multipass).to eq false
+            expect(recipe.frame_grab_time).to eq "3.5"
+            expect(recipe.generate_animated_thumb).to eq true
+            expect(recipe.generate_sprite).to eq true
+            expect(recipe.use_watermark).to eq true
+            expect(recipe.send_to_youtube).to eq false
+            expect(recipe.encoding_presets.count).to eq 5
+            expect(recipe.created_at).to eq '2016-11-09T11:01:38.000Z'
+            expect(recipe.updated_at).to eq '2016-11-09T11:01:38.000Z'
+          end
+        end
+      end
+
+      context 'when the recipe cannot be found' do
+        it 'raises an error' do
+          VCR.use_cassette('ingest_recipes/find_404') do
+            expect { described_class.find(-1) }.
+              to raise_error(Error, 'Not found: Resource cannot be found')
+          end
+        end
+      end
+    end
+
+    describe '.create' do
+      context 'when recipe is created successfully' do
+        let(:attrs) do
+          {
+            name: 'new-recipe',
+            description: 'the new recipe',
+            default: true,
+            frame_grab_time: 5.5,
+            multipass: false,
+            generate_animated_thumb: true,
+            generate_sprite: true,
+            use_watermark: true,
+            send_to_youtube: true,
+            encoding_preset_ids: [1,2,3,4]
+          }
+        end
+
+        it 'returns the ingest recipe object' do
+          VCR.use_cassette('ingest_recipes/create_200') do
+            recipe = described_class.create(attrs)
+            expect(recipe.id).to eq 8
+            expect(recipe.name).to eq "new-recipe"
+            expect(recipe.recipe_type).to eq "new_video"
+            expect(recipe.description).to eq 'the new recipe'
+            expect(recipe.account_id).to eq 79357
+            expect(recipe.user_id).to eq 79357
+            expect(recipe.default).to eq true
+            expect(recipe.multipass).to eq false
+            expect(recipe.frame_grab_time).to eq '5.5'
+            expect(recipe.generate_animated_thumb).to eq true
+            expect(recipe.generate_sprite).to eq true
+            expect(recipe.use_watermark).to eq true
+            expect(recipe.send_to_youtube).to eq true
+            expect(recipe.encoding_presets.count).to eq 4
+            expect(recipe.created_at).to eq '2016-11-18T10:25:47.996Z'
+            expect(recipe.updated_at).to eq '2016-11-18T10:25:47.996Z'
+          end
+        end
+      end
+
+      context 'when an error is returned' do
+        let(:attrs) { { junk: 'yard' } }
+        it 'raises the error returned form the API' do
+          VCR.use_cassette('ingest_recipes/create_422') do
+            expect { described_class.create(attrs) }.
+              to raise_error(Error, 'Invalid parameters: name is missing, ' \
+                'encoding_preset_ids is missing, encoding_preset_ids is invalid')
+          end
+        end
+      end
+    end
+
+    describe '#save' do
+      context 'when recipe is updated successfully' do
+        it 'returns the ingest recipe object' do
+          VCR.use_cassette('ingest_recipes/update_200') do
+            recipe = described_class.find(8)
+            recipe.encoding_presets = nil
+            recipe.encoding_presets << EncodingPreset.find(1)
+            recipe.encoding_presets << EncodingPreset.find(2)
+            recipe.name = 'updated'
+            expect(recipe.save).to eq true
+            expect(recipe.name).to eq 'updated'
+            expect(recipe.encoding_presets.count).to eq 2
+            expect(recipe.created_at).to eq '2016-11-18T10:25:47.000Z'
+            expect(recipe.updated_at).to eq '2016-11-18T11:20:06.000Z'
+          end
+        end
+      end
+
+      context 'when an error is returned' do
+        it 'raises the error returned form the API' do
+          VCR.use_cassette('ingest_recipes/update_422') do
+            recipe = described_class.find(8)
+            recipe.encoding_presets = nil
+            expect { recipe.save }.to raise_error(
+              Error, 'Invalid parameters: encoding_preset_ids is invalid')
+          end
+        end
+      end
+    end
+
+    describe '#delete' do
+      context 'when recipe is deleted successfully' do
+        it 'returns true' do
+          VCR.use_cassette('ingest_recipes/delete_204') do
+            recipe = described_class.find(7)
+            expect(recipe.delete).to eq true
+            expect { described_class.find(7) }.
+              to raise_error(Error, 'Not found: Resource cannot be found')
+          end
+        end
+      end
+
+      context 'when an error is returned' do
+        it 'raises the error returned form the API' do
+          VCR.use_cassette('ingest_recipes/delete_422') do
+            recipe = described_class.find(8)
+            expect { recipe.delete }.to raise_error(
+              Error, 'Invalid parameters: You cannot delete your default ingest recipe')
+          end
+        end
+      end
+    end
+
+    describe '.each_item' do
+      it 'loads the category collection' do
+        VCR.use_cassette('ingest_recipes/each_item') do
+          enum = described_class.each_item(per_page: 2)
+          ids = enum.map { |recipe| recipe.id }
+          expect(ids).to match_array [1, 2, 3, 5, 8]
+        end
+      end
+    end
+
+    describe '.paginate' do
+      it 'loads the recipe collection' do
+        VCR.use_cassette('ingest_recipes/paginate_first') do
+          pager = described_class.paginate(per_page: 1)
+          pager.first
+          ids = pager.collection.map { |recipe| recipe.id }
+          expect(ids).to match_array [1]
+        end
+      end
+
+      it 'loads the recipe collection' do
+        VCR.use_cassette('ingest_recipes/paginate_next') do
+          pager = described_class.paginate(per_page: 1)
+          pager.next
+          ids = pager.collection.map { |recipe| recipe.id }
+          expect(ids).to match_array [2]
+        end
+      end
+
+      it 'loads the recipe collection' do
+        VCR.use_cassette('ingest_recipes/paginate_last') do
+          pager = described_class.paginate(per_page: 1)
+          pager.last
+          ids = pager.collection.map { |recipe| recipe.id }
+          expect(ids).to match_array [7]
+        end
+      end
+
+      it 'loads the recipe collection' do
+        VCR.use_cassette('ingest_recipes/paginate_previous') do
+          pager = described_class.paginate(page: 4, per_page: 1)
+          pager.previous
+          ids = pager.collection.map { |recipe| recipe.id }
+          expect(ids).to match_array [3]
+        end
+      end
+    end
+
+  end
+end

data/spec/vzaar_api/lib/api_spec.rb

@@ -0,0 +1,28 @@
+module VzaarApi
+  module Lib
+    describe Api do
+
+      before do
+        VzaarApi.auth_token = auth_token
+        VzaarApi.client_id = client_id
+        VzaarApi.hostname = hostname
+      end
+
+      let(:auth_token) { 'auth-token' }
+      let(:client_id) { 'client-id' }
+      let(:hostname) { 'app.vzaar.localhost' }
+
+      describe '#headers' do
+        let(:expected_result) do
+          {
+            'X-Auth-Token' => auth_token,
+            'X-Client-Id'  => client_id,
+            'Content-Type' => 'application/json'
+          }
+        end
+        specify { expect(subject.headers).to eq expected_result }
+      end
+
+    end
+  end
+end

data/spec/vzaar_api/playlist_spec.rb

@@ -0,0 +1,97 @@
+module VzaarApi
+  describe Playlist do
+
+    before { setup_auth! }
+
+    describe '.find' do
+      context 'when the playlist can be found' do
+        it 'finds the playlist' do
+          VCR.use_cassette 'playlists/find' do
+            playlist = described_class.find(12692)
+            expect(playlist.id).to eq 12692
+            expect(playlist.category_id).to eq 2253
+            expect(playlist.max_vids).to eq 43
+            expect(playlist.title).to eq 'test'
+            expect(playlist.sort_by).to eq 'created_at'
+            expect(playlist.sort_order).to eq 'desc'
+            expect(playlist.private).to be_falsey
+            expect(playlist.dimensions).to eq '768x340'
+            expect(playlist.position).to eq 'right'
+            expect(playlist.autoplay).to be_truthy
+            expect(playlist.continuous_play).to be_truthy
+            expect(playlist.embed_code).to match(
+              "<iframe id=\"vzpl-12692\" name=\"vzpl-12692\" " \
+              "title=\"vzaar video player\" class=\"vzaar video player\" " \
+              "type=\"text/html\" width=\"927\" height=\"340\" frameborder=\"0\" " \
+              "allowFullScreen allowTransparency=\"true\" mozallowfullscreen " \
+              "webkitAllowFullScreen src=\"//view.vzaar.localhost/playlists/12692\">" \
+              "</iframe>"
+            )
+            expect(playlist.created_at).to eq "2017-04-21T14:16:50.000Z"
+            expect(playlist.updated_at).to eq "2017-04-21T14:16:50.000Z"
+          end
+        end
+      end
+
+      context 'when the playlist cannot be found' do
+        it 'raises an error' do
+          VCR.use_cassette('playlists/find_404') do
+            expect { described_class.find(-1) }.
+              to raise_error(Error, 'Not found: Resource cannot be found')
+          end
+        end
+      end
+    end
+
+    describe '.each_item' do
+      it 'loads the playlist collection' do
+        VCR.use_cassette('playlists/each_item') do
+          enum = described_class.each_item(per_page: 2)
+          ids = enum.map { |playlist| playlist.id }
+          expect(ids).to match_array [
+            12, 1065, 12676, 12677, 12678, 12679, 12680, 12681, 12682, 12683,
+            12684, 12685, 12686, 12687, 12688, 12689, 12691, 12692
+          ]
+        end
+      end
+    end
+
+    describe '.paginate' do
+      it 'loads the playlist collection' do
+        VCR.use_cassette('playlists/paginate_first') do
+          pager = described_class.paginate(per_page: 3)
+          pager.first
+          ids = pager.collection.map { |playlist| playlist.id }
+          expect(ids).to match_array [12, 12676, 12677]
+        end
+      end
+
+      it 'loads the playlist collection' do
+        VCR.use_cassette('playlists/paginate_next') do
+          pager = described_class.paginate(per_page: 3)
+          pager.next
+          ids = pager.collection.map { |playlist| playlist.id }
+          expect(ids).to match_array [12678, 12679, 12680]
+        end
+      end
+
+      it 'loads the playlist collection' do
+        VCR.use_cassette('playlists/paginate_last') do
+          pager = described_class.paginate(per_page: 3)
+          pager.last
+          ids = pager.collection.map { |playlist| playlist.id }
+          expect(ids).to match_array [1065, 12691, 12692]
+        end
+      end
+
+      it 'loads the playlist collection' do
+        VCR.use_cassette('playlists/paginate_previous') do
+          pager = described_class.paginate(page: 4, per_page: 3)
+          pager.previous
+          ids = pager.collection.map { |playlist| playlist.id }
+          expect(ids).to match_array [12681, 12682, 12683]
+        end
+      end
+    end
+  end
+end

data/spec/vzaar_api/rendition_spec.rb

@@ -0,0 +1,55 @@
+module VzaarApi
+  describe Rendition do
+
+    subject { described_class.new attrs }
+
+    let(:attrs) do
+      {
+        id: 'id',
+        encoding_preset_id: 'encoding_preset_id',
+        state: 'state',
+        source_as_rendition: 'source_as_rendition',
+        name: 'name',
+        output_format: 'output_format',
+        bitrate_kbps: 'bitrate_kbps',
+        width: 'width',
+        height: 'height',
+        video_codec: 'video_codec',
+        profile: 'profile',
+        frame_rate: 'frame_rate',
+        keyframe: 'keyframe',
+        audio_bitrate_kbps: 'audio_bitrate_kbps',
+        audio_channels: 'audio_channels',
+        audio_sample_rate: 'audio_sample_rate',
+        size_in_bytes: 'size_in_bytes',
+        error_message: 'error_message',
+        created_at: 'created_at',
+        updated_at: 'updated_at'
+      }
+    end
+
+    describe '#initialize' do
+      specify { expect(subject.id).to eq 'id' }
+      specify { expect(subject.encoding_preset_id).to eq 'encoding_preset_id' }
+      specify { expect(subject.state).to eq 'state' }
+      specify { expect(subject.source_as_rendition).to eq 'source_as_rendition' }
+      specify { expect(subject.name).to eq 'name' }
+      specify { expect(subject.output_format).to eq 'output_format' }
+      specify { expect(subject.bitrate_kbps).to eq 'bitrate_kbps' }
+      specify { expect(subject.width).to eq 'width' }
+      specify { expect(subject.height).to eq 'height' }
+      specify { expect(subject.video_codec).to eq 'video_codec' }
+      specify { expect(subject.profile).to eq 'profile' }
+      specify { expect(subject.frame_rate).to eq 'frame_rate' }
+      specify { expect(subject.keyframe).to eq 'keyframe' }
+      specify { expect(subject.audio_bitrate_kbps).to eq 'audio_bitrate_kbps' }
+      specify { expect(subject.audio_channels).to eq 'audio_channels' }
+      specify { expect(subject.audio_sample_rate).to eq 'audio_sample_rate' }
+      specify { expect(subject.size_in_bytes).to eq 'size_in_bytes' }
+      specify { expect(subject.error_message).to eq 'error_message' }
+      specify { expect(subject.created_at).to eq 'created_at' }
+      specify { expect(subject.updated_at).to eq 'updated_at' }
+    end
+
+  end
+end

data/spec/vzaar_api/signature/factory_spec.rb

@@ -0,0 +1,68 @@
+module VzaarApi
+  module Signature
+    describe Factory do
+
+      subject { described_class.new attrs }
+
+      let(:attrs) do
+        { path: './spec/support/files/video-5.0MB.mp4' }
+      end
+
+      describe '.create' do
+        before do
+          allow(described_class).to receive(:new).with(attrs) { instance }
+        end
+
+        let(:instance) { double create: true }
+        let(:result) { described_class.create attrs }
+        specify { expect(result).to be true }
+      end
+
+      describe '#create' do
+        before do
+          allow(subject).to receive(:multipart?) { multipart }
+          allow(Multipart).to receive(:create).with(multipart_attrs) { 'multipart' }
+          allow(Single).to receive(:create).with(multipart_attrs) { 'single' }
+        end
+
+        let(:multipart_attrs) do
+          {
+            filesize: 5242880,
+            filename: 'video-5.0MB.mp4'
+          }
+        end
+
+        context 'when multipart' do
+          let(:multipart) { true }
+          specify { expect(subject.create).to eq 'multipart' }
+        end
+
+        context 'when single' do
+          let(:multipart) { false }
+          specify { expect(subject.create).to eq 'single' }
+        end
+      end
+
+      describe '#multipart?' do
+        context 'when multipart params are provided' do
+          let(:attrs) { { path: './spec/support/files/video-5.0MB.mp4' } }
+          specify { expect(subject.multipart?).to be true }
+        end
+
+        context 'when non-multipart params are provided' do
+          let(:attrs) { { path: './spec/support/files/video-4.9MB.mp4' } }
+          specify { expect(subject.multipart?).to be false }
+        end
+
+        context 'when invalid params are provided' do
+          let(:attrs) { { path: './no/file/here.mp4' } }
+          it 'raises an error' do
+            expect { subject.multipart? }.to raise_error(
+              Error, 'Invalid parameters: path is invalid')
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/vzaar_api/signature/multipart_spec.rb

@@ -0,0 +1,81 @@
+module VzaarApi
+  module Signature
+    describe Multipart do
+
+      before do
+        setup_auth!
+      end
+
+      describe '#initialize' do
+        subject { described_class.new attrs }
+
+        let(:attrs) do
+          {
+            access_key_id: 'access_key_id',
+            acl: 'acl',
+            bucket: 'bucket',
+            content_type: 'content_type',
+            guid: 'guid',
+            key: 'key',
+            policy: 'policy',
+            signature: 'signature',
+            success_action_status: 'success_action_status',
+            upload_hostname: 'upload_hostname',
+            part_size: 'part_size',
+            part_size_in_bytes: 'part_size_in_bytes',
+            parts: 'parts'
+          }
+        end
+
+        specify { expect(subject.access_key_id).to eq 'access_key_id' }
+        specify { expect(subject.acl).to eq 'acl' }
+        specify { expect(subject.bucket).to eq 'bucket' }
+        specify { expect(subject.content_type).to eq 'content_type' }
+        specify { expect(subject.guid).to eq 'guid' }
+        specify { expect(subject.key).to eq 'key' }
+        specify { expect(subject.policy).to eq 'policy' }
+        specify { expect(subject.signature).to eq 'signature' }
+        specify { expect(subject.success_action_status).to eq 'success_action_status' }
+        specify { expect(subject.upload_hostname).to eq 'upload_hostname' }
+        specify { expect(subject.part_size).to eq 'part_size' }
+        specify { expect(subject.part_size_in_bytes).to eq 'part_size_in_bytes' }
+        specify { expect(subject.parts).to eq 'parts' }
+      end
+
+      describe '#create' do
+        context 'when successful' do
+          it 'builds a signature' do
+            VCR.use_cassette('signature/multipart_201') do
+              attrs = { filename: 'video.mp4', filesize: 25165824, uploader: UPLOADER }
+              signature = described_class.create attrs
+              expect(signature.access_key_id).to eq 'access_key_id'
+              expect(signature.acl).to eq 'private'
+              expect(signature.bucket).to eq 'vzaar-upload-development'
+              expect(signature.content_type).to eq 'binary/octet-stream'
+              expect(signature.guid).to eq 'guid'
+              expect(signature.key).to eq 'vzaar/t8d/ec9/source/t8dec9434bcc64622b68d1dc16f3ddffap/${filename}'
+              expect(signature.policy).to eq 'policy'
+              expect(signature.signature).to eq 'signature'
+              expect(signature.success_action_status).to eq '201'
+              expect(signature.upload_hostname).to eq 'https://vzaar-upload-development.s3.amazonaws.com'
+              expect(signature.part_size).to eq '5MB'
+              expect(signature.part_size_in_bytes).to eq 5242880
+              expect(signature.parts).to eq 5
+            end
+          end
+        end
+
+        context 'when unsuccessful' do
+          it 'raises an error' do
+            VCR.use_cassette('signature/multipart_422') do
+              attrs = { filename: 'video.mp4', filesize: nil, uploader: UPLOADER }
+              expect { described_class.create attrs }.
+                to raise_error(Error, 'Invalid parameters: Filesize must be between 5MB and 5TB')
+            end
+          end
+        end
+      end
+
+    end
+  end
+end