koala 2.4.0 → 3.5.0

data/spec/support/graph_api_shared_examples.rb

@@ -1,5 +1,6 @@
 shared_examples_for "Koala GraphAPI" do
   # all Graph API instances should pass these tests, regardless of configuration
+  let(:dummy_response) { double("fake response", data: {}, status: 200, body: "", headers: {}) }
 
   # API
   it "never uses the rest api server" do
@@ -13,80 +14,7 @@ shared_examples_for "Koala GraphAPI" do
     @api.api("anything")
   end
 
-  # GRAPH CALL
-  describe "graph_call" do
-    it "passes all arguments to the api method" do
-      user = KoalaTest.user1
-      args = {}
-      verb = 'get'
-      opts = {:a => :b}
-      expect(@api).to receive(:api).with(user, args, verb, opts)
-      @api.graph_call(user, args, verb, opts)
-    end
-
-    it "throws an APIError if the result hash has an error key" do
-      allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(500, '{"error": "An error occurred!"}', {}))
-      expect { @api.graph_call(KoalaTest.user1, {}) }.to raise_exception(Koala::Facebook::APIError)
-    end
-
-    it "passes the results through GraphCollection.evaluate" do
-      result = {}
-      allow(@api).to receive(:api).and_return(result)
-      expect(Koala::Facebook::GraphCollection).to receive(:evaluate).with(result, @api)
-      @api.graph_call("/me")
-    end
-
-    it "returns the results of GraphCollection.evaluate" do
-      expected = {}
-      allow(@api).to receive(:api).and_return([])
-      expect(Koala::Facebook::GraphCollection).to receive(:evaluate).and_return(expected)
-      expect(@api.graph_call("/me")).to eq(expected)
-    end
-
-    it "returns the post_processing block's results if one is supplied" do
-      other_result = [:a, 2, :three]
-      block = Proc.new {|r| other_result}
-      allow(@api).to receive(:api).and_return({})
-      expect(@api.graph_call("/me", {}, "get", {}, &block)).to eq(other_result)
-    end
-  end
-
-  # SEARCH
-  it "can search" do
-    result = @api.search("facebook")
-    expect(result.length).to be_an(Integer)
-  end
-
   # DATA
-  # access public info
-
-  # get_object
-  it "gets public data about a user" do
-    result = @api.get_object(KoalaTest.user1)
-    # the results should have an ID and a name, among other things
-    expect(result["id"] && result["name"]).not_to be_nil
-  end
-
-  it "gets public data about a Page" do
-    result = @api.get_object(KoalaTest.page)
-    # the results should have an ID and a name, among other things
-    expect(result["id"] && result["name"]).to be_truthy
-  end
-
-  it "returns [] from get_objects if passed an empty array" do
-    results = @api.get_objects([])
-    expect(results).to eq([])
-  end
-
-  it "gets multiple objects" do
-    results = @api.get_objects([KoalaTest.page, KoalaTest.user1])
-    expect(results.size).to eq(2)
-  end
-
-  it "gets multiple objects if they're a string" do
-    results = @api.get_objects("facebook,#{KoalaTest.user1}")
-    expect(results.size).to eq(2)
-  end
 
   describe "#get_picture" do
     it "can access a user's picture" do
@@ -123,27 +51,6 @@ shared_examples_for "Koala GraphAPI" do
     end
   end
 
-  it "can access connections from public Pages" do
-    result = @api.get_connections(KoalaTest.page, "photos")
-    expect(result).to be_a(Array)
-  end
-
-  it "can access comments for a URL" do
-    result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/472"])
-    expect(result["http://developers.facebook.com/blog/post/472"]).to be_truthy
-  end
-
-  it "can access comments for 2 URLs" do
-    result = @api.get_comments_for_urls(["http://developers.facebook.com/blog/post/490", "http://developers.facebook.com/blog/post/472"])
-    expect(result["http://developers.facebook.com/blog/post/490"] && result["http://developers.facebook.com/blog/post/472"]).to be_truthy
-  end
-
-  # SEARCH
-  it "can search" do
-    result = @api.search("facebook")
-    expect(result.length).to be_an(Integer)
-  end
-
   # PAGING THROUGH COLLECTIONS
   # see also graph_collection_tests
   it "makes a request for a page when provided a specific set of page params" do
@@ -151,74 +58,44 @@ shared_examples_for "Koala GraphAPI" do
     expect(@api).to receive(:graph_call).with(*query)
     @api.get_page(query)
   end
+end
 
-  # Beta tier
-  it "can use the beta tier" do
-    result = @api.get_object(KoalaTest.user1, {}, :beta => true)
-    # the results should have an ID and a name, among other things
-    expect(result["id"] && result["name"]).to be_truthy
-  end
-
-  # FQL
-  describe "#fql_query" do
-    it "makes a request to /fql" do
-      expect(@api).to receive(:get_object).with("fql", anything, anything)
-      @api.fql_query double('query string')
-    end
 
-    it "passes a query argument" do
-      query = double('query string')
-      expect(@api).to receive(:get_object).with(anything, hash_including(:q => query), anything)
-      @api.fql_query(query)
-    end
+shared_examples_for "Koala GraphAPI with an access token" do
+  let(:dummy_response) { double("fake response", data: {}, status: 200, body: "", headers: {}) }
 
-    it "passes on any other arguments provided" do
-      args = {:a => 2}
-      expect(@api).to receive(:get_object).with(anything, hash_including(args), anything)
-      @api.fql_query("a query", args)
-    end
+  it "gets public data about a user" do
+    result = @api.get_object(KoalaTest.user1)
+    # the results should have an ID and a name, among other things
+    expect(result["id"] && result["name"]).not_to be_nil
   end
 
-  describe "#fql_multiquery" do
-    it "makes a request to /fql" do
-      expect(@api).to receive(:get_object).with("fql", anything, anything)
-      @api.fql_multiquery 'query string'
-    end
-
-    it "passes a queries argument" do
-      queries = double('query string')
-      queries_json = "some JSON"
-      allow(MultiJson).to receive(:dump).with(queries).and_return(queries_json)
-
-      expect(@api).to receive(:get_object).with(anything, hash_including(:q => queries_json), anything)
-      @api.fql_multiquery(queries)
+  it "gets public data about a Page" do
+    begin
+      Koala::Utils.level = 0
+      result = @api.get_object(KoalaTest.page)
+      # the results should have an ID and a name, among other things
+      expect(result["id"] && result["name"]).to be_truthy
+    ensure
+      Koala::Utils.level = Logger::ERROR
     end
+  end
 
-    it "simplifies the response format" do
-      raw_results = [
-        {"name" => "query1", "fql_result_set" => [1, 2, 3]},
-        {"name" => "query2", "fql_result_set" => [:a, :b, :c]}
-      ]
-      expected_results = {
-        "query1" => [1, 2, 3],
-        "query2" => [:a, :b, :c]
-      }
-
-      allow(@api).to receive(:get_object).and_return(raw_results)
-      results = @api.fql_multiquery({:query => true})
-      expect(results).to eq(expected_results)
-    end
+  it "returns [] from get_objects if passed an empty array" do
+    results = @api.get_objects([])
+    expect(results).to eq([])
+  end
 
-    it "passes on any other arguments provided" do
-      args = {:a => 2}
-      expect(@api).to receive(:get_object).with(anything, hash_including(args), anything)
-      @api.fql_multiquery("a query", args)
-    end
+  it "gets multiple objects" do
+    results = @api.get_objects([KoalaTest.page, KoalaTest.user1])
+    expect(results.size).to eq(2)
   end
-end
 
+  it "gets multiple objects if they're a string" do
+    results = @api.get_objects("facebook,#{KoalaTest.user1}")
+    expect(results.size).to eq(2)
+  end
 
-shared_examples_for "Koala GraphAPI with an access token" do
   it "gets private data about a user" do
     result = @api.get_object(KoalaTest.user1)
     # updated_time should be a pretty fixed test case
@@ -231,14 +108,38 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   it "gets multiple objects" do
-    result = @api.get_objects([KoalaTest.page, KoalaTest.user1])
-    expect(result.length).to eq(2)
+    begin
+      Koala::Utils.level = 0
+      result = @api.get_objects([KoalaTest.page, KoalaTest.user1])
+      expect(result.length).to eq(2)
+    ensure
+      Koala::Utils.level = Logger::ERROR
+    end
+  end
+
+  it "can access connections from public Pages" do
+    result = @api.get_connections(KoalaTest.page, "events")
+    expect(result).to be_a(Array)
+  end
+
+  describe "#get_object_metadata" do
+    it "can access an object's metadata" do
+      result = @api.get_object_metadata(KoalaTest.user1)
+      expect(result["type"]).to eq("user")
+    end
   end
+
   it "can access connections from users" do
-    result = @api.get_connections(KoalaTest.user2, "friends")
+    result = @api.get_connections(KoalaTest.user2, "likes")
     expect(result.length).to be > 0
   end
 
+  # SEARCH
+  it "can search" do
+    result = @api.search("facebook", type: "page")
+    expect(result.length).to be_an(Integer)
+  end
+
   # PUT
   it "can write an object to the graph" do
     result = @api.put_wall_post("Hello, world, from the test suite!")
@@ -251,7 +152,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
     result = @api.put_wall_post("Hello, world, from the test suite delete method!")
     object_id_to_delete = result["id"]
     delete_result = @api.delete_object(object_id_to_delete)
-    expect(delete_result).to eq(true)
+    expect(delete_result).to eq("success" => true)
   end
 
   it "can delete likes" do
@@ -259,7 +160,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
     @temporary_object_id = result["id"]
     @api.put_like(@temporary_object_id)
     delete_like_result = @api.delete_like(@temporary_object_id)
-    expect(delete_like_result).to eq(true)
+    expect(delete_like_result).to eq("success" => true)
   end
 
   # additional put tests
@@ -274,7 +175,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   it "can post a message with an attachment to a feed" do
-    result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"})
+    result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "OAuth Playground", :link => "http://testdomain.koalatest.test/"})
     @temporary_object_id = result["id"]
     expect(@temporary_object_id).not_to be_nil
   end
@@ -302,52 +203,53 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   describe "#put_picture" do
-    it "can post photos to the user's wall with an open file object" do
-      content_type = "image/jpg"
-      file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
-
-      result = @api.put_picture(file, content_type)
-      @temporary_object_id = result["id"]
-      expect(@temporary_object_id).not_to be_nil
-    end
+    context "with a file object" do
+      let(:content_type) { "image/jpg" }
+      let(:file) { File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")) }
+      let(:file_path) { File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg") }
 
-    it "can post photos to the user's wall without an open file object" do
-      content_type = "image/jpg",
-      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
+      it "can post photos to the user's wall with an open file object" do
+        result = @api.put_picture(file, content_type)
+        @temporary_object_id = result["id"]
+        expect(@temporary_object_id).not_to be_nil
+      end
 
-      result = @api.put_picture(file_path, content_type)
-      @temporary_object_id = result["id"]
-      expect(@temporary_object_id).not_to be_nil
-    end
+      it "can post photos to the user's wall without an open file object" do
+        result = @api.put_picture(file_path, content_type)
+        @temporary_object_id = result["id"]
+        expect(@temporary_object_id).not_to be_nil
+      end
 
-    it "can verify a photo posted to a user's wall" do
-      content_type = "image/jpg",
-      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
+      it "can verify a photo posted to a user's wall" do
+        expected_message = "This is the test message"
 
-      expected_message = "This is the test message"
+        result = @api.put_picture(file_path, content_type, :message => expected_message)
+        @temporary_object_id = result["id"]
+        expect(@temporary_object_id).not_to be_nil
 
-      result = @api.put_picture(file_path, content_type, :message => expected_message)
-      @temporary_object_id = result["id"]
-      expect(@temporary_object_id).not_to be_nil
+        get_result = @api.get_object(@temporary_object_id)
+        expect(get_result["name"]).to eq(expected_message)
+      end
 
-      get_result = @api.get_object(@temporary_object_id)
-      expect(get_result["name"]).to eq(expected_message)
+      it "passes options and block through" do
+        opts = {a: 2}
+        block = Proc.new {}
+        expect(@api).to receive(:graph_call).with(anything, anything, anything, hash_including(opts), &block)
+        @api.put_picture(file_path, content_type, {:message => "my message"}, "target", opts, &block)
+      end
     end
 
-
     describe "using a URL instead of a file" do
-      before :each do
-        @url = "http://img.slate.com/images/redesign2008/slate_logo.gif"
-      end
+      let(:url) { "http://img.slate.com/images/redesign2008/slate_logo.gif" }
 
       it "can post photo to the user's wall using a URL" do
-        result = @api.put_picture(@url)
+        result = @api.put_picture(url)
         @temporary_object_id = result["id"]
         expect(@temporary_object_id).not_to be_nil
       end
 
-      it "can post photo to the user's wall using a URL and an additional param" do
-        result = @api.put_picture(@url, :message => "my message")
+      it "can post photo to the user's wall using aurl and an additional param" do
+        result = @api.put_picture(url, :message => "my message")
         @temporary_object_id = result["id"]
         expect(@temporary_object_id).not_to be_nil
       end
@@ -355,29 +257,35 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   describe "#put_video" do
-    before :each do
-      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")
-      @content_type = "video/mpeg4"
-    end
+    let(:cat_movie) { File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v") }
+    let(:content_type) { "video/mpeg4" }
 
     it "sets options[:video] to true" do
       source = double("UploadIO")
-      allow(Koala::UploadableIO).to receive(:new).and_return(source)
+      allow(Koala::HTTPService::UploadableIO).to receive(:new).and_return(source)
       allow(source).to receive(:requires_base_http_service).and_return(false)
       expect(Koala).to receive(:make_request).with(anything, anything, anything, hash_including(:video => true)).and_return(Koala::HTTPService::Response.new(200, "[]", {}))
       @api.put_video("foo")
     end
 
+    it "passes options and block through" do
+      opts = {a: 2}
+      block = Proc.new {}
+      expect(@api).to receive(:graph_call).with(anything, anything, anything, hash_including(opts), &block)
+      file = File.open(cat_movie)
+      @api.put_video(file, content_type, {}, "target", opts, &block)
+    end
+
     it "can post videos to the user's wall with an open file object" do
-      file = File.open(@cat_movie)
+      file = File.open(cat_movie)
 
-      result = @api.put_video(file, @content_type)
+      result = @api.put_video(file, content_type)
       @temporary_object_id = result["id"]
       expect(@temporary_object_id).not_to be_nil
     end
 
     it "can post videos to the user's wall without an open file object" do
-      result = @api.put_video(@cat_movie, @content_type)
+      result = @api.put_video(cat_movie, content_type)
       @temporary_object_id = result["id"]
       expect(@temporary_object_id).not_to be_nil
     end
@@ -385,21 +293,17 @@ shared_examples_for "Koala GraphAPI with an access token" do
     # note: Facebook doesn't post videos immediately to the wall, due to processing time
     # during which get_object(video_id) will return false
     # hence we can't do the same verify test we do for photos
+    describe "using aurl instead of a file" do
+      let(:url) { "http://techslides.com/demos/sample-videos/small.mp4" }
 
-
-    describe "using a URL instead of a file" do
-      before :each do
-        @url = "http://techslides.com/demos/sample-videos/small.mp4"
-      end
-
-      it "can post photo to the user's wall using a URL" do
-        result = @api.put_video(@url)
+      it "can post photo to the user's wall using aurl" do
+        result = @api.put_video(url)
         @temporary_object_id = result["id"]
         expect(@temporary_object_id).not_to be_nil
       end
 
-      it "can post photo to the user's wall using a URL and an additional param" do
-        result = @api.put_video(@url, :description => "my message")
+      it "can post photo to the user's wall using aurl and an additional param" do
+        result = @api.put_video(url, :description => "my message")
         @temporary_object_id = result["id"]
         expect(@temporary_object_id).not_to be_nil
       end
@@ -407,14 +311,14 @@ shared_examples_for "Koala GraphAPI with an access token" do
   end
 
   it "can verify a message with an attachment posted to a feed" do
-    attachment = {"name" => "OAuth Playground", "link" => "http://oauth.twoalex.com/"}
+    attachment = {"name" => "OAuth Playground", "link" => "http://testdomain.koalatest.test/"}
     result = @api.put_wall_post("Hello, world, from the test suite again!", attachment)
     @temporary_object_id = result["id"]
     get_result = @api.get_object(@temporary_object_id)
 
     # make sure the result we fetch includes all the parameters we sent
     it_matches = attachment.inject(true) {|valid, param| valid && (get_result[param[0]] == attachment[param[0]])}
-    expect(it_matches).to eq(true)
+    expect(it_matches).to be true
   end
 
   it "can comment on an object" do
@@ -443,7 +347,8 @@ shared_examples_for "Koala GraphAPI with an access token" do
   it "can like an object" do
     result = @api.put_wall_post("Hello, world, from the test suite, testing liking!")
     @temporary_object_id = result["id"]
-    like_result = @api.put_like(@temporary_object_id)
+    app_api = Koala::Facebook::API.new(@app_access_token)
+    like_result = app_api.put_like(@temporary_object_id)
     expect(like_result).to be_truthy
   end
 
@@ -451,14 +356,14 @@ shared_examples_for "Koala GraphAPI with an access token" do
   describe "#get_page_access_token" do
     it "gets the page object with the access_token field" do
       # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
-      expect(@api).to receive(:api).with("my_page", hash_including({:fields => "access_token"}), "get", anything)
+      expect(@api).to receive(:api).with("my_page", hash_including({:fields => "access_token"}), "get", anything).and_return(dummy_response)
       @api.get_page_access_token("my_page")
     end
 
     it "merges in any other arguments" do
       # we can't test this live since test users (or random real users) can't be guaranteed to have pages to manage
       args = {:a => 3}
-      expect(@api).to receive(:api).with("my_page", hash_including(args), "get", anything)
+      expect(@api).to receive(:api).with("my_page", hash_including(args), "get", anything).and_return(dummy_response)
       @api.get_page_access_token("my_page", args)
     end
   end
@@ -485,7 +390,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
     end
 
     it "JSON-encodes the restrictions" do
-      expect(@app_api).to receive(:graph_call).with(anything, hash_including(:restrictions => MultiJson.dump(@restrictions)), anything, anything)
+      expect(@app_api).to receive(:graph_call).with(anything, hash_including(:restrictions => JSON.dump(@restrictions)), anything, anything)
       @app_api.set_app_restrictions(KoalaTest.app_id, @restrictions)
     end
 
@@ -500,87 +405,26 @@ shared_examples_for "Koala GraphAPI with an access token" do
     end
   end
 
-  it "can access public information via FQL" do
-    result = @api.fql_query("select uid, first_name from user where uid = #{KoalaTest.user2_id}")
-    expect(result.size).to eq(1)
-    expect(result.first['first_name']).to eq(KoalaTest.user2_name)
-    expect(result.first['uid']).to eq(KoalaTest.user2_id.to_i)
-  end
-
-  it "can access public information via FQL.multiquery" do
-    result = @api.fql_multiquery(
-      :query1 => "select uid, first_name from user where uid = #{KoalaTest.user2_id}",
-      :query2 => "select uid, first_name from user where uid = #{KoalaTest.user1_id}"
-    )
-    expect(result.size).to eq(2)
-    # this should check for first_name, but there's an FB bug currently
-    expect(result["query1"].first['uid']).to eq(KoalaTest.user2_id.to_i)
-    # result["query1"].first['first_name'].should == KoalaTest.user2_name
-    expect(result["query2"].first['first_name']).to eq(KoalaTest.user1_name)
-  end
-
-  it "can access protected information via FQL" do
-    # Tests agains the permissions fql table
-
-    # get the current user's ID
-    # we're sneakily using the Graph API, which should be okay since it has its own tests
-    g = Koala::Facebook::API.new(@token)
-    id = g.get_object("me", :fields => "id")["id"]
-
-    # now send a query about your permissions
-    result = @api.fql_query("select read_stream from permissions where uid = #{id}")
-
-    expect(result.size).to eq(1)
-    # we've verified that you have read_stream permissions, so we can test against that
-    expect(result.first["read_stream"]).to eq(1)
-  end
-
-  it "can access protected information via FQL.multiquery" do
-    result = @api.fql_multiquery(
-      :query1 => "select post_id from stream where source_id = me()",
-      :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
-      :query3 => "select uid, name from user where uid in (select fromid from #query2)"
-    )
-    expect(result.size).to eq(3)
-    expect(result.keys).to include("query1", "query2", "query3")
-  end
-
   # test all methods to make sure they pass data through to the API
   # we run the tests here (rather than in the common shared example group)
   # since some require access tokens
   describe "HTTP options" do
-    # Each of the below methods should take an options hash as their last argument
-    # ideally we'd use introspection to determine how many arguments a method has
-    # but some methods require specially formatted arguments for processing
-    # (and anyway, Ruby 1.8's arity method fails (for this) for methods w/ 2+ optional arguments)
-    # (Ruby 1.9's parameters method is perfect, but only in 1.9)
-    # so we have to double-document
-    {
-      :get_object => 3, :put_object => 4, :delete_object => 2,
-      :get_connections => 4, :put_connections => 4, :delete_connections => 4,
-      :put_wall_post => 4,
-      :put_comment => 3,
-      :put_like => 2, :delete_like => 2,
-      :search => 3,
-      :set_app_restrictions => 4,
-      :get_page_access_token => 3,
-      :fql_query => 3, :fql_multiquery => 3,
-      # methods that have special arguments
-      :get_comments_for_urls => [["url1", "url2"], {}],
-      :put_picture => ["x.jpg", "image/jpg", {}, "me"],
-      :put_video => ["x.mp4", "video/mpeg4", {}, "me"],
-      :get_objects => [["x"], {}]
-    }.each_pair do |method_name, params|
+    # Each of the below methods should take an options hash as their last argument.
+    [
+      :get_object,
+      :get_connections,
+      :put_wall_post,
+      :put_comment,
+      :put_like,
+      :search,
+      :set_app_restrictions,
+      :get_page_access_token,
+      :get_objects
+    ].each do |method_name|
       it "passes http options through for #{method_name}" do
-        options = {:a => 2}
-        # graph call should ultimately receive options as the fourth argument
-        expect(@api).to receive(:graph_call).with(anything, anything, anything, options)
-
-        # if we supply args, use them (since some methods process params)
-        # the method should receive as args n-1 anythings and then options
-        args = (params.is_a?(Integer) ? ([{}] * (params - 1)) : params) + [options]
-
-        @api.send(method_name, *args)
+        params = @api.method(method_name).parameters
+        expect(params.last).to eq([:block, :block])
+        expect(params[-2]).to eq([:opt, :options])
       end
     end
 
@@ -592,16 +436,26 @@ shared_examples_for "Koala GraphAPI with an access token" do
       @api.send(:get_picture, "x", {}, options)
     end
   end
+
+  # Beta tier
+  # In theory this is usable by both but so few operations now allow access without a token
+  it "can use the beta tier" do
+    result = @api.get_object(KoalaTest.user1, {}, :beta => true)
+    # the results should have an ID and a name, among other things
+    expect(result["id"] && result["name"]).to be_truthy
+  end
 end
 
 
 # GraphCollection
 shared_examples_for "Koala GraphAPI with GraphCollection" do
+  let(:dummy_response) { double("fake response", data: {}, status: 200, body: "", headers: {}) }
+
   describe "when getting a collection" do
     # GraphCollection methods
     it "gets a GraphCollection when getting connections" do
-      @result = @api.get_connections(KoalaTest.page, "photos")
-      expect(@result).to be_a(Koala::Facebook::GraphCollection)
+      @result = @api.get_connections(KoalaTest.page, "events")
+      expect(@result).to be_a(Koala::Facebook::API::GraphCollection)
     end
 
     it "returns nil if the get_collections call fails with nil" do
@@ -611,43 +465,37 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
     end
 
     it "gets a GraphCollection when searching" do
-      result = @api.search("facebook")
-      expect(result).to be_a(Koala::Facebook::GraphCollection)
+      result = @api.search("facebook", type: "page")
+      expect(result).to be_a(Koala::Facebook::API::GraphCollection)
     end
 
     it "returns nil if the search call fails with nil" do
       # this happens sometimes
       expect(@api).to receive(:graph_call).and_return(nil)
-      expect(@api.search("facebook")).to be_nil
+      expect(@api.search("facebook", type: "page")).to be_nil
     end
 
     it "gets a GraphCollection when paging through results" do
-      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}])
-      expect(@results).to be_a(Koala::Facebook::GraphCollection)
+      @results = @api.get_page(["search", {"q"=>"facebook", "type" => "page", "limit"=>"25", "until"=> KoalaTest.search_time}])
+      expect(@results).to be_a(Koala::Facebook::API::GraphCollection)
     end
 
     it "returns nil if the page call fails with nil" do
       # this happens sometimes
       expect(@api).to receive(:graph_call).and_return(nil)
-      expect(@api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=> KoalaTest.search_time}])).to be_nil
+      expect(@api.get_page(["search", {"q"=>"facebook", "type" => "page", "limit"=>"25", "until"=> KoalaTest.search_time}])).to be_nil
     end
   end
 end
 
 
 shared_examples_for "Koala GraphAPI without an access token" do
-  it "can't get private data about a user" do
-    result = @api.get_object(KoalaTest.user1)
-    # updated_time should be a pretty fixed test case
-    expect(result["updated_time"]).to be_nil
-  end
-
   it "can't get data about 'me'" do
     expect { @api.get_object("me") }.to raise_error(Koala::Facebook::ClientError)
   end
 
   it "can't access connections from users" do
-    expect { @api.get_connections(KoalaTest.user2, "friends") }.to raise_error(Koala::Facebook::ClientError)
+    expect { @api.get_connections(KoalaTest.user2, "likes") }.to raise_error(Koala::Facebook::ClientError)
   end
 
   it "can't put an object" do
@@ -660,7 +508,7 @@ shared_examples_for "Koala GraphAPI without an access token" do
   # but are here for completeness
   it "can't post to a feed" do
     expect(lambda do
-      attachment = {:name => "OAuth Playground", :link => "http://oauth.twoalex.com/"}
+      attachment = {:name => "OAuth Playground", :link => "http://testdomain.koalatest.test/"}
       @result = @api.put_wall_post("Hello, world", attachment, "facebook")
     end).to raise_error(Koala::Facebook::AuthenticationError)
   end
@@ -683,37 +531,4 @@ shared_examples_for "Koala GraphAPI without an access token" do
   it "can't delete a like" do
     expect { @api.delete_like("7204941866_119776748033392") }.to raise_error(Koala::Facebook::AuthenticationError)
   end
-
-  # FQL_QUERY
-  describe "when making a FQL request" do
-    it "can access public information via FQL" do
-      result = @api.fql_query("select uid, first_name from user where uid = #{KoalaTest.user2_id}")
-      expect(result.size).to eq(1)
-      expect(result.first['first_name']).to eq(KoalaTest.user2_name)
-    end
-
-    it "can access public information via FQL.multiquery" do
-      result = @api.fql_multiquery(
-        :query1 => "select uid, first_name from user where uid = #{KoalaTest.user2_id}",
-        :query2 => "select uid, first_name from user where uid = #{KoalaTest.user1_id}"
-      )
-      expect(result.size).to eq(2)
-      expect(result["query1"].first['first_name']).to eq(KoalaTest.user2_name)
-      expect(result["query2"].first['first_name']).to eq(KoalaTest.user1_name)
-    end
-
-    it "can't access protected information via FQL" do
-      expect { @api.fql_query("select read_stream from permissions where uid = #{KoalaTest.user2_id}") }.to raise_error(Koala::Facebook::APIError)
-    end
-
-    it "can't access protected information via FQL.multiquery" do
-      expect {
-        @api.fql_multiquery(
-          :query1 => "select post_id from stream where source_id = me()",
-          :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
-          :query3 => "select uid, name from user where uid in (select fromid from #query2)"
-        )
-      }.to raise_error(Koala::Facebook::APIError)
-    end
-  end
 end