helix 0.0.4.4.pre → 0.0.4.5.pre

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjA5ODZhZTViNWE2ZjhlYzk2NTMyZTRmMGUzZDA4YjM5NzExNGM1NQ==
+  data.tar.gz: !binary |-
+    MWVjMTliMTgyNWJlM2U0NzFmMDU2ZmU5NzhjZjNmNWE0OTM0ZDY0Mg==
+SHA512:
+  metadata.gz: !binary |-
+    M2M2MGQ2NmMxNTI4YzhjYmJlNzZhNmMyMTgyM2VhYTEyYzI2MmU3NjE3NzA1
+    NzIyZTFlYTUxYmNkYTkyNWNhYjQ4Nzg3ZDQzNmI0NmVjYTJjOTEyZDM5ODgx
+    ZDI1NTFlMTRlOGEyNmQxN2Q5MzA3OTVjMjVjNDE5ZTNhYTUwMTM=
+  data.tar.gz: !binary |-
+    ZTcwNjBmM2Q3ODVkZjAxNGY5NDA2ZmYwZGRmYjNlY2JlODI0ZDI1Y2RlYjgy
+    YmZkNDE5NTYxODZkZGViYjRhOGU5ZDkyZmQ4ZGQzMWE2MGFkY2VhNWU5NTdl
+    MTIzNzQ3NDgzOTM2OTNhZmRiNWFmODU1YTNjZWVlMWM0ZTRkZTc=

data/lib/helix/album.rb

@@ -22,10 +22,6 @@ module Helix
       raise "Albums Update is not currently supported."
     end
 
-    def self.known_attributes
-      [:title, :description]
-    end
-
   end
 
 end

data/lib/helix/library.rb

@@ -43,11 +43,6 @@ module Helix
       "libraries"
     end
 
-    #TODO: Revisit and document.
-    def self.known_attributes
-      [:player_profile, :ingest_profile, :secure_stream_callback_url, :hooks_attributes]
-    end
-
   end
 
 end

data/lib/helix/paginates.rb

@@ -16,13 +16,14 @@ module Helix
     # @return [Array] The accumulated attribute Hashes for ORM instances
     def get_aggregated_data_sets(url, plural_resource_label, original_opts={})
       data_sets, page, per_page = [], STARTING_PAGE
+      specific_page_requested   = specific_page_requested?(original_opts)
       begin
         aggregation_opts = {page: page, per_page: ITEMS_PER_PAGE}.merge(original_opts)
         raw_response = get_response(url, {sig_type: :view}.merge(aggregation_opts))
         data_set     = raw_response[plural_resource_label]
         data_sets   += data_set if data_set
         page        += 1
-      end until last_page? || specific_page_requested?(original_opts)
+      end until specific_page_requested || last_page?
       data_sets
     end
 
@@ -71,19 +72,17 @@ module Helix
     end
 
     def parse_response_by_url_format(response, url)
-      ### FIXME: This is ugly. Clean it up.
-      if url =~ /json/
-        JSON.parse(response)
-      elsif url =~ /xml/
-        #TODO: Cleanup Nori and response gsub.
-        Nori.parser = :nokogiri
-        xml = response.gsub(/<custom-fields type='array'>/, '<custom-fields type=\'hash\'>')
-        Nori.parse(xml)
-      elsif url =~ /csv/
-        response
-      else
-        raise "Could not parse #{url}"
-      end
+      return JSON.parse(response)              if url =~ /json/
+      return response                          if url =~ /csv/
+      return parse_xml_response(response, url) if url =~ /xml/
+      raise "Could not parse #{url}"
+    end
+
+    def parse_xml_response(response, url)
+      #TODO: Cleanup Nori and response gsub.
+      Nori.parser = :nokogiri
+      xml = response.gsub(/<custom-fields type='array'>/, "<custom-fields type='hash'>")
+      Nori.parse(xml)
     end
 
   end

data/lib/helix/uploadable.rb

@@ -6,24 +6,24 @@ module Helix
 
     module ClassMethods
 
-      def upload(file_name)
-        url     = upload_server_name
+      def upload(file_name, opts={})
+        url     = upload_server_name(opts)
         payload = { file: File.new(file_name.to_s, "rb") }
-        headers = { multipart:  true }
+        headers = { multipart: true }
         RestClient.post(url, payload, headers)
         http_close
       end
 
-      def upload_server_name
-        upload_get(:http_open, ingest_opts)
+      def upload_server_name(http_open_opts={})
+        upload_get(:http_open, ingest_sig_opts, http_open_opts)
       end
 
-      def http_open
-        upload_server_name
+      def http_open(opts={})
+        upload_server_name(opts)
       end
 
-      def upload_open
-        upload_server_name
+      def upload_open(opts={})
+        upload_server_name(opts)
       end
 
       def http_close
@@ -36,21 +36,37 @@ module Helix
 
       private
 
-      def ingest_opts
+      # OPTIMIZE: This only accepts a flat Hash for http_open_opts, and
+      # doesn't encode. Neither is a big problem for the expected use
+      # cases, but should still be noted.
+      def add_params_to_url(url, http_open_opts)
+        return url if http_open_opts == {}
+        query_string = http_open_opts.inject([]) do |memo,pair|
+          k,v   = *pair
+          memo << "#{k}=#{v}"
+        end.join('&')
+        "#{url}?#{query_string}"
+      end
+
+      def ingest_sig_opts
         cc = config.credentials
-        ingest_opts = {
+        ingest_sig_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:   "" )
+      def upload_get(action, ingest_sig_opts={}, http_open_opts={})
+        guid     = config.signature(:ingest, ingest_sig_opts)
+        url_opts = {
+          resource_label: "upload_sessions",
+          guid:           guid,
+          action:         action,
+          content_type:   ""
+        }
+        url      = config.build_url(url_opts)
+        url      = add_params_to_url(url, http_open_opts)
         RestClient.get(url)
       end
 

data/lib/helix/user.rb

@@ -29,10 +29,6 @@ module Helix
       "users"
     end
 
-    def self.known_attributes
-      []
-    end
-
   end
 
 end

data/spec/_integration_spec.rb

@@ -6,7 +6,7 @@ config = File.exists?(config_filename) ? Helix::Config.load(config_filename) : n
 
 if config.nil?
   puts "No config, skipping integration specs"
-elsif %w(1 t true).include?(ENV['SKIP_INTEGRATION'])
+elsif %w(1 t true).include?(ENV['SKIP_INTEGRATION']) or not %w(1 t true).include?(ENV['INTEGRATION'])
   puts "Skipping integration specs due to user request"
 else
 

data/spec/album_spec.rb

@@ -14,14 +14,6 @@ describe Helix::Album do
     it { should respond_to(crud_call) }
   end
 
-  describe ".known_attributes" do
-    let(:meth)            { :known_attributes }
-    let(:expected_attrs)  { [:title, :description] }
-    it "should equal expected_attrs" do
-      expect(klass.send(meth)).to eq(expected_attrs)
-    end
-  end
-
   describe "Constants"
 
   describe "an instance" do

data/spec/config_spec.rb

@@ -624,4 +624,15 @@ describe Helix::Config do
     end
   end
 
+  describe "#sub_url_scoping" do
+    context "when given 'base_url_with_companies', {resource_label: 'libraries'})" do
+      subject { obj.send(:sub_url_scoping, 'base_url_with_companies', {resource_label: 'libraries'}) }
+      it { should eq('base_url_with_companies/libraries') }
+    end
+    context "when given 'base_url_without', {resource_label: 'libraries'})" do
+      subject { obj.send(:sub_url_scoping, 'base_url_without', {resource_label: 'libraries'}) }
+      it { should eq('base_url_without/companies/the_co/libraries') }
+    end
+  end
+
 end

data/spec/document_spec.rb

@@ -29,8 +29,8 @@ describe Helix::Document do
 
   ### CLASS METHODS
 
-  describe ".ingest_opts" do
-    let(:meth)        { :ingest_opts }
+  describe ".ingest_sig_opts" do
+    let(:meth)        { :ingest_sig_opts }
     let(:mock_config) { double(Helix::Config, credentials: {}) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(0) }
@@ -61,110 +61,7 @@ describe Helix::Document do
     end
   end
 
-  describe ".upload" do
-    let(:meth)            { :upload }
-    let(:mock_config)     { double(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) { double(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
-      klass.should_receive(:ingest_opts) { :ingest_opts }
-      mock_config.should_receive(:build_url).with(url_opts) { :url }
-      mock_config.should_receive(:signature).with(:ingest, :ingest_opts) { :some_sig }
-      RestClient.should_receive(:get).with(:url)
-      klass.send(meth)
-    end
-  end
-
-  describe ".http_close" do
-    let(:meth)        { :http_close }
-    let(:mock_config) { double(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) { double(Helix::Config) }
-    subject           { klass.method(meth) }
-    its(:arity)       { should eq(-2) }
-    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) { double(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) { double(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) { double(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
+  it_behaves_like "ingest_sig_opts", Helix::Document
+  it_behaves_like "uploads",         Helix::Document
 
 end

data/spec/library_spec.rb

@@ -17,43 +17,8 @@ describe Helix::Library do
     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,
-                              :hooks_attributes] }
-    it "should equal expected_attrs" do
-      expect(klass.send(meth)).to eq(expected_attrs)
-    end
-  end
-
   describe "Constants"
 
-  describe ".find" do
-    let(:meth)  { :find }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(-2) }
-    context "when given just a nickname" do
-=begin
-      it "should call super(nickname, {content_type: :xml})" do
-        Helix::Base.should_not_receive(:load)
-        Helix::RESTful.should_not_receive(:find)
-        expect(klass.send(meth, :a_nickname)).to be :blah
-      end
-=end
-    end
-    context "when given a nickname and opts" do
-=begin
-      it "should call super(nickname, opts.merge(content_type: :xml))" do
-        Helix::Base.should_not_receive(:load)
-        Helix::RESTful.should_not_receive(:find)
-        expect(klass.send(meth, :a_nickname, {k: :v})).to be :blah
-      end
-=end
-    end
-  end
-
   describe "an instance" do
     let(:obj)            { klass.new({'library_id' => 'some_library_id'}) }
     subject              { obj }

data/spec/media_spec.rb

@@ -17,7 +17,7 @@ describe Helix::Media do
     end
   end
 
-  klasses = [ Helix::Album, Helix::Document, Helix::Image, Helix::Track, Helix::User, Helix::Video ]
+  klasses = [ Helix::Album, Helix::Document, Helix::Image, Helix::Library, Helix::Track, Helix::User, Helix::Video ]
   klasses.each do |klass|
 
     subject { klass }
@@ -168,8 +168,9 @@ describe Helix::Media do
                   klass.should_receive(:new).with({attributes: {guid_name => guid}, config: mock_config})
                   klass.send(meth, guid, content_type: content_type)
                 end
-                it "should load(content_type: #{content_type}" do
-                  mock_obj.should_receive(:load).with(content_type: content_type)
+                internal_content_type = (klass == Helix::Library) ? :xml : content_type
+                it "should load(content_type: #{internal_content_type}" do
+                  mock_obj.should_receive(:load).with(content_type: internal_content_type)
                   klass.send(meth, guid, content_type: content_type)
                 end
               end

data/spec/spec_helper.rb

@@ -5,3 +5,9 @@ SimpleCov.start do
   add_filter 'spec'
   add_group 'Libraries', 'lib'
 end
+
+require 'support/downloads'
+require 'support/ingest_sig_opts'
+require 'support/plays'
+require 'support/uploads'
+

data/spec/track_spec.rb

@@ -3,8 +3,8 @@ require 'helix'
 
 describe Helix::Track do
 
-  let(:klass) { Helix::Track }
-  subject     { klass }
+  klass = Helix::Track
+  subject { klass }
   mods = [ Helix::Base, Helix::Durationed, Helix::Media ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name)             { should eq('track_id') }
@@ -19,214 +19,19 @@ describe Helix::Track do
   ### INSTANCE METHODS
 
   describe "an instance" do
-    let(:obj)            { klass.new({'track_id' => 'some_track_guid'}) }
-    subject              { obj }
+    obj = klass.new({'track_id' => 'some_track_guid'})
+    subject { obj }
     its(:resource_label_sym) { should be(:track) }
     [:destroy, :update].each do |crud_call|
       it { should respond_to(crud_call) }
     end
-
-    describe "#download" do
-      let(:meth)        { :download }
-      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
-        obj.stub(:config)            { mock_config }
-        obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_resource_label) { :resource_label }
-        RestClient.stub(:get) { '' }
-      end
-      { '' => '', mp3: :mp3, nil => '' }.each do |arg,actual|
-        build_url_h = {action: :file, content_type: actual, guid: :some_guid, resource_label: :resource_label}
-        context "when given {content_type: #{arg}" do
-          it "should build_url(#{build_url_h})" do
-            mock_config.should_receive(:build_url).with(build_url_h)
-            obj.send(meth, content_type: arg)
-          end
-          it "should get a view signature" do
-            mock_config.should_receive(:signature).with(:view) { :some_sig }
-            obj.send(meth, content_type: arg)
-          end
-          it "should return an HTTP get to the built URL with the view sig" do
-            mock_config.stub(:build_url).with(build_url_h) { :the_url }
-            RestClient.should_receive(:get).with(:the_url, params) { :expected }
-            expect(obj.send(meth, content_type: arg)).to be(:expected)
-          end
-        end
-      end
-    end
-
-    describe "#play" do
-      let(:meth)        { :play }
-      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
-        obj.stub(:config)            { mock_config }
-        obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_resource_label) { :resource_label }
-        RestClient.stub(:get) { '' }
-      end
-      { '' => '', mp3: :mp3, nil => '' }.each do |arg,actual|
-        build_url_h = {action: :play, content_type: actual, guid: :some_guid, resource_label: :resource_label}
-        context "when given {content_type: #{arg}" do
-          it "should build_url(#{build_url_h})" do
-            mock_config.should_receive(:build_url).with(build_url_h)
-            obj.send(meth, content_type: arg)
-          end
-          it "should get a view signature" do
-            mock_config.should_receive(:signature).with(:view) { :some_sig }
-            obj.send(meth, content_type: arg)
-          end
-          it "should return an HTTP get to the built URL with the view sig" do
-            mock_config.stub(:build_url).with(build_url_h) { :the_url }
-            RestClient.should_receive(:get).with(:the_url, params) { :expected }
-            expect(obj.send(meth, content_type: arg)).to be(:expected)
-          end
-        end
-      end
-    end
-
+    it_behaves_like "downloads", obj
+    it_behaves_like "plays",     obj
   end
 
   ### 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)     { double(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) { double(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
-      klass.should_receive(:ingest_opts) { :ingest_opts }
-      mock_config.should_receive(:build_url).with(url_opts) { :url }
-      mock_config.should_receive(:signature).with(:ingest, :ingest_opts) { :some_sig }
-      RestClient.should_receive(:get).with(:url)
-      klass.send(meth)
-    end
-  end
-
-  describe ".http_close" do
-    let(:meth)        { :http_close }
-    let(:mock_config) { double(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) { double(Helix::Config) }
-    subject           { klass.method(meth) }
-    its(:arity)       { should eq(-2) }
-    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) { double(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) { double(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) { double(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
+  it_behaves_like "ingest_sig_opts", Helix::Track
+  it_behaves_like "uploads",         Helix::Track
 
 end

data/spec/user_spec.rb

@@ -17,10 +17,6 @@ describe Helix::User do
     it { should respond_to(crud_call) }
   end
 
-  describe ".known_attributes" do
-    its(:known_attributes) { should eq([]) }
-  end
-
   describe "Constants"
 
   describe "an instance" do

data/spec/video_spec.rb

@@ -7,8 +7,8 @@ describe Helix::Video do
     { list: { entry: values[:url_params] || {} } }.to_xml(root: :add)
   end
 
-  let(:klass) { Helix::Video }
-  subject     { klass }
+  klass = Helix::Video
+  subject { klass }
   mods = [ Helix::Base, Helix::Durationed, Helix::Media ]
   mods.each { |mod| its(:ancestors) { should include(mod) } }
   its(:guid_name)             { should eq('video_id') }
@@ -23,71 +23,12 @@ describe Helix::Video do
   ### INSTANCE METHODS
 
   describe "an instance" do
-    let(:obj) { klass.new({video_id: 'some_video_guid'}) }
+    obj = klass.new({video_id: 'some_video_guid'})
     subject   { obj }
     its(:resource_label_sym) { should be(:video) }
 
-    describe "#download" do
-      let(:meth)        { :download }
-      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
-        obj.stub(:config)            { mock_config }
-        obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_resource_label) { :resource_label }
-        RestClient.stub(:get) { '' }
-      end
-      { '' => '', mp3: :mp3, nil => '' }.each do |arg,actual|
-        build_url_h = {action: :file, content_type: actual, guid: :some_guid, resource_label: :resource_label}
-        context "when given {content_type: #{arg}" do
-          it "should build_url(#{build_url_h})" do
-            mock_config.should_receive(:build_url).with(build_url_h)
-            obj.send(meth, content_type: arg)
-          end
-          it "should get a view signature" do
-            mock_config.should_receive(:signature).with(:view) { :some_sig }
-            obj.send(meth, content_type: arg)
-          end
-          it "should return an HTTP get to the built URL with the view sig" do
-            mock_config.stub(:build_url).with(build_url_h) { :the_url }
-            RestClient.should_receive(:get).with(:the_url, params) { :expected }
-            expect(obj.send(meth, content_type: arg)).to be(:expected)
-          end
-        end
-      end
-    end
-
-    describe "#play" do
-      let(:meth)        { :play }
-      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
-        obj.stub(:config)            { mock_config }
-        obj.stub(:guid)              { :some_guid  }
-        obj.stub(:plural_resource_label) { :resource_label }
-        RestClient.stub(:get) { '' }
-      end
-      { '' => '', mp3: :mp3, nil => '' }.each do |arg,actual|
-        build_url_h = {action: :play, content_type: actual, guid: :some_guid, resource_label: :resource_label}
-        context "when given {content_type: #{arg}" do
-          it "should build_url(#{build_url_h})" do
-            mock_config.should_receive(:build_url).with(build_url_h)
-            obj.send(meth, content_type: arg)
-          end
-          it "should get a view signature" do
-            mock_config.should_receive(:signature).with(:view) { :some_sig }
-            obj.send(meth, content_type: arg)
-          end
-          it "should return an HTTP get to the built URL with the view sig" do
-            mock_config.stub(:build_url).with(build_url_h) { :the_url }
-            RestClient.should_receive(:get).with(:the_url, params) { :expected }
-            expect(obj.send(meth, content_type: arg)).to be(:expected)
-          end
-        end
-      end
-    end
+    it_behaves_like "downloads", obj
+    it_behaves_like "plays",     obj
 
     describe "#stillframe" do
       let(:meth)        { :stillframe }
@@ -182,142 +123,8 @@ 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)     { double(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) { double(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
-      klass.should_receive(:ingest_opts) { :ingest_opts }
-      mock_config.should_receive(:build_url).with(url_opts) { :url }
-      mock_config.should_receive(:signature).with(:ingest, :ingest_opts) { :some_sig }
-      RestClient.should_receive(:get).with(:url)
-      klass.send(meth)
-    end
-  end
-
-  describe ".http_close" do
-    let(:meth)        { :http_close }
-    let(:mock_config) { double(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) { double(Helix::Config) }
-    subject           { klass.method(meth) }
-    its(:arity)       { should eq(-2) }
-    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) { double(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) { double(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) { double(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
+  it_behaves_like "ingest_sig_opts", Helix::Video
+  it_behaves_like "uploads",         Helix::Video
 
   describe ".slice" do
     let(:meth)        { :slice }

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: helix
 version: !ruby/object:Gem::Version
-  version: 0.0.4.4.pre
-  prerelease: 8
+  version: 0.0.4.5.pre
 platform: ruby
 authors:
 - Twistage, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-12 00:00:00.000000000 Z
+date: 2013-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -46,7 +41,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: nori
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -54,7 +48,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
@@ -115,27 +108,26 @@ files:
 homepage: https://github.com/Twistage/helix/
 licenses:
 - 3-Clause BSD
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>'
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.1.4
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Wrapper library for the video API
 test_files: []
 has_rdoc: yard