reagent-fleakr 0.2.1 → 0.3.0

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

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+    class RequestTest < Test::Unit::TestCase
+
+      describe "A Request instance" do
+
+        context "with an API key" do
+
+          before do
+            @api_key = 'f00b4r'
+            Fleakr.stubs(:api_key).with().returns(@api_key)
+          end
+
+          it "should know the full query parameters" do
+            request = Request.new('flickr.people.findByUsername', :username => 'foobar')
+
+            expected = [
+              "api_key=#{@api_key}",
+              "method=flickr.people.findByUsername",
+              "username=foobar"
+            ]
+
+            request.query_parameters.split('&').sort.should == expected
+          end
+
+          it "should escape the keys and values in the parameter list" do
+            request = Request.new('flickr.people.findByUsername', :username => 'the decapitator')
+            request.query_parameters.split('&').include?("username=#{CGI.escape('the decapitator')}").should be(true)
+          end
+
+          it "should translate a shorthand API call" do
+            request = Request.new('people.findByUsername')
+            request.query_parameters.split('&').include?('method=flickr.people.findByUsername').should be(true)
+          end
+
+          it "should know the endpoint with full parameters" do
+            query_parameters = 'foo=bar'
+
+            request = Request.new('people.getInfo')
+            request.stubs(:query_parameters).with().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.endpoint_uri.should == uri_mock
+          end
+
+          it "should be able to make a request" do
+            endpoint_uri = stub()
+
+            request = Request.new('flickr.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()
+
+            request = Request.new('flickr.people.findByUsername')
+
+            Net::HTTP.stubs(:get).returns(response_xml)
+            Response.expects(:new).with(response_xml).returns(response_stub)
+
+            request.send.should == response_stub
+          end
+
+          it "should be able to make a full request and response cycle" do
+            response = stub(:error? => false)
+            Response.expects(:new).with(kind_of(String)).returns(response)
+
+            Request.with_response!('flickr.people.findByUsername', :username => 'foobar').should == response
+          end
+
+          it "should raise an exception when the full request / response cycle has errors" do
+            response = stub(:error? => true, :error => stub(:code => '1', :message => 'User not found'))
+            Response.stubs(:new).with(kind_of(String)).returns(response)
+
+            lambda do
+              Request.with_response!('flickr.people.findByUsername', :username => 'foobar')
+            end.should raise_error(Fleakr::Api::Request::ApiError)
+          end
+
+        end
+
+      end
+    end
+  end

data/test/{fleakr → unit/fleakr/api}/response_test.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../../test_helper'
 
-module Fleakr
+module Fleakr::Api
   class ResponseTest < Test::Unit::TestCase
 
     describe "An instance of Response" do

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

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class ContactTest < Test::Unit::TestCase
+
+    describe "The Contact class" do
+      
+      should "return a list of users for a specified user's contacts" do
+        user_1, user_2 = [stub(), stub()]
+        contact_1, contact_2 = [stub(:to_user => user_1), stub(:to_user => user_2)]
+        
+        response = mock_request_cycle :for => 'contacts.getPublicList', :with => {:user_id => '1'}
+        
+        contact_1_doc, contact_2_doc = (response.body/'rsp/contacts/contact').map
+        
+        Contact.stubs(:new).with(contact_1_doc).returns(contact_1)
+        Contact.stubs(:new).with(contact_2_doc).returns(contact_2)
+        
+        Contact.find_all_by_user_id('1').should == [user_1, user_2]
+      end
+      
+    end
+
+    describe "An instance of the Contact class" do
+      context "when populating from an XML document" do
+        before do
+          @object = Contact.new(Hpricot.XML(read_fixture('contacts.getPublicList')).at('contacts/contact'))
+        end
+
+        should_have_a_value_for :id          => '9302864@N42'
+        should_have_a_value_for :username    => 'blinky'
+        should_have_a_value_for :icon_server => '2263'
+        should_have_a_value_for :icon_farm   => '3'
+
+      end
+
+      context "in general" do
+        
+        should "be able to convert to a user" do
+          contact = Contact.new
+          user    = mock()
+          
+          User.stubs(:new).returns(user)
+          
+          [:id, :username, :icon_server, :icon_farm].each do |method|
+            contact.stubs(method).with().returns(method.to_s)
+            user.expects("#{method}=".to_sym).with(method.to_s)
+          end
+          
+          contact.to_user.should == user
+        end
+        
+      end
+
+    end
+    
+  end
+end

data/test/{fleakr → unit/fleakr/objects}/error_test.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../../test_helper'
 
-module Fleakr
+module Fleakr::Objects
   class ErrorTest < Test::Unit::TestCase
     
     describe "An instance of the Error class" do

data/test/{fleakr → unit/fleakr/objects}/group_test.rb

@@ -1,8 +1,12 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../../test_helper'
 
-module Fleakr
+module Fleakr::Objects
   class GroupTest < Test::Unit::TestCase
 
+    should_have_many :photos
+    
+    should_search_by :group_id
+
     describe "The Group class" do
       
       should_find_all :groups, :by => :user_id, :call => 'people.getPublicGroups', :path => 'rsp/groups/group'

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

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class ImageTest < Test::Unit::TestCase
+
+    describe "The Image class" do
+
+      should_find_all :images, :by => :photo_id, :call => 'photos.getSizes', :path => 'sizes/size'
+
+    end
+
+    describe "An instance of the Image class" do
+
+      context "when populating the object from an XML document" do
+
+        before do
+          @object = Image.new(Hpricot.XML(read_fixture('photos.getSizes')).at('sizes/size'))
+        end
+
+        should_have_a_value_for :size   => 'Square'
+        should_have_a_value_for :width  => '75'
+        should_have_a_value_for :height => '75'
+        should_have_a_value_for :url    => 'http://farm4.static.flickr.com/3093/2409912100_71e14ed08a_s.jpg'
+        should_have_a_value_for :page   => 'http://www.flickr.com/photos/the_decapitator/2409912100/sizes/sq/'
+
+      end
+
+      context "in general" do
+
+        it "should know its filename" do
+          image = Image.new
+          image.stubs(:url).with().returns('http://flickr.com/photos/foobar.jpg')
+
+          image.filename.should == 'foobar.jpg'
+        end
+
+        context "when saving the file" do
+
+          before do
+            @tmp_dir = create_temp_directory
+
+            @url = 'http://host.com/image.jpg'
+            @image_filename = 'image.jpg'
+
+            @image = Image.new
+            @image.stubs(:url).with().returns(@url)
+            @image.stubs(:filename).with().returns(@image_filename)
+          end
+
+          after do
+            FileUtils.rm_rf(@tmp_dir)
+          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'
+          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'
+          end
+
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class PhotoTest < Test::Unit::TestCase
+
+    should_have_many :images
+
+    describe "The Photo class" do
+
+      should_find_all :photos, :by => :user_id, :call => 'people.getPublicPhotos', :path => 'rsp/photos/photo'
+      should_find_all :photos, :by => :photoset_id, :call => 'photosets.getPhotos', :path => 'rsp/photoset/photo'
+      should_find_all :photos, :by => :group_id, :call => 'groups.pools.getPhotos', :path => 'rsp/photos/photo'
+
+    end
+
+    describe "An instance of the Photo class" do
+      context "when populating from an XML document" do
+        before do
+          @object = Photo.new(Hpricot.XML(read_fixture('people.getPublicPhotos')).at('rsp/photos/photo'))
+        end
+
+        should_have_a_value_for :id        => '2924549350'
+        should_have_a_value_for :title     => 'Photo #1'
+        should_have_a_value_for :farm_id   => '4'
+        should_have_a_value_for :server_id => '3250'
+        should_have_a_value_for :secret    => 'cbc1804258'
+
+      end
+      
+      context "in general" do
+        
+        it "should have a collection of images by size" do
+          photo = Photo.new
+          
+          small_image, large_image = [stub(:size => 'Small'), stub(:size => 'Large')]
+          
+          photo.stubs(:images).returns([small_image, large_image])
+          
+          expected = {
+            :square    => nil,
+            :thumbnail => nil,
+            :small     => small_image, 
+            :medium    => nil,
+            :large     => large_image,
+            :original  => nil
+          }
+          
+          photo.send(:images_by_size).should == expected
+        end
+        
+        [:square, :thumbnail, :small, :medium, :large, :original].each do |method|
+          it "should have a reader for the :#{method} image" do
+            photo = Photo.new
+            image = stub()
+            
+            photo.stubs(:images_by_size).returns(method => image)
+            photo.send(method).should == image
+          end
+        end
+        
+        
+      end
+    end
+
+    # context "in general" do
+    # 
+    #   before do
+    #     @photo = Photo.new
+    # 
+    #     @photo.stubs(:id).with().returns('1')
+    #     @photo.stubs(:farm_id).with().returns('2')
+    #     @photo.stubs(:server_id).with().returns('3')
+    #     @photo.stubs(:secret).with().returns('secret')
+    #   end
+    # 
+    #   it "should know the base URL to retrieve images" do
+    #     @photo.send(:base_url).should == "http://farm2.static.flickr.com/3/1_secret"
+    #   end
+    # 
+    # end
+
+    # context "with a base URL" do
+    # 
+    #   before do
+    #     @photo = Photo.new
+    #     @photo.stubs(:base_url).with().returns('url')
+    #   end
+    # 
+    #   [:square, :thumbnail, :small, :medium, :large].each do |size|
+    #     it "should have a :#{size} image" do
+    #       image = stub()
+    #       Image.expects(:new).with('url', size).returns(image)
+    #       
+    #       @photo.send(size).should == image
+    #     end
+    #   end
+    # 
+    # end
+  end
+
+end

data/test/{fleakr → unit/fleakr/objects}/search_test.rb

@@ -1,38 +1,43 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../../../test_helper'
 
-module Fleakr
+module Fleakr::Objects
   class SearchTest < Test::Unit::TestCase
     
     describe "An instance of the Search class" do
 
       it "should be able to generate a list of tags from a single-valued parameter" do
-        search = Search.new(nil, :tags => 'foo')
-        search.tag_list.should == 'foo'
+        search = Search.new(:tags => 'foo')
+        search.send(:tag_list).should == 'foo'
       end
       
       it "should be able to generate a list of tags from multi-valued parameters" do
-        search = Search.new(nil, :tags => %w(foo bar))
-        search.tag_list.should == 'foo,bar'
+        search = Search.new(:tags => %w(foo bar))
+        search.send(:tag_list).should == 'foo,bar'
       end
       
       it "should be able to create parameters for the search" do
-        search = Search.new(nil, :tags => %w(foo bar))
-        search.parameters.should == {:tags => 'foo,bar'}
+        search = Search.new(:tags => %w(foo bar))
+        search.send(:parameters).should == {:tags => 'foo,bar'}
+      end
+      
+      it "should preserve the original :tags parameter if it is a comma-separated string" do
+        search = Search.new(:tags => 'one,two')
+        search.send(:parameters).should == {:tags => 'one,two'}
       end
       
       it "should not have any :tags parameters if none are supplied" do
-        search = Search.new
-        search.parameters.should == {}
+        search = Search.new({})
+        search.send(:parameters).should == {}
       end
       
       it "should convert the search term into the appropriate parameter" do
-        search = Search.new('foo')
-        search.parameters.should == {:text => 'foo'}
+        search = Search.new(:text => 'foo')
+        search.send(:parameters).should == {:text => 'foo'}
       end
       
       it "should be able to search photos based on text" do
         response = mock_request_cycle :for => 'photos.search', :with => {:text => 'foo'}
-        search = Search.new('foo')
+        search = Search.new(:text => 'foo')
         search.results
       end
       
@@ -45,19 +50,19 @@ module Fleakr
         Photo.expects(:new).with(photo_1_doc).returns(photo_1)
         Photo.expects(:new).with(photo_2_doc).returns(photo_2)
       
-        search = Search.new(nil, :tags => %w(one two))
+        search = Search.new(:tags => %w(one two))
         search.results.should == [photo_1, photo_2]
       end
       
       should "memoize the search results" do
         response = stub(:body => Hpricot.XML(read_fixture('photos.search')))
-        Request.expects(:with_response!).with(kind_of(String), kind_of(Hash)).once.returns(response)
+        Fleakr::Api::Request.expects(:with_response!).with(kind_of(String), kind_of(Hash)).once.returns(response)
         
         (response.body/'rsp/photos/photo').each do |doc|
           Photo.expects(:new).with(doc).once
         end
         
-        search = Search.new(nil, :tags => %w(foo))
+        search = Search.new(:tags => %w(foo))
         
         2.times { search.results }
       end