helix 0.0.3.3.pre → 0.0.3.4.pre

data/lib/helix.rb

@@ -10,7 +10,25 @@ require 'helix/document'
 require 'helix/config'
 require 'helix/statistics'
 require 'helix/library'
+require 'helix/user'
 require 'active_support/core_ext'
 
 module Helix
+
+  # @param [String] The name of the Company to scope to.
+  def self.scope_to_company(co_id)
+    Helix::Config.instance.credentials.delete(:library)
+    Helix::Config.instance.credentials[:company] = co_id
+  end
+
+  # @param [String] The name of the Library to scope to.
+  def self.scope_to_library(lib_id)
+    Helix::Config.instance.credentials[:library] = lib_id
+  end
+
+  # @param [String] The license key to use.
+  def self.set_license_key(license_key)
+    Helix::Config.instance.credentials[:license_key] = license_key
+  end
+
 end

data/lib/helix/library.rb

@@ -6,6 +6,9 @@ module Helix
 
     include RESTful
 
+    # @return [String] A blank String
+    def self.create(attrs={}); super; end
+
     # 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/restful.rb

@@ -56,8 +56,13 @@ module Helix
         raise Helix::NoConfigurationLoaded.new if config.nil?
         url       = config.build_url(build_url_opts)
         response  = RestClient.post(url, attributes.merge(signature: config.signature(:update)))
-        attrs     = Hash.from_xml(response)
-        self.new(attributes: attrs[resource_label_sym.to_s], config: config)
+        return if response == ''
+        begin
+          attrs   = Hash.from_xml(response)
+          self.new(attributes: attrs[resource_label_sym.to_s], config: config)
+        rescue REXML::ParseException
+          response
+        end
       end
 
       # Finds and returns a record in instance form for a class, through

data/lib/helix/user.rb

@@ -0,0 +1,38 @@
+require 'helix/media'
+
+module Helix
+
+  class User < Base
+
+    include RESTful
+
+    # @return [String] the license_key associated with newly-created API User
+    def self.create(attrs={}); super; end
+
+    # The class name, to be used by supporting classes. Such as Config which uses
+    # this method as a way to build URLs.
+    #
+    #
+    # @example
+    #   Helix::User.resource_label_sym #=> :user
+    #
+    # @return [Symbol] Name of the class.
+    def self.resource_label_sym; :user; end
+
+    # Creates a string associated with a class name pluralized
+    #
+    # @example
+    #   Helix::User.plural_resource_label #=> "users"
+    #
+    # @return [String] The class name pluralized
+    def self.plural_resource_label
+      "users"
+    end
+
+    def self.known_attributes
+      []
+    end
+
+  end
+
+end

data/spec/helix_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'helix'
+
+describe Helix do
+  let(:klass) { Helix }
+
+  describe "Constants"
+
+  describe "scope_to_company" do
+    let(:meth) { :scope_to_company }
+    let(:the_co_id) { :the_co_id }
+    describe "arity" do
+      subject { klass.method(meth) }
+      its(:arity) { should eq(1) }
+    end
+    it "should add the company arg to credentials" do
+      klass.send(meth, the_co_id)
+      expect(Helix::Config.instance.credentials).to include(company: the_co_id)
+    end
+    it "should clear any pre-exisiting library from credentials" do
+      klass.send(:scope_to_library, :the_lib_name)
+      expect(Helix::Config.instance.credentials).to include(library: :the_lib_name)
+      klass.send(meth, the_co_id)
+      expect(Helix::Config.instance.credentials.keys).not_to include(:library)
+    end
+  end
+
+  describe "scope_to_library" do
+    let(:meth) { :scope_to_library }
+    let(:the_lib_name) { :the_lib_name }
+    describe "arity" do
+      subject { klass.method(meth) }
+      its(:arity) { should eq(1) }
+    end
+    it "should add the library arg to credentials" do
+      klass.send(meth, the_lib_name)
+      expect(Helix::Config.instance.credentials).to include(library: the_lib_name)
+    end
+  end
+
+  describe "set_license_key" do
+    let(:meth) { :set_license_key }
+    let(:the_key) { :alicense_key }
+    describe "arity" do
+      subject { klass.method(meth) }
+      its(:arity) { should eq(1) }
+    end
+    it "should add the license_key arg to credentials" do
+      klass.send(meth, the_key)
+      Helix::Config.instance.credentials.should include(license_key: the_key)
+    end
+  end
+
+end

data/spec/media_spec.rb

@@ -17,55 +17,90 @@ describe Helix::Media do
     end
   end
 
-  klasses = [ Helix::Album, Helix::Image, Helix::Track, Helix::Video ]
+  klasses = [ Helix::Album, Helix::Document, Helix::Image, Helix::Track, Helix::User, Helix::Video ]
   klasses.each do |klass|
 
     subject { klass }
+    klass_sym = {
+      Helix::Album    => :album,
+      Helix::Document => :document,
+      Helix::Image    => :image,
+      Helix::Library  => :library,
+      Helix::Track    => :track,
+      Helix::User     => :user,
+      Helix::Video    => :video,
+    }
 
     mods = [ Helix::RESTful, Helix::Uploadable ]
     mods.each { |mod| its(:ancestors) { should include(mod) } }
 
     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 } }
-      context "when a Helix:Config instance is absent" do
+      let(:meth)          { :create }
+      let(:mock_config)   { mock(Helix::Config) }
+      subject             { klass.method(meth) }
+      its(:arity)         { should eq(-1) }
+      let(:hash_from_xml) { { klass_sym.to_s => { attribute: :value } } }
+      let(:resp_xml)      { "Fake XML" }
+      let(:params)        { { signature: "some_sig" } }
+      let(:expected)      { { attributes: { attribute: :value }, config: mock_config } }
+      context "when a Helix:Config instance is nil" do
         before(:each) do Helix::Config.stub(:instance) { nil } end
         it "should raise a NoConfigurationLoaded exception" do
           lambda { klass.send(meth) }.should raise_error(Helix::NoConfigurationLoaded)
         end
       end
-      context "when a Helix:Config instance is present" do
+      context "when a Helix:Config instance is NOT nil" do
         before(:each) do
           klass.stub(:plural_resource_label) { :klasses }
           klass.stub(:resource_label_sym)    { klass_sym }
           mock_config.stub(:build_url).with(content_type: :xml, resource_label: :klasses) { :url }
           mock_config.stub(:signature).with(:update) { "some_sig" }
           Helix::Config.stub(:instance) { mock_config }
+          RestClient.stub(:post) { resp_xml }
+          Hash.stub(:from_xml).with(resp_xml) { hash_from_xml }
         end
-        it "should get an ingest signature" do
-          mock_config.should_receive(:build_url).with(resource_label: :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" }
+        it "should build a POST url" do
+          build_url_opts = {resource_label: :klasses, content_type: :xml}
+          mock_config.should_receive(:build_url).with(build_url_opts)
           klass.send(meth)
         end
-        it "should do an HTTP post call, parse response and call new" do
-          mock_config.should_receive(:build_url).with(resource_label: :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)
+        it "should POST to the created URL" do
+          RestClient.should_receive(:post).with(:url, params) { resp_xml }
           klass.send(meth)
         end
+        context "when the POST response is ''" do
+          before(:each) do RestClient.stub(:post) { '' } end
+          it "should return nil"
+          it "should NOT create a Hash from XML" do
+            Hash.should_not_receive(:from_xml)
+            klass.send(meth)
+          end
+          it "should NOT instantiate an instance based on that Hash" do
+            klass.should_not_receive(:new)
+            klass.send(meth)
+          end
+        end
+        context "when the POST response is NOT ''" do
+          before(:each) do RestClient.stub(:post) { resp_xml } end
+          it "should create a Hash from XML" do
+            Hash.should_receive(:from_xml).with(resp_xml) { hash_from_xml }
+            klass.send(meth)
+          end
+          it "should instantiate an instance based on that Hash" do
+            klass.should_receive(:new).with(expected)
+            klass.send(meth)
+          end
+          context "and the response is not parseable as XML" do
+            before(:each) do Hash.should_receive(:from_xml).with(resp_xml) { raise(REXML::ParseException.new(:some_arg)) } end
+            it "should NOT instantiate an instance based on that Hash" do
+              klass.should_not_receive(:new)
+              klass.send(meth)
+            end
+            it "should return the unparseable response" do
+              expect(klass.send(meth)).to be(resp_xml)
+            end
+          end
+        end
       end
     end
 

data/spec/user_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'helix'
+
+describe Helix::User do
+
+  let(:klass) { Helix::User }
+  subject     { klass }
+
+  mods = [ Helix::Base, Helix::RESTful ]
+  mods.each { |mod| its(:ancestors) { should include(mod) } }
+  its(:ancestors) { should_not include(Helix::Media) }
+
+  its(:guid_name)             { should eq('user_id') }
+  its(:resource_label_sym)    { should be(:user)     }
+  its(:plural_resource_label) { should eq('users')   }
+  [:find, :create, :all, :find_all, :where].each do |crud_call|
+    it { should respond_to(crud_call) }
+  end
+
+  describe ".known_attributes" do
+    its(:known_attributes) { should eq([]) }
+  end
+
+  describe "Constants"
+
+  describe "an instance" do
+    let(:obj)            { klass.new({}) }
+    subject              { obj }
+    its(:resource_label_sym) { should be(:user) }
+    [:destroy, :update].each do |crud_call|
+      it { should respond_to(crud_call) }
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: helix
 version: !ruby/object:Gem::Version 
   prerelease: 8
-  version: 0.0.3.3.pre
+  version: 0.0.3.4.pre
 platform: ruby
 authors: 
 - Twistage, Inc
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-05-16 00:00:00 Z
+date: 2013-05-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json
@@ -82,6 +82,7 @@ files:
 - lib/helix/image.rb
 - lib/helix/restful.rb
 - lib/helix/library.rb
+- lib/helix/user.rb
 - lib/helix/uploadable.rb
 - lib/helix/statistics.rb
 - lib/helix/document.rb
@@ -104,9 +105,11 @@ files:
 - spec/playlist_spec.rb
 - spec/video_spec.rb
 - spec/tag_spec.rb
+- spec/user_spec.rb
 - spec/durationed_media_spec.rb
 - spec/album_spec.rb
 - spec/image_spec.rb
+- spec/helix_spec.rb
 - spec/statistics_spec.rb
 - spec/video_playlist_spec.rb
 - spec/media_spec.rb