mogli 0.0.29 → 0.0.30

data/spec/fetching_array_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+describe Mogli::FetchingArray do
+  
+  let :fetching_array do
+    array = Mogli::FetchingArray.new
+    array << Mogli::User.new(:id=>4)
+    array << Mogli::User.new(:id=>5)
+    array.next_url = "https://next"
+    array.previous_url = "https://previous"
+    array.client = client
+    array.classes = [Mogli::User]
+    array
+  end
+  
+  let :client do
+    Mogli::Client.new
+  end
+  
+  it "has a next_url" do
+    fetching_array.next_url.should == "https://next"
+  end
+  
+  it "has a previous url" do
+    fetching_array.previous_url.should == "https://previous"    
+  end
+  
+  it "has a client" do
+    fetching_array.client.should == client
+  end
+  
+  it "has the classes that it fetches for" do
+    fetching_array.classes = ["User"]
+    fetching_array.classes.should == ["User"]
+  end
+
+
+  describe "fetching" do
+    before(:each) do
+      Mogli::Client.stub!(:get).and_return("data"=>[:id=>3],"paging"=>{"previous"=>"https://new_previous","next"=>"https://new_next"})
+    end
+    
+    describe "fetch next" do
+
+      it "returns an empty array if there is no next_url" do
+        Mogli::FetchingArray.new.fetch_next.should == []
+      end
+
+      it "adds the contents to this container" do
+        fetching_array.fetch_next
+        fetching_array.should == [Mogli::User.new(:id=>4),Mogli::User.new(:id=>5),Mogli::User.new(:id=>3)]
+      end
+    
+      it "updates the next url with the newly fetched next url" do
+        fetching_array.fetch_next
+        fetching_array.next_url.should == "https://new_next"
+      
+      end
+      
+      it "should not change the previous url" do
+        fetching_array.fetch_next
+        fetching_array.previous_url.should == "https://previous"
+      end
+    
+      it "returns the new records" do
+        fetching_array.fetch_next.should == [Mogli::User.new(:id=>3)]
+      end
+    
+    end
+  
+    describe "fetch previous" do
+    
+      it "returns an empty array if there is no previous url" do
+        Mogli::FetchingArray.new.fetch_previous.should == []
+      
+      end
+    
+      it "adds the contents to this container" do
+        fetching_array.fetch_previous
+        fetching_array.should == [Mogli::User.new(:id=>3),Mogli::User.new(:id=>4),Mogli::User.new(:id=>5)]
+      end
+    
+      it "updates the previous url with the newly fetched previous url" do
+        fetching_array.fetch_previous
+        fetching_array.previous_url.should == "https://new_previous"
+      end
+      
+      it "should not change the next url" do
+        fetching_array.fetch_previous
+        fetching_array.next_url.should == "https://next"
+      end
+    
+      it "returns the new records" do
+        fetching_array.fetch_previous.should == [Mogli::User.new(:id=>3)]      
+      end
+    
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,245 @@
+require "spec_helper"
+class TestModel < Mogli::Model
+  set_search_type :test_model
+  define_properties :id, :other_property, :actions
+  creation_properties :other_property, :actions
+  has_association :comments, "Comment"
+
+  hash_populating_accessor :from, "User"
+  hash_populating_accessor :activities, "Activity"
+  hash_populating_accessor :actions, "Action"
+end
+
+
+describe Mogli::Model do
+
+  let :model do
+    model = TestModel.new(:id=>1)
+    model.client = mock_client
+    model
+  end
+
+  let :mock_client do
+    Mogli::Client.new
+  end
+
+
+  it "allows setting the client" do
+    user = Mogli::Model.new
+    user.client = "client"
+    user.client.should == "client"
+  end
+
+  it "has a define properties method" do
+    model.respond_to?(:id).should be_true
+    model.respond_to?(:other_property).should be_true
+  end
+  
+  it "warns when you try to set invalid properties" do
+    lambda do
+      TestModel.new(:invalid_property=>1,:id=>2)
+    end.should_not raise_error
+  end
+
+  it "has a comments attribute which fetches when called" do
+    mock_client.should_receive(:get_and_map).with("1/comments","Comment", {}).and_return("comments")
+    model.comments.should == "comments"
+  end
+  
+  it "populates associations if available" do
+    model = TestModel.new("id"=>1, "comments"=>{"data"=>[{"id"=>1,"message"=>"first"},{"id"=>2,"message"=>"second"}]})
+    mock_client.should_receive(:get_and_map).never
+    model.comments.size.should == 2
+    model.comments.first.id.should == 1
+    model.comments.last.message.should == "second"
+  end
+
+  it "only fetches activities once" do
+    mock_client.should_receive(:get_and_map).once.with("1/comments","Comment", {}).and_return([])
+    model.comments
+    model.comments
+  end
+
+  describe "creation" do
+
+    it "has a create method on associations" do
+      mock_client.stub!(:post)
+      model.comments_create(Mogli::Activity.new)
+    end
+
+    it "posts the params to the client" do
+      mock_client.should_receive(:post).with("1/comments","Comment",:message=>"my message")
+      model.comments_create(Mogli::Comment.new(:message=>"my message"))
+    end
+
+  end
+
+  it "populates from as the user from a hash" do
+    model.from = {"id" => "12451752", "name" => "Mike Mangino"}
+    model.from.should be_an_instance_of(Mogli::User)
+    model.from.id.should == "12451752"
+    model.from.name.should == "Mike Mangino"
+  end
+
+  it "populates activities from a hash array" do
+    model.activities = {"data"=>[{"id"=>1,"name"=>"Coding"},{"id"=>2}]}
+    model.activities.size.should == 2
+    model.activities.each {|c| c.should be_an_instance_of(Mogli::Activity)}
+    model.activities.first.id.should == 1
+    model.activities.first.client.should == mock_client
+  end
+
+  it "allows deleting the post" do
+    mock_client.should_receive(:delete).with(1)
+    model.destroy
+  end
+
+  it "freezes deleted objects" do
+    mock_client.should_receive(:delete).with(1)
+    model.destroy
+    model.should be_frozen
+  end
+
+  it "emits warnings when properties that don't exist are written to" do
+    model.should_receive(:warn_about_invalid_property).with("doesnt_exist")
+    model.doesnt_exist=1
+  end
+
+  describe "Posting" do
+    it "knows which properties are posted" do
+      TestModel.new(:id=>1,:other_property=>2).post_params.keys.map(&:to_s).sort.should == TestModel.creation_keys.map(&:to_s).sort
+    end
+
+    it "includes regular hash properties for posting" do
+      TestModel.new(:id=>1,:other_property=>2).post_params[:other_property].should == 2
+    end
+
+    it "includes associated properties for posting" do
+      actions_data = {:name => 'Action Name', :link => 'http://example.com'}
+      new_model = TestModel.new(:id=>1,:other_property=>2,:actions => [actions_data])
+      new_model.post_params[:actions].should == "[{\"name\":\"Action Name\",\"link\":\"http://example.com\"}]"
+    end
+
+    it "includes associated properties for posting even if Array doesn't have to_json method" do
+      actions_data = {:name => 'Action Name', :link => 'http://example.com'}
+      actions_data_array = [actions_data]
+      actions_data_array.stub!(:respond_to?).with(:to_json).and_return(false)
+      actions_data_array.stub!(:respond_to?).with(:code).and_return(false)
+      actions_data_array.stub!(:respond_to?).with(:parsed_response).and_return(false)
+
+      new_model = TestModel.new(:id=>1,:other_property=>2,:actions => actions_data_array)
+      new_model.post_params[:actions].should == "[{\"name\":\"Action Name\",\"link\":\"http://example.com\"}]"
+    end
+
+    it "will allow updating status with no object" do
+      mock_client.should_receive(:post).once.with("1/comments",nil,{}).and_return([])
+      model.comments_create
+    end
+  end
+
+  describe "Fetching" do
+
+    it "fetches data for a model with an id " do
+      Mogli::Client.should_receive(:get).with("https://graph.facebook.com/1", :query=>{}).and_return({:id=>1,:other_property=>2})
+      model.fetch
+      model.other_property.should == 2
+    end
+    it "fetches data and returns itself" do
+      Mogli::Client.stub!(:get).and_return({:id=>1,:other_property=>2})
+      model.fetch.should == model
+    end
+
+    it "raises an exception when there is no id" do
+      lambda do
+        TestModel.new.fetch
+      end.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "Finding" do
+
+    it "finds many models when id is an Array" do
+      Mogli::Client.should_receive(:get).with(
+        "https://graph.facebook.com/", :query =>{ :ids => '1,2'}
+      ).and_return({
+        "1" => { :id => 1 }, "2" => { :id => 2 , :other_property => "Bob"}
+      })
+      users = TestModel.find([1,2])
+      users.should have(2).elements
+      users.each {|user| user.should be_instance_of(TestModel)}
+      users[1].other_property.should == "Bob"
+    end
+
+    it "raises an exeption if id doesn't exist" do
+      Mogli::Client.should_receive(:get).with(
+        "https://graph.facebook.com/123456", :query => {}
+      ).and_return({
+        "error"=> {"type"=>"QueryParseException", "message"=>"Some of the aliases you requested do not exist: 123456"}
+      })
+      lambda do
+        TestModel.find(123456)
+      end.should raise_error(Mogli::Client::QueryParseException, "Some of the aliases you requested do not exist: 123456")
+
+    end
+
+    it "raises an exception if one from many ids doesn't exist" do
+      Mogli::Client.should_receive(:get).with(
+        "https://graph.facebook.com/", :query =>{ :ids => '1,123456'}
+      ).and_return({
+        "error"=> {"type"=>"QueryParseException", "message"=>"Some of the aliases you requested do not exist: 123456"}
+      })
+      lambda do
+        TestModel.find([1,123456])
+      end.should raise_error(Mogli::Client::QueryParseException, "Some of the aliases you requested do not exist: 123456")
+
+    end
+
+  end
+
+  describe "Searching" do
+
+
+    it "search for graph resources if specific class defined search type" do
+      client = Mogli::Client.new('123');
+      Mogli::Client.should_receive(:get).with(
+        "https://graph.facebook.com/search", :query => {:q=> "s", :type => 'test_model', :access_token => "123"}
+      ).and_return({
+        'data' => [{'id' => 1, 'other_property' => "Test"}]
+      })
+      results = TestModel.search('s',client)
+      results.class.should == Mogli::FetchingArray
+      results.first.id.should == 1
+    end
+
+    it "search in all resource types when searching in Mogli::Model" do
+      client = Mogli::Client.new('123');
+      Mogli::Client.should_receive(:get).with(
+        "https://graph.facebook.com/search", :query => {:q=> "s", :access_token => "123"}
+      ).and_return({
+        'data' => [{'id' => 1, 'message' => "status!", 'type' => "status"},
+        {'id' => 2, 'email' => "bob@example.org", 'type' => "user"}
+      ]})
+      results = Mogli::Model.search('s',client)
+      results.map(&:class).sort_by(&:to_s).should == [Mogli::Status, Mogli::User]
+    end
+
+    it "raises access token error if client is not defined" do
+      Mogli::Client.should_receive(:get).with(
+        "https://graph.facebook.com/search", :query => {:q=> "s", :type => 'user'}
+      ).and_return({
+        "error"=> {"type"=>"OAuthUnauthorizedClientException", "message"=>"An access token is required to request this resource."}
+      })
+      lambda {
+        Mogli::User.search('s')
+      }.should raise_error(Mogli::Client::OAuthUnauthorizedClientException, "An access token is required to request this resource.")
+    end
+
+    it "raises error if class doesn't define search type" do
+      lambda {
+        Mogli::Album.search("Joe")
+      }.should raise_error(NoMethodError, "Can't search for Mogli::Album")
+    end
+
+  end
+
+end

data/spec/page_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+describe Mogli::Page do
+  it "has an access_token" do
+    Mogli::Page.new.access_token.should be_nil
+  end
+  
+  it "gets raises an error if the accesstoken is nil" do
+    lambda do
+      Mogli::Page.new.client_for_page
+    end.should raise_error(Mogli::Page::MissingAccessToken)
+  end
+  
+  it "gets a client if access token has been populated" do
+    page = Mogli::Page.new
+    page.access_token="my token"
+    client = page.client_for_page
+    client.access_token.should == "my token"
+  end
+end

data/spec/profile_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+describe Mogli::Profile do
+  it "has an image_url" do
+    profile = Mogli::Profile.new
+    profile.id="1"
+    profile.image_url.should == "https://graph.facebook.com/1/picture"
+  end
+  
+  it "has image_url methods for small/large/square" do
+    profile = Mogli::Profile.new
+    profile.id="1"
+    profile.square_image_url.should == "https://graph.facebook.com/1/picture?type=square"
+    profile.large_image_url.should == "https://graph.facebook.com/1/picture?type=large"
+    profile.small_image_url.should == "https://graph.facebook.com/1/picture?type=small"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "rubygems"
+require (Pathname(__FILE__).dirname + '../init')

data/spec/test_user_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+describe Mogli::User do
+
+  let(:app_id) { '12345' }
+  let(:access_token) { '678910' }
+
+  describe "#create" do
+    it "POSTs to the test user creation url" do
+      Mogli::Client.should_receive(:post).with("https://graph.facebook.com/#{app_id}/accounts/test-users",
+        :body => {:access_token => access_token, :installed => false, :name => 'The Sock Hammer'}).
+        and_return({:id=>1, :login_url => 'http://example.com/hamsocks' })
+      user = Mogli::TestUser.create({:installed => false, :name => 'The Sock Hammer'}, Mogli::AppClient.new(access_token, app_id))
+      user.login_url.should == 'http://example.com/hamsocks'
+    end
+  end
+
+  describe "#all" do
+    it "GETs the test user url" do
+      Mogli::Client.should_receive(:get).with("https://graph.facebook.com/#{app_id}/accounts/test-users",
+        :query => {:access_token => access_token}).and_return([{:id=>1, :login_url => 'http://example.com/hamsocks'}])
+      users = Mogli::TestUser.all(Mogli::AppClient.new(access_token, app_id))
+      users.first.login_url.should == 'http://example.com/hamsocks'
+    end
+  end
+end

data/spec/user_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+describe Mogli::User do
+
+  let :user_1 do
+    user_1 = Mogli::User.new(:id=>1)
+    user_1.client = mock_client
+    user_1
+  end
+
+  let :mock_client do
+    mock("client")
+  end
+
+
+  it "won't recognize pages" do
+    Mogli::User.recognize?("id"=>1,"name"=>"bob","category"=>"fdhsjkfsd")
+  end
+
+  it "will recognize itself" do
+    Mogli::User.recognize?("id"=>1,"name"=>"bob")
+  end
+
+
+  describe "Finding" do
+
+    it "finds optional fields for a user" do
+      Mogli::Client.should_receive(:get).with("https://graph.facebook.com/1",
+        :query=>{:fields => "birthday,gender"}).and_return({:id=>1, :birthday=>'09/15', :gender => 'male'})
+      user = Mogli::User.find(1, nil, :birthday, :gender)
+      user.birthday.should == '09/15'
+      user.gender.should == 'male'
+    end
+
+    it "finds a user's friends with optional fields" do
+      mock_client.should_receive(:get_and_map).with(
+        "1/friends", "User", {:fields => [:birthday, :gender]}).and_return(
+        [Mogli::User.new(:id=>2, :birthday=>'09/15', :gender => 'male')])
+      friends = user_1.friends(:birthday, :gender)
+      friends.size.should == 1
+    end
+  end
+
+  describe "checking extended permissions" do
+    before :each do
+      # construct a response that will avoid errors: we're just testing query
+      @dummy_response = 'dummy response'
+      @dummy_response.stub!(:parsed_response).and_return [{}]
+
+      # this HTTParty parsed response is taken directly from an actual fql response
+      @valid_response = 'valid response'
+      @valid_response.stub!(:parsed_response).and_return [{"publish_stream"=>1, "create_event"=>0, "rsvp_event"=>0, "sms"=>0, "offline_access"=>1, "publish_checkins"=>0, "user_about_me"=>0, "user_activities"=>0, "user_birthday"=>0, "user_education_history"=>0, "user_events"=>0, "user_groups"=>0, "user_hometown"=>0, "user_interests"=>0, "user_likes"=>0, "user_location"=>0, "user_notes"=>0, "user_online_presence"=>0, "user_photo_video_tags"=>0, "user_photos"=>0, "user_relationships"=>0, "user_relationship_details"=>0, "user_religion_politics"=>0, "user_status"=>0, "user_videos"=>0, "user_website"=>0, "user_work_history"=>0, "email"=>1, "read_friendlists"=>0, "read_insights"=>0, "read_mailbox"=>0, "read_requests"=>0, "read_stream"=>0, "xmpp_login"=>0, "ads_management"=>0, "user_checkins"=>0, "manage_pages"=>0}]
+
+      @request_regexp = /^SELECT ([\w,]*) FROM permissions WHERE uid = \d*$/
+    end
+
+    it "sends FQL with correct syntax when querying permissions" do
+      user_1.client.should_receive(:fql_query).with(@request_regexp).and_return @dummy_response
+      user_1.send :fetch_permissions
+    end
+
+    it "includes all known permissions in FQL query" do
+      user_1.client.should_receive(:fql_query) do |query|
+        @request_regexp =~ query
+        permissions_list = $1
+
+        Mogli::User::ALL_EXTENDED_PERMISSIONS.each do |perm|
+          permissions_list.should match /,?#{perm.to_s},?/
+        end
+
+        @dummy_response # stubbed return val
+      end
+
+      user_1.send :fetch_permissions
+    end
+
+    it "only submits permissions-checking FQL once when checking a permission" do
+      user_1.client.should_receive(:fql_query).once.and_return @dummy_response
+      user_1.has_permission? :publish_stream
+      user_1.has_permission? :offline_access
+    end
+
+    it "correctly converts FQL response into the permissions hash" do
+      user_1.client.should_receive(:fql_query).and_return @valid_response
+      user_1.send :fetch_permissions
+      Mogli::User::ALL_EXTENDED_PERMISSIONS.each do |perm|
+        user_1.extended_permissions.should be_include perm
+      end
+    end
+
+    it "correctly reports that user has permission they have granted" do
+      user_1.client.should_receive(:fql_query).and_return @valid_response
+      user_1.should be_has_permission(:offline_access)
+    end
+
+    it "correctly reports that user does not have permission they have not granted" do
+      user_1.client.should_receive(:fql_query).and_return @valid_response
+      user_1.should_not be_has_permission(:manage_pages)
+    end
+
+    it "should raise exception on unrecognized permission" do
+      lambda {
+        user_1.has_permission? :not_a_permission
+      }.should raise_error(Mogli::User::UnrecognizedExtendedPermissionException)
+    end
+  end
+
+end