fleakr 0.6.3 → 0.7.0

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

@@ -1,37 +1,37 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 module Fleakr::Api
   class AuthenticationRequestTest < Test::Unit::TestCase
-    
+
     context "An instance of AuthenticationRequest" do
-      
+
       should "know the endpoint URL" do
         request = AuthenticationRequest.new
         request.endpoint_url.should == 'http://flickr.com/services/auth/'
       end
-      
+
       should "be able to make a request" do
         endpoint_uri = stub()
-        
+
         request = AuthenticationRequest.new
         request.stubs(:endpoint_uri).with().returns(endpoint_uri)
-      
+
         Net::HTTP.expects(:get_response).with(endpoint_uri).returns('response')
-      
+
         request.response.should == 'response'
       end
-      
+
       should "know the authorization_url for the authentication request" do
         response_headers = {'Location' => 'http://example.com/auth'}
         response = stub() {|r| r.stubs(:header).with().returns(response_headers) }
-        
+
         request = AuthenticationRequest.new
         request.stubs(:response).with().returns(response)
-        
+
         request.authorization_url.should == 'http://example.com/auth'
       end
-      
+
     end
-    
+
   end
 end

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

@@ -1,40 +1,40 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 module Fleakr::Api
   class FileParameterTest < Test::Unit::TestCase
-    
+
     context "An instance of the FileParameter class" do
-      
+
       setup do
         @temp_dir = File.expand_path(create_temp_directory)
         @filename = "#{@temp_dir}/image.jpg"
       end
-      
+
       teardown do
         FileUtils.rm_rf(@temp_dir)
       end
-      
+
       {'jpg' => 'image/jpeg', 'png' => 'image/png', 'gif' => 'image/gif'}.each do |ext, mime_type|
         should "know the correct MIME type for an extension of #{ext}" do
           parameter = FileParameter.new('photo', "#{@temp_dir}/image.#{ext}")
           parameter.mime_type.should == mime_type
         end
       end
-      
+
       should "retrieve the contents of the file when accessing the value" do
         File.expects(:read).with(@filename).returns('bopbip')
-        
+
         parameter = FileParameter.new('photo', @filename)
         parameter.value.should == 'bopbip'
       end
-      
+
       should "cache the file contents after retrieving them" do
         File.expects(:read).with(@filename).once.returns('bopbip')
-        
+
         parameter = FileParameter.new('photo', @filename)
         2.times { parameter.value }
       end
-      
+
       should "know how to generate a form representation of itself" do
         filename  = 'image.jpg'
         mime_type = 'image/jpeg'
@@ -42,17 +42,17 @@ module Fleakr::Api
         parameter = FileParameter.new('photo', filename)
         parameter.stubs(:mime_type).with().returns(mime_type)
         parameter.stubs(:value).with().returns('data')
-        
-        expected = 
+
+        expected =
           "Content-Disposition: form-data; name=\"photo\"; filename=\"#{filename}\"\r\n" +
           "Content-Type: image/jpeg\r\n" +
           "\r\n" +
           "data\r\n"
-        
+
         parameter.to_form.should == expected
       end
-      
+
     end
-    
+
   end
 end

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

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 module Fleakr::Api
   class MethodRequestTest < Test::Unit::TestCase

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

@@ -1,15 +1,15 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 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
@@ -18,64 +18,64 @@ module Fleakr::Api
       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)
@@ -86,94 +86,94 @@ module Fleakr::Api
         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

@@ -1,13 +1,13 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 module Fleakr::Api
   class ParameterListTest < Test::Unit::TestCase
-    
+
     context "An instance of the ParameterList class with an available API key" do
       setup do
         @api_key_value = 'api_key_value'
         Fleakr.stubs(:api_key).with().returns(@api_key_value)
-        
+
         @parameter_list = ParameterList.new
       end
 
@@ -15,146 +15,146 @@ module Fleakr::Api
         @parameter_list.stubs(:authentication_token).with().returns('toke')
         @parameter_list.send_authentication_token?.should be(true)
       end
-      
+
       should "know not to send the authentication token" do
         pl = ParameterList.new({}, false)
         pl.stubs(:authentication_token).with().returns('toke')
-        
+
         pl.send_authentication_token?.should be(false)
       end
-      
+
       should "know not to send the authentication token if it's not available from the global value" do
         @parameter_list.stubs(:authentication_token).with().returns(nil)
         @parameter_list.send_authentication_token?.should be(false)
       end
-      
+
       should "have a default list of options" do
         @parameter_list.default_options.should == {:api_key => @api_key_value}
       end
-      
+
       should "use the authentication_token in the options if we're to authenticate" do
         @parameter_list.stubs(:send_authentication_token?).with().returns(true)
         @parameter_list.stubs(:authentication_token).with().returns('toke')
         @parameter_list.stubs(:default_options).with().returns({})
-        
+
         @parameter_list.options.should == {:auth_token => 'toke'}
       end
-      
+
       should "add additional options from the constructor" do
         pl = ParameterList.new(:foo => 'bar')
         pl.options.should == {:foo => 'bar', :api_key => @api_key_value}
       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('secrit')
         @parameter_list.sign?.should be(true)
       end
-      
+
       should "be able to add an option to the list" do
         @parameter_list.stubs(:default_options).with().returns({})
-        
+
         @parameter_list.add_option(:foo, 'bar')
         @parameter_list.options.should == {:foo => 'bar'}
       end
-      
+
       should "have an empty list of upload options by default" do
         @parameter_list.upload_options.should == {}
       end
-      
+
       should "be able to add an upload option to the list" do
         @parameter_list.add_upload_option(:file, '/path/to/foo')
         @parameter_list.upload_options.should == {:file => '/path/to/foo'}
       end
-      
+
       should "be able to generate the list of parameters without a signature" do
         @parameter_list.stubs(:options).with().returns({:foo => 'bar', :api_sig => '1234'})
         @parameter_list.options_without_signature.should == {:foo => 'bar'}
       end
-      
+
       should "be able to calculate the signature of the parameters" do
         Fleakr.stubs(:shared_secret).with().returns('sekrit')
-        
+
         options = {:api_key => @api_key_value, :foo => 'bar', :blip => 'zeeez'}
         @parameter_list.stubs(:options_without_signature).with().returns(options)
 
         @parameter_list.signature.should == Digest::MD5.hexdigest("sekritapi_key#{@api_key_value}blipzeeezfoobar")
       end
-      
+
       should "be able to generate a list of options with a signature" do
         parameters = [ValueParameter.new('foo', 'bar')]
-        
+
         @parameter_list.stubs(:options_without_signature).with().returns(:foo => 'bar')
         @parameter_list.stubs(:signature).with().returns('sig')
-        
+
         @parameter_list.options_with_signature.should == {:foo => 'bar', :api_sig => 'sig'}
       end
-      
+
       should "know the auth token when provided to the constructor" do
         pl = ParameterList.new(:auth_token => 'toke')
         pl.authentication_token.should == 'toke'
       end
-      
+
       should "know the auth token when available as a global value" do
         Fleakr.stubs(:auth_token).with().returns('toke')
-        
+
         pl = ParameterList.new
         pl.authentication_token.should == 'toke'
       end
-      
+
       should "know that there is no authentication token if it is not available as a param or global value" do
         Fleakr.stubs(:auth_token).with().returns(nil)
-        
+
         pl = ParameterList.new
         pl.authentication_token.should be_nil
       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 "be able to generate a list of parameters without a signature" do
         parameter = stub()
-        
+
         @parameter_list.stubs(:sign?).with().returns(false)
         @parameter_list.expects(:options_without_signature).with().returns(:foo => 'bar')
 
         ValueParameter.expects(:new).with(:foo, 'bar').returns(parameter)
-        
+
         @parameter_list.list.should == [parameter]
       end
-      
+
       should "be able to generate a list of parameters with a signature" do
         parameter = stub()
-        
+
         @parameter_list.stubs(:sign?).with().returns(true)
         @parameter_list.expects(:options_with_signature).with().returns(:foo => 'bar')
 
         ValueParameter.expects(:new).with(:foo, 'bar').returns(parameter)
-        
+
         @parameter_list.list.should == [parameter]
       end
-      
+
       should "be able to generate a list of parameters with upload parameters if available" do
         value_parameter = stub()
         file_parameter  = stub()
-        
+
         @parameter_list.stubs(:sign?).with().returns(true)
         @parameter_list.expects(:options_with_signature).with().returns(:foo => 'bar')
         @parameter_list.expects(:upload_options).with().returns(:file => 'path')
-        
+
         ValueParameter.expects(:new).with(:foo, 'bar').returns(value_parameter)
         FileParameter.expects(:new).with(:file, 'path').returns(file_parameter)
-        
+
         @parameter_list.list.should == [value_parameter, file_parameter]
       end
-            
+
       context "with associated parameters" do
 
         setup do
@@ -177,7 +177,7 @@ module Fleakr::Api
         should "be able to represent a form representation of itself" do
           @parameter_list.stubs(:boundary).returns('bound')
 
-          expected = 
+          expected =
             "--bound\r\n" +
             "f1" +
             "--bound\r\n" +
@@ -190,6 +190,6 @@ module Fleakr::Api
       end
 
     end
-    
+
   end
 end