facebooker-lite 1.0.67

data/test/facebooker/batch_request_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Facebooker::BatchRequestTest < Test::Unit::TestCase
+  
+  def setup
+    @proc_called=false
+    @batch_request=Facebooker::BatchRequest.new({:params=>true},nil)
+  end
+  
+  def test_can_set_result
+    
+  end
+  
+  def test_can_set_result_with_proc_and_have_proc_called
+    p=Proc.new {@proc_called=true}
+    
+    @batch_request=Facebooker::BatchRequest.new({:params=>true},p)
+    @batch_request.result="Mike"
+    assert @proc_called
+  end
+  def test_can_set_result_with_proc_and_use_proc_result
+    p=Proc.new {@proc_called=true}
+    
+    @batch_request=Facebooker::BatchRequest.new({:params=>true},p)
+    @batch_request.result="Mike"
+    assert @batch_request
+  end
+  
+  def test_proxies_methods
+    @batch_request.result="Mike"
+    assert @batch_request == "Mike"
+  end
+  
+  def test_threequal_works
+    @batch_request.result="Mike"
+    assert @batch_request === String
+  end
+  
+  def test_can_set_exception_and_check_it
+    @batch_request.exception_raised=ArgumentError.new
+    assert_raises(ArgumentError) {
+      @batch_request.exception_raised?
+    }
+  end
+  def test_can_set_exception_and_have_it_raised_on_access
+    @batch_request.exception_raised=ArgumentError.new
+    assert_raises(ArgumentError) {
+      @batch_request == true
+    }
+  end
+  def test_exception_raised_false_when_no_exception
+    @batch_request.result="Mike"
+    assert ! @batch_request.exception_raised?
+  end
+  
+  # def test_case_works
+  #   @batch_request.result="Mike"
+  #   case @batch_request
+  #     when String
+  #     else 
+  #       fail("case failed")
+  #   end
+  #   
+  # end
+  
+  def test_calling_method_without_result_raises_exception
+    assert_raises(Facebooker::BatchRequest::UnexecutedRequest) {
+      @batch_request.to_s
+    }
+  end
+  
+  def test_respond_to
+    @batch_request.result=[]
+    assert @batch_request.respond_to?(:empty?)
+  end
+  
+  def test_calling_method_after_exception_re_raises_exception
+    @batch_request.result="String"
+    assert_raises(NoMethodError) {
+      @batch_request.fake
+    }
+  end
+end

data/test/facebooker/data_test.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Facebooker::DataTest < Test::Unit::TestCase
+  def setup
+    @session = Facebooker::Session.create('apikey', 'secretkey')
+    #make sure we use net::http since that's what the tests expect
+    Facebooker.use_curl=false
+  end
+
+  def test_can_ask_facebook_to_set_a_cookies
+    expect_http_posts_with_responses(example_set_cookie_xml)
+    assert(@session.data.set_cookie(12345, 'name', 'value'))
+  end
+
+  def test_can_ask_facebook_to_get_cookies
+    expect_http_posts_with_responses(example_get_cookies_xml)
+    assert(@session.data.get_cookies(12345))
+  end
+
+  def test_can_get_cookies_for_user
+    mock_http = establish_session
+    mock_http.should_receive(:post_form).and_return(example_get_cookies_xml).once.ordered(:posts)
+    cookies = @session.data.get_cookies(508508326)
+    assert_equal 'Foo', cookies.first.name
+    assert_equal 'Bar', cookies.first.value
+  end
+
+  def test_can_ask_facebook_to_set_a_preference
+    expect_http_posts_with_responses(example_set_preference_xml)
+    assert(@session.data.set_preference(0, 'hello'))
+  end
+
+  def test_can_ask_facebook_to_get_preference
+    expect_http_posts_with_responses(example_get_preference_xml)
+    assert(@session.data.get_preference(0))
+  end
+
+  def test_can_get_preference
+    mock_http = establish_session
+    mock_http.should_receive(:post_form).and_return(example_get_preference_xml).once.ordered(:posts)
+    assert_equal 'hello', @session.data.get_preference(0)
+  end
+
+  private
+  def example_set_cookie_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <data_setCookie_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd">1</data_setCookie_response>
+    XML
+  end
+
+  def example_get_cookies_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <data_getCookie_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd">
+      <cookies>
+        <uid>508508326</uid>
+        <name>Foo</name>
+        <value>Bar</value>
+        <expires>0</expires>
+        <path>/tmp/</path>
+      </cookies>
+    </data_getCookie_response>
+    XML
+  end
+
+  def example_set_preference_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <data_setUserPreference_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd"/>
+    XML
+  end
+
+  def example_get_preference_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <data_getUserPreference_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd">
+      hello
+    </data_getUserPreference_response>
+    XML
+  end
+end

data/test/facebooker/logging_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require 'logger'
+
+class Facebooker::LoggingTest < Test::Unit::TestCase
+  def setup
+    super
+    Facebooker.logger = Logger.new(STDERR)
+    Facebooker::Logging.skip_api_logging=false
+  end  
+  def teardown
+    Facebooker.logger = nil    
+    super
+  end
+  
+  def test_does_not_crash_with_nil_logger
+    Facebooker.logger = nil
+    Facebooker::Logging.log_fb_api('sample.api.call',
+                          {'param1' => true, 'param2' => 'value2'})
+  end
+
+  def test_does_not_crash_outside_rails
+    flexmock(Facebooker.logger, :logger).should_receive(:info).once.with(String)
+    Facebooker::Logging.log_fb_api('sample.api.call',
+                          {'param1' => true, 'param2' => 'value2'})
+  end
+  
+  def test_can_disable_logging
+    Facebooker::Logging.skip_api_logging = true
+    flexmock(Facebooker::Logging).should_receive(:log_info).never
+    Facebooker::Logging.log_fb_api('sample.api.call',
+                          {'param1' => true, 'param2' => 'value2'})
+  end 
+  
+  def test_plain_format
+    flexmock(Facebooker.logger, :logger).should_receive(:info).once.with(
+        'sample.api.call (0) param1 = true')
+    Facebooker::Logging.log_fb_api('sample.api.call',
+                          {'param1' => true})
+  ensure
+    Facebooker.logger = nil
+  end
+
+end

data/test/facebooker/mobile_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Facebooker::MobileTest < Test::Unit::TestCase
+  def setup
+    @session = Facebooker::Session.create('apikey', 'secretkey')
+    @user = Facebooker::User.new(1234, @session)
+    Facebooker.use_curl=false
+  end
+  
+  def test_can_send
+    expect_http_posts_with_responses(example_can_send_xml)
+    assert(@session.mobile.can_send(@user))
+  end
+
+  def test_send
+    expect_http_posts_with_responses(example_send_xml)
+    assert(@session.mobile.send(@user, "Some sort of message"))    
+  end
+
+private
+  def example_can_send_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <sms_canSend_response
+      xmlns="http://api.facebook.com/1.0/"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://api.facebook.com/1.0/http://api.facebook.com/1.0/facebook.xsd">
+      0
+    </sms_canSend_response>
+    XML
+  end
+  
+  def example_send_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <sms_send_response
+      xmlns="http://api.facebook.com/1.0/"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xsi:schemaLocation="http://api.facebook.com/1.0/http://api.facebook.com/1.0/facebook.xsd">
+      0
+    </sms_send_response>
+    XML
+  end
+  
+end

data/test/facebooker/model_test.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Facebooker::ModelTest < Test::Unit::TestCase
+  
+  class ComplexThing
+    include Facebooker::Model
+    attr_accessor :weight, :height
+  end
+  
+  class Thing
+    include Facebooker::Model
+    attr_accessor :name, :job
+    hash_settable_accessor :complex_thing, ComplexThing
+    hash_settable_list_accessor :list_of_complex_things, ComplexThing
+
+    def initialize *args
+      @session = nil
+      super
+    end
+  end
+
+  class PopulatingThing
+    include Facebooker::Model
+    populating_attr_accessor :first_name
+
+    def initialize
+      @first_name = nil
+      @populated  = false
+    end
+  end
+  
+  def test_can_instantiate_an_object_with_a_hash
+    h = {:name => "Blob", :job => "Monster"}
+    assert_equal("Blob", Thing.from_hash(h).name)
+  end
+  
+  def test_ignores_non_model_keys
+    h = {:name => "Blob", :job => "Monster", :not_there=>true}
+    assert_equal("Blob", Thing.from_hash(h).name)    
+  end
+  
+  def test_logs_non_model_keys
+    flexmock(Facebooker::Logging).should_receive(:log_info)
+    h = {:name => "Blob", :job => "Monster", :not_there=>true}
+    Thing.from_hash(h)
+  end
+    
+  
+  def test_if_no_hash_is_given_to_model_constructor_no_attributes_are_set
+    assert_nothing_raised {
+      t = Thing.new
+      assert_nil(t.name)
+    }
+  end
+  
+  def test_can_declare_hash_settable_attributes
+    t = Thing.new({})
+    t.complex_thing = {:weight => 123, :height => 5.4}
+    assert_equal(123, t.complex_thing.weight)
+    t.complex_thing = ComplexThing.new(:weight => 321)
+    assert_equal(321, t.complex_thing.weight)
+  end
+  
+  def test_can_declare_attributes_which_are_settable_via_a_list_of_hashes
+    t = Thing.new
+    t.list_of_complex_things = [{:weight => 444, :height => 123.0}, {:weight => 222, :height => 321.1}]
+    assert_equal("123.0, 321.1", t.list_of_complex_things.map{|ct| ct.height.to_s}.sort.join(', '))
+    t.list_of_complex_things = [ComplexThing.new(:weight => 555), ComplexThing.new(:weight => 111)]
+    assert_equal("111, 555", t.list_of_complex_things.map{|ct| ct.weight.to_s}.sort.join(', '))
+  end
+  
+  def test_if_you_try_to_use_a_models_session_without_initializing_it_first_you_get_a_descriptive_error
+    t = Thing.new
+    assert_raises(Facebooker::Model::UnboundSessionException) {
+      t.session
+    }
+  end
+  
+  def test_populating_reader_will_call_populate_if_model_was_not_previously_populated
+    t = PopulatingThing.new
+    flexmock(t).should_receive(:populate).once
+    t.first_name
+  end
+  
+  def test_populating_reader_will_not_call_populate_if_model_was_previously_populated
+    t = PopulatingThing.new
+    flexmock(t).should_receive(:populated?).and_return(true)
+    flexmock(t).should_receive(:populate).never
+    t.first_name
+  end
+  
+  def test_attempting_to_access_a_populating_reader_will_raise_an_exception_if_populate_was_not_defined
+    t = PopulatingThing.new
+    assert_raises(NotImplementedError) {
+      t.first_name
+    }
+  end
+
+  def test_populate_from_hash_e_should_call_a_setter_for_a_key
+    t = PopulatingThing.new
+    flexmock(t).should_receive('mykey=').with('a value')
+    t.populate_from_hash!({ :mykey => 'a value' })
+  end
+  
+  def test_populate_from_hash_e_should_call_a_setter_for_a_key_if_the_value_is_false
+    t = PopulatingThing.new
+    flexmock(t).should_receive('mykey=').with(false)
+    t.populate_from_hash!({ :mykey => false })
+  end
+
+  def test_populate_from_hash_e_should_call_not_a_setter_for_a_key_if_the_value_is_nil
+    t = PopulatingThing.new
+    flexmock(t).should_receive('mykey=').never
+    t.populate_from_hash!({ :mykey => nil })
+  end
+
+  def test_populate_from_hash_should_check_for_an_empty_hash
+    t = PopulatingThing.new
+    hash = {}
+    flexmock(hash).should_receive('empty?')
+    t.populate_from_hash!(hash)
+  end
+
+  def test_populate_from_hash_should_check_for_a_nil_param
+    t = PopulatingThing.new
+    hash = nil
+    assert_nothing_raised do
+      t.populate_from_hash!(hash)
+    end
+  end
+
+end
+

data/test/facebooker/models/event_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+class Facebooker::EventTest < Test::Unit::TestCase
+  def test_attendance_will_query_for_event_when_asked_for_full_event_object
+    session = flexmock("a session object")
+    eid = 123
+    attendance = Facebooker::Event::Attendance.new
+    attendance.eid = eid
+    attendance.session = session
+    event = Facebooker::Event.new
+    event.eid = eid
+    session.should_receive(:post).once.with('facebook.events.get', :eids => [eid]).and_return([{:eid => eid}])    
+    assert_equal(123, attendance.event.eid)
+  end
+end

data/test/facebooker/models/page_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'active_support'
+
+class Facebooker::PageTest < Test::Unit::TestCase
+
+  def setup
+    super
+    Facebooker::Session.current = mock("session")
+  end
+
+  def test_should_be_able_to_populate_with_photo_id_as_integer
+    p = Facebooker::Page.new(12345)
+    assert_equal(12345,p.page_id)
+  end
+  
+  def test_should_be_able_to_initialize_with_photo_id_as_string
+    p = Facebooker::Page.new("12345")
+    assert_equal("12345",p.page_id)    
+  end
+  
+  def test_should_alias_photo_id_as_id
+    p = Facebooker::Page.new("12345")
+    assert_equal("12345", p.id)    
+  end
+  
+  def test_should_be_able_to_initialize_with_hash
+    p = Facebooker::Page.new(:page_id=>12345,:name=>"test page")
+    assert_equal("test page",p.name)
+    assert_equal(12345,p.page_id)
+  end
+  
+  def test_should_be_able_to_see_if_user_is_fan_with_id
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isFan",:page_id=>12345,:uid=>12451752).returns(true)
+    p = Facebooker::Page.new(12345)
+    assert p.user_is_fan?(12451752)
+  end
+  
+  def test_should_be_able_to_see_if_user_is_fan_with_user
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isFan",:page_id=>12345,:uid=>12451752).returns(false)
+    p = Facebooker::Page.new(12345)
+    assert !p.user_is_fan?(Facebooker::User.new(12451752))
+  end
+  
+  def test_should_be_able_to_see_if_user_is_admin_with_id
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isAdmin",:page_id=>12345,:uid=>12451752).returns(false)
+    p = Facebooker::Page.new(12345)
+    assert !p.user_is_admin?(12451752)
+    
+  end
+  
+  def test_should_be_able_to_see_if_user_is_admin_with_user
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isAdmin",:page_id=>12345,:uid=>12451752).returns(true)
+    p = Facebooker::Page.new(12345)
+    assert p.user_is_admin?(Facebooker::User.new(12451752))
+  end
+end