slaskis-fleakr 0.5.0

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
+    
+    context "An instance of the Parameter class" do
+      
+      should "have a name" do
+        parameter = Parameter.new('foo')
+        parameter.name.should == 'foo'
+      end
+      
+      should "know to include it in the signature by default" do
+        parameter = Parameter.new('foo')
+        parameter.include_in_signature?.should be(true)
+      end
+      
+      should "know not to include it in the signature" do
+        parameter = Parameter.new('foo', false)
+        parameter.include_in_signature?.should be(false)
+      end
+      
+      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/response_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class ResponseTest < Test::Unit::TestCase
+
+    context "An instance of Response" do
+
+      should "provide the response body as an Hpricot element" do
+        response_xml = '<xml>'
+        hpricot_stub = stub()
+
+        Hpricot.expects(:XML).with(response_xml).returns(hpricot_stub)
+        
+        response = Response.new(response_xml)
+        response.body.should == hpricot_stub
+      end
+      
+      should "memoize the Hpricot document" do
+        response = Response.new('<xml>')
+        
+        Hpricot.expects(:XML).with(kind_of(String)).once.returns(stub())
+        
+        2.times { response.body }
+      end
+      
+      should "know if there are errors in the response" do
+        response_xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<rsp stat=\"fail\">\n\t<err code=\"1\" msg=\"User not found\" />\n</rsp>\n"
+        response = Response.new(response_xml)
+        
+        response.error?.should be(true)
+      end
+      
+      should "not have an error if there are no errors in the XML" do
+        response = Response.new(read_fixture('people.findByUsername'))
+        response.error.should be(nil)
+      end
+      
+      should "have an error if there is an error in the response" do
+        response_xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<rsp stat=\"fail\">\n\t<err code=\"1\" msg=\"User not found\" />\n</rsp>\n"
+        response = Response.new(response_xml)
+        
+        response.error.code.should == '1'
+        response.error.message.should == 'User not found'
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class UploadRequestTest < Test::Unit::TestCase
+
+    context "An instance of the UploadRequest class" do
+
+      setup do
+        @secret = 'sekrit'
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+      end
+      
+      should "have a collection of upload_options" do
+        request = UploadRequest.new('foo', :create, {:title => 'foo', :tags => %w(a b)})
+        
+        option_1, option_2 = [stub(:to_hash => {:one => 'value_1'}), stub(:to_hash => {:two => 'value_2'})]
+        
+        Option.expects(:for).with(:title, 'foo').returns(option_1)
+        Option.expects(:for).with(:tags, %w(a b)).returns(option_2)
+        
+        request.upload_options.should == {:one => 'value_1', :two => 'value_2'}
+      end
+      
+      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()
+        parameter_list.expects(:<<).with(parameter)
+        
+        ParameterList.expects(:new).with({}).returns(parameter_list)
+
+        UploadRequest.new(filename)
+      end
+      
+      should "allow setting options on initialization" do
+        option = stub()
+        option.stubs(:to_hash).with().returns({:title => 'foo'})
+        
+        Option.expects(:for).with(:title, 'foo').returns(option)
+        
+        ParameterList.expects(:new).with({:title => 'foo'}).returns(stub(:<<))
+        
+        UploadRequest.new('filename', :create, {:title => 'foo'})
+      end
+
+      context "after initialization" do
+
+        setup { ParameterList.stubs(:new).returns(stub(:<< => nil)) }
+
+        should "default the type to :create" do
+          request = UploadRequest.new('file')
+          request.type.should == :create
+        end
+        
+        should "allow setting the type to :update" do
+          request = UploadRequest.new('file', :update)
+          request.type.should == :update
+        end
+
+        should "know the endpoint_uri" do
+          request = UploadRequest.new('filename')
+          request.__send__(:endpoint_uri).should == URI.parse('http://api.flickr.com/services/upload/')
+        end
+        
+        should "know the endpoint_uri for an :update request" do
+          request = UploadRequest.new('filename', :update)
+          request.__send__(:endpoint_uri).should == URI.parse('http://api.flickr.com/services/replace/')
+        end
+        
+        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
+
+        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
+
+        should "be able to send a POST request to the API service" do
+          request = UploadRequest.new('filename')
+          
+          uri = stub()
+          uri.stubs(:host).with().returns('host')
+          uri.stubs(:path).with().returns('path')
+          uri.stubs(:port).with().returns(80)
+          
+          request.stubs(:endpoint_uri).with().returns(uri)
+          
+          request.stubs(:headers).with().returns('header' => 'value')
+          request.parameters.stubs(:to_form).with().returns('form')
+
+          http = mock()
+          http.expects(:post).with('path', 'form', {'header' => 'value'})
+
+          Net::HTTP.expects(:start).with('host', 80).yields(http).returns(stub(:body))
+          
+          request.send
+        end
+        
+        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
+        
+        should "be able to make a full request and response cycle" do
+          filename = 'filename'
+          response = stub(:error? => false)
+          
+          UploadRequest.expects(:new).with(filename, :create, {}).returns(stub(:send => response))
+          UploadRequest.with_response!(filename).should == response
+        end
+        
+        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, :create, {}).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
+
+   context "An instance of the ValueParameter class" do
+      
+     should "have a value" do
+       parameter = ValueParameter.new('foo', 'bar')
+       parameter.value.should == 'bar'
+     end
+      
+      should "know how to generate the query representation of itself" do
+        parameter = ValueParameter.new('foo', 'bar')
+        parameter.to_query.should == 'foo=bar'
+      end
+      
+      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
+      
+      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
+      
+      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/false_class_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+class FalseClassTest < Test::Unit::TestCase
+  
+  context "An instance of the FalseClass class" do
+    
+    should "have 0 as its integer value" do
+      false.to_i.should == 0
+    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
+  
+  context "An instance of Hash" do
+    context "when extracting key/value pairs" do
+      
+      setup do
+        @hash = {:one => 'two', :three => 'four'}
+      end
+      
+      should "return a hash with the matching key/value pairs" do
+        @hash.extract!(:one).should == {:one => 'two'}
+      end
+      
+      should "return an empty hash if the key isn't found" do
+        @hash.extract!(:foo).should == {}
+      end
+      
+      should "alter the original hash when a value is extracted" do
+        @hash.extract!(:one)
+        @hash.should == {:three => 'four'}
+      end
+      
+      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/core_ext/true_class_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+class TrueClassTest < Test::Unit::TestCase
+  
+  context "An instance of the TrueClass class" do
+    
+    should "have 1 as its integer value" do
+      true.to_i.should == 1
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class AuthenticationTokenTest < Test::Unit::TestCase
+    
+    context "The AuthenticationToken class" do
+      
+      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, :authenticate? => false}
+        
+        AuthenticationToken.expects(:new).with(response.body).returns(auth_token)
+        
+        AuthenticationToken.from_mini_token(token).should == auth_token
+      end
+      
+      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, :authenticate? => false}
+        
+        AuthenticationToken.expects(:new).with(response.body).returns(auth_token)
+        AuthenticationToken.from_auth_token(token).should == auth_token
+      end
+      
+      
+      should "be able to create an instance from a frob" do
+        frob       = '12345678901234567-abcde89012fg3456-7890123'
+        auth_token = stub()
+        
+        response = mock_request_cycle :for => 'auth.getToken', :with => {:frob => frob, :authenticate? => false}
+        
+        AuthenticationToken.expects(:new).with(response.body).returns(auth_token)
+        AuthenticationToken.from_frob(frob).should == auth_token
+      end
+      
+    end
+    
+    context "An instance of the AuthenticationToken class" do
+      
+      context "when populating from an XML document" do
+        
+        setup 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'
+        should_have_a_value_for :user_id     => '31066442@N69'
+        should_have_a_value_for :full_name   => 'Sir Froot Pants'
+        should_have_a_value_for :user_name   => 'frootpantz'
+        
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class CommentTest < Test::Unit::TestCase
+
+    context "The Comment class" do
+
+      should_find_all :comments, :by => :photo_id, :call => 'photos.comments.getList', :path => 'rsp/comments/comment'
+      should_find_all :comments, :by => :set_id, :using => :photoset_id, :call => 'photosets.comments.getList', :path => 'rsp/comments/comment'
+
+    end
+
+    context "An instance of the Comment class" do
+
+      context "when populating from the photos_comments_getList XML data" do
+        setup do
+          @object = Comment.new(Hpricot.XML(read_fixture('photos.comments.getList')).at('rsp/comments/comment'))
+        end
+
+        should_have_a_value_for :id        => '1'
+        should_have_a_value_for :author_id => '10490170@N04'
+        should_have_a_value_for :created   => '1239217523'
+        should_have_a_value_for :url       => 'http://www.flickr.com/photos/frootpantz/3422268412/#comment72157616515348062'
+        should_have_a_value_for :body      => 'comment one'
+        
+      end
+      
+      context "in general" do
+        
+        setup { @comment = Comment.new }
+
+        should "have a value for :created_at" do
+          @comment.expects(:created).with().returns('1239217523')
+          Time.expects(:at).with(1239217523).returns('time')
+          
+          @comment.created_at.should == 'time'
+        end
+
+        should "use the body as the string representation" do
+          @comment.expects(:body).with().returns('bod')
+          @comment.to_s.should == 'bod'
+        end
+        
+        should "be able to find the author of the comment" do
+          author = stub()
+          
+          
+          @comment.stubs(:author_id).with().returns('1')
+          User.expects(:find_by_id).with('1').returns(author)
+          
+          @comment.author.should == author
+        end
+        
+        should "memoize the owner information" do
+          @comment.stubs(:author_id).with().returns('1')
+          
+          User.expects(:find_by_id).with('1').once.returns(stub())
+          
+          2.times { @comment.author }
+        end
+        
+      end
+    end
+
+  end
+end