helix 0.0.2.7.pre → 0.0.2.8.pre

data/lib/helix/track.rb

@@ -15,5 +15,7 @@ module Helix
     #
     # @return [Symbol] Name of the class.
     def self.resource_label_sym; super; end
+
   end
+
 end

data/lib/helix/uploadable.rb

@@ -0,0 +1,52 @@
+module Helix
+
+  # Mixed-in to ORM classes that are capable of being uploaded.
+
+  module Uploadable
+
+    module ClassMethods
+
+      def upload(file_name)
+        RestClient.post(upload_server_name,
+                        { file:       File.new(file_name.to_s, "rb") },
+                        { multipart:  true } )
+        http_close
+      end
+
+      def upload_server_name
+        upload_get(:http_open)
+      end
+
+      def http_open
+        upload_server_name
+      end
+
+      def upload_open
+        upload_server_name
+      end
+
+      def http_close
+        upload_get(:http_close)
+      end
+
+      def upload_close
+        http_close
+      end
+
+      private
+
+      def upload_get(action)
+        url = config.build_url( resource_label: "upload_sessions",
+                                guid:           config.signature(:ingest),
+                                action:         action,
+                                content_type:   "" )
+        RestClient.get(url)
+      end
+
+    end
+
+    def self.included(klass); klass.extend(ClassMethods); end
+
+  end
+
+end

data/lib/helix/video.rb

@@ -17,25 +17,38 @@ module Helix
     # @return [Symbol] Name of the class.
     def self.resource_label_sym; super; end
 
+    # Used to create a slice video from an existing video.
+    # API doc reference: /doc/api/video/slice
+    #
+    #
+    # @example
+    # Reference Twistage API documentation
+    # to see valid xml to pass.
+    #   xml_string = "<xml></xml>"
+    #   Helix::Video.slice({  guid:         "239c59483d346",
+    #                         use_raw_xml:  xml_string  })
+    #
+    # @param  [Hash] The hash used in this.
+    # @return [String] Returns a blank string.
     def self.slice(attrs={})
       rest_post(:slice, attrs)
     end
 
-
     # Used to retrieve a stillframe for a video by using
     # the video guid.
+    # API doc reference: /doc/api/video/still_frames
     #
     # @example
-    #   sf_data = Helix::Video.get_stillframe("239c59483d346") #=> xDC\xF1?\xE9*?\xFF\xD9
+    #   sf_data = Helix::Video.stillframe_for("239c59483d346") #=> xDC\xF1?\xE9*?\xFF\xD9
     #   File.open("original.jpg", "w") { |f| f.puts sf_data }
     #
-    # @param [String] guid is the string containing the guid for the video.
-    # @param [Hash] opts a hash of options for building URL
+    # @param  [String] Guid is the string containing the guid for the video.
+    # @param  [Hash] Opts a hash of options for building URL.
     # @return [String] Stillframe jpg data, save it to a file with extension .jpg.
-    def self.get_stillframe(guid, original_opts={})
-      opts = original_opts.clone
-      RestClient.log = 'helix.log' if opts.delete(:log)
-      url = get_stillframe_url(guid, opts)
+    def self.stillframe_for(guid, original_opts={})
+      opts            = original_opts.clone
+      RestClient.log  = 'helix.log' if opts.delete(:log)
+      url             = stillframe_url(guid, opts)
       RestClient.get(url)
     end
 
@@ -46,7 +59,7 @@ module Helix
     #   video_data = video.download #=> xDC\xF1?\xE9*?\xFF\xD9
     #   File.open("my_video.mp4", "w") { |f| f.puts video_data }
     #
-    # @param [Hash] opts a hash of options for building URL
+    # @param  [Hash] opts a hash of options for building URL
     # @return [String] Raw video data, save it to a file
     def download(opts={})
       generic_download(opts.merge(action: :file))
@@ -58,35 +71,48 @@ module Helix
     #   video      = Helix::Video.find("239c59483d346")
     #   video_data = video.play #=> xDC\xF1?\xE9*?\xFF\xD9
     #
-    # @param [Hash] opts a hash of options for building URL
+    # @param  [Hash] opts a hash of options for building URL
     # @return [String] Raw video data
     def play(opts={})
       generic_download(opts.merge(action: :play))
     end
 
+    # Used to retrieve a stillframe data for a video by using
+    # the video guid.
+    #
+    # @example
+    #   video   = Helix::Video.find("239c59483d346")
+    #   sf_data = video.stillframe #=> xDC\xF1?\xE9*?\xFF\xD9
+    #   File.open("original.jpg", "w") { |f| f.puts sf_data }
+    #
+    # @param  [Hash] opts a hash of options for building URL
+    # @return [String] Stillframe jpg data, save it to a file with extension .jpg.
     def stillframe(opts={})
-      self.class.get_stillframe(self.guid, opts)
+      self.class.stillframe_for(self.guid, opts)
     end
 
     private
 
-    def self.get_stillframe_dimensions(opts)
+    def self.stillframe_dimensions(opts)
       width   = opts[:width].to_s  + "w" unless opts[:width].nil?
       height  = opts[:height].to_s + "h" unless opts[:height].nil?
       width   = "original" if opts[:width].nil? && opts[:height].nil?
       [width, height]
     end
 
-    def self.get_stillframe_url(guid, opts)
+    def self.stillframe_url(guid, opts)
       server  = opts[:server] || config.credentials[:server] || "service-staging"
-      width, height = get_stillframe_dimensions(opts)
+      width, height = stillframe_dimensions(opts)
       url     = "#{server}.twistage.com/videos/#{guid}/screenshots/"
       url    << "#{width.to_s}#{height.to_s}.jpg"
     end
 
     def generic_download(opts)
-      content_type = opts[:content_type] || ''
-      url = config.build_url(action: opts[:action], content_type: content_type, guid: guid, resource_label: plural_resource_label)
+      content_type  = opts[:content_type] || ''
+      url           = config.build_url( action:         opts[:action],
+                                        content_type:   content_type,
+                                        guid:           guid,
+                                        resource_label: plural_resource_label )
       RestClient.get(url, params: {signature: config.signature(:view)})
     end
 

data/spec/album_spec.rb

@@ -5,7 +5,8 @@ describe Helix::Album do
   let(:klass) { Helix::Album }
 
   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('album_id') }
   its(:resource_label_sym)    { should be(:album)   }
   its(:plural_resource_label) { should eq('albums') }

data/spec/base_spec.rb

@@ -3,14 +3,6 @@ require 'helix'
 
 describe Helix::Base do
 
-  def set_stubs(obj, even_sig=false)
-    obj.instance_variable_set(:@attributes, {})
-    obj.stub(:resource_label_sym)    { :video      }
-    obj.stub(:plural_resource_label) { 'videos'    }
-    obj.stub(:guid)                  { 'some_guid' }
-    obj.stub(:signature)             { 'some_sig'  } if even_sig
-  end
-
   let(:klass) { Helix::Base }
 
   subject { klass }
@@ -35,82 +27,67 @@ describe Helix::Base do
   end
 
   shared_examples_for "a search all with opts" do
-    let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: {}) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(-1) }
-    before(:each) do Helix::Config.stub(:instance) { mock_config } end
-    context "when given a config instances and an opts Hash" do
-      let(:opts) { {opts_key1: :opts_val1} }
-      let(:plural_resource_label) { :videos }
-      before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
-      it "should clone the opts arg" do
-        opts.should_receive(:clone) { opts }
-        klass.send(meth, opts)
-      end
-      it "should build a XML URL -> the_url" do
-        mock_config.should_receive(:build_url).with(content_type:   :xml,
-                                                    resource_label: plural_resource_label)
-        klass.send(meth, opts)
-      end
-      it "should get_response(the_url, {sig_type: :view}.merge(opts) -> raw_response" do
-        mock_config.should_receive(:get_response).with(:built_url, {sig_type: :view}.merge(opts))
-        klass.send(meth, opts)
+    context "when there is NOT a config instance" 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
-      it "should read raw_response[plural_resource_label] -> data_sets" do
-        mock_raw_response = mock(Object)
-        mock_config.stub(:get_response) { mock_raw_response }
-        mock_raw_response.should_receive(:[]).with(plural_resource_label)
-        klass.send(meth, opts)
-      end
-      context "when data_sets is nil" do
-        it "should return []" do expect(klass.send(meth, opts)).to eq([]) end
+    end
+    context "when there is a config instance" do
+      let(:mock_config) do
+        dss = (0..2).map { |x| :"attrs_#{x}" }
+        mock(Helix::Config, build_url: :built_url, get_aggregated_data_sets: dss)
       end
-      context "when data_sets is NOT nil" do
-        let(:data_set) { (0..2).to_a }
-        before(:each) do mock_config.stub(:get_response) { {plural_resource_label => data_set } } end
-        it "should map instantiation with attributes: each data set element" do
-          klass.should_receive(:new).with(attributes: data_set[0], config: mock_config) { :a }
-          klass.should_receive(:new).with(attributes: data_set[1], config: mock_config) { :b }
-          klass.should_receive(:new).with(attributes: data_set[2], config: mock_config) { :c }
-          expect(klass.send(meth, opts)).to eq([:a, :b, :c])
+      before(:each) do Helix::Config.stub(:instance) { mock_config } end
+      context "and NOT given an opts Hash" do
+        let(:plural_resource_label) { :videos }
+        before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
+        it "should get_aggregated_data_sets(the_url, plural_resource_label, {sig_type: :view}" do
+          opts = {sig_type: :view}
+          mock_config.should_receive(:get_aggregated_data_sets).with(:built_url, plural_resource_label, opts) { [:expected] }
+          klass.send(meth, opts)
+        end
+        [ Helix::Video ].each do |child|
+          it "should should instantiate #{child.to_s} from each data_set" do
+            opts = {sig_type: :view}
+            children = child.send(meth, opts)
+            children.each_with_index do |c,idx|
+              expect(c).to be_a(child)
+              expect(c.attributes).to be(:"attrs_#{idx}")
+            end
+          end
         end
       end
     end
   end
 
   shared_examples_for "a search all without opts" do
-    let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: {}) }
-    subject           { klass.method(meth) }
-    before(:each) do Helix::Config.stub(:instance) { mock_config } end
-    context "when given a config instances and NO opts Hash" do
-      let(:plural_resource_label) { :videos }
-      before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
-      it "should build a XML URL -> the_url" do
-        mock_config.should_receive(:build_url).with(content_type:   :xml,
-                                                    resource_label: plural_resource_label)
-        klass.send(meth)
-      end
-      it "should get_response(the_url, {sig_type: :view} -> raw_response" do
-        mock_config.should_receive(:get_response).with(:built_url, {sig_type: :view})
-        klass.send(meth)
-      end
-      it "should read raw_response[plural_resource_label] -> data_sets" do
-        mock_raw_response = mock(Object)
-        mock_config.stub(:get_response) { mock_raw_response }
-        mock_raw_response.should_receive(:[]).with(plural_resource_label)
-        klass.send(meth)
+    subject { klass.method(meth) }
+    context "when there is a config instance" do
+      let(:mock_config) do
+        dss = (0..2).map { |x| :"attrs_#{x}" }
+        mock(Helix::Config, build_url: :built_url, get_aggregated_data_sets: dss)
       end
-      context "when data_sets is nil" do
-        it "should return []" do expect(klass.send(meth)).to eq([]) end
-      end
-      context "when data_sets is NOT nil" do
-        let(:data_set) { (0..2).to_a }
-        before(:each) do mock_config.stub(:get_response) { {plural_resource_label => data_set } } end
-        it "should map instantiation with attributes: each data set element" do
-          klass.should_receive(:new).with(attributes: data_set[0], config: mock_config) { :a }
-          klass.should_receive(:new).with(attributes: data_set[1], config: mock_config) { :b }
-          klass.should_receive(:new).with(attributes: data_set[2], config: mock_config) { :c }
-          expect(klass.send(meth)).to eq([:a, :b, :c])
+      before(:each) do Helix::Config.stub(:instance) { mock_config } end
+      context "and NOT given an opts Hash" do
+        let(:plural_resource_label) { :videos }
+        before(:each) do klass.stub(:plural_resource_label) { plural_resource_label } end
+        it "should get_aggregated_data_sets(the_url, plural_resource_label, {sig_type: :view}" do
+          opts = {sig_type: :view}
+          mock_config.should_receive(:get_aggregated_data_sets).with(:built_url, plural_resource_label, opts) { [:expected] }
+          klass.send(meth)
+        end
+        [ Helix::Video ].each do |child|
+          it "should should instantiate #{child.to_s} from each data_set" do
+            opts = {sig_type: :view}
+            children = child.send(meth)
+            children.each_with_index do |c,idx|
+              expect(c).to be_a(child)
+              expect(c.attributes).to be(:"attrs_#{idx}")
+            end
+          end
         end
       end
     end

data/spec/config_spec.rb

@@ -23,10 +23,26 @@ describe Helix::Config do
       subject { klass::DEFAULT_FILENAME }
       it { should eq('./helix.yml') }
     end
+    describe "ITEMS_PER_PAGE" do
+      subject { klass::ITEMS_PER_PAGE }
+      it { should eq(100) }
+    end
     describe "SCOPES" do
       subject { klass::SCOPES }
       it { should eq([:reseller, :company, :library]) }
     end
+    describe "SIG_DURATION" do
+      subject { klass::SIG_DURATION }
+      it { should eq(1200) } # in minutes
+    end
+    describe "STARTING_PAGE" do
+      subject { klass::STARTING_PAGE }
+      it { should eq(1) }
+    end
+    describe "TIME_OFFSET" do
+      subject { klass::TIME_OFFSET }
+      it { should eq(1000 * 60) } # 1000 minutes
+    end
     describe "VALID_SIG_TYPES" do
       subject { klass::VALID_SIG_TYPES }
       it { should eq([:ingest, :update, :view]) }
@@ -302,6 +318,34 @@ describe Helix::Config do
     end
   end
 
+  describe "#get_aggregated_data_sets" do
+    let(:meth)  { :get_aggregated_data_sets }
+    subject     { obj.method(meth) }
+    its(:arity) { should eq(-3) }
+    context "when called" do
+      let(:opts)  { {opts_key1: :opts_val1} }
+      let(:label) { :videos }
+      before(:each) do
+        obj.stub(:signature) { :the_sig }
+      end
+      subject { obj.send(meth, :a_url, label, opts) }
+      it "should successively call RestClient.get with the opts arg merged with pagination info and return the parsed results" do
+        base_opts = {opts_key1: :opts_val1, per_page: 100, signature: :the_sig}
+        opts1 = {params: base_opts.merge(page: 1)}
+        opts2 = {params: base_opts.merge(page: 2)}
+        opts3 = {params: base_opts.merge(page: 3)}
+        non_final_response = mock(String, headers: {is_last_page: 'false'})
+        final_response     = mock(String, headers: {is_last_page: 'true'})
+        RestClient.should_receive(:get).with(:a_url, opts1) { non_final_response }
+        RestClient.should_receive(:get).with(:a_url, opts2) { non_final_response }
+        RestClient.should_receive(:get).with(:a_url, opts3) { final_response }
+        obj.stub(:parse_response_by_url_format).with(non_final_response, :a_url) { {label => [:non_final]} }
+        obj.stub(:parse_response_by_url_format).with(final_response, :a_url)     { {label => [:final]}     }
+        expect(obj.send(meth, :a_url, label, opts)).to eq([:non_final, :non_final, :final])
+      end
+    end
+  end
+
   describe "#get_response" do
     let(:meth)  { :get_response }
     subject     { obj.method(meth) }
@@ -363,6 +407,43 @@ describe Helix::Config do
     end
   end
 
+  describe "#last_page?" do
+    let(:meth)  { :last_page? }
+    subject     { obj.method(meth) }
+    its(:arity) { should eq(0) }
+    context "when called" do
+      subject { obj.send(meth) }
+      context "when there is no @response" do
+        before(:each) { obj.instance_variable_set(:@response, nil) }
+        it { should be false }
+      end
+      context "when there is a @response" do
+        let(:mock_response) { mock(String) }
+        before(:each) { obj.instance_variable_set(:@response, mock_response) }
+        context "and there is no @response.headers" do
+          before(:each) { mock_response.stub(:headers) { nil } }
+          it { should be false }
+        end
+        context "and there is a @response.headers" do
+          context "and @response.headers does NOT have the key :is_last_page" do
+            before(:each) do mock_response.stub(:headers) { {} } end
+            it { should be false }
+          end
+          context "and @response.headers has the key :is_last_page" do
+            context "and @response.headers[:is_last_page] == 'truthy'" do
+              before(:each) do mock_response.stub(:headers) { {is_last_page: 'truthy'} } end
+              it { should be false }
+            end
+            context "and @response.headers[:is_last_page] == 'true'" do
+              before(:each) do mock_response.stub(:headers) { {is_last_page: 'true'} } end
+              it { should be true }
+            end
+          end
+        end
+      end
+    end
+  end
+
   describe "#license_key" do
     let(:meth)  { :license_key }
     subject     { obj.method(meth) }
@@ -399,7 +480,7 @@ describe Helix::Config do
     end
     it "should return the proxy specified in the config" do
       obj.credentials[:proxy_uri] = 'http://test.proxy'
-      expect(obj.send(meth)).to eq 'http://test.proxy' 
+      expect(obj.send(meth)).to eq 'http://test.proxy'
     end
     it "should return just proxy uri if only pass exists" do
       obj.credentials[:proxy_password] = 'fake_pass'

data/spec/durationed_media_spec.rb

@@ -10,7 +10,8 @@ describe Helix::DurationedMedia do
   klasses = [ Helix::Video, Helix::Track ]
   klasses.each do |klass|
     subject         { klass }
-    its(:ancestors) { should include(Helix::Base) }
+    mods = [ Helix::Base, Helix::DurationedMedia, Helix::Media ]
+    mods.each { |mod| its(:ancestors) { should include(mod) } }
 
     describe "Constants"