slaskis-fleakr 0.5.0

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, :collections
+    
+    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

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

@@ -0,0 +1,126 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Support
+  class AttributeTest < Test::Unit::TestCase
+    context "An instance of the Attribute class" do
+
+      should "know the name of the attribute" do
+        attr = Attribute.new('foo')
+        attr.name.should == :foo
+      end
+
+      should "have a default source" do
+        attr = Attribute.new(:foo)
+        attr.sources.should == ['foo']
+      end
+      
+      should "be able to assign multiple sources" do
+        attr = Attribute.new(:foo, ['foo1', 'foo2'])
+        attr.sources.should == ['foo1', 'foo2']
+      end
+
+      should "pull the location from the source" do
+        attr = Attribute.new('foo')
+        attr.location('foo').should == 'foo'
+      end
+      
+      should "return the location when splitting" do
+        attr = Attribute.new('foo')
+        attr.split('foo').should == ['foo', nil]
+      end
+      
+      should "return the name for the location when splitting if the location isn't specified" do
+        attr = Attribute.new('foo')
+        attr.split('@bar').should == ['foo', 'bar']
+      end
+      
+      should "allow the setting of the location information" do
+        attr = Attribute.new('foo', 'bar')
+        attr.sources.should == ['bar']
+      end
+      
+      should "allow the setting of the attribute value" do
+        attr = Attribute.new('foo')
+        attr.attribute('@bogon').should == 'bogon'
+      end
+      
+      should "use the location as the attribute" do
+        attr = Attribute.new('foo')
+        attr.attribute('foo').should == 'foo'
+      end
+      
+      should "use the attribute for the attribute if specified" do
+        attr = Attribute.new(:id, '@nsid')
+        attr.attribute('@nsid').should == 'nsid'
+      end
+
+      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
+      
+      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
+
+      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
+      
+      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
+
+      should "be able to pull an attribute value from the current XML node" do
+        document = Hpricot.XML('<user id="1337" />')
+        attr = Attribute.new(:id)
+        attr.value_from(document).should == '1337'
+      end
+        
+      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
+
+      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, 'station/genre@slug')
+        attr.value_from(document).should == 'dnb'
+      end
+        
+      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
+
+      should "return nil if it cannot find the specified node" do
+        document = Hpricot.XML('<user id="1" />')
+        attr = Attribute.new(:photoset, '@nsid')
+        attr.value_from(document).should be(nil)
+      end
+
+      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