slaskis-fleakr 0.5.0

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

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class ContactTest < Test::Unit::TestCase
+
+    context "The Contact class" do
+      
+      should "return a list of users for a specified user's contacts" do
+        # user_1, user_2 = [stub(), stub()]
+        user_1 = stub()
+        user_2 = 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').to_a
+        
+        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
+
+    context "An instance of the Contact class" do
+      context "when populating from an XML document" do
+        setup 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/unit/fleakr/objects/error_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class ErrorTest < Test::Unit::TestCase
+    
+    context "An instance of the Error class" do
+      
+      should "have a code and a message" do
+        response_xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<rsp stat=\"fail\">\n\t<err code=\"1\" msg=\"User not found\" />\n</rsp>\n"
+        
+        error = Error.new(Hpricot.XML(response_xml))
+        
+        error.code.should == '1'
+        error.message.should == 'User not found'
+      end
+      
+    end
+    
+    
+  end
+end

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

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class GroupTest < Test::Unit::TestCase
+
+    should_have_many :photos
+    
+    should_search_by :group_id
+
+    context "The Group class" do
+      
+      should_find_all :groups, :by => :user_id, :call => 'people.getPublicGroups', :path => 'rsp/groups/group'
+      
+    end
+    
+    context "An instance of the Group class" do
+      context "when initializing from an Hpricot document" do
+        
+        setup do
+          doc = Hpricot.XML(read_fixture('people.getPublicGroups')).at('rsp/groups/group')
+          @object = Group.new(doc)
+        end
+        
+        should_have_a_value_for :id   => '13378274@N00'
+        should_have_a_value_for :name => 'Group #1'
+        should_have_a_value_for :adult_flag => '1'
+        
+      end
+
+      should "know that the group is adult-only" do
+        group = Group.new
+        group.stubs(:adult_flag).with().returns('1')
+        group.adult?.should be(true)
+      end
+      
+      should "know that the group is not adult-only" do
+        group = Group.new
+        group.stubs(:adult_flag).with().returns('0')
+        group.adult?.should be(false)
+      end
+      
+    end
+    
+  end
+end
+

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

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class ImageTest < Test::Unit::TestCase
+
+    context "The Image class" do
+
+      should_find_all :images, :by => :photo_id, :call => 'photos.getSizes', :path => 'sizes/size'
+
+    end
+
+    context "An instance of the Image class" do
+
+      context "when populating the object from an XML document" do
+
+        setup 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
+
+        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
+
+          setup 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)
+            
+            @image_data = 'image_data'
+            Net::HTTP.expects(:get).with(URI.parse(@url)).returns(@image_data)
+          end
+
+          teardown do
+            FileUtils.rm_rf(@tmp_dir)
+          end
+
+          should "be able to save to a directory with the original filename" do
+            @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
+            existing_file = "#{@tmp_dir}/existing_file.jpg"
+
+            FileUtils.touch(existing_file)
+
+            @image.save_to(existing_file)
+            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
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Objects
+  class PhotoContextTest < Test::Unit::TestCase
+    
+    context "An instance of the PhotoContext class" do
+      
+      setup { @context = PhotoContext.new }
+      
+      context "when populating from the photos_getContext XML data" do
+        setup do
+          @object = PhotoContext.new(Hpricot.XML(read_fixture('photos.getContext')))
+        end
+        
+        should_have_a_value_for :count       => '5584'
+        should_have_a_value_for :next_id     => '12343'
+        should_have_a_value_for :previous_id => '12345'
+
+      end
+      
+      should "know that there is a previous photo" do
+        @context.expects(:previous_id).with().returns('1')
+        @context.previous?.should be(true)
+      end
+      
+      should "know that there isn't a previous photo" do
+        @context.expects(:previous_id).with().returns('0')
+        @context.previous?.should be(false)
+      end
+      
+      should "know that there is a next photo" do
+        @context.expects(:next_id).with().returns('1')
+        @context.next?.should be(true)
+      end
+      
+      should "know that there isn't a next photo" do
+        @context.expects(:next_id).with().returns('0')
+        @context.next?.should be(false)
+      end
+      
+      should "find the previous photo" do
+        photo = stub()
+        
+        @context.expects(:previous_id).with().returns('1')
+        @context.expects(:previous?).with().returns(true)
+        
+        Photo.expects(:find_by_id).with('1').returns(photo)
+        
+        @context.previous.should == photo
+      end
+      
+      should "not try to find the previous photo if it doesn't exist" do
+        @context.expects(:previous?).with().returns(false)
+        Photo.expects(:find_by_id).never
+        
+        @context.previous.should be(nil)
+      end
+      
+      should "find the next photo" do
+        photo = stub()
+        @context.expects(:next_id).with().returns('1')
+        @context.expects(:next?).with().returns(true)
+                
+        Photo.expects(:find_by_id).with('1').returns(photo)
+        
+        @context.next.should == photo
+      end
+      
+      should "not try to find the next photo if it doesn't exist" do
+        @context.expects(:next?).with().returns(false)
+        Photo.expects(:find_by_id).never
+        
+        @context.next.should be(nil)
+      end
+      
+      
+    end
+    
+  end
+end

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