reagent-fleakr 0.3.0 → 0.4.0

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

@@ -45,6 +45,9 @@ module Fleakr::Objects
             @image = Image.new
             @image.stubs(:url).with().returns(@url)
             @image.stubs(:filename).with().returns(@image_filename)
+            
+            @image_data = 'image_data'
+            Net::HTTP.expects(:get).with(URI.parse(@url)).returns(@image_data)
           end
 
           after do
@@ -52,20 +55,22 @@ module Fleakr::Objects
           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'
+            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'
+            File.read(existing_file).should == @image_data
+          end
+          
+          should "be able to save the file using a specified prefix" do
+            @image.save_to(@tmp_dir, '001_')
+            File.read("#{@tmp_dir}/001_image.jpg").should == @image_data
           end
 
         end

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

@@ -5,16 +5,52 @@ module Fleakr::Objects
 
     should_have_many :images
 
+    should_autoload_when_accessing :posted, :taken, :updated, :comment_count, :with => :load_info
+    should_autoload_when_accessing :url, :description, :with => :load_info
+
     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'
+      
+      should_find_one :photo, :by => :id, :with => :photo_id, :call => 'photos.getInfo'
+
+
+      it "should be able to upload a photo and return the new photo information" 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).returns(response)
+        Photo.expects(:find_by_id).with('123', :authenticate? => true).returns(photo)
+        
+        Photo.upload(filename).should == photo
+      end
 
     end
 
     describe "An instance of the Photo class" do
-      context "when populating from an XML document" do
+      
+      it "should be able to replace the associated photo data" do
+        filename = '/path/to/file.jpg'
+        response = stub(:body => 'body')
+        
+        params = {:type => :update, :photo_id => '1'}
+
+        Fleakr::Api::UploadRequest.expects(:with_response!).with(filename, params).returns(response)
+
+        photo = Photo.new
+        photo.stubs(:id).returns('1')
+        photo.expects(:populate_from).with('body')
+        
+        photo.replace_with(filename).should == photo
+      end
+      
+      context "when populating from the people_getPublicPhotos XML data" do
         before do
           @object = Photo.new(Hpricot.XML(read_fixture('people.getPublicPhotos')).at('rsp/photos/photo'))
         end
@@ -24,11 +60,69 @@ module Fleakr::Objects
         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 "when populating from the photo upload XML data" do
+        before do
+          @object = Photo.new(Hpricot.XML('<photoid>123</photoid>'))
+        end
+        
+        should_have_a_value_for :id => '123'
+      end
+      
+      context "when populating from the photos_getInfo XML data" do
+        before do
+          @object = Photo.new(Hpricot.XML(read_fixture('photos.getInfo')))
+          
+        end
+        
+        should_have_a_value_for :id            => '1'
+        should_have_a_value_for :title         => 'Tree'
+        should_have_a_value_for :description   => 'A Tree'
+        should_have_a_value_for :farm_id       => '4'
+        should_have_a_value_for :server_id     => '3085'
+        should_have_a_value_for :secret        => 'secret'
+        should_have_a_value_for :posted        => '1230274722'
+        should_have_a_value_for :taken         => '2008-12-25 18:26:55'
+        should_have_a_value_for :updated       => '1230276652'
+        should_have_a_value_for :comment_count => '0'
+        should_have_a_value_for :url           => 'http://www.flickr.com/photos/yes/1'
+        
       end
       
       context "in general" do
         
+        before do
+          @photo = Photo.new
+          @time = Time.parse('2009-08-01 00:00:00')
+        end
+        
+        it "should be able to retrieve additional information about the current user" do
+          photo_id = '1'
+          photo = Photo.new
+          photo.expects(:id).with().returns(photo_id)
+          response = mock_request_cycle :for => 'photos.getInfo', :with => {:photo_id => photo_id}
+          
+          photo.expects(:populate_from).with(response.body)
+
+          photo.load_info
+        end
+        
+        it "should have a value for :posted_at" do
+          @photo.expects(:posted).with().returns("#{@time.to_i}")
+          @photo.posted_at.should == @time
+        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
+        end
+        
+        it "should have a value for :updated_at" do
+          @photo.expects(:updated).with().returns("#{@time.to_i}")
+          @photo.updated_at.should == @time
+        end
+        
         it "should have a collection of images by size" do
           photo = Photo.new
           
@@ -62,40 +156,6 @@ module Fleakr::Objects
       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

@@ -56,7 +56,7 @@ module Fleakr::Objects
       
       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)
+        Fleakr::Api::MethodRequest.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

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

@@ -21,6 +21,7 @@ module Fleakr::Objects
         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.'
+        should_have_a_value_for :count       => '138'
         
       end
       
@@ -34,14 +35,24 @@ module Fleakr::Objects
         end
         
         after { FileUtils.rm_rf(@tmp_dir) }
+
+        it "should know the prefix string based on the number of photos in the set" do
+          set = Set.new
+          set.stubs(:count).with().returns('5')
+          set.file_prefix(0).should == '1_'
+          
+          set.stubs(:count).with().returns('99')
+          set.file_prefix(0).should == '01_'
+        end
         
         it "should save all files of the specified size to the specified directory" do
           image = mock()
-          image.expects(:save_to).with("#{@tmp_dir}/set")
+          image.expects(:save_to).with("#{@tmp_dir}/set", '1_')
           
           photo = stub(:small => image)
 
           @set.stubs(:photos).with().returns([photo])
+          @set.stubs(:file_prefix).with(0).returns('1_')
           
           FileUtils.expects(:mkdir).with("#{@tmp_dir}/set")
           

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

@@ -3,22 +3,11 @@ 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 :name, :photos_url, :profile_url, :photos_count, :location, :with => :load_info
     should_autoload_when_accessing :icon_server, :icon_farm, :pro, :admin, :icon_url, :with => :load_info
 
     describe "The User class" do
@@ -38,6 +27,7 @@ module Fleakr::Objects
         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 :location     => 'The Moon'
         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'
@@ -93,10 +83,6 @@ module Fleakr::Objects
           @user.admin?.should be(true)
         end
         
-        
-        
-
-        
       end
     end
 

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

@@ -9,60 +9,118 @@ module Fleakr::Support
         attr.name.should == :foo
       end
 
-      it "should infer the xpath information from the attribute name" do
-        attr = Attribute.new('foo')
-        attr.xpath.should == 'foo'
+      it "should have a default source" do
+        attr = Attribute.new(:foo)
+        attr.sources.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'
+      it "should be able to assign multiple sources" do
+        attr = Attribute.new(:foo, ['foo1', 'foo2'])
+        attr.sources.should == ['foo1', 'foo2']
+      end
+
+      it "should pull the location from the source" do
+        attr = Attribute.new('foo')
+        attr.location('foo').should == 'foo'
       end
       
-      it "should allow the setting of the xpath information" do
-        attr = Attribute.new('foo', :xpath => 'bar')
-        attr.xpath.should == 'bar'
+      it "should return the location when splitting" do
+        attr = Attribute.new('foo')
+        attr.split('foo').should == ['foo', nil]
       end
       
-      it "should have a default attribute value of nil" do
+      it "should return the name for the location when splitting if the location isn't specified" do
         attr = Attribute.new('foo')
-        attr.attribute.should be(nil)
+        attr.split('@bar').should == ['foo', 'bar']
+      end
+      
+      it "should allow the setting of the location information" do
+        attr = Attribute.new('foo', 'bar')
+        attr.sources.should == ['bar']
       end
       
       it "should allow the setting of the attribute value" do
-        attr = Attribute.new('foo', :attribute => 'bogon')
-        attr.attribute.should == 'bogon'
+        attr = Attribute.new('foo')
+        attr.attribute('@bogon').should == 'bogon'
+      end
+      
+      it "should use the location as the attribute" do
+        attr = Attribute.new('foo')
+        attr.attribute('foo').should == 'foo'
       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)
+      it "should use the attribute for the attribute if specified" do
+        attr = Attribute.new(:id, '@nsid')
+        attr.attribute('@nsid').should == 'nsid'
+      end
+
+      it "should be able to retrieve the node from the path" do
+        document = Hpricot.XML('<name>Bassdrive</name>')
+        expected = document.at('name')
+        
+        attr = Attribute.new(:name)
+        attr.node_for(document, 'name').should == expected
+      end
+      
+      it "should be able to retrieve the node that contains the specified attribute" do
+        document = Hpricot.XML('<user id="1337" />')
+        expected = document.at('user')
+        
+        attr = Attribute.new(:id)
+        attr.node_for(document, '@id').should == expected
+      end
+
+      it "should be able to retrieve the node for the specified attribute" do
+        document = Hpricot.XML('<user nsid="1337" />')
+        expected = document.at('user')
+        
+        attr = Attribute.new(:id, '@nsid')
+        attr.node_for(document, '@nsid').should == expected
       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 = 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')
+        document = Hpricot.XML('<user id="1337" />')
+        attr = Attribute.new(:id)
         attr.value_from(document).should == '1337'
       end
-      
+        
+      it "should be able to pull a specific attribute value from the current XML node" do
+        document = Hpricot.XML('<user nsid="1337" />')
+        attr = Attribute.new(:id, '@nsid')
+        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 = Attribute.new(:slug, 'station/genre@slug')
         attr.value_from(document).should == 'dnb'
       end
-      
+        
+      it "should be able to pull a value from a nested XML node" do
+        document = Hpricot.XML('<rsp><user>blip</user></rsp>')
+        attr = Attribute.new(:user)
+        attr.value_from(document).should == 'blip'
+      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 = Attribute.new(:photoset, '@nsid')
         attr.value_from(document).should be(nil)
       end
 
+      it "should be able to try a series of nodes to find a value" do
+        document = Hpricot.XML('<photoid>123</photoid>')
+
+        attr = Attribute.new(:id, ['photo@nsid', 'photoid'])
+        attr.value_from(document).should == '123'
+      end
+
     end
   end
 end

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

@@ -9,9 +9,11 @@ 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'
+  flickr_attribute :description, :from => 'desc'
+  flickr_attribute :id, :from => '@nsid'
+  flickr_attribute :photoset_id, :from => 'photoset@id'
+  
+  find_one :by_id, :call => 'people.getInfo'
   
 end
 
@@ -28,6 +30,27 @@ module Fleakr
         FlickrObject.attributes.map {|a| a.name.to_s }.should == %w(name description id photoset_id)
       end
       
+      it "should be able to find by ID" do
+        id = 1
+        flickr_object = stub()
+        
+        response = mock_request_cycle :for => 'people.getInfo', :with => {:id => id}
+        FlickrObject.expects(:new).with(response.body).returns(flickr_object)
+        
+        FlickrObject.find_by_id(id).should == flickr_object
+      end
+      
+      it "should be able to pass parameters to the :find_by_id method" do
+        id = 1
+        params = {:authenticate? => true}
+        flickr_object = stub()
+        
+        response = mock_request_cycle :for => 'people.getInfo', :with => {:id => id, :authenticate? => true}
+        FlickrObject.expects(:new).with(response.body).returns(flickr_object)
+        
+        FlickrObject.find_by_id(id, params).should == flickr_object
+      end
+      
     end
     
     describe "An instance method provided by the Flickr::Object module" do