fleakr 0.3.0

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/unit/fleakr/objects/search_test.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+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(: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(: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(: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.send(:parameters).should == {}
+      end
+      
+      it "should convert the search term into the appropriate parameter" do
+        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(:text => 'foo')
+        search.results
+      end
+      
+      it "should be able to search photos based on tags" do
+        response = mock_request_cycle :for => 'photos.search', :with => {:tags => 'one,two'}
+        
+        photo_1, photo_2 = [stub(), stub()]
+        photo_1_doc, photo_2_doc = (response.body/'rsp/photos/photo').map {|doc| doc }
+      
+        Photo.expects(:new).with(photo_1_doc).returns(photo_1)
+        Photo.expects(:new).with(photo_2_doc).returns(photo_2)
+      
+        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')))
+        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(:tags => %w(foo))
+        
+        2.times { search.results }
+      end
+      
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class SetTest < Test::Unit::TestCase
+
+    should_have_many :photos, :using => 'photoset_id'
+
+    describe "The Set class" do
+      
+      should_find_all :sets, :by => :user_id, :call => 'photosets.getList', :path => 'rsp/photosets/photoset'
+      
+    end
+
+    describe "An instance of the Set class" do
+      
+      context "when populating from an XML document" do
+        before do
+          @object = Set.new(Hpricot.XML(read_fixture('photosets.getList')).at('rsp/photosets/photoset'))
+        end
+        
+        should_have_a_value_for :id          => '72157609490909659'
+        should_have_a_value_for :title       => 'Second Set'
+        should_have_a_value_for :description => 'This is the second set.'
+        
+      end
+      
+      context "when saving the set" do
+        before do
+          @tmp_dir = create_temp_directory
+          @set_title = 'set'
+          
+          @set = Set.new
+          @set.stubs(:title).with().returns(@set_title)
+        end
+        
+        after { FileUtils.rm_rf(@tmp_dir) }
+        
+        it "should save all files of the specified size to the specified directory" do
+          image = mock()
+          image.expects(:save_to).with("#{@tmp_dir}/set")
+          
+          photo = stub(:small => image)
+
+          @set.stubs(:photos).with().returns([photo])
+          
+          FileUtils.expects(:mkdir).with("#{@tmp_dir}/set")
+          
+          @set.save_to(@tmp_dir, :small)
+        end
+        
+        it "should not create the directory if it already exists" do
+          FileUtils.mkdir("#{@tmp_dir}/set")
+
+          @set.stubs(:photos).with().returns([])
+          
+          FileUtils.expects(:mkdir).with("#{@tmp_dir}/set").never
+          
+          @set.save_to(@tmp_dir, :small)
+        end
+        
+        it "should not raise errors when saving an image size that doesn't exist" do
+          @set.stubs(:photos).with().returns([stub(:large => nil)])
+          lambda { @set.save_to(@tmp_dir, :large) }.should_not raise_error
+        end
+        
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class UserTest < Test::Unit::TestCase
+
+    def self.should_autoload_when_accessing(*attributes)
+      options = attributes.extract_options!
+      attributes.each do |accessor_name|
+        it "should load the additional user information when accessing the :#{accessor_name} attribute" do
+          user = User.new
+          user.expects(options[:with]).with()
+          user.send(accessor_name)
+        end
+      end
+    end
+    
+    should_search_by :user_id
+
+    should_have_many :photos, :groups, :sets, :contacts
+    
+    should_autoload_when_accessing :name, :photos_url, :profile_url, :photos_count, :with => :load_info
+    should_autoload_when_accessing :icon_server, :icon_farm, :pro, :admin, :icon_url, :with => :load_info
+
+    describe "The User class" do
+
+      should_find_one :user, :by => :username, :call => 'people.findByUsername', :path => 'rsp/user'
+      should_find_one :user, :by => :email, :with => :find_email, :call => 'people.findByEmail', :path => 'rsp/user'
+
+    end
+
+    describe "An instance of User" do
+      context "when populating the object from an XML document" do
+        before do
+          @object = User.new(Hpricot.XML(read_fixture('people.findByUsername')))
+          @object.populate_from(Hpricot.XML(read_fixture('people.getInfo')))
+        end
+
+        should_have_a_value_for :id           => '31066442@N69'
+        should_have_a_value_for :username     => 'frootpantz'
+        should_have_a_value_for :name         => 'Sir Froot Pantz'
+        should_have_a_value_for :photos_url   => 'http://www.flickr.com/photos/frootpantz/'
+        should_have_a_value_for :profile_url  => 'http://www.flickr.com/people/frootpantz/'
+        should_have_a_value_for :photos_count => '3907'
+        should_have_a_value_for :icon_server  => '30'
+        should_have_a_value_for :icon_farm    => '1'
+        should_have_a_value_for :pro          => '1'
+        should_have_a_value_for :admin        => '0'
+        
+      end
+
+      context "in general" do
+
+        before { @user = User.new }
+
+        it "should be able to retrieve additional information about the current user" do
+          response = mock_request_cycle :for => 'people.getInfo', :with => {:user_id => @user.id}
+          @user.expects(:populate_from).with(response.body)
+
+          @user.load_info
+        end
+
+        it "should be able to generate an icon URL when the :icon_server value is greater than zero" do
+          @user.stubs(:icon_server).with().returns('1')
+          @user.stubs(:icon_farm).with().returns('2')
+          @user.stubs(:id).with().returns('45')
+
+          @user.icon_url.should == 'http://farm2.static.flickr.com/1/buddyicons/45.jpg'
+        end
+
+        it "should return the default icon URL when the :icon_server value is zero" do
+          @user.stubs(:icon_server).with().returns('0')
+          @user.icon_url.should == 'http://www.flickr.com/images/buddyicon.jpg'
+        end
+
+        it "should return the default icon URL when the :icon_server value is nil" do
+          @user.stubs(:icon_server).with().returns(nil)
+          @user.icon_url.should == 'http://www.flickr.com/images/buddyicon.jpg'
+        end
+        
+        it "should return a boolean value for :pro?" do
+          @user.stubs(:pro).with().returns('0')
+          @user.pro?.should be(false)
+          
+          @user.stubs(:pro).with().returns('1')
+          @user.pro?.should be(true)
+        end
+        
+        it "should return a boolean value for :admin?" do
+          @user.stubs(:admin).with().returns('0')
+          @user.admin?.should be(false)
+          
+          @user.stubs(:admin).with().returns('1')
+          @user.admin?.should be(true)
+        end
+        
+        
+        
+
+        
+      end
+    end
+
+  end
+end

data/test/unit/fleakr/support/attribute_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Support
+  class AttributeTest < Test::Unit::TestCase
+    describe "An instance of the Attribute class" do
+
+      it "should know the name of the attribute" do
+        attr = Attribute.new('foo')
+        attr.name.should == :foo
+      end
+
+      it "should infer the xpath information from the attribute name" do
+        attr = Attribute.new('foo')
+        attr.xpath.should == 'foo'
+      end
+      
+      it "should use a string value for the xpath from the inferred attribute name" do
+        attr = Attribute.new(:foo)
+        attr.xpath.should == 'foo'
+      end
+      
+      it "should allow the setting of the xpath information" do
+        attr = Attribute.new('foo', :xpath => 'bar')
+        attr.xpath.should == 'bar'
+      end
+      
+      it "should have a default attribute value of nil" do
+        attr = Attribute.new('foo')
+        attr.attribute.should be(nil)
+      end
+      
+      it "should allow the setting of the attribute value" do
+        attr = Attribute.new('foo', :attribute => 'bogon')
+        attr.attribute.should == 'bogon'
+      end
+      
+      it "should not infer the xpath value when the attribute is set" do
+        attr = Attribute.new(:foo, :attribute => 'bogon')
+        attr.xpath.should be(nil)
+      end
+      
+      it "should be able to pull simple values from an XML document" do
+        document = Hpricot.XML('<name>Bassdrive</name>')
+        attr = Attribute.new('name')
+        attr.value_from(document).should == 'Bassdrive'
+      end
+      
+      it "should be able to pull an attribute value from the current XML node" do
+        document = Hpricot.XML('<user id="1337" />').at('user')
+        attr = Attribute.new(:id, :attribute => 'id')
+        attr.value_from(document).should == '1337'
+      end
+      
+      it "should be able to pull an attribute value for a node and attribute" do
+        document = Hpricot.XML('<station><genre slug="dnb">Drum & Bass</genre></station>')
+        attr = Attribute.new(:slug, :xpath => 'station/genre', :attribute => 'slug')
+        attr.value_from(document).should == 'dnb'
+      end
+      
+      it "should return nil if it cannot find the specified node" do
+        document = Hpricot.XML('<user id="1" />')
+        attr = Attribute.new(:photoset, :attribute => 'id')
+        attr.value_from(document).should be(nil)
+      end
+
+    end
+  end
+end

data/test/unit/fleakr/support/object_test.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+class EmptyObject
+  include Fleakr::Support::Object
+end
+
+class FlickrObject
+  
+  include Fleakr::Support::Object
+  
+  flickr_attribute :name
+  flickr_attribute :description, :xpath => 'desc'
+  flickr_attribute :id, :attribute => 'nsid'
+  flickr_attribute :photoset_id, :xpath => 'photoset', :attribute => 'id'
+  
+end
+
+module Fleakr
+  class ObjectTest < Test::Unit::TestCase
+    
+    describe "A class method provided by the Flickr::Object module" do
+   
+      it "should have an empty list of attributes if none are supplied" do
+        EmptyObject.attributes.should == []
+      end
+      
+      it "should know the names of all its attributes" do
+        FlickrObject.attributes.map {|a| a.name.to_s }.should == %w(name description id photoset_id)
+      end
+      
+    end
+    
+    describe "An instance method provided by the Flickr::Object module" do
+      
+      it "should have default reader methods" do
+        [:name, :description, :id, :photoset_id].each do |method_name|
+          FlickrObject.new.respond_to?(method_name).should == true
+        end
+      end
+      
+      context "when populating data from an XML document" do
+        before do
+          xml = <<-XML
+            <name>Fleakr</name>
+            <desc>Awesome</desc>
+            <photoset id="1" />
+          XML
+
+          @object = FlickrObject.new
+          @object.populate_from(Hpricot.XML(xml))
+        end
+        
+        it "should have the correct value for :name" do
+          @object.name.should == 'Fleakr'
+        end
+        
+        it "should have the correct value for :description" do
+          @object.description.should == 'Awesome'
+        end
+        
+        it "should have the correct value for :photoset_id" do
+          @object.photoset_id.should == '1'
+        end
+        
+        it "should have the correct value for :id" do
+          document = Hpricot.XML('<object nsid="1" />').at('object')
+          @object.populate_from(document)
+          
+          @object.id.should == '1'
+        end
+      end
+      
+      it "should populate its data from an XML document when initializing" do
+        document = stub()
+        FlickrObject.any_instance.expects(:populate_from).with(document)
+        
+        FlickrObject.new(document)
+      end
+      
+      it "should not attempt to populate itself from an XML document if one is not available" do
+        FlickrObject.any_instance.expects(:populate_from).never
+        FlickrObject.new
+      end
+      
+      it "should not overwrite existing attributes when pulling in a partial new XML document" do
+        object = FlickrObject.new(Hpricot.XML('<name>Fleakr</name>'))
+        object.populate_from(Hpricot.XML('<desc>Awesome</desc>'))
+        
+        object.name.should == 'Fleakr'
+      end
+      
+    end
+    
+  end
+end

data/test/unit/fleakr_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class FleakrTest < Test::Unit::TestCase
+  
+  describe "The Fleakr module" do
+    
+    it "should be able to set an API key" do
+      key = 'f00b4r'
+      Fleakr.api_key = key
+      
+      Fleakr.api_key.should == key
+    end
+    
+    it "should provide a means to find a user by his username" do
+      user = stub()
+      Fleakr::Objects::User.expects(:find_by_username).with('username').returns(user)
+      Fleakr.user('username').should == user
+    end
+    
+    it "should fall back to finding a user by email if finding by username fails" do
+      user = stub()
+      email = 'user@host.com'
+      
+      Fleakr::Objects::User.stubs(:find_by_username).with(email).raises(Fleakr::Api::Request::ApiError)
+      Fleakr::Objects::User.expects(:find_by_email).with(email).returns(user)
+      
+      Fleakr.user(email).should == user
+    end
+    
+    it "should be able to perform text searches" do
+      photos = [stub()]
+      
+      Fleakr::Objects::Search.expects(:new).with(:text => 'foo').returns(stub(:results => photos))
+      Fleakr.search('foo').should == photos
+    end
+    
+    it "should be able to perform searches based on tags" do
+      Fleakr::Objects::Search.expects(:new).with(:tags => %w(one two)).returns(stub(:results => []))
+      Fleakr.search(:tags => %w(one two))
+    end
+    
+  end
+  
+end