fleakr 0.3.0 → 0.4.0

data/test/unit/fleakr/api/method_request_test.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class MethodRequestTest < Test::Unit::TestCase
+
+    describe "An instance of MethodRequest" do
+
+      context "with API credentials" do
+
+        before do
+          @api_key = 'f00b4r'
+          Fleakr.stubs(:api_key).with().returns(@api_key)
+          Fleakr.stubs(:shared_secret).with().returns('sekrit')
+        end
+
+        it "should know the full query parameters" do
+          request = MethodRequest.new('flickr.people.findByUsername', :username => 'foobar')
+
+          request.parameters[:api_key].value.should  == @api_key
+          request.parameters[:method].value.should   == 'flickr.people.findByUsername'
+          request.parameters[:username].value.should == 'foobar'
+        end
+        
+        it "should translate a shorthand API call" do
+          request = MethodRequest.new('people.findByUsername')
+          request.parameters[:method].value.should == 'flickr.people.findByUsername'
+        end
+        
+        it "should know that it needs to sign the request" do
+          ParameterList.expects(:new).with(:sign? => true).returns(stub(:<< => nil))
+          request = MethodRequest.new('people.findByUsername', :sign? => true)
+        end
+        
+        it "should know that it needs to authenticate the request" do
+          ParameterList.expects(:new).with(:authenticate? => true).returns(stub(:<< => nil))
+          request = MethodRequest.new('activity.userPhotos', :authenticate? => true)
+        end
+
+        it "should know the endpoint with full parameters" do
+          query_parameters = 'foo=bar'
+        
+          request = MethodRequest.new('people.getInfo')
+          request.parameters.stubs(:to_query).returns(query_parameters)
+        
+          uri_mock = mock() {|m| m.expects(:query=).with(query_parameters)}
+          URI.expects(:parse).with("http://api.flickr.com/services/rest/").returns(uri_mock)
+        
+          request.__send__(:endpoint_uri).should == uri_mock
+        end
+        
+        it "should be able to make a request" do
+          endpoint_uri = stub()
+          
+          request = MethodRequest.new('people.findByUsername')
+          request.stubs(:endpoint_uri).with().returns(endpoint_uri)
+        
+          Net::HTTP.expects(:get).with(endpoint_uri).returns('<xml>')
+        
+          request.send
+        end
+        
+        it "should create a response from the request" do
+          response_xml  = '<xml>'
+          response_stub = stub()
+        
+          Net::HTTP.stubs(:get).returns(response_xml)
+          Response.expects(:new).with(response_xml).returns(response_stub)
+          
+          request = MethodRequest.new('people.findByUsername')
+          request.stubs(:endpoint_uri)
+        
+          request.send.should == response_stub
+        end
+        
+        it "should be able to make a full request and response cycle" do
+          method = 'flickr.people.findByUsername'
+          params = {:username => 'foobar'}
+
+          response = stub(:error? => false)
+          
+          MethodRequest.expects(:new).with(method, params).returns(stub(:send => response))
+          
+          MethodRequest.with_response!(method, params).should == response
+        end
+        
+        it "should raise an exception when the full request / response cycle has errors" do
+          method = 'flickr.people.findByUsername'
+          params = {:username => 'foobar'}
+          
+          response = stub(:error? => true, :error => stub(:code => '1', :message => 'User not found'))
+          
+          MethodRequest.expects(:new).with(method, params).returns(stub(:send => response))
+          
+          lambda do
+            MethodRequest.with_response!('flickr.people.findByUsername', :username => 'foobar')
+          end.should raise_error(Fleakr::ApiError)
+        end
+        
+      end
+    end
+    
+  end
+end

data/test/unit/fleakr/api/parameter_list_test.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class ParameterListTest < Test::Unit::TestCase
+    
+    describe "An instance of the ParameterList class" do
+      
+      before do
+        @api_key = 'key'
+        @secret  = 'foobar'
+
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+        Fleakr.stubs(:api_key).with().returns(@api_key)
+        @parameter_list = ParameterList.new
+      end
+      
+      it "should contain the :api_key by default" do
+        @parameter_list[:api_key].name.should == 'api_key'
+        @parameter_list[:api_key].value.should == @api_key
+        @parameter_list[:api_key].include_in_signature?.should be(true)
+      end
+      
+      it "should be able to create an initial list of parameters" do
+        parameter_list = ParameterList.new(:one => 'two')
+        parameter_list[:one].value.should == 'two'
+      end
+
+      it "should be able to add parameters to its list" do
+        parameter = ValueParameter.new('foo', 'bar')
+        
+        @parameter_list << parameter
+        @parameter_list['foo'].should == parameter
+      end
+      
+      it "should allow access to parameters by symbol" do
+        parameter = ValueParameter.new('foo', 'bar')
+        @parameter_list << parameter
+        
+        @parameter_list[:foo].should == parameter
+      end
+      
+      it "should overwrite existing values when a duplicate is added" do
+        length = @parameter_list.instance_variable_get(:@list).length
+        2.times {@parameter_list << ValueParameter.new('foo', 'bar') }
+        
+        @parameter_list.instance_variable_get(:@list).length.should == length + 1
+      end
+      
+      it "should be able to calculate the signature of the parameters" do
+        @parameter_list << ValueParameter.new('foo', 'bar')
+        @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}api_key#{@api_key}foobar")
+      end
+      
+      it "should use the correct order when signing a list of multiple parameters" do
+        @parameter_list << ValueParameter.new('z', 'a')
+        @parameter_list << ValueParameter.new('a', 'z')
+        
+        @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}azapi_key#{@api_key}za")
+      end
+      
+      it "should ignore the parameters that aren't included in the signature" do
+        @parameter_list << ValueParameter.new('foo', 'bar')
+        @parameter_list << ValueParameter.new('yes', 'no', false)
+        
+        @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}api_key#{@api_key}foobar")
+      end
+      
+      it "should be able to generate a boundary for post data" do
+        rand = '0.123'
+        
+        @parameter_list.stubs(:rand).with().returns(stub(:to_s => rand))
+        @parameter_list.boundary.should == Digest::MD5.hexdigest(rand)
+      end
+      
+      it "should know that it doesn't need to sign the request by default" do
+        @parameter_list.sign?.should be(false)
+      end
+      
+      it "should know that it needs to sign the request when asked" do
+        parameter_list = ParameterList.new(:sign? => true)
+        parameter_list.sign?.should be(true)
+      end
+      
+      it "should know that it doesn't need to authenticate the request by default" do
+        @parameter_list.authenticate?.should be(false)
+      end
+      
+      it "should know to authenticate the request when asked" do
+        Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
+        
+        parameter_list = ParameterList.new(:authenticate? => true)
+        parameter_list.authenticate?.should be(true)
+      end
+      
+      it "should contain the :auth_token parameter in the list if the request is to be authenticated" do
+        Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
+        
+        parameter_list = ParameterList.new(:authenticate? => true)
+        auth_param = parameter_list[:auth_token]
+        
+        auth_param.name.should == 'auth_token'
+        auth_param.value.should == 'toke'
+        auth_param.include_in_signature?.should be(true)
+      end
+      
+      it "should know that it needs to sign the request when it is to be authenticated" do
+        Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
+        
+        parameter_list = ParameterList.new(:authenticate? => true)
+        parameter_list.sign?.should be(true)
+      end
+      
+      it "should include the signature in the list of parameters if the request is to be signed" do
+        parameter_list = ParameterList.new(:sign? => true)
+        parameter_list.stubs(:signature).with().returns('sig')
+        
+        signature_param = parameter_list[:api_sig]
+        
+        signature_param.name.should == 'api_sig'
+        signature_param.value.should == 'sig'
+        signature_param.include_in_signature?.should be(false)
+      end
+      
+      context "with associated parameters" do
+
+        before do
+          @p1 = ValueParameter.new('a', 'b')
+          @p2 = ValueParameter.new('c', 'd')
+
+          @p1.stubs(:to_query).with().returns('q1')
+          @p1.stubs(:to_form).with().returns('f1')
+          
+          @p2.stubs(:to_query).with().returns('q2')
+          @p2.stubs(:to_form).with().returns('f2')
+
+          @parameter_list.stubs(:list).with().returns('a' => @p1, 'c' => @p2)
+        end
+
+        it "should be able to generate a query representation of itself" do
+          @parameter_list.to_query.should == 'q1&q2'
+        end
+
+        it "should be able to represent a form representation of itself" do
+          @parameter_list.stubs(:boundary).returns('bound')
+          
+          expected = 
+            "--bound\r\n" +
+            "f1" +
+            "--bound\r\n" +
+            "f2" +
+            "--bound--"
+            
+          @parameter_list.to_form.should == expected
+        end
+        
+      end
+      
+    end
+    
+  end
+end

data/test/unit/fleakr/api/parameter_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class ParameterTest < Test::Unit::TestCase
+    
+    describe "An instance of the Parameter class" do
+      
+      it "should have a name" do
+        parameter = Parameter.new('foo')
+        parameter.name.should == 'foo'
+      end
+      
+      it "should know to include it in the signature by default" do
+        parameter = Parameter.new('foo')
+        parameter.include_in_signature?.should be(true)
+      end
+      
+      it "should know not to include it in the signature" do
+        parameter = Parameter.new('foo', false)
+        parameter.include_in_signature?.should be(false)
+      end
+      
+      it "should be able to compare itself to another parameter instance" do
+        p1 = Parameter.new('z', 'a')
+        p2 = Parameter.new('a', 'z')
+        
+        (p1 <=> p2).should == 1
+      end
+      
+      
+    end
+    
+  end
+end

data/test/unit/fleakr/api/upload_request_test.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class UploadRequestTest < Test::Unit::TestCase
+
+    describe "An instance of the UploadRequest class" do
+
+      before do
+        @secret = 'sekrit'
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+      end
+      
+      it "should create a file parameter on initialization" do
+        filename = '/path/to/image.jpg'
+
+        parameter = stub()
+        FileParameter.expects(:new).with('photo', filename).returns(parameter)
+
+        parameter_list = mock() {|m| m.expects(:<<).with(parameter) }
+        ParameterList.expects(:new).with(:authenticate? => true).returns(parameter_list)
+
+        UploadRequest.new(filename)
+      end
+      
+      it "should allow setting additional parameters on initialization" do
+        params = {:is_public => 1}
+        
+        ParameterList.expects(:new).with({:is_public => 1, :authenticate? => true}).returns(stub(:<<))
+        
+        UploadRequest.new('filename', params)
+      end
+
+      context "after initialization" do
+
+        before { ParameterList.stubs(:new).returns(stub(:<< => nil)) }
+
+        it "should default the type to :create" do
+          request = UploadRequest.new('file')
+          request.type.should == :create
+        end
+        
+        it "should allow setting the type to :update" do
+          request = UploadRequest.new('file', :type => :update)
+          request.type.should == :update
+        end
+
+        it "should know the endpoint_uri" do
+          request = UploadRequest.new('filename')
+          request.__send__(:endpoint_uri).should == URI.parse('http://api.flickr.com/services/upload/')
+        end
+        
+        it "should know the endpoint_uri for an :update request" do
+          request = UploadRequest.new('filename', :type => :update)
+          request.__send__(:endpoint_uri).should == URI.parse('http://api.flickr.com/services/replace/')
+        end
+        
+        it "should only parse the endpoint URI once" do
+          request = UploadRequest.new('filename')
+          URI.expects(:parse).with(kind_of(String)).once.returns('uri')
+          
+          2.times { request.__send__(:endpoint_uri) }
+        end
+
+        it "should have a collection of required headers" do
+          form_data = 'data'
+
+          request = UploadRequest.new('filename')
+          request.parameters.stubs(:boundary).with().returns('bound')
+          request.parameters.stubs(:to_form).with().returns(form_data)
+
+          expected = {
+            'Content-Type' => 'multipart/form-data; boundary=bound'
+          }
+
+          request.headers.should == expected
+        end
+
+        it "should be able to send a POST request to the API service" do
+          request = UploadRequest.new('filename')
+          
+          uri = stub do |s|
+            s.stubs(:host).with().returns('host')
+            s.stubs(:path).with().returns('path')
+            s.stubs(:port).with().returns(80)
+          end
+          
+          request.stubs(:endpoint_uri).with().returns(uri)
+          
+          request.stubs(:headers).with().returns('header' => 'value')
+          request.parameters.stubs(:to_form).with().returns('form')
+
+          http = mock {|m| m.expects(:post).with('path', 'form', {'header' => 'value'}) }
+
+          Net::HTTP.expects(:start).with('host', 80).yields(http).returns(stub(:body))
+          
+          request.send
+        end
+        
+        it "should get back a response from a POST operation" do
+          response = stub()
+          
+          Net::HTTP.expects(:start).with(kind_of(String), kind_of(Fixnum)).returns(stub(:body => '<xml>'))
+          Response.expects(:new).with('<xml>').returns(response)
+          
+          request = UploadRequest.new('filename')
+          request.send.should == response
+        end
+        
+        it "should be able to make a full request and response cycle" do
+          filename = 'filename'
+          response = stub(:error? => false)
+          
+          UploadRequest.expects(:new).with(filename, {}).returns(stub(:send => response))
+          UploadRequest.with_response!(filename).should == response
+        end
+        
+        it "should raise an exception when the full request / response cycle has errors" do
+          filename = 'filename'
+          response = stub(:error? => true, :error => stub(:code => '1', :message => 'User not found'))
+          
+          UploadRequest.expects(:new).with(filename, {}).returns(stub(:send => response))
+          
+          lambda do
+            UploadRequest.with_response!(filename)
+          end.should raise_error(Fleakr::ApiError)
+        end
+        
+      end
+
+    end
+
+  end
+end

data/test/unit/fleakr/api/value_parameter_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class ValueParameterTest < Test::Unit::TestCase
+
+   describe "An instance of the ValueParameter class" do
+      
+     it "should have a value" do
+       parameter = ValueParameter.new('foo', 'bar')
+       parameter.value.should == 'bar'
+     end
+      
+      it "should know how to generate the query representation of itself" do
+        parameter = ValueParameter.new('foo', 'bar')
+        parameter.to_query.should == 'foo=bar'
+      end
+      
+      it "should escape the value when generating the query representation" do
+        parameter = ValueParameter.new('foo', 'Mr. Crystal?')
+        parameter.to_query.should == 'foo=Mr.+Crystal%3F'
+      end
+      
+      it "should use an empty string when generating a query if the parameter value is nil" do
+        parameter = ValueParameter.new('foo', nil)
+        parameter.to_query.should == 'foo='
+      end
+      
+      it "should know how to generate the form representation of itself" do
+        parameter = ValueParameter.new('foo', 'bar')
+        expected = 
+          'Content-Disposition: form-data; name="foo"' + "\r\n" +
+          "\r\n" +
+          "bar\r\n"
+          
+        parameter.to_form.should == expected
+      end
+   
+   end
+    
+  end
+end

data/test/unit/fleakr/core_ext/hash_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+class HashTest < Test::Unit::TestCase
+  
+  describe "An instance of Hash" do
+    context "when extracting key/value pairs" do
+      
+      before do
+        @hash = {:one => 'two', :three => 'four'}
+      end
+      
+      it "should return a hash with the matching key/value pairs" do
+        @hash.extract!(:one).should == {:one => 'two'}
+      end
+      
+      it "should return an empty hash if the key isn't found" do
+        @hash.extract!(:foo).should == {}
+      end
+      
+      it "should alter the original hash when a value is extracted" do
+        @hash.extract!(:one)
+        @hash.should == {:three => 'four'}
+      end
+      
+      it "should be able to extract multiple keys" do
+        @hash.extract!(:one, :three, :missing).should == {:one => 'two', :three => 'four'}
+      end
+      
+    end
+  end
+  
+end

data/test/unit/fleakr/objects/authentication_token_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class AuthenticationTokenTest < Test::Unit::TestCase
+    
+    describe "The AuthenticationToken class" do
+      
+      it "should be able to create an instance from a mini_token" do
+        token = '123-123-123'
+        auth_token = stub()
+        
+        response = mock_request_cycle :for => 'auth.getFullToken', :with => {:mini_token => token, :sign? => true}
+        
+        AuthenticationToken.expects(:new).with(response.body).returns(auth_token)
+        
+        AuthenticationToken.from_mini_token(token).should == auth_token
+      end
+      
+      it "should be able to create an instance from an auth_token" do
+        token      = 'abc123'
+        auth_token = stub()
+
+        response = mock_request_cycle :for => 'auth.checkToken', :with => {:auth_token => token, :sign? => true}
+        
+        AuthenticationToken.expects(:new).with(response.body).returns(auth_token)
+        AuthenticationToken.from_auth_token(token).should == auth_token
+      end
+      
+    end
+    
+    describe "An instance of the AuthenticationToken class" do
+      
+      context "when populating from an XML document" do
+        
+        before do
+          @object = AuthenticationToken.new(Hpricot.XML(read_fixture('auth.getFullToken')))
+        end
+        
+        should_have_a_value_for :value       => 'abc-123'
+        should_have_a_value_for :permissions => 'delete'
+        
+      end
+      
+    end
+    
+  end
+end

data/test/unit/fleakr/objects/image_test.rb

@@ -45,6 +45,9 @@ module Fleakr::Objects
             @image = Image.new
             @image.stubs(:url).with().returns(@url)
             @image.stubs(:filename).with().returns(@image_filename)
+            
+            @image_data = 'image_data'
+            Net::HTTP.expects(:get).with(URI.parse(@url)).returns(@image_data)
           end
 
           after do
@@ -52,20 +55,22 @@ module Fleakr::Objects
           end
 
           should "be able to save to a directory with the original filename" do
-            Net::HTTP.expects(:get).with(URI.parse(@url)).returns('image_data')
-
             @image.save_to(@tmp_dir)
-            File.read("#{@tmp_dir}/image.jpg").should == 'image_data'
+            File.read("#{@tmp_dir}/image.jpg").should == @image_data
           end
 
           should "be able to save to a specified file" do
-            Net::HTTP.expects(:get).with(URI.parse(@url)).returns('image_data')
             existing_file = "#{@tmp_dir}/existing_file.jpg"
 
             FileUtils.touch(existing_file)
 
             @image.save_to(existing_file)
-            File.read(existing_file).should == 'image_data'
+            File.read(existing_file).should == @image_data
+          end
+          
+          should "be able to save the file using a specified prefix" do
+            @image.save_to(@tmp_dir, '001_')
+            File.read("#{@tmp_dir}/001_image.jpg").should == @image_data
           end
 
         end