slaskis-fleakr 0.5.0

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

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class MethodRequestTest < Test::Unit::TestCase
+
+    context "An instance of MethodRequest" do
+
+      context "with API credentials" do
+
+        setup do
+          @api_key = 'f00b4r'
+          Fleakr.stubs(:api_key).with().returns(@api_key)
+          Fleakr.stubs(:shared_secret).with().returns('sekrit')
+        end
+
+        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
+        
+        should "translate a shorthand API call" do
+          request = MethodRequest.new('people.findByUsername')
+          request.parameters[:method].value.should == 'flickr.people.findByUsername'
+        end
+        
+        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()
+          uri_mock.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
+        
+        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
+        
+        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
+        
+        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
+        
+        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/option_test.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+    
+  class OptionTest < Test::Unit::TestCase
+    
+    def self.should_know_the_class_for(type, options)
+      should "know the class for the :#{type} type" do
+        Option.class_for(type).should == options[:is]
+      end
+    end
+    
+    context "The Option class" do
+      should_know_the_class_for :title,       :is => Fleakr::Api::SimpleOption
+      should_know_the_class_for :description, :is => Fleakr::Api::SimpleOption
+      should_know_the_class_for :tags,        :is => Fleakr::Api::TagOption
+      should_know_the_class_for :viewable_by, :is => Fleakr::Api::ViewOption
+      should_know_the_class_for :level,       :is => Fleakr::Api::LevelOption
+      should_know_the_class_for :type,        :is => Fleakr::Api::TypeOption
+      should_know_the_class_for :hide?,       :is => Fleakr::Api::HiddenOption
+      
+      should "be able to create an option for a type" do
+        option = stub()
+        
+        Option.expects(:class_for).with(:title).returns(Fleakr::Api::SimpleOption)
+        Fleakr::Api::SimpleOption.expects(:new).with(:title, 'blip').returns(option)
+        
+        Option.for(:title, 'blip').should == option
+      end
+    end
+    
+  end
+  
+  class SimpleOptionTest < Test::Unit::TestCase
+    
+    context "An instance of the SimpleOption class" do
+      should "have a type" do
+        so = SimpleOption.new(:title, 'blip')
+        so.type.should == :title
+      end
+      
+      should "have a value" do
+        so = SimpleOption.new(:title, 'blip')
+        so.value.should == 'blip'
+      end
+      
+      should "be able to generate a hash representation of itself" do
+        so = SimpleOption.new(:title, 'blip')
+        so.to_hash.should == {:title => 'blip'}
+      end
+    end
+    
+  end
+
+  class TagOptionTest < Test::Unit::TestCase
+    
+    context "An instance of the TagOption class" do
+      
+      should "normalize the input value to an array" do
+        to = TagOption.new(:tags, 'blip')
+        to.value.should == ['blip']
+      end
+      
+      should "be able to generate a hash representation of itself with tags joined on spaces" do
+        to = TagOption.new(:tags, %w(bop bip))
+        to.to_hash.should == {:tags => '"bop" "bip"'}
+      end
+      
+      should "quote tag values with spaces" do
+        to = TagOption.new(:tags, ['tag', 'one with spaces'])
+        to.to_hash.should == {:tags => '"tag" "one with spaces"'}
+      end
+    end
+    
+  end
+  
+  class ViewOptionTest < Test::Unit::TestCase
+    
+    context "An instance of the ViewOption class" do
+      should "be able to generate a hash representation for viewing by :everyone" do
+        vo = ViewOption.new(:viewable_by, :everyone)
+        vo.to_hash.should == {:is_public => 1, :is_family => 0, :is_friend => 0}
+      end
+
+      should "be able to generate a hash representation for viewing by :family" do
+        vo = ViewOption.new(:viewable_by, :family)
+        vo.to_hash.should == {:is_public => 0, :is_family => 1, :is_friend => 0}
+      end
+      
+      should "be able to generate a hash representation for viewing by :friends" do
+        vo = ViewOption.new(:viewable_by, :friends)
+        vo.to_hash.should == {:is_public => 0, :is_family => 0, :is_friend => 1}
+      end
+      
+      should "know the visibility is public if value is set to :everyone" do
+        vo = ViewOption.new(:viewable_by, :everyone)
+        vo.public?.should be(true)
+      end
+      
+      should "know the visibility is not public if :everyone is not the only value" do
+        vo = ViewOption.new(:viewable_by, [:everyone, :family])
+        vo.public?.should be(false)
+      end
+      
+      should "know that its visible to friends and family if specified as such" do
+        vo = ViewOption.new(:viewable_by, [:friends, :family])
+        vo.friends?.should be(true)
+        vo.family?.should be(true)
+      end
+      
+    end
+    
+  end
+
+  class LevelOptionTest < Test::Unit::TestCase
+    
+    context "An instance of the LevelOption class" do
+      
+      should "be able to generate a hash representation for the :safe level" do
+        lo = LevelOption.new(:level, :safe)
+        lo.to_hash.should == {:safety_level => 1}
+      end
+      
+      should "be able to generate a hash representation for the :moderate level" do
+        lo = LevelOption.new(:level, :moderate)
+        lo.to_hash.should == {:safety_level => 2}
+      end
+      
+      should "be able to generate a hash representation for the :restricted level" do
+        lo = LevelOption.new(:level, :restricted)
+        lo.to_hash.should == {:safety_level => 3}
+      end
+      
+    end
+    
+  end
+
+  class TypeOptionTest < Test::Unit::TestCase
+    
+    context "An instance of the TypeOption class" do
+      
+      should "be able to generate a hash representation for the :photo type" do
+        to = TypeOption.new(:type, :photo)
+        to.to_hash.should == {:content_type => 1}
+      end
+      
+      should "be able to generate a hash representation for the :screenshot type" do
+        to = TypeOption.new(:type, :screenshot)
+        to.to_hash.should == {:content_type => 2}
+      end
+      
+      should "be able to generate a hash representation for the :other type" do
+        to = TypeOption.new(:type, :other)
+        to.to_hash.should == {:content_type => 3}
+      end
+      
+    end
+    
+  end
+  
+  class HiddenOptionTest < Test::Unit::TestCase
+    
+    context "An instance of the HiddenOption class" do
+      
+      should "be able to generate a hash representation when set to true" do
+        ho = HiddenOption.new(:hide?, true)
+        ho.to_hash.should == {:hidden => 2}
+      end
+      
+      should "be able to generate a hash representation when set to false" do
+        ho = HiddenOption.new(:hide?, false)
+        ho.to_hash.should == {:hidden => 1}
+      end
+      
+    end
+    
+  end
+
+end

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

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class ParameterListTest < Test::Unit::TestCase
+    
+    context "An instance of the ParameterList class" do
+      
+      setup do
+        @api_key = 'key'
+        @secret  = 'foobar'
+
+        Fleakr.stubs(:api_key).with().returns(@api_key)
+        @parameter_list = ParameterList.new
+      end
+      
+      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
+      
+      should "be able to create an initial list of parameters" do
+        parameter_list = ParameterList.new(:one => 'two')
+        parameter_list[:one].value.should == 'two'
+      end
+      
+      should "be able to add parameters to its list" do
+        parameter = ValueParameter.new('foo', 'bar')
+        
+        @parameter_list << parameter
+        @parameter_list['foo'].should == parameter
+      end
+      
+      should "allow access to parameters by symbol" do
+        parameter = ValueParameter.new('foo', 'bar')
+        @parameter_list << parameter
+        
+        @parameter_list[:foo].should == parameter
+      end
+      
+      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
+      
+      should "be able to calculate the signature of the parameters" do
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+        
+        @parameter_list << ValueParameter.new('foo', 'bar')
+        @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}api_key#{@api_key}foobar")
+      end
+      
+      should "use the correct order when signing a list of multiple parameters" do
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+        
+        @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
+      
+      should "ignore the parameters that aren't included in the signature" do
+        Fleakr.stubs(:shared_secret).with().returns(@secret)
+        
+        @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
+      
+      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
+      
+      should "know that it doesn't need to sign the request by default" do
+        @parameter_list.sign?.should be(false)
+      end
+      
+      should "know that it needs to sign the request when a shared secret is available" do
+        Fleakr.expects(:shared_secret).with().returns(@secret)
+        @parameter_list.sign?.should be(true)
+      end
+      
+      should "know that it doesn't need to authenticate the request by default" do
+        @parameter_list.authenticate?.should be(false)
+      end
+      
+      should "know to authenticate the request when a token is available" do
+        Fleakr.stubs(:token).with().returns(stub(:value => 'toke'))
+        parameter_list = ParameterList.new
+
+        parameter_list.authenticate?.should be(true)
+      end
+      
+      should "not authenticate the request if it's been specifically told not to" do
+        Fleakr.expects(:token).with().never
+        
+        parameter_list = ParameterList.new(:authenticate? => false)
+        parameter_list.authenticate?.should be(false)
+      end
+      
+      
+      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
+      
+      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
+      
+      should "include the signature in the list of parameters if the request is to be signed" do
+        parameter_list = ParameterList.new
+        
+        parameter_list.stubs(:sign?).with().returns(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
+      
+        setup 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
+      
+        should "be able to generate a query representation of itself" do
+          @parameter_list.to_query.should == 'q1&q2'
+        end
+      
+        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