helix 0.0.2.3.pre → 0.0.2.4.pre

data/lib/helix.rb

@@ -1,6 +1,7 @@
 require 'helix/durationed_media'
 require 'helix/video'
 require 'helix/track'
+require 'helix/tag'
 require 'helix/album'
 require 'helix/image'
 require 'helix/config'

data/lib/helix/album.rb

@@ -1,8 +1,8 @@
-require 'helix/base'
+require 'helix/media'
 
 module Helix
 
-  class Album < Base
+  class Album < Media
 
     # The class name, to be used by supporting classes. Such as Config which uses
     # this method as a way to build URLs.

data/lib/helix/base.rb

@@ -2,6 +2,7 @@ require 'rest-client'
 require 'json'
 require 'yaml'
 require 'nori'
+require 'time'
 
 module Helix
   class Base
@@ -13,38 +14,6 @@ module Helix
     attr_accessor :attributes
     attr_writer   :config
 
-    # Creates a new record via API and then returns an instance of that record.
-    #
-    # Example is using Video class since Video inherits from Base. This won't
-    # normally be called as Helix::Base.create
-    #
-    # @example
-    #   Helix::Album.create({title: "My new album"})
-    #
-    # @param [Hash] attributes a hash containing the attributes used in the create
-    # @return [Base] An instance of Helix::Base
-    def self.create(attributes={})
-      url       = config.build_url(media_type:    plural_media_type,
-                                   content_type:  :xml)
-      response  = RestClient.post(url, attributes.merge(signature: config.signature(:update)))
-      attrs     = Hash.from_xml(response)
-      self.new(attributes: attrs[media_type_sym.to_s], config: config)
-    end
-
-    # Finds and returns a record in instance form for a class, through
-    # guid lookup.
-    #
-    # @example
-    #   video_guid  = "8e0701c142ab1"
-    #   video       = Helix::Video.find(video_guid)
-    #
-    # @param [String] guid an id in guid form.
-    # @return [Base] An instance of Helix::Base
-    def self.find(guid)
-      item   = self.new(attributes: { guid_name => guid }, config: config)
-      item.load
-    end
-
     # Fetches all accessible records, places them into instances, and returns
     # them as an array.
     #
@@ -56,9 +25,27 @@ module Helix
     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) }
+      data_sets.map { |attrs| self.new( attributes: massage_attrs(attrs),
+                                        config:     config) }
     end
 
+    # (see .find_all)
+    def self.where(opts={})
+      find_all(opts)
+    end
+
+    # (see .find_all)
+    # @note this method takes no query options, unlike find_all
+    def self.all
+      find_all
+    end
+
+    # Does a GET call to the api and defaults to content_type xml and
+    # signature_type view.
+    #
+    #
+    # @param [Hash] opts a hash of options for parameters passed into the HTTP GET
+    # @return [Array] The array of attributes (for a model) in hash form.
     def self.get_data_sets(opts)
       url          = config.build_url(content_type: opts[:content_type] || :xml,
                                       media_type:   self.plural_media_type)
@@ -96,27 +83,16 @@ module Helix
       @config     = opts[:config]
     end
 
+    # Returns the singleton instance of the Helix::Config.
     def self.config
       Helix::Config.instance
     end
 
+    # (see .config)
     def config
       @config ||= Helix::Config.instance
     end
 
-    # Deletes the record of the Helix::Base instance.
-    #
-    # @example
-    #   video = Helix::Video.create({title: "Some Title"})
-    #   video.destroy
-    #
-    # @return [String] The response from the HTTP DELETE call.
-    def destroy
-      RestClient.log = 'helix.log'
-      url      = config.build_url(content_type: :xml, guid: guid, media_type: plural_media_type)
-      RestClient.delete(url, params: {signature: config.signature(:update)})
-    end
-
     # Creates a string that associates to the class id.
     #
     # @example
@@ -154,25 +130,6 @@ module Helix
       end
     end
 
-    # Updates instance and record with attributes passed in.
-    #
-    # @example
-    #   video = Helix::Video.find(video_guid)
-    #   video.update({title: "My new title"})
-    #
-    # @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(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
-    end
-
     private
 
     def massage_raw_attrs(raw_attrs)
@@ -181,5 +138,35 @@ module Helix
       proper_hash ? raw_attrs : raw_attrs.first
     end
 
+    def self.massage_attrs(attrs)
+      return attrs unless attrs.is_a?(Hash)
+      Hash[massage_custom_field_attrs(massage_time_attrs(attrs)).sort]
+    end
+
+    def self.massage_time_attrs(attrs)
+      return attrs unless attrs.is_a?(Hash)
+      attrs.each do |key, val|
+        begin
+          if val.is_a?(String) && val =~ /(\d{4}-\d{2}-\d{2})/
+            attrs[key] = Time.parse(val)
+          end
+        rescue ArgumentError,RangeError;end
+        massage_time_attrs(val)
+      end
+    end
+
+    def self.massage_custom_field_attrs(attrs)
+      return attrs unless attrs.is_a?(Hash)
+      return attrs unless attrs["custom_fields"].is_a?(Hash)
+      attrs["custom_fields"].delete_if { |key, val| key.to_s =~ /^@/ }
+      cfs = []
+      attrs["custom_fields"].each do |key, val|
+        val.each do |val_val|
+          cfs << { "name" => key, "value" => val_val.to_s }
+        end
+      end
+      attrs.merge({'custom_fields' => cfs})
+    end
+
   end
 end

data/lib/helix/config.rb

@@ -36,6 +36,7 @@ module Helix
       config.instance_variable_set(:@filename, yaml_file_location)
       creds = YAML.load(File.open(yaml_file_location)).symbolize_keys
       config.instance_variable_set(:@credentials, creds)
+      RestClient.proxy = config.proxy
       config
     end
 
@@ -117,6 +118,20 @@ module Helix
       @signature_for[lk][sig_type] = RestClient.get(url_for(sig_type, opts))
     end
 
+    def proxy
+      if @credentials[:proxy_uri]
+        protocol, uri = @credentials[:proxy_uri].split "://"
+        user, pass    = @credentials[:proxy_username], @credentials[:proxy_password]
+        proxy_str     = "#{protocol}://"
+        proxy_str    += "#{user}:"  if user
+        proxy_str    += "#{pass}"   if user && pass
+        proxy_str    += '@'         if user
+        proxy_str    += "#{uri}"
+      elsif @credentials[:proxy_used] == true
+        ENV['http_proxy']
+      end
+    end
+
     private
 
     def error_message_for(sig_type)

data/lib/helix/exceptions.rb

@@ -0,0 +1,4 @@
+require 'helix/base'
+module Helix
+  class NoConfigurationLoaded < StandardError ; end
+end

data/lib/helix/image.rb

@@ -1,8 +1,8 @@
-require 'helix/base'
+require 'helix/media'
 
 module Helix
 
-  class Image < Base
+  class Image < Media
 
     # The class name, to be used by supporting classes. Such as Config which uses
     # this method as a way to build URLs.

data/lib/helix/media.rb

@@ -0,0 +1,68 @@
+require 'helix/base'
+
+module Helix
+  class Media < Base
+    # Creates a new record via API and then returns an instance of that record.
+    #
+    # Example is using Video class since Video inherits from Base. This won't
+    # normally be called as Helix::Base.create
+    #
+    # @example
+    #   Helix::Album.create({title: "My new album"})
+    #
+    # @param [Hash] attributes a hash containing the attributes used in the create
+    # @return [Base] An instance of Helix::Base
+    def self.create(attributes={})
+      url       = config.build_url(media_type:    plural_media_type,
+                                   content_type:  :xml)
+      response  = RestClient.post(url, attributes.merge(signature: config.signature(:update)))
+      attrs     = Hash.from_xml(response)
+      self.new(attributes: attrs[media_type_sym.to_s], config: config)
+    end
+
+    # Finds and returns a record in instance form for a class, through
+    # guid lookup.
+    #
+    # @example
+    #   video_guid  = "8e0701c142ab1"
+    #   video       = Helix::Video.find(video_guid)
+    #
+    # @param [String] guid an id in guid form.
+    # @return [Base] An instance of Helix::Base
+    def self.find(guid)
+      item   = self.new(attributes: { guid_name => guid }, config: config)
+      item.load
+    end
+
+    # Deletes the record of the Helix::Base instance.
+    #
+    # @example
+    #   video = Helix::Video.create({title: "Some Title"})
+    #   video.destroy
+    #
+    # @return [String] The response from the HTTP DELETE call.
+    def destroy
+      url      = config.build_url(content_type: :xml, guid: guid, media_type: plural_media_type)
+      RestClient.delete(url, params: {signature: config.signature(:update)})
+    end
+
+    # Updates instance and record with attributes passed in.
+    #
+    # @example
+    #   video = Helix::Video.find(video_guid)
+    #   video.update({title: "My new title"})
+    #
+    # @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(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
+    end
+  end
+end

data/lib/helix/tag.rb

@@ -0,0 +1,18 @@
+require 'rest-client'
+require 'json'
+require 'yaml'
+require 'nori'
+
+module Helix
+  class Tag < Base
+    # The class name, to be used by supporting classes. Such as Config which uses
+    # this method as a way to build URLs.
+    #
+    #
+    # @example
+    #   Helix::Tag.media_type_sym #=> :tag
+    #
+    # @return [Symbol] Name of the class.
+    def self.media_type_sym; :tag; end
+  end
+end

data/lib/helix/track.rb

@@ -1,6 +1,8 @@
+require 'helix/media'
+
 module Helix
 
-  class Track < Base
+  class Track < Media
 
     include DurationedMedia
 

data/lib/helix/video.rb

@@ -1,9 +1,9 @@
-require 'helix/base'
+require 'helix/media'
 require 'active_support/core_ext'
 
 module Helix
 
-  class Video < Base
+  class Video < Media
 
     include DurationedMedia
 

data/spec/album_spec.rb

@@ -9,6 +9,9 @@ describe Helix::Album do
   its(:guid_name) { should eq('album_id') }
   its(:media_type_sym)    { should be(:album)   }
   its(:plural_media_type) { should eq('albums') }
+  [:find, :create, :all, :find_all, :where].each do |crud_call|
+    it { should respond_to(crud_call) }
+  end
 
   describe "Constants"
 
@@ -22,6 +25,9 @@ describe Helix::Album do
         expect(lambda { obj.send(meth) }).to raise_error("Albums Update is not currently supported.")
       end
     end
+    [:destroy, :update].each do |crud_call|
+      it { should respond_to(crud_call) }
+    end
   end
 
 end

data/spec/base_spec.rb

@@ -34,80 +34,16 @@ describe Helix::Base do
     end
   end
 
-  describe ".create" do
-    let(:meth)        { :create }
-    let(:mock_config) { mock(Helix::Config) }
+  shared_examples_for "a search all with opts" do
+    let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: {}) }
     subject           { klass.method(meth) }
     its(:arity)       { should eq(-1) }
-    let(:klass_sym)   { :klass }
-    let(:resp_value)  { { klass_sym.to_s => { attribute: :value } } }
-    let(:resp_json)   { "JSON" }
-    let(:params)      { { signature: "some_sig" } }
-    let(:expected)    { { attributes: { attribute: :value }, config: mock_config } }
-    before(:each) do
-      klass.stub(:plural_media_type) { :klasses }
-      klass.stub(:media_type_sym)    { klass_sym }
-      mock_config.stub(:build_url).with(action: :create_many, media_type: :klasses) { :url }
-      mock_config.stub(:signature).with(:update) { "some_sig" }
-      Helix::Config.stub(:instance) { mock_config }
-    end
-    it "should get an ingest signature" do
-      mock_config.should_receive(:build_url).with(media_type:   :klasses,
-                                                  content_type: :xml)
-      RestClient.stub(:post).with(:url, params) { resp_json }
-      Hash.should_receive(:from_xml).with(resp_json) { resp_value }
-      klass.stub(:new).with(expected)
-      mock_config.should_receive(:signature).with(:update) { "some_sig" }
-      klass.send(meth)
-    end
-    it "should do an HTTP post call, parse response and call new" do
-      mock_config.should_receive(:build_url).with(media_type:   :klasses,
-                                                  content_type: :xml)
-      RestClient.should_receive(:post).with(:url, params) { resp_json }
-      Hash.should_receive(:from_xml).with(resp_json)      { resp_value }
-      klass.should_receive(:new).with(expected)
-      klass.send(meth)
-    end
-  end
-
-  describe ".find" do
-    let(:meth)  { :find }
-    let(:mock_config) { mock(Helix::Config) }
-    let(:mock_obj)    { mock(klass, :load => :output_of_load) }
-    subject     { klass.method(meth) }
-    its(:arity) { should eq(1) }
-    before(:each) do Helix::Config.stub(:instance) { mock_config } end
-    context "when given a Helix::Config instance and a guid" do
-      let(:guid)       { :a_guid }
-      let(:guid_name)  { :the_guid_name }
-      let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
-      before(:each) do
-        klass.stub(:attributes) { mock_attrs }
-        klass.stub(:guid_name)  { guid_name  }
-        klass.stub(:new)        { mock_obj }
-      end
-      it "should instantiate with {attributes: guid_name => the_guid, config: config}" do
-        klass.should_receive(:new).with({attributes: {guid_name => guid}, config: mock_config})
-        klass.send(meth, guid)
-      end
-      it "should load" do
-        mock_obj.should_receive(:load)
-        klass.send(meth, guid)
-      end
-    end
-  end
-
-  describe ".find_all" 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) }
     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
+      it "should build a XML URL -> the_url" do
         mock_config.should_receive(:build_url).with(content_type: :xml,
                                                     media_type:   plural_media_type)
         klass.send(meth, opts)
@@ -138,6 +74,101 @@ describe Helix::Base do
     end
   end
 
+  shared_examples_for "a search all without opts" do
+    let(:mock_config) { mock(Helix::Config, build_url: :built_url, get_response: {}) }
+    subject           { klass.method(meth) }
+    before(:each) do Helix::Config.stub(:instance) { mock_config } end
+    context "when given a config instances and NO opts Hash" do
+      let(:plural_media_type) { :videos }
+      before(:each) do klass.stub(:plural_media_type) { plural_media_type } end
+      it "should build a XML URL -> the_url" do
+        mock_config.should_receive(:build_url).with(content_type: :xml,
+                                                    media_type:   plural_media_type)
+        klass.send(meth)
+      end
+      it "should get_response(the_url, {sig_type: :view} -> raw_response" do
+        mock_config.should_receive(:get_response).with(:built_url, {sig_type: :view})
+        klass.send(meth)
+      end
+      it "should read raw_response[plural_media_type] -> data_sets" do
+        mock_raw_response = mock(Object)
+        mock_config.stub(:get_response) { mock_raw_response }
+        mock_raw_response.should_receive(:[]).with(plural_media_type)
+        klass.send(meth)
+      end
+      context "when data_sets is nil" do
+        it "should return []" do expect(klass.send(meth)).to eq([]) end
+      end
+      context "when data_sets is NOT nil" do
+        let(:data_set) { (0..2).to_a }
+        before(:each) do mock_config.stub(:get_response) { {plural_media_type => data_set } } end
+        it "should map instantiation with attributes: each data set element" do
+          klass.should_receive(:new).with(attributes: data_set[0], config: mock_config) { :a }
+          klass.should_receive(:new).with(attributes: data_set[1], config: mock_config) { :b }
+          klass.should_receive(:new).with(attributes: data_set[2], config: mock_config) { :c }
+          expect(klass.send(meth)).to eq([:a, :b, :c])
+        end
+      end
+    end
+  end
+
+  describe ".find_all" do
+    let(:meth) { :find_all }
+    it_behaves_like "a search all with opts"
+    it_behaves_like "a search all without opts"
+  end
+
+  describe ".all" do
+    let(:meth)  { :all }
+    subject     { klass.method(meth) }
+    its(:arity) { should eq(0) }
+    it_behaves_like "a search all without opts"
+  end
+
+  describe ".where" do
+    let(:meth) { :where }
+    it_behaves_like "a search all with opts"
+    it_behaves_like "a search all without opts"
+  end
+
+  describe ".massage_attrs" do
+    let(:meth)  { :massage_attrs }
+    subject     { klass.method(meth) }
+    its(:arity) { should eq(1) }
+    let(:attrs) { Hash.new }
+    it "should call massage_custom_field_attrs and massage_time_attrs" do
+      klass.should_receive(:massage_time_attrs).and_return attrs
+      klass.should_receive(:massage_custom_field_attrs).and_return attrs
+      klass.send(meth, attrs)
+    end
+  end
+
+  describe ".massage_time_attrs" do
+    let(:meth)      { :massage_time_attrs }
+    subject         { klass.method(meth) }
+    its(:arity)     { should eq(1) }
+    let(:time)      { Time.new(2013) }
+    let(:attrs)     { { key_one: time.to_s, key_two: { key_three: time, key_four: { key_five: time.to_s } } } }
+    let(:expected)  { { key_one: time, key_two: { key_three: time, key_four: { key_five: time } } } }
+    it "should turn stringified time values into time objects" do
+      expect(klass.send(meth, attrs)).to eq(expected)
+    end
+  end
+
+  describe ".massage_custom_field_attrs" do
+    let(:meth)        { :massage_custom_field_attrs }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(1) }
+    let(:custom_hash) { { "custom_fields" => {"boole"=>[nil, nil], "@type"=>"hash"} } }
+    let(:expected)    { { "custom_fields" => [{"name"=>"boole", "value"=>""}, {"name"=>"boole", "value"=>""}] } }
+    it "should turn custom_hash into expected" do
+      expect(klass.send(meth, custom_hash)).to eq(expected)
+    end
+    it "should return the custom_hash in its form" do
+      expect(klass.send(meth, expected)).to eq(expected)
+    end
+  end
+
   describe "an instance" do
     let(:obj) { klass.new({}) }
 
@@ -160,33 +191,6 @@ describe Helix::Base do
       end
     end
 
-    describe "#destroy" do
-      let(:meth)   { :destroy }
-      let(:mock_config) { mock(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_media_type) { :media_type }
-      end
-      it "should get an update signature" do
-        url = mock_config.build_url(media_type: :media_type,
-                                    guid:       :some_guid,
-                                    content_type:     :xml)
-        RestClient.stub(:delete).with(url, params)
-        mock_config.should_receive(:signature).with(:update) { :some_sig }
-        obj.send(meth)
-      end
-      it "should call for an HTTP delete and return nil" do
-        url = mock_config.build_url(media_type: :media_type,
-                                    guid:       :some_guid,
-                                    content_type:     :xml)
-        RestClient.should_receive(:delete).with(url, params)
-        expect(obj.send(meth)).to be_nil
-      end
-    end
-
     describe "#guid" do
       let(:meth) { :guid }
       it "should return @attributes[guid_name]" do
@@ -305,49 +309,6 @@ describe Helix::Base do
       end
     end
 
-    describe "#update" do
-      let(:meth)  { :update }
-      let(:mock_config) { mock(Helix::Config) }
-      subject     { obj.method(meth) }
-      its(:arity) { should eq(-1) }
-      before(:each) do
-        obj.stub(:config) { mock_config }
-        obj.stub(:guid)   { :the_guid }
-        obj.stub(:media_type_sym) { :video }
-        obj.stub(:plural_media_type) { :the_media_type }
-        mock_config.stub(:signature).with(:update) { 'some_sig' }
-        mock_config.stub(:build_url) { :expected_url }
-      end
-      shared_examples_for "builds URL for update" do
-        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
-        it "should get an update signature" do
-          mock_config.stub(:build_url)
-          RestClient.stub(:put)
-          mock_config.should_receive(:signature).with(:update) { 'some_sig' }
-          obj.send(meth)
-        end
-      end
-      context "when given no argument" do
-        it_behaves_like "builds URL for update"
-        it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: {}}) and return instance of klass" do
-          RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: {}})
-          expect(obj.send(meth)).to be_an_instance_of(klass)
-        end
-      end
-      context "when given an opts argument of {key1: :value1}" do
-        let(:opts)  { {key1: :value1} }
-        it_behaves_like "builds URL for update"
-        it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: opts}) and return instance of klass" do
-          RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: opts})
-          expect(obj.send(meth, opts)).to be_an_instance_of(klass)
-        end
-      end
-    end
-
   end
 
 end

data/spec/config_spec.rb

@@ -34,8 +34,8 @@ describe Helix::Config do
   end
 
   describe ".load" do
-    let(:meth) { :load }
-    let(:mock_obj)  { mock(klass) }
+    let(:meth)      { :load }
+    let(:mock_obj)  { mock(klass, proxy: :stubbed_proxy) }
     let(:mock_file) { mock(File)  }
     let(:mock_cred) { mock(Hash, symbolize_keys: :symbolized_creds) }
     before(:each) do
@@ -68,6 +68,10 @@ describe Helix::Config do
         mock_obj.should_receive(:instance_variable_set).with(:@credentials, mock_cred.symbolize_keys)
         klass.send(meth)
       end
+      it "should set the proxy" do
+        mock_obj.should_receive(:proxy) { :mock_proxy }
+        klass.send(meth)
+      end
       it "should return the instance" do
         expect(klass.send(meth)).to be(mock_obj)
       end
@@ -359,6 +363,25 @@ describe Helix::Config do
     end
   end
 
+  describe "#proxy" do
+    let(:meth)  { :proxy }
+    subject     { obj.method(meth) }
+    its(:arity) { should eq(0) }
+    it "should return the system proxy" do
+      ENV['http_proxy'] = 'http://test.proxy'
+      obj.credentials[:proxy_used] = true
+      expect(obj.send(meth)).to eq(ENV['http_proxy'])
+    end
+    it "should return the proxy specified in the config" do
+      obj.credentials[:proxy_uri] = 'http://test.proxy'
+      expect(obj.send(meth)).to eq 'http://test.proxy' 
+    end
+    it "should return just proxy uri if only pass exists" do
+      obj.credentials[:proxy_password] = 'fake_pass'
+      expect(obj.send(meth)).to eq 'http://test.proxy'
+    end
+  end
+
   describe "#signature" do
     let(:meth)  { :signature }
 

data/spec/image_spec.rb

@@ -9,6 +9,9 @@ describe Helix::Image do
   its(:guid_name) { should eq('image_id') }
   its(:media_type_sym)    { should be(:image)   }
   its(:plural_media_type) { should eq('images') }
+  [:find, :create, :all, :find_all, :where].each do |crud_call|
+    it { should respond_to(crud_call) }
+  end
 
   describe "Constants"
 
@@ -16,6 +19,9 @@ describe Helix::Image do
     let(:obj) { klass.new({'image_id' => 'some_image_guid'}) }
     subject { obj }
     its(:media_type_sym) { should be(:image) }
+    [:destroy, :update].each do |crud_call|
+      it { should respond_to(crud_call) }
+    end
   end
 
 end

data/spec/media_spec.rb

@@ -0,0 +1,145 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'helix'
+
+describe Helix::Media do
+
+  let(:klass) { Helix::Media }
+
+  subject { klass }
+
+  describe ".create" do
+    let(:meth)        { :create }
+    let(:mock_config) { mock(Helix::Config) }
+    subject           { klass.method(meth) }
+    its(:arity)       { should eq(-1) }
+    let(:klass_sym)   { :klass }
+    let(:resp_value)  { { klass_sym.to_s => { attribute: :value } } }
+    let(:resp_json)   { "JSON" }
+    let(:params)      { { signature: "some_sig" } }
+    let(:expected)    { { attributes: { attribute: :value }, config: mock_config } }
+    before(:each) do
+      klass.stub(:plural_media_type) { :klasses }
+      klass.stub(:media_type_sym)    { klass_sym }
+      mock_config.stub(:build_url).with(action: :create_many, media_type: :klasses) { :url }
+      mock_config.stub(:signature).with(:update) { "some_sig" }
+      Helix::Config.stub(:instance) { mock_config }
+    end
+    it "should get an ingest signature" do
+      mock_config.should_receive(:build_url).with(media_type:   :klasses,
+                                                  content_type: :xml)
+      RestClient.stub(:post).with(:url, params) { resp_json }
+      Hash.should_receive(:from_xml).with(resp_json) { resp_value }
+      klass.stub(:new).with(expected)
+      mock_config.should_receive(:signature).with(:update) { "some_sig" }
+      klass.send(meth)
+    end
+    it "should do an HTTP post call, parse response and call new" do
+      mock_config.should_receive(:build_url).with(media_type:   :klasses,
+                                                  content_type: :xml)
+      RestClient.should_receive(:post).with(:url, params) { resp_json }
+      Hash.should_receive(:from_xml).with(resp_json)      { resp_value }
+      klass.should_receive(:new).with(expected)
+      klass.send(meth)
+    end
+  end
+
+  describe ".find" do
+    let(:meth)        { :find }
+    let(:mock_config) { mock(Helix::Config) }
+    let(:mock_obj)    { mock(klass, :load => :output_of_load) }
+    subject     { klass.method(meth) }
+    its(:arity) { should eq(1) }
+    before(:each) do Helix::Config.stub(:instance) { mock_config } end
+    context "when given a Helix::Config instance and a guid" do
+      let(:guid)       { :a_guid }
+      let(:guid_name)  { :the_guid_name }
+      let(:mock_attrs) { mock(Object, :[]= => :output_of_setting_val) }
+      before(:each) do
+        klass.stub(:attributes) { mock_attrs }
+        klass.stub(:guid_name)  { guid_name  }
+        klass.stub(:new)        { mock_obj }
+      end
+      it "should instantiate with {attributes: guid_name => the_guid, config: config}" do
+        klass.should_receive(:new).with({attributes: {guid_name => guid}, config: mock_config})
+        klass.send(meth, guid)
+      end
+      it "should load" do
+        mock_obj.should_receive(:load)
+        klass.send(meth, guid)
+      end
+    end
+  end
+
+  describe "an instance" do
+    let(:obj) { klass.new({}) }
+
+    describe "#destroy" do
+      let(:meth)   { :destroy }
+      let(:mock_config) { mock(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_media_type) { :media_type }
+      end
+      it "should get an update signature" do
+        url = mock_config.build_url(media_type: :media_type,
+                                    guid:       :some_guid,
+                                    content_type:     :xml)
+        RestClient.stub(:delete).with(url, params)
+        mock_config.should_receive(:signature).with(:update) { :some_sig }
+        obj.send(meth)
+      end
+      it "should call for an HTTP delete and return nil" do
+        url = mock_config.build_url(media_type: :media_type,
+                                    guid:       :some_guid,
+                                    content_type:     :xml)
+        RestClient.should_receive(:delete).with(url, params)
+        expect(obj.send(meth)).to be_nil
+      end
+    end
+    describe "#update" do
+      let(:meth)  { :update }
+      let(:mock_config) { mock(Helix::Config) }
+      subject     { obj.method(meth) }
+      its(:arity) { should eq(-1) }
+      before(:each) do
+        obj.stub(:config) { mock_config }
+        obj.stub(:guid)   { :the_guid }
+        obj.stub(:media_type_sym) { :video }
+        obj.stub(:plural_media_type) { :the_media_type }
+        mock_config.stub(:signature).with(:update) { 'some_sig' }
+        mock_config.stub(:build_url) { :expected_url }
+      end
+      shared_examples_for "builds URL for update" do
+        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
+        it "should get an update signature" do
+          mock_config.stub(:build_url)
+          RestClient.stub(:put)
+          mock_config.should_receive(:signature).with(:update) { 'some_sig' }
+          obj.send(meth)
+        end
+      end
+      context "when given no argument" do
+        it_behaves_like "builds URL for update"
+        it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: {}}) and return instance of klass" do
+          RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: {}})
+          expect(obj.send(meth)).to be_an_instance_of(klass)
+        end
+      end
+      context "when given an opts argument of {key1: :value1}" do
+        let(:opts)  { {key1: :value1} }
+        it_behaves_like "builds URL for update"
+        it "should call RestClient.put(output_of_build_url, {signature: the_sig, video: opts}) and return instance of klass" do
+          RestClient.should_receive(:put).with(:expected_url, {signature: 'some_sig', video: opts})
+          expect(obj.send(meth, opts)).to be_an_instance_of(klass)
+        end
+      end
+    end
+  end
+end

data/spec/tag_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'helix'
+
+describe Helix::Tag do
+
+  let(:klass)             { Helix::Tag }
+  subject                 { klass }
+  its(:media_type_sym)    { should be(:tag)   }
+  its(:plural_media_type) { should eq('tags') }
+  it { should_not respond_to(:find) }
+  it { should_not respond_to(:create) }
+  it { should respond_to(:all)}
+  it { should respond_to(:find_all)}
+
+  describe "Constants"
+
+  describe "an instance" do
+    let(:obj)             { klass.new({}) }
+    subject               { obj }
+    its(:media_type_sym)  { should be(:tag) }
+    it { should_not respond_to(:destroy) }
+    it { should_not respond_to(:update) }
+  end  
+end

data/spec/track_spec.rb

@@ -8,6 +8,9 @@ describe Helix::Track do
   its(:guid_name)         { should eq('track_id') }
   its(:media_type_sym)    { should be(:track)   }
   its(:plural_media_type) { should eq('tracks') }
+  [:find, :create, :all, :find_all, :where].each do |crud_call|
+    it { should respond_to(crud_call) }
+  end
 
   describe "Constants"
 
@@ -15,5 +18,8 @@ describe Helix::Track do
     let(:obj)            { klass.new({'track_id' => 'some_track_guid'}) }
     subject              { obj }
     its(:media_type_sym) { should be(:track) }
+    [:destroy, :update].each do |crud_call|
+      it { should respond_to(crud_call) }
+    end
   end
 end

data/spec/video_spec.rb

@@ -12,6 +12,9 @@ describe Helix::Video do
   its(:guid_name)         { should eq('video_id') }
   its(:media_type_sym)    { should be(:video)   }
   its(:plural_media_type) { should eq('videos') }
+  [:find, :create, :all, :find_all, :where].each do |crud_call|
+    it { should respond_to(crud_call) }
+  end
 
   describe "Constants"
 
@@ -32,6 +35,9 @@ describe Helix::Video do
         obj.send(meth)
       end
     end
+    [:destroy, :update].each do |crud_call|
+      it { should respond_to(crud_call) }
+    end
   end
 
   ### CLASS METHODS

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: helix
 version: !ruby/object:Gem::Version
-  version: 0.0.2.3.pre
+  version: 0.0.2.4.pre
   prerelease: 8
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-24 00:00:00.000000000 Z
+date: 2013-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -69,8 +69,11 @@ files:
 - lib/helix/album.rb
 - lib/helix/base.rb
 - lib/helix/image.rb
+- lib/helix/media.rb
 - lib/helix/durationed_media.rb
+- lib/helix/exceptions.rb
 - lib/helix/config.rb
+- lib/helix/tag.rb
 - lib/helix/video.rb
 - lib/helix/track.rb
 - lib/helix/statistics.rb
@@ -78,11 +81,13 @@ files:
 - spec/spec_helper.rb
 - spec/statistics_spec.rb
 - spec/config_spec.rb
+- spec/media_spec.rb
 - spec/image_spec.rb
 - spec/album_spec.rb
 - spec/track_spec.rb
 - spec/base_spec.rb
 - spec/durationed_media_spec.rb
+- spec/tag_spec.rb
 - LICENSE
 - README.md
 homepage: https://github.com/Twistage/helix/