taweili-facebooker 1.0.37

data/templates/layout.erb

@@ -0,0 +1,24 @@
+<fb:fbml>
+      <style>
+    body { background-color: #fff; color: #333; }
+
+    body, p, ol, ul, td {
+      font-family: verdana, arial, helvetica, sans-serif;
+      font-size:   13px;
+      line-height: 18px;
+    }
+
+    pre {
+      background-color: #eee;
+      padding: 10px;
+      font-size: 11px;
+    }
+
+    a { color: #000; }
+    a:visited { color: #666; }
+    a:hover { color: #fff; background-color:#000; }
+  </style>
+
+<%= @contents %>
+
+</fb:fbml>

data/test/facebooker/adapters_test.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Facebooker::AdaptersTest < Test::Unit::TestCase
+  def setup
+    ENV['FACEBOOK_API_KEY'] = '1234567'
+    ENV['FACEBOOK_SECRET_KEY'] = '7654321'
+    @current_adapter = Facebooker.current_adapter
+    Facebooker.current_adapter = nil
+    @bebo_api_key = "bebo_api_key"; @bebo_secret_key = "bebo_secret_key"
+  end
+
+  def teardown
+   flexmock_close
+    Facebooker.current_adapter = @current_adapter
+  end
+
+  def test_load_default_adapter
+    session = Facebooker::CanvasSession.create(ENV['FACEBOOK_API_KEY'], ENV['FACEBOOK_SECRET_KEY'])
+    assert_equal(ENV['FACEBOOK_API_KEY'], Facebooker::Session.api_key)
+    assert( Facebooker::FacebookAdapter === Facebooker.current_adapter)
+
+    ENV['FACEBOOK_API_KEY'] = nil
+    ENV['FACEBOOK_SECRET_KEY'] = nil
+    Facebooker.current_adapter = nil
+    Facebooker::AdapterBase.stubs(:facebooker_config).returns({"api_key" => "facebook_key", "secret_key" => "facebook_secret" })
+    assert( Facebooker::FacebookAdapter === Facebooker.current_adapter)
+    assert_equal("facebook_key", Facebooker::Session.api_key)
+  end
+
+  def test_load_bebo_adapter
+
+    load_bebo_adapter
+    assert_equal(@bebo_api_key, Facebooker::Session.api_key)
+    assert_equal(@bebo_secret_key, Facebooker::Session.secret_key)
+    assert(Facebooker::BeboAdapter === Facebooker.current_adapter, " Bebo adapter not loaded correctly.")
+  end
+
+  def load_bebo_adapter
+    @bebo_api_key = "bebo_api_key"; @bebo_secret_key = "bebo_secret_key"
+
+    Facebooker::AdapterBase.stubs(:facebooker_config).returns({"bebo_api_key" => @bebo_api_key, "bebo_adapter" => "BeboAdapter", "bebo_secret_key" => @bebo_secret_key, "foo" => "bar"})
+    Facebooker.load_adapter(:config_key_base => "bebo")
+    @session = Facebooker::CanvasSession.create(@bebo_api_key, @bebo_secret_key)
+  end
+
+  def test_adapter_details
+     test_load_default_adapter
+
+     assert_equal("apps.facebook.com", Facebooker.canvas_server_base)
+     assert_equal("api.facebook.com", Facebooker.api_server_base)
+     assert_equal("www.facebook.com", Facebooker.www_server_base_url)
+     assert_equal("http://api.facebook.com", Facebooker.api_server_base_url)
+     assert(Facebooker.is_for?(:facebook))
+    load_bebo_adapter
+
+      assert_equal("apps.bebo.com", Facebooker.canvas_server_base)
+     assert_equal("apps.bebo.com", Facebooker.api_server_base)
+     assert_equal("www.bebo.com", Facebooker.www_server_base_url)
+     assert_equal("http://apps.bebo.com", Facebooker.api_server_base_url)
+     assert_equal("http://www.bebo.com/SignIn.jsp?ApiKey=bebo_api_key&v=1.0&canvas=true", @session.login_url)
+     assert_equal("http://www.bebo.com/c/apps/add?ApiKey=bebo_api_key&v=1.0", @session.install_url)
+     assert(Facebooker.is_for?(:bebo))
+
+  end
+
+  def test_adapter_failures
+      Facebooker::AdapterBase.stubs(:facebooker_config).returns({})
+
+      assert_raises(Facebooker::AdapterBase::UnableToLoadAdapter){
+        Facebooker.load_adapter(:config_key_base => "bebo")
+      }
+  end
+
+  def test_bebo_specific_issues
+    load_bebo_adapter
+
+    # @session.send(:service).stubs(:post).returns([{:name => "foo"}])
+     Net::HTTP.stubs(:post_form).returns("<profile_setFBML_response></profile_setFBML_response>")
+     user = Facebooker::User.new(:uid => "123456")
+     user.session = @session
+     user.set_profile_fbml("foo","bar","foo")
+     assert(true)
+     Net::HTTP.stubs(:post_form).returns("<users_getInfo_response> <user><uid>123456</uid><name>foo</name></user></users_getInfo_response>")
+     user.populate(:name)
+     assert(true)
+     assert_equal("foo", user.name)
+     action = Facebooker::Feed::TemplatizedAction.new()
+     action.title_template = "foo"
+     Net::HTTP.stubs(:post_form).returns("<feed_publishTemplatizedAction_response>1</feed_publishTemplatizedAction_response>")
+     user.publish_templatized_action(action)
+  end
+
+  def test_bebo_process_data
+
+  end
+end

data/test/facebooker/admin_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Facebooker::AdminTest < Test::Unit::TestCase
+  def setup
+    @session = Facebooker::Session.create('apikey', 'secretkey')
+    Facebooker.use_curl=false
+  end
+  
+  def test_can_ask_facebook_to_set_app_properties
+    expect_http_posts_with_responses(example_set_properties_xml)
+    properties = { :application_name => "Video Jukebox", :dev_mode => 0 }    
+    assert(@session.admin.set_app_properties(properties))
+  end
+
+  def test_set_app_properties_json_conversion
+    properties = { :application_name => "Video Jukebox", :dev_mode => 0 }
+    flexmock(@session).should_receive(:post).with('facebook.admin.setAppProperties', :properties => properties.to_json).and_return('1').once
+    assert(@session.admin.set_app_properties(properties))
+  end
+    
+  def test_can_ask_facebook_to_get_app_properties
+    expect_http_posts_with_responses(example_get_properties_xml)
+    properties = [ :application_name, :dev_mode ]
+    assert(@session.admin.get_app_properties(properties))
+  end
+  
+  def test_can_get_properties
+    mock_http = establish_session
+    mock_http.should_receive(:post_form).and_return(example_get_properties_xml).once.ordered(:posts)
+    p = @session.admin.get_app_properties(:application_name, :dev_mode, :canvas_name)
+    assert_equal 'Video Jukebox', p.application_name
+    assert_equal 0, p.dev_mode
+    assert_equal 'my_canvas', p.canvas_name
+  end
+  
+  def test_can_set_restriction_info
+    restrictions = {:age => '21', :type => 'alcohol'}
+    flexmock(@session).should_receive(:post).with('facebook.admin.setRestrictionInfo', :restriction_str => restrictions.to_json).and_return('1').once
+    assert(@session.admin.set_restriction_info(restrictions))
+  end
+  
+  def test_can_get_restriction_info
+    mock_http = establish_session
+    mock_http.should_receive(:post_form).and_return(example_get_restriction_info_xml).once.ordered(:posts)
+    r = @session.admin.get_restriction_info
+    assert_equal 'alcohol', r.type
+    assert_equal '21', r.age
+  end
+
+  def test_can_get_allocation
+    mock_http = establish_session
+    mock_http.should_receive(:post_form).and_return(example_get_allocation_xml).once.ordered(:posts)
+    alloc = @session.admin.get_allocation(:notifications_per_day)
+    assert_equal 40, alloc
+  end
+
+  private
+  def example_set_properties_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <admin_setAppProperties_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</admin_setAppProperties_response>
+    XML
+  end
+
+  def example_get_properties_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <admin_getAppProperties_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">
+        {&quot;application_name&quot;:&quot;Video Jukebox&quot;,&quot;callback_url&quot;:&quot;http:\/\/67.207.144.245\/&quot;,&quot;dev_mode&quot;:0,&quot;canvas_name&quot;:&quot;my_canvas&quot;}
+    </admin_getAppProperties_response>
+    XML
+  end
+  
+  def example_get_restriction_info_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <admin_getRestrictionInfo_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">
+        {&quot;age&quot;:&quot;21&quot;,&quot;location&quot;:&quot;&quot;,&quot;age_distribution&quot;:&quot;&quot;,&quot;type&quot;:&quot;alcohol&quot;}
+    </admin_getRestrictionInfo_response>
+    XML
+  end
+  
+  def example_get_allocation_xml
+    <<-XML
+    <?xml version="1.0" encoding="UTF-8"?>
+    <admin_getAllocation_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">
+        40
+    </admin_getAllocation_response>
+    XML
+  end
+    
+end

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/photo_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'active_support'
+
+class Facebooker::UserTest < Test::Unit::TestCase
+
+  def test_pid_should_be_treated_as_a_string
+    @photo = Facebooker::Photo.new(:pid=>"100000025509592_6801")
+    assert_equal("100000025509592_6801",@photo.pid)
+  end
+  
+  def test_setting_id_should_also_use_new_method
+    @photo = Facebooker::Photo.new(:id=>"100000025509592_6801")
+    assert_equal("100000025509592_6801",@photo.id)
+  end
+
+end