reagent-fleakr 0.4.1 → 0.4.2

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)
+      it "should know the class for the :#{type} type" do
+        Option.class_for(type).should == options[:is]
+      end
+    end
+    
+    describe "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
+      
+      it "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
+    
+    describe "An instance of the SimpleOption class" do
+      it "should have a type" do
+        so = SimpleOption.new(:title, 'blip')
+        so.type.should == :title
+      end
+      
+      it "should have a value" do
+        so = SimpleOption.new(:title, 'blip')
+        so.value.should == 'blip'
+      end
+      
+      it "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
+    
+    describe "An instance of the TagOption class" do
+      
+      it "should normalize the input value to an array" do
+        to = TagOption.new(:tags, 'blip')
+        to.value.should == ['blip']
+      end
+      
+      it "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
+      
+      it "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
+    
+    describe "An instance of the ViewOption class" do
+      it "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
+
+      it "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
+      
+      it "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
+      
+      it "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
+      
+      it "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
+      
+      it "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
+    
+    describe "An instance of the LevelOption class" do
+      
+      it "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
+      
+      it "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
+      
+      it "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
+    
+    describe "An instance of the TypeOption class" do
+      
+      it "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
+      
+      it "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
+      
+      it "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
+    
+    describe "An instance of the HiddenOption class" do
+      
+      it "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
+      
+      it "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

@@ -9,7 +9,6 @@ module Fleakr::Api
         @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
@@ -24,7 +23,7 @@ module Fleakr::Api
         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')
         
@@ -47,11 +46,15 @@ module Fleakr::Api
       end
       
       it "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
       
       it "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')
         
@@ -59,6 +62,8 @@ module Fleakr::Api
       end
       
       it "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)
         
@@ -76,15 +81,30 @@ module Fleakr::Api
         @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)
+      it "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
       
       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 a token is available" do
+        Fleakr.stubs(:token).with().returns(stub(:value => 'toke'))
+        parameter_list = ParameterList.new
+
+        parameter_list.authenticate?.should be(true)
+      end
+      
+      it "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
+      
+      
       it "should know to authenticate the request when asked" do
         Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
         
@@ -103,15 +123,10 @@ module Fleakr::Api
         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 = ParameterList.new
+        
+        parameter_list.stubs(:sign?).with().returns(true)
         parameter_list.stubs(:signature).with().returns('sig')
         
         signature_param = parameter_list[:api_sig]
@@ -122,24 +137,24 @@ module Fleakr::Api
       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')
           

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

@@ -10,6 +10,17 @@ module Fleakr::Api
         Fleakr.stubs(:shared_secret).with().returns(@secret)
       end
       
+      it "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
+      
       it "should create a file parameter on initialization" do
         filename = '/path/to/image.jpg'
 
@@ -17,17 +28,18 @@ module Fleakr::Api
         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)
+        ParameterList.expects(:new).with({}).returns(parameter_list)
 
         UploadRequest.new(filename)
       end
       
-      it "should allow setting additional parameters on initialization" do
-        params = {:is_public => 1}
+      it "should allow setting options on initialization" do
+        option = stub {|s| s.stubs(:to_hash).with().returns({:title => 'foo'})}
+        Option.expects(:for).with(:title, 'foo').returns(option)
         
-        ParameterList.expects(:new).with({:is_public => 1, :authenticate? => true}).returns(stub(:<<))
+        ParameterList.expects(:new).with({:title => 'foo'}).returns(stub(:<<))
         
-        UploadRequest.new('filename', params)
+        UploadRequest.new('filename', :create, {:title => 'foo'})
       end
 
       context "after initialization" do
@@ -40,7 +52,7 @@ module Fleakr::Api
         end
         
         it "should allow setting the type to :update" do
-          request = UploadRequest.new('file', :type => :update)
+          request = UploadRequest.new('file', :update)
           request.type.should == :update
         end
 
@@ -50,7 +62,7 @@ module Fleakr::Api
         end
         
         it "should know the endpoint_uri for an :update request" do
-          request = UploadRequest.new('filename', :type => :update)
+          request = UploadRequest.new('filename', :update)
           request.__send__(:endpoint_uri).should == URI.parse('http://api.flickr.com/services/replace/')
         end
         
@@ -110,7 +122,7 @@ module Fleakr::Api
           filename = 'filename'
           response = stub(:error? => false)
           
-          UploadRequest.expects(:new).with(filename, {}).returns(stub(:send => response))
+          UploadRequest.expects(:new).with(filename, :create, {}).returns(stub(:send => response))
           UploadRequest.with_response!(filename).should == response
         end
         
@@ -118,7 +130,7 @@ module Fleakr::Api
           filename = 'filename'
           response = stub(:error? => true, :error => stub(:code => '1', :message => 'User not found'))
           
-          UploadRequest.expects(:new).with(filename, {}).returns(stub(:send => response))
+          UploadRequest.expects(:new).with(filename, :create, {}).returns(stub(:send => response))
           
           lambda do
             UploadRequest.with_response!(filename)

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
+  
+  describe "An instance of the FalseClass class" do
+    
+    it "should have 0 as its integer value" do
+      false.to_i.should == 0
+    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
+  
+  describe "An instance of the TrueClass class" do
+    
+    it "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

@@ -9,7 +9,7 @@ module Fleakr::Objects
         token = '123-123-123'
         auth_token = stub()
         
-        response = mock_request_cycle :for => 'auth.getFullToken', :with => {:mini_token => token, :sign? => true}
+        response = mock_request_cycle :for => 'auth.getFullToken', :with => {:mini_token => token, :authenticate? => false}
         
         AuthenticationToken.expects(:new).with(response.body).returns(auth_token)
         
@@ -20,12 +20,23 @@ module Fleakr::Objects
         token      = 'abc123'
         auth_token = stub()
 
-        response = mock_request_cycle :for => 'auth.checkToken', :with => {:auth_token => token, :sign? => true}
+        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
       
+      
+      it "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
     
     describe "An instance of the AuthenticationToken class" do
@@ -38,6 +49,9 @@ module Fleakr::Objects
         
         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
       

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

@@ -16,7 +16,7 @@ module Fleakr::Objects
       
       should_find_one :photo, :by => :id, :with => :photo_id, :call => 'photos.getInfo'
 
-
+      # TODO: refactor these 2 tests
       it "should be able to upload a photo and return the new photo information" do
         filename = '/path/to/mugshot.jpg'
         photo = stub()
@@ -25,11 +25,25 @@ module Fleakr::Objects
           s.stubs(:body).with().returns(Hpricot.XML('<photoid>123</photoid>'))
         end
         
-        Fleakr::Api::UploadRequest.expects(:with_response!).with(filename).returns(response)
-        Photo.expects(:find_by_id).with('123', :authenticate? => true).returns(photo)
+        Fleakr::Api::UploadRequest.expects(:with_response!).with(filename, :create, {}).returns(response)
+        Photo.expects(:find_by_id).with('123').returns(photo)
         
         Photo.upload(filename).should == photo
       end
+      
+      it "should be able to pass additional options when uploading a new file" do
+        filename = '/path/to/mugshot.jpg'
+        photo = stub()
+        
+        response = stub do |s|
+          s.stubs(:body).with().returns(Hpricot.XML('<photoid>123</photoid>'))
+        end
+        
+        Fleakr::Api::UploadRequest.expects(:with_response!).with(filename, :create, {:title => 'foo'}).returns(response)
+        Photo.expects(:find_by_id).with('123').returns(photo)
+        
+        Photo.upload(filename, :title => 'foo').should == photo
+      end
 
     end
 
@@ -39,9 +53,9 @@ module Fleakr::Objects
         filename = '/path/to/file.jpg'
         response = stub(:body => 'body')
         
-        params = {:type => :update, :photo_id => '1'}
+        params = {:photo_id => '1'}
 
-        Fleakr::Api::UploadRequest.expects(:with_response!).with(filename, params).returns(response)
+        Fleakr::Api::UploadRequest.expects(:with_response!).with(filename, :update, params).returns(response)
 
         photo = Photo.new
         photo.stubs(:id).returns('1')
@@ -110,17 +124,17 @@ module Fleakr::Objects
         
         it "should have a value for :posted_at" do
           @photo.expects(:posted).with().returns("#{@time.to_i}")
-          @photo.posted_at.should == @time
+          @photo.posted_at.to_s.should == @time.to_s
         end
         
         it "should have a value for :taken_at" do
           @photo.expects(:taken).with().returns(@time.strftime('%Y-%m-%d %H:%M:%S'))
-          @photo.taken_at.should == @time
+          @photo.taken_at.to_s.should == @time.to_s
         end
         
         it "should have a value for :updated_at" do
           @photo.expects(:updated).with().returns("#{@time.to_i}")
-          @photo.updated_at.should == @time
+          @photo.updated_at.to_s.should == @time.to_s
         end
         
         it "should have a collection of images by size" do

data/test/unit/fleakr_test.rb

@@ -41,18 +41,63 @@ class FleakrTest < Test::Unit::TestCase
       Fleakr.search(:tags => %w(one two))
     end
    
+    # TODO: refactor uploading tests?
     it "should be able to upload a collection of images" do
       glob      = '*.jpg'
       filenames = %w(one.jpg two.jpg)
       
       Dir.expects(:[]).with(glob).returns(filenames)
       
-      Fleakr::Objects::Photo.expects(:upload).with('one.jpg')
-      Fleakr::Objects::Photo.expects(:upload).with('two.jpg')
+      Fleakr::Objects::Photo.expects(:upload).with('one.jpg', {})
+      Fleakr::Objects::Photo.expects(:upload).with('two.jpg', {})
       
       Fleakr.upload(glob)
     end
     
+    it "should return recently uploaded photos" do
+      filename  = '/path/to/image.jpg'
+      new_image = stub()
+      
+      Dir.expects(:[]).with(filename).returns([filename])
+      Fleakr::Objects::Photo.expects(:upload).with(filename, {}).returns(new_image)
+      
+      Fleakr.upload(filename).should == [new_image]
+    end
+    
+    it "should be able to pass options for the uploaded files" do
+      filename  = '/path/to/image.jpg'
+      new_image = stub()
+      
+      Dir.expects(:[]).with(filename).returns([filename])
+      Fleakr::Objects::Photo.expects(:upload).with(filename, :title => 'bop bip').returns(new_image)
+      
+      Fleakr.upload(filename, :title => 'bop bip').should == [new_image]
+    end
+    
+    it "should be able to reset the cached token" do
+      @token = stub()
+      Fleakr.expects(:auth_token).with().at_least_once.returns('abc123')
+      Fleakr::Objects::AuthenticationToken.expects(:from_auth_token).with('abc123').times(2).returns(@token)
+      Fleakr.token # once
+      Fleakr.reset_token
+      Fleakr.token # twice
+    end
+    
+    it "should not have a token by default" do
+      Fleakr.expects(:mini_token).with().returns(nil)
+      Fleakr.expects(:auth_token).with().returns(nil)
+      Fleakr.expects(:frob).with().returns(nil)
+      
+      Fleakr.token.should be(nil)
+    end
+    
+    [:mini_token, :auth_token, :frob].each do |attribute|
+      it "should reset_token when :#{attribute} is set" do
+        Fleakr.expects(:reset_token).with().at_least_once
+        Fleakr.send("#{attribute}=".to_sym, 'value')
+      end
+    end
+    
     context "when generating an AuthenticationToken from an auth_token string" do
 
       before do
@@ -63,7 +108,30 @@ class FleakrTest < Test::Unit::TestCase
       end
 
       # Make sure to clear the cache
-      after { Fleakr.instance_variable_set(:@token, nil) }
+      after { Fleakr.auth_token = nil }
+      
+      it "should return the token" do
+        Fleakr.token.should == @token
+      end
+      
+      it "should cache the result" do
+        2.times { Fleakr.token }
+      end
+
+    end
+    
+    context "when generating an AuthenticationToken from a frob string" do
+
+      before do
+        @token = stub()
+        
+        Fleakr.expects(:auth_token).with().at_least_once.returns(nil)
+        Fleakr.expects(:frob).with().at_least_once.returns('abc123')
+        Fleakr::Objects::AuthenticationToken.expects(:from_frob).with('abc123').returns(@token)
+      end
+
+      # Make sure to clear the cache
+      after { Fleakr.frob = nil }
       
       it "should return the token" do
         Fleakr.token.should == @token
@@ -86,7 +154,7 @@ class FleakrTest < Test::Unit::TestCase
       end
       
       # Make sure to clear the cache
-      after { Fleakr.instance_variable_set(:@token, nil) }
+      after { Fleakr.mini_token = nil }
       
       it "should return the token" do
         Fleakr.token.should == @token