videojuicer-vj-sdk 0.1.0

data/spec/session_spec.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), "helpers", "spec_helper")
+require 'net/http'
+
+describe Videojuicer::Session do
+  
+  before(:all) do 
+    configure_test_settings
+    @session = Videojuicer::Session.new(
+      :seed_name        => fixtures.seed.name,
+      :consumer_key     => fixtures["write-master"].consumer.consumer_key,
+      :consumer_secret  => fixtures["write-master"].consumer.consumer_secret
+    )
+  end
+  
+  describe "instantiation" do
+    before(:all) do
+      @klass = Videojuicer::Session
+    end    
+    it_should_behave_like "a configurable"
+  end
+  
+  describe "authorisation" do
+    describe "(retrieving the request token)" do
+      before(:all) do        
+        @token = @session.get_request_token
+      end
+      
+      it "fetches a token key" do
+        @token["oauth_token"].should be_kind_of(String)
+        @token["oauth_token"].should_not be_empty
+      end
+      it "fetches a token secret" do
+        @token["oauth_token_secret"].should be_kind_of(String)
+        @token["oauth_token_secret"].should_not be_empty
+      end
+      it "fetches the permissions" do
+        @token["permissions"].should == "read-user"
+      end
+    end
+    
+    describe "(authorizing the request token)" do
+      before(:all) do
+        @authorize_url = @session.authorize_url
+        @authorize_url_parsed = URI.parse(@authorize_url)
+      end
+      
+      it "returns the URL when asked for the #authorize_url" do
+        @authorize_url_parsed.port.should == @session.port
+        @authorize_url_parsed.host.should == @session.host
+      end
+      it "returns a valid URL that can be successfully requested" do
+        req = Net::HTTP::Get.new("#{@authorize_url_parsed.path}?#{@authorize_url_parsed.query}")
+        response =  Net::HTTP.start(@authorize_url_parsed.host, @authorize_url_parsed.port) do |http|
+          http.request req
+        end
+        response.code.to_i.should == 200
+      end
+      it "validates that mangling this URL in any way also mangles the response to an error state" do
+        req = Net::HTTP::Get.new("#{@authorize_url_parsed.path}?#{@authorize_url_parsed.query.gsub(/oauth_token=[a-zA-Z0-9]+/,'')}")
+        response =  Net::HTTP.start(@authorize_url_parsed.host, @authorize_url_parsed.port) do |http|
+          http.request req
+        end
+        response.code.to_i.should == 401
+      end
+    end
+    
+    describe "(retrieving the access token)" do
+      before(:all) do
+        @atok_fixture = fixtures["write-master"].access_token
+        @atok = @session.exchange_request_token(@atok_fixture)
+      end
+      
+      it "fetches a token key" do
+        @atok.oauth_token.should be_kind_of(String)
+        @atok.oauth_token.should_not be_empty
+      end
+      it "fetches a token secret" do
+        @atok.oauth_token_secret.should be_kind_of(String)
+        @atok.oauth_token_secret.should_not be_empty
+      end
+      it "fetches the token permissions" do
+        @atok.permissions.should == "write-master"
+      end
+    end
+
+  end
+  
+  describe "concurrency" do
+    
+  end
+  
+  describe "scope control" do
+    
+  end
+  
+end

data/spec/shared/configurable_spec.rb

@@ -0,0 +1,75 @@
+shared_examples_for "a configurable" do
+  
+  before(:all) do
+    Videojuicer.configure!(:foo=>"custom", :bar=>"not overridden")
+  end
+  
+  before(:each) do
+    Videojuicer.exit_all!
+  end
+  
+  after(:each) do
+    Videojuicer.exit_all!
+  end
+  
+  describe "scope control" do
+    before(:all) do
+      @configurable_a = @klass.new
+      @configurable_a.configure! :foo=>"a"
+      
+      @configurable_b = @klass.new
+      @configurable_b.configure! :foo=>"b"
+      
+      @configurable_c = @klass.new
+      @configurable_c.configure!({})
+    end
+    
+    it "moves the configurable's local scope to the global scope stack" do
+      Videojuicer.current_scope.should_not == @configurable_a.config
+      @configurable_a.scope do |config| 
+        config.should == Videojuicer.current_scope
+      end
+      Videojuicer.current_scope.should_not == @configurable_a.config
+    end
+    
+    it "supports nested block behaviour" do
+      @configurable_a.scope do |config_a|
+        config_a[:bar].should == "not overridden"
+        config_a[:foo].should == "a"
+       
+        Videojuicer.scopes.length.should == 2
+        
+        @configurable_b.scope do |config_b|
+          Videojuicer.scopes.length.should == 3
+          config_b[:foo].should == "b"
+          config_b[:bar].should == "not overridden"
+        end
+        
+        Videojuicer.scopes.length.should == 2
+        #raise "ALL SCOPES: #{Videojuicer.scopes.inspect} \n\n\n CURRENT SCOPE: #{Videojuicer.current_scope.inspect} \n\n BLOCK CONFIG: #{config.inspect}"
+           
+        config_a[:foo].should == "a"
+      end
+    end
+  end
+  
+  it "gets the configuration defaults from those already set on the Videojuicer module" do
+    obj = @klass.new
+    obj.config[:foo].should == "custom"
+  end
+  
+  it "can override defaults from the Videojuicer configuration hash" do
+    obj = @klass.new
+    obj.configure!(:bar=>"overridden")
+    obj.config[:bar].should == "overridden"
+  end
+  
+  %w(host port consumer_key consumer_secret token token_secret api_version seed_name protocol).each do |attr|
+    it "provides a direct access method for the #{attr} given in the configuration" do
+      obj = @klass.new
+      obj.configure!((attr.to_sym)=>"#{attr} was set")
+      obj.send(attr).should == "#{attr} was set"
+    end
+  end
+  
+end

data/spec/shared/resource_spec.rb

@@ -0,0 +1,170 @@
+shared_examples_for "a RESTFUL resource model" do
+  
+    # Expects @klass to be a reference to the model class being tested
+    # Expects @singular_name to be a string containing the expected resource name, e.g. Videojuicer::User => "user"
+    # Expects @plural_name to be a string containing the expected pluralised name, e.g. Videojuicer::User => "users"
+    # Expects @good_attributes to be a hash of attributes for objects of the tested type that will successfully create a valid object.
+    
+    describe "inferrable naming" do
+      it "has a resource name that matches the singular class name" do
+        @klass.resource_name.should == @singular_name
+      end
+      it "has a parameter name inferred from the resource name" do
+        @klass.parameter_name.should == @singular_name
+      end
+      it "has a resource path that properly pluralises the resource name" do
+        @klass.resource_path.should == "/#{@plural_name}"
+      end       
+    end
+    
+    describe "a new record" do
+      before(:each) do
+        @record = @klass.new
+      end
+      
+      it "returns true to #new_record?" do
+        @record.new_record?.should be_true
+      end
+      
+      it "uses the class resource path as the instance resource path" do
+        @record.resource_path.should == @klass.resource_path
+      end
+      
+      it "raises an exception when trying to pull attributes remotely" do
+        lambda {@record.reload}.should raise_error(Videojuicer::Exceptions::NoResource)
+      end
+      
+      it "returns false to #valid?" do
+        @record.valid?.should be_false
+      end
+      
+      describe "being saved" do   
+        describe "successfully" do
+          before(:all) do 
+            @successful = @klass.new(@good_attributes)
+            raise @successful.errors.inspect unless @successful.valid?
+            @successful.valid?.should be_true
+            @saved = @successful.save
+          end
+          
+          it "returns true" do
+            @saved.should == true
+          end
+          it "does not set any errors on the object" do
+            @successful.errors.should be_empty
+          end
+          it "gets an ID" do
+            @successful.id.should be_kind_of(Integer)
+          end 
+        end
+        describe "unsuccessfully" do
+          before(:all) do 
+            @bad_attributes = @good_attributes.inject({}) do |memo, (key,value)|
+              memo.merge({key=>""})
+            end
+            @fail = @klass.new(@bad_attributes)
+            @saved = @fail.save
+          end
+          
+          it "is not #valid?" do
+            @fail.valid?.should be_false
+          end
+          
+          it "returns false" do
+            @saved.should be_false
+          end
+          it "sets errors on the object" do
+            @fail.errors.should be_kind_of(Hash)
+            @fail.errors.should_not be_empty
+          end
+          it "does not get an ID" do
+            @fail.id.should be_nil
+          end
+        end
+      end
+    end
+    
+    describe "finding a record by ID" do
+      before(:all) do        
+        attrs = cycle_attributes(@good_attributes)
+        @record = @klass.new(attrs)
+        @record.save.should be_true
+        @found = @klass.get(@record.id)
+      end
+      
+      it "gets all the attributes" do
+        attrs = @found.attributes.dup
+        attrs.delete(:id)
+        attrs = attrs.reject {|k,v| !v}
+        attrs.should_not be_empty
+      end
+    end
+    
+    describe "listing records" do
+      before(:all) do
+        @list = @klass.all
+      end
+      
+      it "should return a collection object" do
+        @list.should be_kind_of(Videojuicer::Resource::Collection)
+      end
+      it "should add the pagination options to the collection object" do
+        @list.limit.should be_kind_of(Numeric)
+      end
+      
+      describe "with pagination settings" do
+        before(:all) do
+          @paginated_list = @klass.all(:limit=>5)
+        end
+        
+        it "should return a collection object" do
+          @paginated_list.should be_kind_of(Videojuicer::Resource::Collection)
+        end
+        it "returns the proper amount of objects" do
+          @paginated_list.limit.should == 5
+        end
+      end
+    end
+    
+    describe "finding a record by conditions" do
+      it "should translate a conditions hash to filterable format"
+    end
+    
+    describe "an existing record" do
+      before(:all) do
+        @record = @klass.new(cycle_attributes(@good_attributes))
+        @record.save.should be_true
+      end
+      
+      it "returns false to #new_record?" do
+        @record.new_record?.should be_false        
+      end
+      
+      it "uses an instance-specific resource path" do
+        @record.resource_path.should == "/#{@plural_name}/#{@record.id}.json"
+      end
+      
+      it "reloads from the remote API successfully" do
+        @record.reload.should be_true
+      end
+      
+      it "saves successfully" do
+        saved = @record.save
+        @record.errors.should == {}
+        saved.should be_true
+      end
+    end
+    
+    describe "deleting a record" do
+      before(:each) do
+        @record = @klass.new(cycle_attributes(@good_attributes))
+        @record.save.should be_true
+      end
+      
+      it "destroys the record" do
+        @record.destroy
+        lambda {@record.reload}.should raise_error(Videojuicer::Exceptions::NoResource)
+      end
+    end
+  
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format
+specdoc

data/spec/text_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), "helpers", "spec_helper")
+
+describe Videojuicer::Asset::Text do
+  
+  before(:all) do
+    @klass = Videojuicer::Asset::Text
+    configure_test_settings
+    Videojuicer.enter_scope :seed_name => fixtures.seed.name, 
+                            :consumer_key=>fixtures["write-master"].consumer.consumer_key,
+                            :consumer_secret=>fixtures["write-master"].consumer.consumer_secret,
+                            :token=>fixtures["write-master"].authorized_token.oauth_token,
+                            :token_secret=>fixtures["write-master"].authorized_token.oauth_token_secret
+  end
+  
+  after(:all) do
+    Videojuicer.exit_scope
+  end
+  
+  describe "instantiation" do
+    it_should_behave_like "a configurable"
+  end
+  
+  describe "general interface:" do
+    before(:all) do
+      @singular_name = "asset"
+      @plural_name = "assets/text"
+      @good_attributes = {
+        :user_id        => rand(100) + 1,
+        :licensed_at    => Time.now,
+        :licensed_by    => "foo, bar",
+        :licensed_under => "CC BY:NC:SA",
+        :published_at   => Time.now,      
+        :duration       => 180000, 
+        :file => File.open(File.join(File.dirname(__FILE__), "files", "text.txt"))
+      }
+    end
+    
+    it_should_behave_like "a RESTFUL resource model"
+  end
+  
+  
+end

data/spec/user_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "helpers", "spec_helper")
+
+describe Videojuicer::User do
+  
+  before(:all) do
+    @klass = Videojuicer::User
+    configure_test_settings
+    Videojuicer.enter_scope :seed_name => fixtures.seed.name, 
+                            :consumer_key=>fixtures["write-master"].consumer.consumer_key,
+                            :consumer_secret=>fixtures["write-master"].consumer.consumer_secret,
+                            :token=>fixtures["write-master"].authorized_token.oauth_token,
+                            :token_secret=>fixtures["write-master"].authorized_token.oauth_token_secret
+  end
+  
+  after(:all) do
+    Videojuicer.exit_scope
+  end
+  
+  describe "instantiation" do
+    it_should_behave_like "a configurable"
+  end
+  
+  describe "general interface:" do
+    before(:all) do
+      @singular_name = "user"
+      @plural_name = "users"
+      @good_attributes = {
+        :login => "testuser#{rand 99999}",
+        :name => "#{rand 9999} Jones",
+        :email => "test#{rand 999999}@test.videojuicer.com",
+        :password => "#{p = rand(99999)}",
+        :password_confirmation => p
+      }
+    end
+    
+    it_should_behave_like "a RESTFUL resource model"
+  end
+  
+  describe "authentication" do
+    before(:all) do
+      @good_attributes = {
+        :login => "testuser#{rand 99999}",
+        :name => "#{rand 9999} Jones",
+        :email => "test#{rand 999999}@test.videojuicer.com",
+        :password => "#{p = rand(99999)}",
+        :password_confirmation => p
+      }
+      @auth_user = Videojuicer::User.new(@good_attributes)
+      @auth_user.save.should be_true
+    end
+    
+    
+    it "returns User with good credentials" do
+      u = Videojuicer::User.authenticate(@good_attributes[:login], @good_attributes[:password])
+      u.should be_kind_of(Videojuicer::User)
+      u.login.should == @good_attributes[:login]
+    end
+    
+    it "returns nil with bad credentials" do
+      Videojuicer::User.authenticate(@good_attributes[:login], "FOOOOBARRRRRR").should be_nil
+    end
+  end
+  
+end

data/spec/video_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "helpers", "spec_helper")
+
+describe Videojuicer::Asset::Video do
+  
+  before(:all) do
+    @klass = Videojuicer::Asset::Video
+    configure_test_settings
+    Videojuicer.enter_scope :seed_name => fixtures.seed.name, 
+                            :consumer_key=>fixtures["write-master"].consumer.consumer_key,
+                            :consumer_secret=>fixtures["write-master"].consumer.consumer_secret,
+                            :token=>fixtures["write-master"].authorized_token.oauth_token,
+                            :token_secret=>fixtures["write-master"].authorized_token.oauth_token_secret
+  end
+  
+  after(:all) do
+    Videojuicer.exit_scope
+  end
+  
+  describe "instantiation" do
+    it_should_behave_like "a configurable"
+  end
+  
+  describe "general interface:" do
+    before(:all) do
+      @singular_name = "asset"
+      @plural_name = "assets/video"
+      @good_attributes = {
+        :user_id        => rand(100) + 1,
+        :licensed_at    => Time.now,
+        :licensed_by    => "foo, bar",
+        :licensed_under => "CC BY:NC:SA",
+        :published_at   => Time.now,      
+        :duration       => 180000, 
+        :width          => 640,
+        :height         => 480,
+        :bit_rate       => 262144,
+        :file => File.open(File.join(File.dirname(__FILE__), "files", "video.mov"))
+      }
+    end
+    
+    it_should_behave_like "a RESTFUL resource model"
+  end
+  
+  
+end

data/spec/videojuicer_spec.rb

@@ -0,0 +1,122 @@
+require File.join(File.dirname(__FILE__), "helpers", "spec_helper")
+
+describe "Videojuicer SDK" do
+  
+  describe "initialization with an options hash" do
+    before(:all) do
+      Videojuicer.configure!(
+        :consumer_key => "consumer_key",
+        :consumer_secret => "consumer_secret",
+        :api_version => 100,
+        :host => "host",
+        :port => 100
+      )
+    end    
+    after(:all) do
+      Videojuicer.unconfigure!
+    end
+    
+    it "respects the :consumer_key option" do
+      Videojuicer.default_options[:consumer_key].should == "consumer_key"
+    end
+    it "respects the :consumer_secret option" do
+      Videojuicer.default_options[:consumer_secret].should == "consumer_secret"
+    end
+    it "respects the :api_version option" do
+      Videojuicer.default_options[:api_version].should == 100
+    end
+    it "respects the :host option" do
+      Videojuicer.default_options[:host].should == "host"
+    end
+    it "respects the :port option" do
+      Videojuicer.default_options[:port].should == 100
+    end
+  end
+  
+  describe "scope management" do
+     before(:all) do
+        @default = {
+          :consumer_key => "consumer_key",
+          :consumer_secret => "consumer_secret",
+          :api_version => 100,
+          :host => "host",
+          :port => 100
+        }
+        Videojuicer.configure!(@default)
+      end
+    
+    describe "with no scope" do      
+      it "should respond false to in_scope?" do
+        Videojuicer.in_scope?.should be_false
+      end
+      
+      it "should give the given defaults as the current scope" do
+        Videojuicer.current_scope.should == Videojuicer::DEFAULTS.merge(@default)
+      end
+    end
+    
+    describe "entering a scope" do
+      before(:all) do
+        @scope1 = {:api_version=>"in scope 1", :scope_1_included=>true}
+        Videojuicer.enter_scope(@scope1)
+      end
+      
+      it "should respond true to in_scope?" do
+        Videojuicer.in_scope?
+      end
+      it "should give the current scope config in response to current_scope" do
+        Videojuicer.current_scope.should == Videojuicer::DEFAULTS.merge(@default).merge(@scope1)
+      end
+      
+      describe "and then entering another scope" do
+        before(:all) do
+          @scope2 = {:api_version=>"in scope 2", :scope_2_included=>true}
+          Videojuicer.enter_scope(@scope2)
+        end
+        
+        it "should respond true to in_scope?" do
+          Videojuicer.in_scope?
+        end
+        it "should inherit from the current scope" do
+          Videojuicer.current_scope.should == Videojuicer::DEFAULTS.merge(@default).merge(@scope1).merge(@scope2)
+        end
+      end
+      
+      describe "and then exiting a scope" do
+        before(:all) do
+          @current_scope = Videojuicer.current_scope
+          @length_at_current_scope = Videojuicer.scopes.length
+          Videojuicer.enter_scope(:entered_scope=>1)
+          Videojuicer.current_scope.should_not == @current_scope
+          Videojuicer.exit_scope
+        end
+        
+        it "should reduce the scope stack length" do
+          Videojuicer.scopes.length.should == @length_at_current_scope
+        end
+        
+        it "should restore the current_scope to the previous value" do
+          Videojuicer.current_scope.should == @current_scope
+        end
+      end
+    end
+    
+  end
+  
+  
+  describe "initialization with defaults" do
+    before(:all) do
+      Videojuicer.unconfigure!
+      Videojuicer.default_options.should == Videojuicer::DEFAULTS
+    end
+    
+    it "provides a default host" do
+      Videojuicer.default_options[:port].should_not be_nil
+    end
+    
+    it "provides a default port" do
+      Videojuicer.default_options[:host].should_not be_nil
+    end
+  end
+  
+end