helix 0.0.2.7.pre → 0.0.2.8.pre

data/spec/image_spec.rb

@@ -5,7 +5,8 @@ describe Helix::Image do
   let(:klass) { Helix::Image }
 
   subject { klass }
-  its(:ancestors) { should include(Helix::Base) }
+  mods = [ Helix::Base, Helix::Media ]
+  mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name) { should eq('image_id') }
   its(:resource_label_sym)    { should be(:image)   }
   its(:plural_resource_label) { should eq('images') }

data/spec/library_spec.rb

@@ -3,20 +3,25 @@ require 'helix'
 
 describe Helix::Library do
 
-  let(:klass)             { Helix::Library }
-  subject                 { klass }
-  its(:guid_name)         { should eq('library_id') }
-  its(:resource_label_sym)    { should be(:library)   }
-  its(:plural_resource_label) { should eq('libraries') }
+  let(:klass) { Helix::Library }
+  subject     { klass }
+
+  mods = [ Helix::Base, Helix::RESTful ]
+  mods.each { |mod| its(:ancestors) { should include(mod) } }
+  its(:ancestors) { should_not include(Helix::Media) }
+
+  its(:guid_name)             { should eq('library_id') }
+  its(:resource_label_sym)    { should be(:library)     }
+  its(:plural_resource_label) { should eq('libraries')  }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
 
   describe ".known_attributes" do
     let(:meth)            { :known_attributes }
-    let(:expected_attrs)  { [ :player_profile, 
-                              :ingest_profile, 
-                              :secure_stream_callback_url, 
+    let(:expected_attrs)  { [ :player_profile,
+                              :ingest_profile,
+                              :secure_stream_callback_url,
                               :hooks_attributes] }
     it "should equal expected_attrs" do
       expect(klass.send(meth)).to eq(expected_attrs)
@@ -33,4 +38,4 @@ describe Helix::Library do
       it { should respond_to(crud_call) }
     end
   end
-end
+end

data/spec/media_spec.rb

@@ -7,6 +7,9 @@ describe Helix::Media do
 
   subject { klass }
 
+  mods = [ Helix::RESTful, Helix::Uploadable ]
+  mods.each { |mod| its(:ancestors) { should include(mod) } }
+
   describe ".create" do
     let(:meth)        { :create }
     let(:mock_config) { mock(Helix::Config) }
@@ -17,29 +20,37 @@ describe Helix::Media do
     let(:resp_json)   { "JSON" }
     let(:params)      { { signature: "some_sig" } }
     let(:expected)    { { attributes: { attribute: :value }, config: mock_config } }
-    before(:each) do
-      klass.stub(:plural_resource_label) { :klasses }
-      klass.stub(:resource_label_sym)    { klass_sym }
-      mock_config.stub(:build_url).with(action: :create_many, resource_label: :klasses) { :url }
-      mock_config.stub(:signature).with(:update) { "some_sig" }
-      Helix::Config.stub(:instance) { mock_config }
-    end
-    it "should get an ingest signature" do
-      mock_config.should_receive(:build_url).with(resource_label: :klasses,
-                                                  content_type:   :xml)
-      RestClient.stub(:post).with(:url, params) { resp_json }
-      Hash.should_receive(:from_xml).with(resp_json) { resp_value }
-      klass.stub(:new).with(expected)
-      mock_config.should_receive(:signature).with(:update) { "some_sig" }
-      klass.send(meth)
+    context "when a Helix:Config instance is absent" do
+      before(:each) do Helix::Config.stub(:instance) { nil } end
+      it "should raise a NoConfigurationLoaded exception" do
+        lambda { klass.send(meth) }.should raise_error(Helix::NoConfigurationLoaded)
+      end
     end
-    it "should do an HTTP post call, parse response and call new" do
-      mock_config.should_receive(:build_url).with(resource_label: :klasses,
-                                                  content_type:   :xml)
-      RestClient.should_receive(:post).with(:url, params) { resp_json }
-      Hash.should_receive(:from_xml).with(resp_json)      { resp_value }
-      klass.should_receive(:new).with(expected)
-      klass.send(meth)
+    context "when a Helix:Config instance is present" do
+      before(:each) do
+        klass.stub(:plural_resource_label) { :klasses }
+        klass.stub(:resource_label_sym)    { klass_sym }
+        mock_config.stub(:build_url).with(content_type: :xml, resource_label: :klasses) { :url }
+        mock_config.stub(:signature).with(:update) { "some_sig" }
+        Helix::Config.stub(:instance) { mock_config }
+      end
+      it "should get an ingest signature" do
+        mock_config.should_receive(:build_url).with(resource_label: :klasses,
+                                                    content_type:   :xml)
+        RestClient.stub(:post).with(:url, params) { resp_json }
+        Hash.should_receive(:from_xml).with(resp_json) { resp_value }
+        klass.stub(:new).with(expected)
+        mock_config.should_receive(:signature).with(:update) { "some_sig" }
+        klass.send(meth)
+      end
+      it "should do an HTTP post call, parse response and call new" do
+        mock_config.should_receive(:build_url).with(resource_label: :klasses,
+                                                    content_type:   :xml)
+        RestClient.should_receive(:post).with(:url, params) { resp_json }
+        Hash.should_receive(:from_xml).with(resp_json)      { resp_value }
+        klass.should_receive(:new).with(expected)
+        klass.send(meth)
+      end
     end
   end
 
@@ -49,30 +60,56 @@ describe Helix::Media do
     let(:mock_obj)    { mock(klass, :load => :output_of_load) }
     subject     { klass.method(meth) }
     its(:arity) { should eq(1) }
-    before(:each) do Helix::Config.stub(:instance) { mock_config } end
-    context "when given a Helix::Config instance and a guid" do
-      let(:guid_name)  { :the_guid_name }
-      let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
-      before(:each) do
-        klass.stub(:attributes) { mock_attrs }
-        klass.stub(:guid_name)  { guid_name  }
-        klass.stub(:new)        { mock_obj }
-      end
-      context "and the guid is nil" do
-        it "should raise an ArgumentError complaining about a nil guid" do
-          msg = 'find requires a non-nil guid argument - received a nil argument.'
-          lambda { klass.send(meth, nil) }.should raise_error(ArgumentError, msg)
+    context "when a Helix:Config instance is absent" do
+      before(:each) do Helix::Config.stub(:instance) { nil } end
+      context "and given a guid" do
+        let(:guid_name)  { :the_guid_name }
+        let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
+        before(:each) do
+          klass.stub(:attributes) { mock_attrs }
+          klass.stub(:guid_name)  { guid_name  }
+          klass.stub(:new)        { mock_obj }
+        end
+        context "and the guid is nil" do
+          it "should raise an ArgumentError complaining about a nil guid" do
+            msg = 'find requires a non-nil guid argument - received a nil argument.'
+            lambda { klass.send(meth, nil) }.should raise_error(ArgumentError, msg)
+          end
+        end
+        context "and the guid is non-nil" do
+          let(:guid) { :a_guid }
+          it "should raise a NoConfigurationLoaded exception" do
+            lambda { klass.send(meth, guid) }.should raise_error(Helix::NoConfigurationLoaded)
+          end
         end
       end
-      context "and the guid is non-nil" do
-        let(:guid) { :a_guid }
-        it "should instantiate with {attributes: guid_name => the_guid, config: config}" do
-          klass.should_receive(:new).with({attributes: {guid_name => guid}, config: mock_config})
-          klass.send(meth, guid)
+    end
+    context "when a Helix::Config instance is present" do
+      before(:each) do Helix::Config.stub(:instance) { mock_config } end
+      context "and given a guid" do
+        let(:guid_name)  { :the_guid_name }
+        let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
+        before(:each) do
+          klass.stub(:attributes) { mock_attrs }
+          klass.stub(:guid_name)  { guid_name  }
+          klass.stub(:new)        { mock_obj }
+        end
+        context "and the guid is nil" do
+          it "should raise an ArgumentError complaining about a nil guid" do
+            msg = 'find requires a non-nil guid argument - received a nil argument.'
+            lambda { klass.send(meth, nil) }.should raise_error(ArgumentError, msg)
+          end
         end
-        it "should load" do
-          mock_obj.should_receive(:load)
-          klass.send(meth, guid)
+        context "and the guid is non-nil" do
+          let(:guid) { :a_guid }
+          it "should instantiate with {attributes: guid_name => the_guid, config: config}" do
+            klass.should_receive(:new).with({attributes: {guid_name => guid}, config: mock_config})
+            klass.send(meth, guid)
+          end
+          it "should load" do
+            mock_obj.should_receive(:load)
+            klass.send(meth, guid)
+          end
         end
       end
     end

data/spec/tag_spec.rb

@@ -20,5 +20,5 @@ describe Helix::Tag do
     its(:resource_label_sym)  { should be(:tag) }
     it { should_not respond_to(:destroy) }
     it { should_not respond_to(:update) }
-  end  
+  end
 end

data/spec/track_spec.rb

@@ -3,17 +3,21 @@ require 'helix'
 
 describe Helix::Track do
 
-  let(:klass)             { Helix::Track }
-  subject                 { klass }
-  its(:guid_name)         { should eq('track_id') }
-  its(:resource_label_sym)    { should be(:track)   }
-  its(:plural_resource_label) { should eq('tracks') }
+  let(:klass) { Helix::Track }
+  subject     { klass }
+  mods = [ Helix::Base, Helix::DurationedMedia, Helix::Media ]
+  mods.each { |mod| its(:ancestors) { should include(mod) } }
+  its(:guid_name)             { should eq('track_id') }
+  its(:resource_label_sym)    { should be(:track)     }
+  its(:plural_resource_label) { should eq('tracks')   }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
 
   describe "Constants"
 
+  ### INSTANCE METHODS
+
   describe "an instance" do
     let(:obj)            { klass.new({'track_id' => 'some_track_guid'}) }
     subject              { obj }
@@ -22,4 +26,112 @@ describe Helix::Track do
       it { should respond_to(crud_call) }
     end
   end
+
+  ### CLASS METHODS
+
+  describe ".upload" do
+    let(:meth)            { :upload }
+    let(:mock_config)     { mock(Helix::Config) }
+    subject               { klass.method(meth) }
+    its(:arity)           { should eq(1) }
+    let(:file_hash)       { { file: :some_file  } }
+    let(:multipart_hash)  { { multipart: true } }
+    it "should call upload_server_name and RestClient.post with params" do
+      klass.should_receive(:upload_server_name) { :some_server_url }
+      File.should_receive(:new).with(:some_file.to_s, "rb") { :some_file }
+      RestClient.should_receive(:post).with(:some_server_url,
+                                            file_hash,
+                                            multipart_hash)
+      klass.should_receive(:http_close)
+      klass.send(meth, :some_file)
+    end
+  end
+
+  describe ".upload_server_name" do
+    let(:meth)        { :upload_server_name }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    let(:url_opts)    { { resource_label: "upload_sessions",
+                          guid:           :some_sig,
+                          action:         :http_open,
+                          content_type:   ""  } }
+    before            { Helix::Config.stub(:instance) { mock_config } }
+    it "should call RestClient.get with correct url building" do
+      mock_config.should_receive(:build_url).with(url_opts) { :url }
+      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      RestClient.should_receive(:get).with(:url)
+      klass.send(meth)
+    end
+  end
+
+  describe ".http_close" do
+    let(:meth)        { :http_close }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    let(:url_opts)    { { resource_label: "upload_sessions",
+                          guid:           :some_sig,
+                          action:         :http_close,
+                          content_type:   ""  } }
+    before            { Helix::Config.stub(:instance) { mock_config } }
+    it "should call RestClient.get with correct url building" do
+      mock_config.should_receive(:build_url).with(url_opts) { :url }
+      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      RestClient.should_receive(:get).with(:url)
+      klass.send(meth)
+    end
+  end
+
+  describe ".upload_get" do
+    let(:meth)        { :upload_get }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(1) }
+    let(:url_opts)    { { resource_label: "upload_sessions",
+                          guid:           :some_sig,
+                          action:         :upload_get,
+                          content_type:   ""  } }
+    before            { Helix::Config.stub(:instance) { mock_config } }
+    it "should call RestClient.get with correct url building" do
+      mock_config.should_receive(:build_url).with(url_opts) { :url }
+      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      RestClient.should_receive(:get).with(:url)
+      klass.send(meth, :upload_get)
+    end
+  end
+
+  describe ".http_open" do
+    let(:meth)        { :http_open }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should call upload_server_name" do
+      klass.should_receive(:upload_server_name)
+      klass.send(meth)
+    end
+  end
+
+  describe ".upload_open" do
+    let(:meth)        { :upload_open }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should call upload_server_name" do
+      klass.should_receive(:upload_server_name)
+      klass.send(meth)
+    end
+  end
+
+  describe ".upload_close" do
+    let(:meth)        { :upload_close }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should call upload_server_name" do
+      klass.should_receive(:http_close)
+      klass.send(meth)
+    end
+  end
+
 end

data/spec/video_spec.rb

@@ -7,11 +7,13 @@ describe Helix::Video do
     { list: { entry: values[:url_params] || {} } }.to_xml(root: :add)
   end
 
-  let(:klass)             { Helix::Video }
-  subject                 { klass }
-  its(:guid_name)         { should eq('video_id') }
-  its(:resource_label_sym)    { should be(:video)   }
-  its(:plural_resource_label) { should eq('videos') }
+  let(:klass) { Helix::Video }
+  subject     { klass }
+  mods = [ Helix::Base, Helix::DurationedMedia, Helix::Media ]
+  mods.each { |mod| its(:ancestors) { should include(mod) } }
+  its(:guid_name)             { should eq('video_id') }
+  its(:resource_label_sym)    { should be(:video)     }
+  its(:plural_resource_label) { should eq('videos')   }
   [:find, :create, :all, :find_all, :where].each do |crud_call|
     it { should respond_to(crud_call) }
   end
@@ -94,11 +96,84 @@ describe Helix::Video do
       its(:arity)       { should eq(-1) }
       it "should call self.class.get_stillframe" do
         obj.stub(:guid) { :some_guid }
-        klass.should_receive(:get_stillframe)
+        klass.should_receive(:stillframe_for)
         obj.send(meth)
       end
     end
 
+    describe "serialization" do
+      let(:mock_attributes) {
+        {
+          "created_at"=>"2013-04-09 16:33:58 UTC",
+          "description"=>"description of updated via rest-client",
+          "hidden"=>false,
+          "publisher_name"=>"kbaird@twistage.com",
+          "title"=>"updated via rest-client",
+          "video_id"=>"ece0d3fd03bf0",
+          "status"=>"available",
+          "contributor"=>"kbaird@twistage.com",
+          "site_name"=>"11701",
+          "library_name"=>"11701",
+          "main_asset_url"=>"http://service-staging.twistage.com/videos/ece0d3fd03bf0/assets/438894/file.flv",
+          "source_asset_url"=>"http://service-staging.twistage.com/videos/ece0d3fd03bf0/assets/438893/file.mp4",
+          "hits_count"=>0,
+          "plays_count"=>0,
+          "duration"=>255.791,
+          "total_size"=>158410133,
+          "availability"=>"available",
+          "main_asset_id"=>438894,
+          "progress"=>100,
+          "artist"=>"",
+          "genre"=>"",
+          "assets"=>[
+            {"id"=>438893, "size"=>140035687, "status_code"=>30, "acodec"=>"er aac ld", "audio_bitrate"=>128, "container"=>"mp4",
+              "download_url"=>"http://service-staging.twistage.com/videos/ece0d3fd03bf0/assets/438893/file.mp4", "duration"=>255.84,
+              "frame_rate"=>25.0, "hresolution"=>1280, "is_main_asset"=>false, "vcodec"=>"avc1", "video_bitrate"=>4247,
+              "video_format_name"=>"source", "vresolution"=>720, "status"=>"complete", "detailed_status"=>nil},
+            {"id"=>438894, "size"=>18374446, "status_code"=>30, "acodec"=>"mp3", "audio_bitrate"=>67, "container"=>"flv",
+              "download_url"=>"http://service-staging.twistage.com/videos/ece0d3fd03bf0/assets/438894/file.flv", "duration"=>255.791,
+              "frame_rate"=>25.0039099155, "hresolution"=>480, "is_main_asset"=>true, "vcodec"=>"h263", "video_bitrate"=>487,
+              "video_format_name"=>"flash-low", "vresolution"=>270, "status"=>"complete", "detailed_status"=>nil}
+          ],
+          "screenshots"=>[
+            {"frame"=>141.4, "content_type"=>"image/jpeg", "width"=>1280, "height"=>720, "size"=>260548,
+              "url"=>"http://service-staging.twistage.com:80/videos/ece0d3fd03bf0/screenshots/original.jpg"}
+          ],
+          "tags"=>[],
+          "custom_fields"=>[{"name"=>"blaaagghhh", "value"=>""}, {"name"=>"videoCF", "value"=>""}]
+        }
+      }
+      before(:each) do obj.instance_variable_set(:@attributes, mock_attributes) end
+
+      describe "#to_json" do
+        let(:meth) { :to_json }
+        context "arity" do
+          subject     { obj.method(meth) }
+          its(:arity) { should eq(0) }
+        end
+        subject { obj.send(meth) }
+        it { should eq({video: mock_attributes}.to_json) }
+      end
+
+      describe "#to_xml" do
+        let(:meth) { :to_xml }
+        context "arity" do
+          subject     { obj.method(meth) }
+          its(:arity) { should eq(0) }
+        end
+        subject { obj.send(meth) }
+        let(:modified_attributes) {
+          custom_fields = mock_attributes['custom_fields']
+          new_cfs = custom_fields.inject({}) do |memo,cf|
+            memo.merge(cf['name'] => cf['value'])
+          end
+          mock_attributes.merge('custom_fields' => new_cfs)
+        }
+        it { should eq(modified_attributes.to_xml(root: :video)) }
+      end
+
+    end
+
     [:destroy, :update].each do |crud_call|
       it { should respond_to(crud_call) }
     end
@@ -107,6 +182,111 @@ describe Helix::Video do
 
   ### CLASS METHODS
 
+  describe ".upload" do
+    let(:meth)            { :upload }
+    let(:mock_config)     { mock(Helix::Config) }
+    subject               { klass.method(meth) }
+    its(:arity)           { should eq(1) }
+    let(:file_hash)       { { file: :some_file  } }
+    let(:multipart_hash)  { { multipart: true } }
+    it "should call upload_server_name and RestClient.post with params" do
+      klass.should_receive(:upload_server_name) { :some_server_url }
+      File.should_receive(:new).with(:some_file.to_s, "rb") { :some_file }
+      RestClient.should_receive(:post).with(:some_server_url,
+                                            file_hash,
+                                            multipart_hash)
+      klass.should_receive(:http_close)
+      klass.send(meth, :some_file)
+    end
+  end
+
+  describe ".upload_server_name" do
+    let(:meth)        { :upload_server_name }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    let(:url_opts)    { { resource_label: "upload_sessions",
+                          guid:           :some_sig,
+                          action:         :http_open,
+                          content_type:   ""  } }
+    before            { Helix::Config.stub(:instance) { mock_config } }
+    it "should call RestClient.get with correct url building" do
+      mock_config.should_receive(:build_url).with(url_opts) { :url }
+      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      RestClient.should_receive(:get).with(:url)
+      klass.send(meth)
+    end
+  end
+
+  describe ".http_close" do
+    let(:meth)        { :http_close }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    let(:url_opts)    { { resource_label: "upload_sessions",
+                          guid:           :some_sig,
+                          action:         :http_close,
+                          content_type:   ""  } }
+    before            { Helix::Config.stub(:instance) { mock_config } }
+    it "should call RestClient.get with correct url building" do
+      mock_config.should_receive(:build_url).with(url_opts) { :url }
+      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      RestClient.should_receive(:get).with(:url)
+      klass.send(meth)
+    end
+  end
+
+  describe ".upload_get" do
+    let(:meth)        { :upload_get }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(1) }
+    let(:url_opts)    { { resource_label: "upload_sessions",
+                          guid:           :some_sig,
+                          action:         :upload_get,
+                          content_type:   ""  } }
+    before            { Helix::Config.stub(:instance) { mock_config } }
+    it "should call RestClient.get with correct url building" do
+      mock_config.should_receive(:build_url).with(url_opts) { :url }
+      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      RestClient.should_receive(:get).with(:url)
+      klass.send(meth, :upload_get)
+    end
+  end
+
+  describe ".http_open" do
+    let(:meth)        { :http_open }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should call upload_server_name" do
+      klass.should_receive(:upload_server_name)
+      klass.send(meth)
+    end
+  end
+
+  describe ".upload_open" do
+    let(:meth)        { :upload_open }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should call upload_server_name" do
+      klass.should_receive(:upload_server_name)
+      klass.send(meth)
+    end
+  end
+
+  describe ".upload_close" do
+    let(:meth)        { :upload_close }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should call upload_server_name" do
+      klass.should_receive(:http_close)
+      klass.send(meth)
+    end
+  end
+
   describe ".slice" do
     let(:meth)        { :slice }
     let(:mock_config) { mock(Helix::Config) }
@@ -131,8 +311,8 @@ describe Helix::Video do
     end
   end
 
-  describe ".get_stillframe" do
-    let(:meth)        { :get_stillframe }
+  describe ".stillframe_for" do
+    let(:meth)        { :stillframe_for }
     let(:mock_config) { mock(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(-2) }