helix 0.0.2.0.pre → 0.0.2.1.pre

data/lib/helix/base.rb

@@ -53,14 +53,14 @@ module Helix
     #
     # @param [Hash] opts a hash of options for parameters passed into the HTTP GET
     # @return [Array] The array of instance objects for a class.
-    def self.find_all(opts)
+    def self.find_all(opts={})
       data_sets = get_data_sets(opts)
       return [] if data_sets.nil?
       data_sets.map { |attrs| self.new(attributes: attrs, config: config) }
     end
 
     def self.get_data_sets(opts)
-      url          = config.build_url(format:     opts[:format] || :json, 
+      url          = config.build_url(format:     opts[:format] || :json,
                                       media_type: self.plural_media_type)
       # We allow opts[:sig_type] for internal negative testing only.
       raw_response = config.get_response(url, {sig_type: :view}.merge(opts))
@@ -162,8 +162,11 @@ module Helix
     # @param [Hash] opts a hash of attributes to update the instance with.
     # @return [Base] Returns an instance of the class after update.
     def update(opts={})
+      RestClient.log = 'helix.log' if opts.delete(:log)
       memo_cfg = config
-      url      = memo_cfg.build_url(format: :xml, guid: guid, media_type: plural_media_type)
+      url      = memo_cfg.build_url(content_type: :xml,
+                                    guid:         guid,
+                                    media_type:   plural_media_type)
       params   = {signature: memo_cfg.signature(:update)}.merge(media_type_sym => opts)
       RestClient.put(url, params)
       self

data/lib/helix/config.rb

@@ -46,11 +46,12 @@ module Helix
     # @param [Hash] opts a hash of options for building URL additions
     # @return [String] The full RESTful URL string object
     def add_sub_urls(base_url, opts)
-      guid, action = [:guid, :action].map { |sub| opts[sub] }
+      guid, action, format = [:guid, :action, :formats].map { |sub| opts[sub] }
       url   = "#{base_url}/#{opts[:media_type]}"
-      url  += "/#{guid}"   if guid
-      url  += "/#{action}" if action
-      "#{url}.#{opts[:format]}"
+      url  += "/#{guid}"            if guid
+      url  += "/formats/#{format}"  if format
+      url  += "/#{action}"          if action
+      "#{url}.#{opts[:content_type]}"
     end
 
     # Creates a full RESTful URL to be used for HTTP requests.
@@ -58,10 +59,10 @@ module Helix
     # @param [Hash] opts a hash of options for building URL
     # @return [String] The full RESTful URL string object
     def build_url(opts={})
-      opts[:format]     ||= :json
-      opts[:media_type] ||= :videos
-      base_url = get_base_url(opts)
-      url      = add_sub_urls(base_url, opts)
+      opts[:content_type] ||= :json
+      opts[:media_type]   ||= :videos
+      base_url              = get_base_url(opts)
+      url                   = add_sub_urls(base_url, opts)
     end
 
     def clear_signatures!

data/lib/helix/durationed_media.rb

@@ -4,14 +4,25 @@ module Helix
 
     module ClassMethods
 
-      # Standard hash values used to generate the create_many
-      # url.
+      # Used to import tracks from a URL into the Twistage system.
+      # Doc reference: /doc/api/track/import
+      # Doc reference: /doc/api/video/import
       #
-      # @return [Hash]
-      def get_url_opts
-        { action:     :create_many,
-          media_type: plural_media_type,
-          format:     :xml }
+      # @example
+      #   track = Helix::Track.import(src:          "www.google.com/track.mp4",
+      #                               title:        "Some Title,
+      #                               description:  "A random track.")
+      #   new_track.track_id # => dd891b83ba39e
+      #
+      #   video = Helix::Video.import(src:          "www.google.com/video.mp4",
+      #                               title:        "Some Title,
+      #                               description:  "A random video.")
+      #   new_video.video_id # => dd891b83ba39e
+      #
+      # @param [Hash] attrs The attributes for creating a track.
+      # @return [RestClient] The response object.
+      def import(attrs={})
+        rest_post(:create_many, attrs)
       end
 
       private
@@ -32,8 +43,9 @@ module Helix
       # Gets the url used in the create_many import call.
       #
       # @return [String] Returns the valid url used for the API call.
-      def get_url
-        Helix::Config.instance.build_url(self.get_url_opts)
+      def get_url_for(api_call, opts)
+        url_opts = url_opts_for(opts[:formats])[api_call].merge(opts)
+        Helix::Config.instance.build_url(url_opts)
       end
 
       # Method allows for :use_raw_xml to be passed into attributes.
@@ -45,9 +57,33 @@ module Helix
       # @return [String] Returns xml either from a raw entry or generated from attributes.
       def get_xml(attrs={})
         return attrs[:use_raw_xml] if attrs[:use_raw_xml].present?
-        { list: { entry: attrs } }.to_xml(root: :add)
+        xml_opts = {root: :add }
+        { list: { entry: attrs[:url_params] || {} } }.to_xml(xml_opts)
+      end
+
+      def rest_post(api_call, attrs)
+        RestClient.log        = 'helix.log' if attrs.delete(:log)
+        content_type          = url_opts_for[api_call][:content_type]
+        content_type_hash     = { content_type: "text/#{content_type}" }
+        RestClient.post(get_url_for(api_call, attrs),
+                        get_xml(attrs),
+                        get_params(attrs).merge(content_type_hash))
       end
 
+      # Standard hash values used to generate the create_many
+      # url.
+      #
+      # @return [Hash]
+      def url_opts_for(format=nil)
+        { slice:       {  action:       :slice,
+                          media_type:   plural_media_type,
+                          content_type: :xml,
+                          formats:      format },
+          create_many: {  action:       :create_many,
+                          media_type:   plural_media_type,
+                          content_type: :xml }
+        }
+      end
     end
 
     def self.included(klass); klass.extend(ClassMethods); end

data/lib/helix/track.rb

@@ -13,25 +13,5 @@ module Helix
     #
     # @return [Symbol] Name of the class.
     def self.media_type_sym; :track; end
-
-    # Used to import tracks from a URL into the Twistage system.
-    # Doc reference: /doc/api/track/import
-    #
-    # @example
-    #   track = Helix::Track.import(src:          "www.google.com/track.mp4",
-    #                               title:        "Some Title,
-    #                               description:  "A random track.")
-    #   new_track.track_id # => dd891b83ba39e
-    #
-    # @param [Hash] attrs The attributes for creating a track.
-    # @return [RestClient] The response object.
-    def self.import(attrs={})
-      #TODO: Pull shared logic (with video) into a shared lib file.
-      RestClient.post(get_url,
-                      get_xml(attrs),
-                      get_params(attrs))
-    end
-
   end
-
 end

data/lib/helix/video.rb

@@ -17,23 +17,34 @@ module Helix
     # @return [Symbol] Name of the class.
     def self.media_type_sym; :video; end
 
-    # Used to import videos from a URL into the Twistage system.
-    # Doc reference: /doc/api/video/import
+    def self.slice(attrs={})
+      rest_post(:slice, attrs)
+    end
+
+
+    # Used to retrieve a stillframe for a video by using
+    # the video guid.
     #
     # @example
-    #   video = Helix::Video.import(src:          "www.google.com/video.mp4",
-    #                               title:        "Some Title,
-    #                               description:  "A random video.")
-    #   new_video.video_id # => dd891b83ba39e
+    #   sf_data = Helix::Video.get_stillframe("239c59483d346") #=> xDC\xF1?\xE9*?\xFF\xD9
+    #   File.open("original.jpg", "w") { |f| f.puts sf_data }
     #
-    # @param [Hash] attrs The attributes for creating a video.
-    # @return [RestClient] The response object.
-    def self.import(attrs={})
-      RestClient.post(get_url,
-                      get_xml(attrs),
-                      get_params(attrs))
+    # @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, opts={})
+      RestClient.log = 'helix.log' if opts.delete(:log)
+      server  = opts[:server] || config.credentials[:server] || "service-staging"
+      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?
+      url     = "#{server}.twistage.com/videos/#{guid}/screenshots/"
+      url    << "#{width.to_s}#{height.to_s}.jpg"
+      RestClient.get(url)
     end
 
+    def stillframe(opts={})
+      self.class.get_stillframe(self.guid, opts)
+    end
   end
-
 end

data/spec/base_spec.rb

@@ -101,14 +101,14 @@ describe Helix::Base do
     let(:meth)  { :find_all }
     let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: {}) }
     subject     { klass.method(meth) }
-    its(:arity) { should eq(1) }
+    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_media_type) { :videos }
       before(:each) do klass.stub(:plural_media_type) { plural_media_type } end
       it "should build a JSON URL -> the_url" do
-        mock_config.should_receive(:build_url).with(format:     :json, 
+        mock_config.should_receive(:build_url).with(format:     :json,
                                                     media_type: plural_media_type)
         klass.send(meth, opts)
       end
@@ -319,8 +319,8 @@ describe Helix::Base do
         mock_config.stub(:build_url) { :expected_url }
       end
       shared_examples_for "builds URL for update" do
-        it "should build_url(format: :xml, guid: guid, media_type: plural_media_type)" do
-          mock_config.should_receive(:build_url).with(format: :xml, guid: :the_guid, media_type: :the_media_type)
+        it "should build_url(content_type: :xml, guid: guid, media_type: plural_media_type)" do
+          mock_config.should_receive(:build_url).with(content_type: :xml, guid: :the_guid, media_type: :the_media_type)
           RestClient.stub(:put)
           obj.send(meth)
         end

data/spec/config_spec.rb

@@ -103,13 +103,13 @@ describe Helix::Config do
     end
   end
 
-  def build_test_url(site, sub_url, guid, action, media_type, format)
+  def build_test_url(site, sub_url, guid, action, media_type, content_type)
     expected_url  = site
     expected_url += sub_url unless guid || action == :create_many
     expected_url += "/#{media_type}"
     expected_url += "/the_guid" if guid
     expected_url += "/#{action}" if action
-    expected_url += ".#{format}"
+    expected_url += ".#{content_type}"
   end
 
   describe "#build_url" do
@@ -118,12 +118,12 @@ describe Helix::Config do
     subject     { obj.method(meth) }
     its(:arity) { should be(-1) }
     before(:each) do obj.credentials = { site: site } end
-    shared_examples_for "reads scope from credentials for build_url" do |media_type,format,more_opts|
+    shared_examples_for "reads scope from credentials for build_url" do |media_type,content_type,more_opts|
       let(:opts)          { more_opts || {} }
-      let(:action)        { opts[:action] } 
-      let(:guid)          { opts[:guid] } 
-      let(:url_pieces)    { [site, sub_url, guid, action, media_type, format] }
-      let(:expected_url)  { build_test_url(*url_pieces) } 
+      let(:action)        { opts[:action] }
+      let(:guid)          { opts[:guid] }
+      let(:url_pieces)    { [site, sub_url, guid, action, media_type, content_type] }
+      let(:expected_url)  { build_test_url(*url_pieces) }
       before(:each) do obj.credentials = {site: 'http://example.com'} end
       context "and credentials has a key for :reseller" do
         before(:each) do obj.credentials.merge!(reseller: 're_id') end
@@ -201,39 +201,39 @@ describe Helix::Config do
         it_behaves_like "reads scope from credentials for build_url", media_type, :json, {guid: :the_guid, action: :the_action}
       end
     end
-    [ :json, :xml ].each do |format|
-      context "when given opts[:format] of :#{format}" do
-        subject { obj.send(meth, format: format) }
-        it_behaves_like "reads scope from credentials for build_url", :videos, format
+    [ :json, :xml ].each do |content_type|
+      context "when given opts[:content_type] of :#{content_type}" do
+        subject { obj.send(meth, content_type: content_type) }
+        it_behaves_like "reads scope from credentials for build_url", :videos, content_type
       end
-      context "when given opts[:format] of :#{format} and opts[:guid] of :the_guid" do
-        subject { obj.send(meth, format: format, guid: :the_guid) }
-        it_behaves_like "reads scope from credentials for build_url", :videos, format, {guid: :the_guid}
+      context "when given opts[:content_type] of :#{content_type} and opts[:guid] of :the_guid" do
+        subject { obj.send(meth, content_type: content_type, guid: :the_guid) }
+        it_behaves_like "reads scope from credentials for build_url", :videos, content_type, {guid: :the_guid}
       end
-      context "when given opts[:format] of :#{format} and opts[:action] of :the_action" do
-        subject { obj.send(meth, format: format, action: :the_action) }
-        it_behaves_like "reads scope from credentials for build_url", :videos, format, {action: :the_action}
+      context "when given opts[:content_type] of :#{content_type} and opts[:action] of :the_action" do
+        subject { obj.send(meth, content_type: content_type, action: :the_action) }
+        it_behaves_like "reads scope from credentials for build_url", :videos, content_type, {action: :the_action}
       end
-      context "when given opts[:format] of :#{format}, opts[:guid] of :the_guid, and opts[:action] of :the_action" do
-        subject { obj.send(meth, format: format, guid: :the_guid, action: :the_action) }
-        it_behaves_like "reads scope from credentials for build_url", :videos, format, {guid: :the_guid, action: :the_action}
+      context "when given opts[:content_type] of :#{content_type}, opts[:guid] of :the_guid, and opts[:action] of :the_action" do
+        subject { obj.send(meth, content_type: content_type, guid: :the_guid, action: :the_action) }
+        it_behaves_like "reads scope from credentials for build_url", :videos, content_type, {guid: :the_guid, action: :the_action}
       end
       [ :videos, :tracks ].each do |media_type|
-        context "when given opts[:format] of :#{format} and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, format: format, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, format
+        context "when given opts[:content_type] of :#{content_type} and opts[:media_type] of :#{media_type}" do
+          subject { obj.send(meth, content_type: content_type, media_type: media_type) }
+          it_behaves_like "reads scope from credentials for build_url", media_type, content_type
         end
-        context "when given opts[:format] of :#{format}, opts[:guid] of :the_guid, and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, format: format, guid: :the_guid, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, format, {guid: :the_guid}
+        context "when given opts[:content_type] of :#{content_type}, opts[:guid] of :the_guid, and opts[:media_type] of :#{media_type}" do
+          subject { obj.send(meth, content_type: content_type, guid: :the_guid, media_type: media_type) }
+          it_behaves_like "reads scope from credentials for build_url", media_type, content_type, {guid: :the_guid}
         end
-        context "when given opts[:format] of :#{format}, opts[:action] of :the_action, and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, format: format, action: :the_action, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, format, {action: :the_action}
+        context "when given opts[:content_type] of :#{content_type}, opts[:action] of :the_action, and opts[:media_type] of :#{media_type}" do
+          subject { obj.send(meth, content_type: content_type, action: :the_action, media_type: media_type) }
+          it_behaves_like "reads scope from credentials for build_url", media_type, content_type, {action: :the_action}
         end
-        context "when given opts[:format] of :#{format}, opts[:guid] of :the_guid, opts[:action] of :the_action, and opts[:media_type] of :#{media_type}" do
-          subject { obj.send(meth, format: format, guid: :the_guid, action: :the_action, media_type: media_type) }
-          it_behaves_like "reads scope from credentials for build_url", media_type, format, {guid: :the_guid, action: :the_action}
+        context "when given opts[:content_type] of :#{content_type}, opts[:guid] of :the_guid, opts[:action] of :the_action, and opts[:media_type] of :#{media_type}" do
+          subject { obj.send(meth, content_type: content_type, guid: :the_guid, action: :the_action, media_type: media_type) }
+          it_behaves_like "reads scope from credentials for build_url", media_type, content_type, {guid: :the_guid, action: :the_action}
         end
       end
     end

data/spec/durationed_media_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'helix'
+
+describe Helix::DurationedMedia do
+
+  def import_xml(values={})
+    { list: { entry: values[:url_params] || {} } }.to_xml(root: :add)
+  end
+
+  klasses = [ Helix::Video, Helix::Track ]
+  klasses.each do |klass|
+    subject         { klass }
+    its(:ancestors) { should include(Helix::Base) }
+
+    describe "Constants"
+
+    let(:sig_opts)  { { contributor:  :helix,
+                        library_id:   :development } }
+    url_opts      =   { action:       :create_many,
+                        media_type:   klass.send(:plural_media_type),
+                        content_type: :xml }
+
+    describe ".import" do
+      let(:meth)        { :import }
+      let(:mock_config) { mock(Helix::Config) }
+      subject           { klass.method(meth) }
+      its(:arity)       { should eq(-1) }
+      let(:params)      { { params:       { signature: :some_sig },
+                            content_type: "text/xml" } }
+      before            { Helix::Config.stub(:instance) { mock_config } }
+
+      it "should get an ingest signature" do
+        mock_config.should_receive(:build_url).with(url_opts)
+        mock_config.should_receive(:signature).with(:ingest, sig_opts) { :some_sig }
+        RestClient.should_receive(:post).with(nil, import_xml, params)
+        klass.send(meth)
+      end
+    end
+
+    describe ".get_xml" do
+      let(:meth)  { :get_xml }
+      subject     { klass.method(meth) }
+      its(:arity) { should eq(-1) }
+      context "when :use_raw_xml is present in attrs" do
+        let(:use_raw_xml) { { use_raw_xml: :xml } }
+        it "should return the value of attrs[:use_raw_xml]" do
+          expect(klass.send(meth, use_raw_xml)).to eq(:xml)
+        end
+      end
+      context "when hash is passed without :use_raw_xml" do
+        let(:attrs) { { url_params: { attribute: :value } } }
+        it "should convert attrs into xml" do
+          expect(klass.send(meth, attrs)).to eq(import_xml(attrs))
+        end
+      end
+      context "when nothing in passed in" do
+        it "should return valid xml" do
+          expect(klass.send(meth)).to eq(import_xml)
+        end
+      end
+    end
+
+    describe ".url_opts_for" do
+      let(:meth)  { :url_opts_for }
+      subject     { klass.method(meth) }
+      its(:arity) { should eq(-1) }
+      it "should return a valid hash url options for Helix::Config#build_url" do
+         expect(klass.send(meth)[:create_many]).to eq(url_opts)
+      end
+    end
+
+    describe ".get_url_for" do
+      let(:meth)  { :get_url_for }
+      subject     { klass.method(meth) }
+      its(:arity) { should eq(2) }
+      it "should call Helix::Config#build_url with url opts" do
+        Helix::Config.instance.should_receive(:build_url).with(klass.send(:url_opts_for)[:create_many])
+        klass.send(meth, :create_many, {})
+      end
+    end
+
+    describe ".get_params" do
+      let(:meth)  { :get_params }
+      subject     { klass.method(meth) }
+      its(:arity) { should eq(-1) }
+      it "should call Helix::Config#signature and return a hash of params" do
+        Helix::Config.instance.should_receive(:signature).with(:ingest, sig_opts) { :sig }
+        expect(klass.send(meth)).to eq({ params: { signature: :sig } })
+      end
+    end
+  end
+end

data/spec/track_spec.rb

@@ -3,98 +3,17 @@ require 'helix'
 
 describe Helix::Track do
 
-  def import_xml(values={})
-    { list: { entry: values } }.to_xml(root: :add)
-  end
-
-  let(:klass) { Helix::Track }
-
+  let(:klass)             { Helix::Track }
   subject                 { klass }
-  its(:ancestors)         { should include(Helix::Base) }
   its(:guid_name)         { should eq('track_id') }
   its(:media_type_sym)    { should be(:track)   }
   its(:plural_media_type) { should eq('tracks') }
 
   describe "Constants"
 
-  let(:sig_opts)  { { contributor:  :helix, 
-                      library_id:   :development } }
-  let(:url_opts)  { { action:       :create_many, 
-                      media_type:   "tracks", 
-                      format:       :xml } }
-
   describe "an instance" do
     let(:obj)            { klass.new({'track_id' => 'some_track_guid'}) }
     subject              { obj }
     its(:media_type_sym) { should be(:track) }
   end
-
-  describe ".import" do
-    let(:meth)        { :import }
-    let(:mock_config) { mock(Helix::Config) }
-    subject           { klass.method(meth) }
-    its(:arity)       { should eq(-1) }
-    let(:params)      { { params: { signature: :some_sig } } }  
-    before            { Helix::Config.stub(:instance) { mock_config } } 
-
-    it "should get an ingest signature" do
-      mock_config.should_receive(:build_url).with(url_opts)
-      mock_config.should_receive(:signature).with(:ingest, sig_opts) { :some_sig }
-      RestClient.should_receive(:post).with(nil, import_xml, params)
-      klass.send(meth)
-    end
-  end
-
-  describe ".get_xml" do 
-    let(:meth)  { :get_xml }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(-1) }
-    context "when :use_raw_xml is present in attrs" do
-      let(:use_raw_xml) { { use_raw_xml: :xml } }
-      it "should return the value of attrs[:use_raw_xml]" do
-        expect(klass.send(meth, use_raw_xml)).to eq(:xml)
-      end
-    end
-    context "when hash is passed without :use_raw_xml" do
-      let(:attrs) { { attribute: :value } }
-      it "should convert attrs into xml" do
-        expect(klass.send(meth, attrs)).to eq(import_xml(attrs))
-      end
-    end
-    context "when nothing in passed in" do
-      it "should return valid xml" do
-        expect(klass.send(meth)).to eq(import_xml)
-      end
-    end
-  end
-
-  describe ".get_url_opts" do
-    let(:meth)  { :get_url_opts }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(0) }
-    it "should return a valid hash url options for Helix::Config#build_url" do
-       expect(klass.send(meth)).to eq(url_opts)
-    end
-  end
-
-  describe ".get_url" do
-    let(:meth)  { :get_url }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(0) }
-    it "should call Helix::Config#build_url with url opts" do
-      Helix::Config.instance.should_receive(:build_url).with(klass.send(:get_url_opts))
-      klass.send(meth)
-    end
-  end
-
-  describe ".get_params" do
-    let(:meth)  { :get_params }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(-1) }
-    it "should call Helix::Config#signature and return a hash of params" do
-      Helix::Config.instance.should_receive(:signature).with(:ingest, sig_opts) { :sig }
-      expect(klass.send(meth)).to eq({ params: { signature: :sig } })
-    end
-  end
-
 end

data/spec/video_spec.rb

@@ -4,96 +4,98 @@ require 'helix'
 describe Helix::Video do
 
   def import_xml(values={})
-    { list: { entry: values } }.to_xml(root: :add)
+    { list: { entry: values[:url_params] || {} } }.to_xml(root: :add)
   end
 
-  let(:klass) { Helix::Video }
-
+  let(:klass)             { Helix::Video }
   subject                 { klass }
-  its(:ancestors)         { should include(Helix::Base) }
   its(:guid_name)         { should eq('video_id') }
   its(:media_type_sym)    { should be(:video)   }
   its(:plural_media_type) { should eq('videos') }
 
   describe "Constants"
 
-  let(:sig_opts)  { { contributor:  :helix, 
-                      library_id:   :development } }
-  let(:url_opts)  { { action:       :create_many, 
-                      media_type:   "videos", 
-                      format:       :xml } }
+  ### INSTANCE METHODS
 
   describe "an instance" do
-    let(:obj)             { klass.new({'video_id' => 'some_video_guid'}) }
-    subject               { obj }
-    its(:media_type_sym)  { should be(:video) }
+    let(:obj)            { klass.new({video_id: 'some_video_guid'}) }
+    subject              { obj }
+    its(:media_type_sym) { should be(:video) }
+    describe "#stillframe" do
+      let(:meth)        { :stillframe }
+      let(:mock_config) { mock(Helix::Config) }
+      subject           { obj.method(meth) }
+      its(:arity)       { should eq(-1) }
+      it "should call self.class.get_stillframe" do
+        obj.stub!(:guid).and_return :some_guid
+        klass.should_receive(:get_stillframe)
+        obj.send(meth)
+      end
+    end
   end
 
-  describe ".import" do
-    let(:meth)        { :import }
+  ### CLASS METHODS
+
+  describe ".slice" do
+    let(:meth)        { :slice }
     let(:mock_config) { mock(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(-1) }
-    let(:params)      { { params: { signature: :some_sig } } }  
-    before            { Helix::Config.stub(:instance) { mock_config } } 
+    let(:params)      { { params:       { signature: :some_sig },
+                          content_type: "text/xml" } }
+    let(:url_opts)    { { action:       :slice,
+                          media_type:   "videos",
+                          content_type: :xml,
+                          formats:      :some_format } }
+    let(:sig_opts)    { { contributor:  :helix,
+                          library_id:   :development,
+                          formats:      :some_format } }
+    before            { Helix::Config.stub(:instance) { mock_config } }
 
     it "should get an ingest signature" do
       mock_config.should_receive(:build_url).with(url_opts)
       mock_config.should_receive(:signature).with(:ingest, sig_opts) { :some_sig }
       RestClient.should_receive(:post).with(nil, import_xml, params)
-      klass.send(meth)
+      klass.send(meth, {formats: :some_format})
     end
   end
 
-  describe ".get_xml" do 
-    let(:meth)  { :get_xml }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(-1) }
-    context "when :use_raw_xml is present in attrs" do
-      let(:use_raw_xml) { { use_raw_xml: :xml } }
-      it "should return the value of attrs[:use_raw_xml]" do
-        expect(klass.send(meth, use_raw_xml)).to eq(:xml)
+  describe ".get_stillframe" do
+    let(:meth)        { :get_stillframe }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(-2) }
+    let(:image_data)  { :some_image_data }
+    let(:guid)        { :some_guid }
+    let(:server)      { "service-staging" }
+    let(:base_url)    { "#{server}.twistage.com/videos/#{guid}/screenshots/" }
+    context "when no height or width is passed in " do
+      let(:full_url) { "#{base_url}original.jpg" }
+      it "should build the correct url and return data" do
+        RestClient.should_receive(:get).with(full_url).and_return image_data
+        expect(klass.send(meth, guid)).to eq(image_data)
       end
     end
-    context "when hash is passed without :use_raw_xml" do
-      let(:attrs) { { attribute: :value } }
-      it "should convert attrs into xml" do
-        expect(klass.send(meth, attrs)).to eq(import_xml(attrs))
+    [:height, :width].each do |dimension|
+      context "when #{dimension} is passed in" do
+        url_tag = (dimension == :height ? "h" : "w")
+        let(:dim_val)   { 100 }
+        let(:full_url)  { "#{base_url}#{dim_val}#{url_tag}.jpg" }
+        let(:opts)      { { dimension => dim_val } }
+        it "should build the correct url and return data" do
+          RestClient.should_receive(:get).with(full_url).and_return image_data
+          expect(klass.send(meth, guid, opts)).to eq(image_data)
+        end
       end
     end
-    context "when nothing in passed in" do
-      it "should return valid xml" do
-        expect(klass.send(meth)).to eq(import_xml)
+    context "when both height and width are passed in" do
+      let(:dim_val)   { 100 }
+      let(:full_url)  { "#{base_url}#{dim_val}w#{dim_val}h.jpg" }
+      let(:opts)      { { height: dim_val, width: dim_val } }
+      it "should build the correct url and return data" do
+        RestClient.should_receive(:get).with(full_url).and_return image_data
+        expect(klass.send(meth, guid, opts)).to eq(image_data)
       end
     end
   end
-
-  describe ".get_url_opts" do
-    let(:meth)  { :get_url_opts }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(0) }
-    it "should return a valid hash url options for Helix::Config#build_url" do
-       expect(klass.send(meth)).to eq(url_opts)
-    end
-  end
-
-  describe ".get_url" do
-    let(:meth)  { :get_url }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(0) }
-    it "should call Helix::Config#build_url with url opts" do
-      Helix::Config.instance.should_receive(:build_url).with(klass.send(:get_url_opts))
-      klass.send(meth)
-    end
-  end
-
-  describe ".get_params" do
-    let(:meth)  { :get_params }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(-1) }
-    it "should call Helix::Config#signature and return a hash of params" do
-      Helix::Config.instance.should_receive(:signature).with(:ingest, sig_opts) { :sig }
-      expect(klass.send(meth)).to eq({ params: { signature: :sig } })
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: helix
 version: !ruby/object:Gem::Version
-  version: 0.0.2.0.pre
+  version: 0.0.2.1.pre
   prerelease: 8
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-08 00:00:00.000000000 Z
+date: 2013-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -82,6 +82,7 @@ files:
 - spec/album_spec.rb
 - spec/track_spec.rb
 - spec/base_spec.rb
+- spec/durationed_media_spec.rb
 - LICENSE
 - README.md
 homepage: https://github.com/Twistage/helix/