helix 0.0.3.9.pre → 0.0.4.0.pre

data/lib/helix/config.rb

@@ -154,7 +154,8 @@ module Helix
 
       lk = license_key
       @signature_expiration_for[lk][sig_type] = Time.now + TIME_OFFSET
-      @signature_for[lk][sig_type] = RestClient.get(url_for(sig_type, opts))
+      new_sig_url                  = url_for(sig_type, opts)
+      @signature_for[lk][sig_type] = RestClient.get(new_sig_url)
     end
 
     def proxy
@@ -226,11 +227,12 @@ module Helix
     end
 
     def url_for(sig_type, opts={})
-      contributor, library_id = [:contributor, :library_id].map { |key| opts[key] }
-      contributor ||= credentials[:contributor]
+      contributor, library_id, company_id = [:contributor, :library_id, :company_id].map { |key| opts[key] }
+      contributor ||= (credentials[:contributor] || 'helix_default_contributor')
       url  = "#{credentials[:site]}/api/#{sig_type}_key?licenseKey=#{credentials[:license_key]}&duration=#{SIG_DURATION}"
-      url += "&contributor=#{contributor}"  if contributor
-      url += "&library_id=#{library_id}"    if library_id
+      url += "&contributor=#{contributor}" if sig_type == :ingest
+      url += "&library_id=#{library_id}"   if library_id
+      url += "&company_id=#{company_id}"   if company_id
       url
     end
 

data/lib/helix/uploadable.rb

@@ -7,14 +7,15 @@ module Helix
     module ClassMethods
 
       def upload(file_name)
-        RestClient.post(upload_server_name,
-                        { file:       File.new(file_name.to_s, "rb") },
-                        { multipart:  true } )
+        url     = upload_server_name
+        payload = { file: File.new(file_name.to_s, "rb") }
+        headers = { multipart:  true }
+        RestClient.post(url, payload, headers)
         http_close
       end
 
       def upload_server_name
-        upload_get(:http_open)
+        upload_get(:http_open, ingest_opts)
       end
 
       def http_open
@@ -35,9 +36,19 @@ module Helix
 
       private
 
-      def upload_get(action)
-        url = config.build_url( resource_label: "upload_sessions",
-                                guid:           config.signature(:ingest),
+      def ingest_opts
+        cc = config.credentials
+        ingest_opts = {
+          contributor: cc[:contributor],
+          company_id:  cc[:company],
+          library_id:  cc[:library],
+        }
+      end
+
+      def upload_get(action, opts={})
+        guid = config.signature(:ingest, opts)
+        url  = config.build_url(resource_label: "upload_sessions",
+                                guid:           guid,
                                 action:         action,
                                 content_type:   "" )
         RestClient.get(url)

data/spec/_integration_spec.rb

@@ -10,16 +10,20 @@ elsif %w(1 t true).include?(ENV['SKIP_INTEGRATION'])
   puts "Skipping integration specs due to user request"
 else
 
-  media_by_id = {
+  default_query_proc = lambda { |h,k| h[k] = 'rest-client' }
+  query_by_guid_key  = Hash.new(&default_query_proc).merge(tag_id: '8143')
+
+  resource_by_id = {
     album_id:    Helix::Album,
     document_id: Helix::Document,
     image_id:    Helix::Image,
     playlist_id: Helix::Playlist,
+    tag_id:      Helix::Tag,
     track_id:    Helix::Track,
     video_id:    Helix::Video
   }
 
-  media_by_id.each do |guid_key,klass|
+  resource_by_id.each do |guid_key,klass|
 
     describe "Integration Specs for #{klass.to_s}" do
 
@@ -28,9 +32,18 @@ else
         it { should_not be_empty }
       end
 
-      describe ".where(query: 'rest-client')" do
+      query = query_by_guid_key[guid_key]
+      describe ".where(query: '#{query}')" do
         it "should not raise an exception" do
-          lambda { klass.where(query: 'rest-client') }.should_not raise_error
+          lambda { klass.where(query: query) }.should_not raise_error
+        end
+        if guid_key == :tag_id
+          subject { klass.where(query: query).first }
+          it { should be_a Helix::Tag }
+          its(:name)  { should be_a String  }
+          its(:name)  { should eq '8143'    }
+          its(:count) { should be_a Integer }
+          its(:count) { should eq 2         }
         end
       end
 
@@ -51,7 +64,7 @@ else
       end
 
       shared_examples_for "found #{klass}" do
-        it { should_not be_empty }
+        it { should_not be_nil }
         if klass == Helix::Playlist
           # Playlist Metadata is just a wrapper for an Array of media items: no guid
           its(guid_key) { should eq(nil) }
@@ -66,7 +79,7 @@ else
               "width"        => 1280,
               "height"       => 720,
               "size"         => 260548,
-              "url"          => "http://edited-yet-again-staging.twistage.com:80/videos/ece0d3fd03bf0/screenshots/original.jpg"
+              "url"          => "http://service-staging.twistage.com:80/videos/ece0d3fd03bf0/screenshots/original.jpg"
             }
             subject { item.screenshots.first }
             it { should eq(expected_ss) }
@@ -87,7 +100,7 @@ else
         end
       end
 
-      unless guid_key == :document_id # no Document stats yet
+      unless [:document_id, :playlist_id, :tag_id].include?(guid_key) # no stats for these yet
         describe "Stats" do
           media_type  = guid_key.to_s.split(/_/).first
           helix_stats = Helix::Statistics

data/spec/base_spec.rb

@@ -38,7 +38,7 @@ describe Helix::Base do
     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)
+        double(Helix::Config, build_url: :built_url, get_aggregated_data_sets: dss)
       end
       before(:each) do Helix::Config.stub(:instance) { mock_config } end
       context "and NOT given an opts Hash" do
@@ -68,7 +68,7 @@ describe Helix::Base do
     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)
+        double(Helix::Config, build_url: :built_url, get_aggregated_data_sets: dss)
       end
       before(:each) do Helix::Config.stub(:instance) { mock_config } end
       context "and NOT given an opts Hash" do
@@ -221,7 +221,7 @@ describe Helix::Base do
       describe "#guid" do
         let(:meth) { :guid }
         it "should return @attributes[guid_name]" do
-          mock_attributes = mock(Object)
+          mock_attributes = double(Object)
           obj.instance_variable_set(:@attributes, mock_attributes)
           obj.should_receive(:guid_name) { :the_guid_name }
           mock_attributes.should_receive(:[]).with(:the_guid_name) { :expected }
@@ -239,7 +239,7 @@ describe Helix::Base do
 
       describe "#load" do
         let(:meth)  { :load }
-        let(:mock_config) { mock(Helix::Config) }
+        let(:mock_config) { double(Helix::Config) }
         subject     { obj.method(meth) }
         its(:arity) { should eq(-1) }
         before(:each) do
@@ -307,7 +307,7 @@ describe Helix::Base do
         its(:arity) { should eq(1) }
         context "when given method_sym" do
           let(:method_sym) { :method_sym }
-          let(:mock_attributes) { mock(Object) }
+          let(:mock_attributes) { double(Object) }
           before(:each) do obj.instance_variable_set(:@attributes, mock_attributes) end
           context "and @attributes[method_sym.to_s] raises an exception" do
             before(:each) do mock_attributes.should_receive(:[]).with(method_sym.to_s).and_raise("some exception") end

data/spec/config_spec.rb

@@ -51,8 +51,8 @@ describe Helix::Config do
 
   describe ".load" do
     let(:meth)      { :load }
-    let(:mock_obj)  { mock(klass, proxy: :stubbed_proxy) }
-    let(:mock_file) { mock(File)  }
+    let(:mock_obj)  { double(klass, proxy: :stubbed_proxy) }
+    let(:mock_file) { double(File)  }
     let(:mock_cred) { {key1: 'value1', 'key2' => 'value2'} }
     let(:symbolized_cred) { {key1: 'value1', key2: 'value2'} }
     before(:each) do
@@ -335,8 +335,8 @@ describe Helix::Config do
         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'})
+        non_final_response = double(String, headers: {is_last_page: 'false'})
+        final_response     = double(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 }
@@ -433,7 +433,7 @@ describe Helix::Config do
         it { should be false }
       end
       context "when there is a @response" do
-        let(:mock_response) { mock(String) }
+        let(:mock_response) { double(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 } }
@@ -532,7 +532,7 @@ describe Helix::Config do
       obj.stub(:prepare_signature_memoization)
     end
 
-    let(:mock_response) { mock(Object) }
+    let(:mock_response) { double(Object) }
     context "when given :some_invalid_sig_type" do
       let(:sig_type) { :some_invalid_sig_type }
       it "should raise an ArgumentError" do
@@ -551,12 +551,13 @@ describe Helix::Config do
       end
       it "should call RestClient.get(#{url})" do
         set_stubs(obj)
-        url = "#{obj.credentials[:site]}/api/#{sig_type}_key?licenseKey=#{license_key}&duration=1200"
+        url  = "#{obj.credentials[:site]}/api/#{sig_type}_key?licenseKey=#{license_key}&duration=1200"
+        url += "&contributor=helix_default_contributor" if sig_type == :ingest
         RestClient.should_receive(:get).with(url) { :fresh_sig }
         expect(obj.send(meth, sig_type)).to be(:fresh_sig)
       end
       it "sets a new sig expiration time" do
-        mock_time = mock(Time)
+        mock_time = double(Time)
         Time.should_receive(:now) { mock_time }
         mock_time.should_receive(:+).with(klass::TIME_OFFSET) { :new_time }
         obj.send(meth, sig_type)
@@ -596,8 +597,8 @@ describe Helix::Config do
 
     context "when given a sig_type" do
       let(:sig_type) { :a_sig_type }
-      let(:mock_expired) { mock(Time) }
-      let(:mock_now)     { mock(Time) }
+      let(:mock_expired) { double(Time) }
+      let(:mock_now)     { double(Time) }
       subject { obj.send(meth, sig_type) }
       context "when @signature_expiration_for[license_key][sig_type] is nil" do
         before(:each) do obj.instance_variable_set(:@signature_expiration_for, {license_key => {sig_type => nil}}) end

data/spec/document_spec.rb

@@ -29,9 +29,41 @@ describe Helix::Document do
 
   ### CLASS METHODS
 
+  describe ".ingest_opts" do
+    let(:meth)        { :ingest_opts }
+    let(:mock_config) { double(Helix::Config, credentials: {}) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should be private" do expect(klass.private_methods).to include(meth) end
+    context "when called" do
+      subject { klass.send(meth) }
+      before(:each) do klass.stub(:config) { mock_config } end
+      it "should be a Hash" do expect(klass.send(meth)).to be_a(Hash) end
+      its(:keys) { should match_array([:contributor, :company_id, :library_id]) }
+      context "the value for :contributor" do
+        it "should be config.credentials[:contributor]" do
+          mock_config.should_receive(:credentials) { {contributor: :expected_contributor} }
+          expect(klass.send(meth)[:contributor]).to be(:expected_contributor)
+        end
+      end
+      context "the value for :company_id" do
+        it "should be config.credentials[:company]" do
+          mock_config.should_receive(:credentials) { {company: :expected_company} }
+          expect(klass.send(meth)[:company_id]).to be(:expected_company)
+        end
+      end
+      context "the value for :library_id" do
+        it "should be config.credentials[:library]" do
+          mock_config.should_receive(:credentials) { {library: :expected_library} }
+          expect(klass.send(meth)[:library_id]).to be(:expected_library)
+        end
+      end
+    end
+  end
+
   describe ".upload" do
     let(:meth)            { :upload }
-    let(:mock_config)     { mock(Helix::Config) }
+    let(:mock_config)     { double(Helix::Config) }
     subject               { klass.method(meth) }
     its(:arity)           { should eq(1) }
     let(:file_hash)       { { file: :some_file  } }
@@ -49,7 +81,7 @@ describe Helix::Document do
 
   describe ".upload_server_name" do
     let(:meth)        { :upload_server_name }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     let(:url_opts)    { { resource_label: "upload_sessions",
@@ -58,8 +90,9 @@ describe Helix::Document do
                           content_type:   ""  } }
     before            { Helix::Config.stub(:instance) { mock_config } }
     it "should call RestClient.get with correct url building" do
+      klass.should_receive(:ingest_opts) { :ingest_opts }
       mock_config.should_receive(:build_url).with(url_opts) { :url }
-      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      mock_config.should_receive(:signature).with(:ingest, :ingest_opts) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth)
     end
@@ -67,7 +100,7 @@ describe Helix::Document do
 
   describe ".http_close" do
     let(:meth)        { :http_close }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     let(:url_opts)    { { resource_label: "upload_sessions",
@@ -77,7 +110,7 @@ describe Helix::Document do
     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 }
+      mock_config.should_receive(:signature).with(:ingest, {}) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth)
     end
@@ -85,9 +118,9 @@ describe Helix::Document do
 
   describe ".upload_get" do
     let(:meth)        { :upload_get }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
-    its(:arity)       { should eq(1) }
+    its(:arity)       { should eq(-2) }
     let(:url_opts)    { { resource_label: "upload_sessions",
                           guid:           :some_sig,
                           action:         :upload_get,
@@ -95,7 +128,7 @@ describe Helix::Document do
     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 }
+      mock_config.should_receive(:signature).with(:ingest, {}) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth, :upload_get)
     end
@@ -103,7 +136,7 @@ describe Helix::Document do
 
   describe ".http_open" do
     let(:meth)        { :http_open }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do
@@ -114,7 +147,7 @@ describe Helix::Document do
 
   describe ".upload_open" do
     let(:meth)        { :upload_open }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do
@@ -125,7 +158,7 @@ describe Helix::Document do
 
   describe ".upload_close" do
     let(:meth)        { :upload_close }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do

data/spec/durationed_spec.rb

@@ -24,7 +24,7 @@ describe Helix::Durationed do
 
     describe ".import" do
       let(:meth)        { :import }
-      let(:mock_config) { mock(Helix::Config) }
+      let(:mock_config) { double(Helix::Config) }
       subject           { klass.method(meth) }
       its(:arity)       { should eq(-1) }
       let(:params)      { { params:       { signature: :some_sig },

data/spec/media_spec.rb

@@ -36,7 +36,7 @@ describe Helix::Media do
 
     describe ".create" do
       let(:meth)          { :create }
-      let(:mock_config)   { mock(Helix::Config) }
+      let(:mock_config)   { double(Helix::Config) }
       subject             { klass.method(meth) }
       its(:arity)         { should eq(-1) }
       let(:hash_from_xml) { { klass_sym.to_s => { attribute: :value } } }
@@ -108,15 +108,15 @@ describe Helix::Media do
 
     describe ".find" do
       let(:meth)        { :find }
-      let(:mock_config) { mock(Helix::Config) }
-      let(:mock_obj)    { mock(klass, :load => :output_of_load) }
+      let(:mock_config) { double(Helix::Config) }
+      let(:mock_obj)    { double(klass, :load => :output_of_load) }
       subject     { klass.method(meth) }
       its(:arity) { should eq(-2) }
       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) }
+          let(:mock_attrs) { double(Object, :[]= => :output_of_setting_val) }
           before(:each) do
             klass.stub(:attributes) { mock_attrs }
             klass.stub(:guid_name)  { guid_name  }
@@ -140,7 +140,7 @@ describe Helix::Media 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) }
+          let(:mock_attrs) { double(Object, :[]= => :output_of_setting_val) }
           before(:each) do
             klass.stub(:attributes) { mock_attrs }
             klass.stub(:guid_name)  { guid_name  }
@@ -185,7 +185,7 @@ describe Helix::Media do
 
         describe "#destroy" do
           let(:meth)   { :destroy }
-          let(:mock_config) { mock(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
+          let(:mock_config) { double(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
           subject      { obj.method(meth) }
           let(:params) { { params: {signature: :some_sig } } }
           before do
@@ -212,7 +212,7 @@ describe Helix::Media do
         describe "#update" do
           next if child_class == Helix::Album
           let(:meth)  { :update }
-          let(:mock_config) { mock(Helix::Config) }
+          let(:mock_config) { double(Helix::Config) }
           subject     { obj.method(meth) }
           its(:arity) { should eq(-1) }
           before(:each) do

data/spec/statistics_spec.rb

@@ -38,7 +38,7 @@ describe Helix::Statistics do
 
       describe ".#{resource_label}_#{stats_type}" do
         let(:meth)  { "#{resource_label}_#{stats_type}" }
-        let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: :raw_response) }
+        let(:mock_config) { double(Helix::Config, build_url: :built_url, get_response: :raw_response) }
         before(:each) do
           Helix::Config.stub(:instance) { mock_config }
           mod.stub(:standardize_raw_stats).with(:raw_response) { :response }

data/spec/tag_spec.rb

@@ -16,7 +16,7 @@ describe Helix::Tag do
   describe ".get_data_sets" do
     let(:meth)         { :get_data_sets }
     let(:raw_response) { {"tags" => :expected} }
-    let(:mock_config)  { mock(Helix::Config, build_url: :the_url, get_response: raw_response) }
+    let(:mock_config)  { double(Helix::Config, build_url: :the_url, get_response: raw_response) }
     let(:opts)         { {} }
     before(:each)      { klass.stub(:config) { mock_config }}
     bu_opts          = {content_type: :xml, resource_label: "tags"}

data/spec/track_spec.rb

@@ -29,9 +29,40 @@ describe Helix::Track do
 
   ### CLASS METHODS
 
+  describe ".ingest_opts" do
+    let(:meth)        { :ingest_opts }
+    let(:mock_config) { double(Helix::Config, credentials: {}) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should be private" do expect(klass.private_methods).to include(meth) end
+    context "when called" do
+      subject { klass.send(meth) }
+      before(:each) do klass.stub(:config) { mock_config } end
+      it "should be a Hash" do expect(klass.send(meth)).to be_a(Hash) end
+      its(:keys) { should match_array([:contributor, :company_id, :library_id]) }
+      context "the value for :contributor" do
+        it "should be config.credentials[:contributor]" do
+          mock_config.should_receive(:credentials) { {contributor: :expected_contributor} }
+          expect(klass.send(meth)[:contributor]).to be(:expected_contributor)
+        end
+      end
+      context "the value for :company_id" do
+        it "should be config.credentials[:company]" do
+          mock_config.should_receive(:credentials) { {company: :expected_company} }
+          expect(klass.send(meth)[:company_id]).to be(:expected_company)
+        end
+      end
+      context "the value for :library_id" do
+        it "should be config.credentials[:library]" do
+          mock_config.should_receive(:credentials) { {library: :expected_library} }
+          expect(klass.send(meth)[:library_id]).to be(:expected_library)
+        end
+      end
+    end
+  end
   describe ".upload" do
     let(:meth)            { :upload }
-    let(:mock_config)     { mock(Helix::Config) }
+    let(:mock_config)     { double(Helix::Config) }
     subject               { klass.method(meth) }
     its(:arity)           { should eq(1) }
     let(:file_hash)       { { file: :some_file  } }
@@ -49,7 +80,7 @@ describe Helix::Track do
 
   describe ".upload_server_name" do
     let(:meth)        { :upload_server_name }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     let(:url_opts)    { { resource_label: "upload_sessions",
@@ -58,8 +89,9 @@ describe Helix::Track do
                           content_type:   ""  } }
     before            { Helix::Config.stub(:instance) { mock_config } }
     it "should call RestClient.get with correct url building" do
+      klass.should_receive(:ingest_opts) { :ingest_opts }
       mock_config.should_receive(:build_url).with(url_opts) { :url }
-      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      mock_config.should_receive(:signature).with(:ingest, :ingest_opts) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth)
     end
@@ -67,7 +99,7 @@ describe Helix::Track do
 
   describe ".http_close" do
     let(:meth)        { :http_close }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     let(:url_opts)    { { resource_label: "upload_sessions",
@@ -77,7 +109,7 @@ describe Helix::Track do
     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 }
+      mock_config.should_receive(:signature).with(:ingest, {}) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth)
     end
@@ -85,9 +117,9 @@ describe Helix::Track do
 
   describe ".upload_get" do
     let(:meth)        { :upload_get }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
-    its(:arity)       { should eq(1) }
+    its(:arity)       { should eq(-2) }
     let(:url_opts)    { { resource_label: "upload_sessions",
                           guid:           :some_sig,
                           action:         :upload_get,
@@ -95,7 +127,7 @@ describe Helix::Track do
     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 }
+      mock_config.should_receive(:signature).with(:ingest, {}) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth, :upload_get)
     end
@@ -103,7 +135,7 @@ describe Helix::Track do
 
   describe ".http_open" do
     let(:meth)        { :http_open }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do
@@ -114,7 +146,7 @@ describe Helix::Track do
 
   describe ".upload_open" do
     let(:meth)        { :upload_open }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do
@@ -125,7 +157,7 @@ describe Helix::Track do
 
   describe ".upload_close" do
     let(:meth)        { :upload_close }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do

data/spec/video_spec.rb

@@ -29,7 +29,7 @@ describe Helix::Video do
 
     describe "#download" do
       let(:meth)        { :download }
-      let(:mock_config) { mock(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
+      let(:mock_config) { double(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
       subject      { obj.method(meth) }
       let(:params) { { params: {signature: :some_sig } } }
       before do
@@ -60,7 +60,7 @@ describe Helix::Video do
 
     describe "#play" do
       let(:meth)        { :play }
-      let(:mock_config) { mock(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
+      let(:mock_config) { double(Helix::Config, build_url: :the_built_url, signature: :some_sig) }
       subject      { obj.method(meth) }
       let(:params) { { params: {signature: :some_sig } } }
       before do
@@ -91,7 +91,7 @@ describe Helix::Video do
 
     describe "#stillframe" do
       let(:meth)        { :stillframe }
-      let(:mock_config) { mock(Helix::Config) }
+      let(:mock_config) { double(Helix::Config) }
       subject           { obj.method(meth) }
       its(:arity)       { should eq(-1) }
       it "should call self.class.get_stillframe" do
@@ -182,9 +182,40 @@ describe Helix::Video do
 
   ### CLASS METHODS
 
+  describe ".ingest_opts" do
+    let(:meth)        { :ingest_opts }
+    let(:mock_config) { double(Helix::Config, credentials: {}) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(0) }
+    it "should be private" do expect(klass.private_methods).to include(meth) end
+    context "when called" do
+      subject { klass.send(meth) }
+      before(:each) do klass.stub(:config) { mock_config } end
+      it "should be a Hash" do expect(klass.send(meth)).to be_a(Hash) end
+      its(:keys) { should match_array([:contributor, :company_id, :library_id]) }
+      context "the value for :contributor" do
+        it "should be config.credentials[:contributor]" do
+          mock_config.should_receive(:credentials) { {contributor: :expected_contributor} }
+          expect(klass.send(meth)[:contributor]).to be(:expected_contributor)
+        end
+      end
+      context "the value for :company_id" do
+        it "should be config.credentials[:company]" do
+          mock_config.should_receive(:credentials) { {company: :expected_company} }
+          expect(klass.send(meth)[:company_id]).to be(:expected_company)
+        end
+      end
+      context "the value for :library_id" do
+        it "should be config.credentials[:library]" do
+          mock_config.should_receive(:credentials) { {library: :expected_library} }
+          expect(klass.send(meth)[:library_id]).to be(:expected_library)
+        end
+      end
+    end
+  end
   describe ".upload" do
     let(:meth)            { :upload }
-    let(:mock_config)     { mock(Helix::Config) }
+    let(:mock_config)     { double(Helix::Config) }
     subject               { klass.method(meth) }
     its(:arity)           { should eq(1) }
     let(:file_hash)       { { file: :some_file  } }
@@ -202,7 +233,7 @@ describe Helix::Video do
 
   describe ".upload_server_name" do
     let(:meth)        { :upload_server_name }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     let(:url_opts)    { { resource_label: "upload_sessions",
@@ -211,8 +242,9 @@ describe Helix::Video do
                           content_type:   ""  } }
     before            { Helix::Config.stub(:instance) { mock_config } }
     it "should call RestClient.get with correct url building" do
+      klass.should_receive(:ingest_opts) { :ingest_opts }
       mock_config.should_receive(:build_url).with(url_opts) { :url }
-      mock_config.should_receive(:signature).with(:ingest) { :some_sig }
+      mock_config.should_receive(:signature).with(:ingest, :ingest_opts) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth)
     end
@@ -220,7 +252,7 @@ describe Helix::Video do
 
   describe ".http_close" do
     let(:meth)        { :http_close }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     let(:url_opts)    { { resource_label: "upload_sessions",
@@ -230,7 +262,7 @@ describe Helix::Video do
     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 }
+      mock_config.should_receive(:signature).with(:ingest, {}) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth)
     end
@@ -238,9 +270,9 @@ describe Helix::Video do
 
   describe ".upload_get" do
     let(:meth)        { :upload_get }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
-    its(:arity)       { should eq(1) }
+    its(:arity)       { should eq(-2) }
     let(:url_opts)    { { resource_label: "upload_sessions",
                           guid:           :some_sig,
                           action:         :upload_get,
@@ -248,7 +280,7 @@ describe Helix::Video do
     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 }
+      mock_config.should_receive(:signature).with(:ingest, {}) { :some_sig }
       RestClient.should_receive(:get).with(:url)
       klass.send(meth, :upload_get)
     end
@@ -256,7 +288,7 @@ describe Helix::Video do
 
   describe ".http_open" do
     let(:meth)        { :http_open }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do
@@ -267,7 +299,7 @@ describe Helix::Video do
 
   describe ".upload_open" do
     let(:meth)        { :upload_open }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do
@@ -278,7 +310,7 @@ describe Helix::Video do
 
   describe ".upload_close" do
     let(:meth)        { :upload_close }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
     it "should call upload_server_name" do
@@ -289,7 +321,7 @@ describe Helix::Video do
 
   describe ".slice" do
     let(:meth)        { :slice }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(-1) }
     let(:params)      { { params:       { signature: :some_sig },
@@ -313,7 +345,7 @@ describe Helix::Video do
 
   describe ".stillframe_for" do
     let(:meth)        { :stillframe_for }
-    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_config) { double(Helix::Config) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(-2) }
     let(:image_data)  { :some_image_data }

metadata

@@ -1,128 +1,136 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: helix
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.4.0.pre
   prerelease: 8
-  version: 0.0.3.9.pre
 platform: ruby
-authors: 
+authors:
 - Twistage, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-07-03 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: json
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.5.4
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rest-client
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.4
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
         version: 1.6.7
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: nori
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+- !ruby/object:Gem::Dependency
+  name: nori
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
         version: 1.1.3
   type: :runtime
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.3
 description: Provides helper libraries for Ruby access to the Twistage API
 email: kevin.baird@perceptivesoftware.com, michael.wood@perceptivesoftware.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/helix.rb
-- lib/helix/user.rb
-- lib/helix/document.rb
-- lib/helix/tag.rb
-- lib/helix/media.rb
-- lib/helix/statistics.rb
-- lib/helix/object_ext.rb
-- lib/helix/library.rb
+- lib/helix/base.rb
 - lib/helix/audio_playlist.rb
+- lib/helix/image.rb
+- lib/helix/restful.rb
+- lib/helix/hash_ext.rb
+- lib/helix/library.rb
+- lib/helix/user.rb
 - lib/helix/uploadable.rb
+- lib/helix/statistics.rb
+- lib/helix/document.rb
 - lib/helix/durationed.rb
-- lib/helix/playlist.rb
-- lib/helix/restful.rb
+- lib/helix/object_ext.rb
 - lib/helix/video_playlist.rb
-- lib/helix/config.rb
+- lib/helix/media.rb
 - lib/helix/video.rb
-- lib/helix/track.rb
-- lib/helix/base.rb
-- lib/helix/image.rb
 - lib/helix/album.rb
+- lib/helix/tag.rb
+- lib/helix/playlist.rb
+- lib/helix/track.rb
 - lib/helix/exceptions.rb
-- lib/helix/hash_ext.rb
-- spec/spec_helper.rb
+- lib/helix/config.rb
+- spec/durationed_spec.rb
+- spec/document_spec.rb
 - spec/audio_playlist_spec.rb
+- spec/library_spec.rb
+- spec/spec_helper.rb
 - spec/config_spec.rb
+- spec/base_spec.rb
+- spec/playlist_spec.rb
+- spec/video_spec.rb
+- spec/tag_spec.rb
+- spec/user_spec.rb
+- spec/_integration_spec.rb
+- spec/album_spec.rb
 - spec/image_spec.rb
-- spec/media_spec.rb
-- spec/durationed_spec.rb
 - spec/helix_spec.rb
-- spec/document_spec.rb
-- spec/album_spec.rb
 - spec/statistics_spec.rb
-- spec/_integration_spec.rb
-- spec/tag_spec.rb
 - spec/video_playlist_spec.rb
+- spec/media_spec.rb
 - spec/track_spec.rb
-- spec/user_spec.rb
-- spec/video_spec.rb
-- spec/playlist_spec.rb
-- spec/library_spec.rb
-- spec/base_spec.rb
 - LICENSE
 - README.md
 homepage: https://github.com/Twistage/helix/
-licenses: 
+licenses:
 - 3-Clause BSD
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Wrapper library for the video API
 test_files: []
-