mwilliams-fleakr 0.5.1

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

@@ -0,0 +1,246 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class PhotoTest < Test::Unit::TestCase
+
+    should_have_many :images, :tags, :comments
+
+    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'
+
+      # 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)
+
+        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'))
+        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'
+        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'
+        should_have_a_value_for :farm_id       => '4'
+        should_have_a_value_for :server_id     => '3085'
+        should_have_a_value_for :owner_id      => '31066442@N69'
+        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
+        
+        setup do
+          @photo = Photo.new
+          @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 "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|
+          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()
+          context.expects(:previous).with().returns(previous_photo)
+
+          photo = Photo.new
+          photo.expects(:context).with().returns(context)
+
+          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
+
+  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
+    
+    context "An instance of the Search class" do
+
+      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
+      
+      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 "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

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class SetTest < Test::Unit::TestCase
+
+    should_have_many :photos, :comments
+
+    context "The Set class" do
+      
+      should_find_all :sets, :by => :user_id, :call => 'photosets.getList', :path => 'rsp/photosets/photoset'
+      
+    end
+
+    context "An instance of the Set class" do
+      
+      context "when populating from an XML document" 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'
+        
+      end
+      
+      context "when saving the set" do
+        setup do
+          @tmp_dir = create_temp_directory
+          @set_title = 'set'
+          
+          @set = Set.new
+          @set.stubs(:title).with().returns(@set_title)
+        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
+
+  end
+end

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

@@ -0,0 +1,98 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class TagTest < Test::Unit::TestCase
+
+    context "The Tag class" do
+      
+      should_find_all :tags, :by => :photo_id, :call => 'tags.getListPhoto', :path => 'rsp/photo/tags/tag'
+      should_find_all :tags, :by => :user_id, :call => 'tags.getListUser', :path => 'rsp/who/tags/tag'      
+    end
+    
+    context "An instance of the Tag class" do
+      
+      setup { @tag = Tag.new }
+      
+      context "when populating from the tags_getListPhoto XML data" do
+        setup do
+          @object = Tag.new(Hpricot.XML(read_fixture('tags.getListPhoto')).at('rsp/photo/tags/tag'))
+        end
+        
+        should_have_a_value_for :id           => '1'
+        should_have_a_value_for :author_id    => '15498419@N05'
+        should_have_a_value_for :value        => 'stu72'
+        should_have_a_value_for :raw          => 'stu 72'
+        should_have_a_value_for :machine_flag => '0'
+        
+      end
+      
+      should "have an author" do
+        user = stub()
+        
+        @tag.expects(:author_id).at_least_once.with().returns('1')
+        
+        
+        User.expects(:find_by_id).with('1').returns(user)
+        
+        @tag.author.should == user
+      end
+      
+      should "memoize the author data" do
+        @tag.expects(:author_id).at_least_once.with().returns('1')
+        
+        User.expects(:find_by_id).with('1').once.returns(stub())
+        
+        2.times { @tag.author }
+      end
+      
+      should "return nil for author if author_id is not present" do
+        @tag.expects(:author_id).with().returns(nil)
+        
+        @tag.author.should be(nil)
+      end
+      
+      should "have related tags" do
+        @tag.expects(:value).with().returns('foo')
+        
+        response = mock_request_cycle :for => 'tags.getRelated', :with => {:tag => 'foo'}
+
+        stubs = []
+        elements = (response.body/'rsp/tags/tag').map
+        
+        elements.each do |element|
+          stub = stub()
+          stubs << stub
+
+          Tag.expects(:new).with(element).returns(stub)
+        end
+        
+        @tag.related.should == stubs
+      end
+      
+      should "memoize the data for related tags" do
+        @tag.expects(:value).with().returns('foo')
+        
+        mock_request_cycle :for => 'tags.getRelated', :with => {:tag => 'foo'}
+        
+        2.times { @tag.related }
+      end
+      
+      should "be able to generate a string representation of itself" do
+        @tag.expects(:value).with().returns('foo')
+        @tag.to_s.should == 'foo'
+      end
+      
+      should "know that it is not a machine tag" do
+        @tag.expects(:machine_flag).with().returns('0')
+        @tag.machine?.should be(false)
+      end
+      
+      should "know that it is a machine tag" do
+        @tag.expects(:machine_flag).with().returns('1')
+        @tag.machine?.should be(true)
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class UserTest < Test::Unit::TestCase
+
+    should_search_by :user_id
+
+    should_have_many :photos, :groups, :sets, :contacts, :tags
+    
+    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
+
+    context "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'
+      should_find_one :user, :by => :id, :with => :user_id, :call => 'people.getInfo', :path => 'rsp/person'
+
+    end
+
+    context "An instance of User" do
+      context "when populating the object from an XML document" do
+        setup 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 :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'
+        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
+
+        setup { @user = User.new }
+
+        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
+
+        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
+
+        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
+
+        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
+        
+        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
+        
+        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