fleakr 0.6.3 → 0.7.0

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

@@ -1,56 +1,58 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 module Fleakr::Objects
   class PhotoTest < Test::Unit::TestCase
 
-    should_have_many :images, :tags, :comments
+    should_have_many :images, :class => Image
+    should_have_many :tags, :class => Tag
+    should_have_many :comments, :class => Comment
 
     should_autoload_when_accessing :posted, :taken, :updated, :comment_count, :with => :load_info
     should_autoload_when_accessing :url, :description, :with => :load_info
 
     context "The Photo class" do
 
-      should_find_all :photos, :by => :user_id, :call => 'people.getPublicPhotos', :path => 'rsp/photos/photo'
-      should_find_all :photos, :by => :set_id, :using => :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'
+      should_find_all :photos, :by => :user_id, :call => 'people.getPublicPhotos', :path => 'rsp/photos/photo', :class => Photo
+      should_find_all :photos, :by => :set_id, :using => :photoset_id, :call => 'photosets.getPhotos', :path => 'rsp/photoset/photo', :class => Photo
+      should_find_all :photos, :by => :group_id, :call => 'groups.pools.getPhotos', :path => 'rsp/photos/photo', :class => Photo
+
+      should_find_one :photo, :by => :id, :with => :photo_id, :call => 'photos.getInfo', :class => Photo
 
       # TODO: refactor these 2 tests
       should "be able to upload a photo and return the new photo information" do
         filename = '/path/to/mugshot.jpg'
         photo = stub()
-        
+
         response = stub()
         response.stubs(:body).with().returns(Hpricot.XML('<photoid>123</photoid>'))
-        
+
         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
-      
+
       should "be able to pass additional options when uploading a new file" do
         filename = '/path/to/mugshot.jpg'
         photo = stub()
-        
+
         response = stub()
         response.stubs(:body).with().returns(Hpricot.XML('<photoid>123</photoid>'))
-        
+
         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
 
     context "An instance of the Photo class" do
-      
+
       should "be able to replace the associated photo data" do
         filename = '/path/to/file.jpg'
         response = stub(:body => 'body')
-        
+
         params = {:photo_id => '1'}
 
         Fleakr::Api::UploadRequest.expects(:with_response!).with(filename, :update, params).returns(response)
@@ -58,10 +60,10 @@ module Fleakr::Objects
         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
         setup do
           @object = Photo.new(Hpricot.XML(read_fixture('people.getPublicPhotos')).at('rsp/photos/photo'))
@@ -73,23 +75,23 @@ module Fleakr::Objects
         should_have_a_value_for :server_id => '3250'
         should_have_a_value_for :secret    => 'cbc1804258'
         should_have_a_value_for :owner_id  => '21775151@N06'
-        
+
       end
-      
+
       context "when populating from the photo upload XML data" do
         setup 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
         setup 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'
@@ -103,111 +105,116 @@ module Fleakr::Objects
         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
-        
+
         setup do
           @photo = Photo.new
-          @time = Time.parse('2009-08-01 00:00:00')
+          @time  = Time.parse('2009-08-01 00:00:00')
         end
-        
+
         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
-        
+
         should "have a value for :posted_at" do
           @photo.expects(:posted).with().returns("#{@time.to_i}")
           @photo.posted_at.to_s.should == @time.to_s
         end
-        
+
         should "have a value for :taken_at" do
           @photo.expects(:taken).with().returns(@time.strftime('%Y-%m-%d %H:%M:%S'))
           @photo.taken_at.to_s.should == @time.to_s
         end
-        
+
         should "have a value for :updated_at" do
           @photo.expects(:updated).with().returns("#{@time.to_i}")
           @photo.updated_at.to_s.should == @time.to_s
         end
-        
+
+        should "be able to retrieve the metadata" do
+          MetadataCollection.expects(:new).with(@photo).returns('metadata')
+          @photo.metadata.should == 'metadata'
+        end
+
         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, 
+            :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|
           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
-        
+
         should "be able to retrieve the context for this photo" do
           id = '1'
-          
+
           context = stub()
-          
+
           photo = Photo.new
           photo.stubs(:id).with().returns(id)
-          
+
           response = mock_request_cycle :for => 'photos.getContext', :with => {:photo_id => id}
           PhotoContext.expects(:new).with(response.body).returns(context)
-          
+
           photo.context.should == context
         end
-        
+
         should "memoize the context data" do
           id = '1'
-          
+
           context = stub()
-          
+
           photo = Photo.new
           photo.stubs(:id).with().returns(id)
-          
+
           response = mock_request_cycle :for => 'photos.getContext', :with => {:photo_id => id}
           PhotoContext.expects(:new).once.returns(context)
-          
+
           2.times { photo.context }
         end
-        
+
         should "be able to retrieve the next photo" do
           next_photo = stub()
           context = mock()
           context.expects(:next).with().returns(next_photo)
-          
+
           photo = Photo.new
-          
+
           photo.expects(:context).with().returns(context)
-          
+
           photo.next.should == next_photo
         end
-        
+
         should "be able to retrieve the previous photo" do
           previous_photo = stub()
           context = mock()
@@ -218,27 +225,27 @@ module Fleakr::Objects
 
           photo.previous.should == previous_photo
         end
-        
+
         should "be able to find the owner of the photo" do
           owner = stub()
-          
+
           photo = Photo.new
           photo.stubs(:owner_id).with().returns('1')
-          
+
           User.expects(:find_by_id).with('1').returns(owner)
-          
+
           photo.owner.should == owner
         end
-        
+
         should "memoize the owner information" do
           photo = Photo.new
           photo.stubs(:owner_id).with().returns('1')
-          
+
           User.expects(:find_by_id).with('1').once.returns(stub())
-          
+
           2.times { photo.owner }
         end
-        
+
       end
     end
 

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

@@ -1,15 +1,15 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 module Fleakr::Objects
   class SearchTest < Test::Unit::TestCase
-    
+
     context "An instance of the Search class" do
 
       should "have a list of tags" do
         search = Search.new(:tags => %w(a b c))
         search.tags.should == %w(a b c)
       end
-      
+
       should "have convert tags into an array" do
         search = Search.new(:tags => 'a')
         search.tags.should == ['a']
@@ -19,76 +19,76 @@ module Fleakr::Objects
         search = Search.new(:tags => 'foo')
         search.send(:tag_list).should == 'foo'
       end
-      
+
       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
-      
+
       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
-      
+
       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
-      
+
       should "not have any :tags parameters if none are supplied" do
         search = Search.new({})
         search.send(:parameters).should == {}
       end
-      
+
       should "convert the search term into the appropriate parameter" do
         search = Search.new(:text => 'foo')
         search.send(:parameters).should == {:text => 'foo'}
       end
-      
+
       should "convert a single string parameter into a text search" do
         search = Search.new('term')
         search.send(:parameters).should == {:text => 'term'}
       end
-      
+
       should "be able to handle a combination of text and options" do
         search = Search.new('term', :tags => %w(a b))
         search.send(:parameters).should == {:text => 'term', :tags => 'a,b'}
       end
-      
+
       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
-      
+
       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::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
         end
-        
+
         search = Search.new(:tags => %w(foo))
-        
+
         2.times { search.results }
       end
-      
-      
+
+
     end
-    
+
   end
 end

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

@@ -1,133 +1,155 @@
-require File.dirname(__FILE__) + '/../../../test_helper'
+require File.expand_path('../../../../test_helper', __FILE__)
 
 module Fleakr::Objects
   class SetTest < Test::Unit::TestCase
 
-    should_have_many :photos, :comments
-    
+    should_have_many :photos, :class => Photo
+    should_have_many :comments, :class => Comment
+
     should_autoload_when_accessing :user_id, :with => :load_info
 
     context "The Set class" do
-      
-      should_find_all :sets, :by => :user_id, :call => 'photosets.getList', :path => 'rsp/photosets/photoset'
-      should_find_one :set, :by => :id, :with => :photoset_id, :call => 'photosets.getInfo', :path => 'rsp/photoset'
-      
+
+      should_find_all :sets, :by => :user_id, :call => 'photosets.getList', :path => 'rsp/photosets/photoset', :class => Set
+      should_find_one :set, :by => :id, :with => :photoset_id, :call => 'photosets.getInfo', :path => 'rsp/photoset', :class => Set
+
     end
 
     context "An instance of the Set class" do
-      
+
       context "when populating from photosets.getList" do
         setup 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.'
         should_have_a_value_for :count            => '138'
         should_have_a_value_for :primary_photo_id => '3044180117'
-        
+
       end
-      
+
       context "when populating from photosets.getInfo" do
         setup do
           @object = Set.new
           @object.populate_from(Hpricot.XML(read_fixture('photosets.getInfo')))
         end
-        
+
         should_have_a_value_for :user_id => '43955217@N05'
       end
-      
+
       should "know the URL for the photoset" do
         s = Set.new
         s.stubs(:user_id).with().returns('123')
         s.stubs(:id).with().returns('456')
-        
+
         s.url.should == "http://www.flickr.com/photos/123/sets/456/"
       end
-      
+
       should "be able to retrieve the user for the set" do
         s = Set.new
         s.stubs(:user_id).with().returns('1')
-        
+
         User.expects(:find_by_id).with('1').returns('user')
-        
+
         s.user.should == 'user'
       end
-      
+
       should "know the primary photo in the set" do
         id    = '1'
         photo = stub()
-        
+
         Photo.expects(:find_by_id).with(id).returns(photo)
-        
+
         set = Set.new
         set.stubs(:primary_photo_id).with().returns(id)
-        
+
         set.primary_photo.should == photo
       end
-      
+
       should "memoize the primary photo" do
         id    = '1'
         photo = stub()
-        
+
         Photo.expects(:find_by_id).with(id).once.returns(photo)
-        
+
         set = Set.new
         set.stubs(:primary_photo_id).with().returns(id)
-        
+
         2.times { set.primary_photo }
       end
-      
+
+      should "know the folder name" do
+        set = Set.new
+        set.stubs(:title).with().returns('Title')
+
+        set.folder_name.should == 'Title'
+      end
+
+      should "remove forward slashes from the folder name" do
+        set = Set.new
+        set.stubs(:title).with().returns("This/That")
+
+        set.folder_name.should == 'This That'
+      end
+
+      should "collapse spaces when generating the folder name" do
+        set = Set.new
+        set.stubs(:title).with().returns('This / That')
+
+        set.folder_name.should == 'This That'
+      end
+
       context "when saving the set" do
         setup do
           @tmp_dir = create_temp_directory
-          @set_title = 'set'
-          
+          @set_folder_name = 'set'
+
           @set = Set.new
-          @set.stubs(:title).with().returns(@set_title)
+          @set.stubs(:folder_name).with().returns(@set_folder_name)
         end
-        
+
         teardown { FileUtils.rm_rf(@tmp_dir) }
 
         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
-        
+
         should "save all files of the specified size to the specified directory" do
           image = mock()
           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")
-          
+
           @set.save_to(@tmp_dir, :small)
         end
-        
+
         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
-        
+
         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