koala 2.5.0 → 3.0.0.beta1

data/readme.md

@@ -1,6 +1,6 @@
 Koala [![Version](https://img.shields.io/gem/v/koala.svg)](https://rubygems.org/gems/koala) [![Dependencies](https://img.shields.io/gemnasium/arsduo/koala.svg)](https://gemnasium.com/arsduo/koala) [![Build Status](https://img.shields.io/travis/arsduo/koala.svg)](http://travis-ci.org/arsduo/koala) [![Code Climate](https://img.shields.io/codeclimate/github/arsduo/koala.svg)](https://codeclimate.com/github/arsduo/koala) [![Code Coverage](https://img.shields.io/codeclimate/coverage/github/arsduo/koala.svg)](https://codeclimate.com/github/arsduo/koala)
 ====
-[Koala](http://github.com/arsduo/koala) is a Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), the REST API, realtime updates, test users, and OAuth validation.  We wrote Koala with four goals:
+[Koala](http://github.com/arsduo/koala) is a Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), realtime updates, test users, and OAuth validation.  We wrote Koala with four goals:
 
 * Lightweight: Koala should be as light and simple as Facebook’s own libraries, providing API accessors and returning simple JSON.
 * Fast: Koala should, out of the box, be quick. Out of the box, we use Facebook's faster read-only servers when possible and if available, the Typhoeus gem to make snappy Facebook requests.  Of course, that brings us to our next topic:
@@ -39,7 +39,7 @@ Then, go exploring:
 
 ```ruby
 require 'koala'
- 
+
 @graph = Koala::Facebook::API.new(oauth_access_token)
 
 profile = @graph.get_object("me")
@@ -115,27 +115,6 @@ the results apart from a long list of array entries:
 
 Check out the wiki for more details and examples.
 
-The REST API
-------------
-
-Where the Graph API and the old REST API overlap, you should choose the Graph API.  Unfortunately, that overlap is far from complete, and there are many important API calls that can't yet be done via the Graph.
-
-Fortunately, Koala supports the REST API using the very same interface; to use this, instantiate an API:
-```ruby
-@rest = Koala::Facebook::API.new(oauth_access_token)
-
-@rest.fql_query(my_fql_query) # convenience method
-@rest.fql_multiquery(fql_query_hash) # convenience method
-@rest.rest_call("stream.publish", arguments_hash) # generic version
-```
-
-Of course, you can use the Graph API methods on the same object -- the power of two APIs right in the palm of your hand.
-```ruby
-@api = Koala::Facebook::API.new(oauth_access_token)
-fql = @api.fql_query(my_fql_query)
-@api.put_wall_post(process_result(fql))
-```
-
 Configuration
 -------------
 
@@ -146,7 +125,7 @@ require 'koala'
 
 Koala.configure do |config|
   config.graph_server = 'my-graph-mock.mysite.com'
-  # other common options are `rest_server` and `dialog_host`
+  # another common option: `dialog_host`
   # see lib/koala/http_service.rb
 end
 ```
@@ -157,7 +136,7 @@ tier and video upload matching and replacement strings.
 OAuth
 -----
 
-You can use the Graph and REST APIs without an OAuth access token, but the real magic happens when you provide Facebook an OAuth token to prove you're authenticated.  Koala provides an OAuth class to make that process easy:
+You can use the Graph API without an OAuth access token, but the real magic happens when you provide Facebook an OAuth token to prove you're authenticated.  Koala provides an OAuth class to make that process easy:
 ```ruby
 @oauth = Koala::Facebook::OAuth.new(app_id, app_secret, callback_url)
 ```
@@ -225,7 +204,7 @@ For more information about meet_challenge and the RealtimeUpdates class, check o
 Test Users
 ----------
 
-We also support the test users API, allowing you to conjure up fake users and command them to do your bidding using the Graph or REST API:
+We also support the test users API, allowing you to conjure up fake users and command them to do your bidding using the Graph API:
 ```ruby
 @test_users = Koala::Facebook::TestUsers.new(app_id: id, secret: secret)
 user = @test_users.create(is_app_installed, desired_permissions)

data/spec/cases/api_spec.rb

@@ -128,7 +128,7 @@ describe "Koala::Facebook::API" do
     allow(Koala).to receive(:make_request).and_return(response)
 
     json_body = double('JSON body')
-    allow(JSON).to receive(:load).and_return([json_body])
+    allow(JSON).to receive(:parse).and_return([json_body])
 
     expect(@service.api('anything')).to eq(json_body)
   end
@@ -181,9 +181,6 @@ describe "Koala::Facebook::API" do
       @api = Koala::Facebook::API.new(@token)
     end
 
-    it_should_behave_like "Koala RestAPI"
-    it_should_behave_like "Koala RestAPI with an access token"
-
     it_should_behave_like "Koala GraphAPI"
     it_should_behave_like "Koala GraphAPI with an access token"
     it_should_behave_like "Koala GraphAPI with GraphCollection"
@@ -194,9 +191,6 @@ describe "Koala::Facebook::API" do
       @api = Koala::Facebook::API.new
     end
 
-    it_should_behave_like "Koala RestAPI"
-    it_should_behave_like "Koala RestAPI without an access token"
-
     it_should_behave_like "Koala GraphAPI"
     it_should_behave_like "Koala GraphAPI without an access token"
     it_should_behave_like "Koala GraphAPI with GraphCollection"

data/spec/cases/graph_api_batch_spec.rb

@@ -58,11 +58,11 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
           @batch_queue = []
           allow(Koala::Facebook::API).to receive(:batch_calls).and_return(@batch_queue)
 
-          allow(Koala::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
-          allow(Koala::UploadableIO).to receive(:binary_content?).and_return(false)
-          allow(Koala::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
-          allow(Koala::UploadableIO).to receive(:binary_content?).with(@uploadable_io).and_return(true)
-          allow(@uploadable_io).to receive(:is_a?).with(Koala::UploadableIO).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).and_return(false)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).with(@uploadable_io).and_return(true)
+          allow(@uploadable_io).to receive(:is_a?).with(Koala::HTTPService::UploadableIO).and_return(true)
 
           @args[:method] = "post" # files are always post
         end
@@ -243,11 +243,11 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       describe "with binary files" do
         before :each do
           @binary = double("Binary file")
-          allow(Koala::UploadableIO).to receive(:binary_content?).and_return(false)
-          allow(Koala::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).and_return(false)
+          allow(Koala::HTTPService::UploadableIO).to receive(:binary_content?).with(@binary).and_return(true)
           @uploadable_io = double("UploadableIO")
-          allow(Koala::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
-          allow(@uploadable_io).to receive(:is_a?).with(Koala::UploadableIO).and_return(true)
+          allow(Koala::HTTPService::UploadableIO).to receive(:new).with(@binary).and_return(@uploadable_io)
+          allow(@uploadable_io).to receive(:is_a?).with(Koala::HTTPService::UploadableIO).and_return(true)
 
           @batch_queue = []
           allow(Koala::Facebook::API).to receive(:batch_calls).and_return(@batch_queue)
@@ -486,7 +486,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         batch_api.get_object('me')
         batch_api.get_connections('me', 'friends')
       end
-      expect(friends).to be_a(Koala::Facebook::GraphCollection)
+      expect(friends).to be_a(Koala::Facebook::API::GraphCollection)
     end
 
     it 'turns pageable results into GraphCollections' do
@@ -519,7 +519,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         batch_api.get_connections(@app_id, 'insights', {}, {"access_token" => @app_api.access_token})
       end
       expect(me['id']).not_to be_nil
-      expect(insights).to be_an(Koala::Facebook::GraphCollection)
+      expect(insights).to be_an(Koala::Facebook::API::GraphCollection)
     end
 
     it "handles requests passing the access token option as a symbol instead of a string" do
@@ -528,7 +528,7 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
         batch_api.get_connections(@app_id, 'insights', {}, {:access_token => @app_api.access_token})
       end
       expect(me['id']).not_to be_nil
-      expect(insights).to be_an(Koala::Facebook::GraphCollection)
+      expect(insights).to be_an(Koala::Facebook::API::GraphCollection)
     end
 
     it "preserves batch-op specific access tokens in GraphCollection returned from batch" do
@@ -577,16 +577,6 @@ describe "Koala::Facebook::GraphAPI in batch mode" do
       end
     end
 
-    it "allows FQL" do
-      result = @api.batch do |batch_api|
-        batch_api.graph_call("method/fql.query", {:query=>"select first_name from user where uid=#{KoalaTest.user1_id}"}, "post")
-      end
-
-      fql_result = result[0]
-      expect(fql_result[0]).to be_a(Hash)
-      expect(fql_result[0]["first_name"]).to eq("Alex")
-    end
-
     describe 'with post-processing callback' do
       let(:me_result) { double("me result") }
       let(:friends_result) { [double("friends result")] }

data/spec/cases/graph_api_spec.rb

@@ -35,25 +35,6 @@ describe 'Koala::Facebook::GraphAPIMethods' do
       end
     end
 
-    context '#fql_multiquery' do
-      before do
-        expect(@api).to receive(:get_object).and_return([
-          {"name" => "query1", "fql_result_set" => [{"id" => 123}]},
-          {"name" => "query2", "fql_result_set" => ["id" => 456]}
-        ])
-      end
-
-      it 'is called with resolved response' do
-        resolved_result = {
-          'query1' => [{'id' => 123}],
-          'query2' => [{'id' => 456}]
-        }
-        response = @api.fql_multiquery({}, &post_processing)
-        expect(response["args"]).to eq(resolved_result)
-        expect(response["result"]).to eq(result)
-      end
-    end
-
     context '#get_page_access_token' do
       it 'returns result of block' do
         token = Koala::MockHTTPService::APP_ACCESS_TOKEN

data/spec/cases/graph_collection_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Koala::Facebook::GraphCollection do
+describe Koala::Facebook::API::GraphCollection do
   let(:paging){ {:paging => true} }
 
   before(:each) do
@@ -10,15 +10,15 @@ describe Koala::Facebook::GraphCollection do
       "summary" => [3]
     }
     @api = Koala::Facebook::API.new("123")
-    @collection = Koala::Facebook::GraphCollection.new(@result, @api)
+    @collection = Koala::Facebook::API::GraphCollection.new(@result, @api)
   end
 
   it "subclasses Array" do
-    expect(Koala::Facebook::GraphCollection.ancestors).to include(Array)
+    expect(Koala::Facebook::API::GraphCollection.ancestors).to include(Array)
   end
 
   it "creates an array-like object" do
-    expect(Koala::Facebook::GraphCollection.new(@result, @api)).to be_an(Array)
+    expect(Koala::Facebook::API::GraphCollection.new(@result, @api)).to be_an(Array)
   end
 
   it "contains the result data" do
@@ -60,14 +60,14 @@ describe Koala::Facebook::GraphCollection do
     it "should return the previous page of results" do
       expect(@collection).to receive(:previous_page_params).and_return([@base, @args])
       expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
       expect(@collection.previous_page).to eq(@page_of_results)
     end
 
     it "should return the next page of results" do
       expect(@collection).to receive(:next_page_params).and_return([@base, @args])
       expect(@api).to receive(:api).with(@base, @args, anything, anything).and_return(@second_page)
-      expect(Koala::Facebook::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(@second_page, @api).and_return(@page_of_results)
 
       expect(@collection.next_page).to eq(@page_of_results)
     end
@@ -84,13 +84,13 @@ describe Koala::Facebook::GraphCollection do
     describe "#parse_page_url" do
       it "should pass the url to the class method" do
         url = double("url")
-        expect(Koala::Facebook::GraphCollection).to receive(:parse_page_url).with(url)
+        expect(Koala::Facebook::API::GraphCollection).to receive(:parse_page_url).with(url)
         @collection.parse_page_url(url)
       end
 
       it "should return the result of the class method" do
         parsed_content = double("parsed_content")
-        allow(Koala::Facebook::GraphCollection).to receive(:parse_page_url).and_return(parsed_content)
+        allow(Koala::Facebook::API::GraphCollection).to receive(:parse_page_url).and_return(parsed_content)
         expect(@collection.parse_page_url(double("url"))).to eq(parsed_content)
       end
     end
@@ -98,23 +98,23 @@ describe Koala::Facebook::GraphCollection do
     describe ".parse_page_url" do
       it "should return the base as the first array entry" do
         base = "url_path"
-        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first).to eq(base)
+        expect(Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/#{base}?anything").first).to eq(base)
       end
 
       it "should return the arguments as a hash as the last array entry" do
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last).to eq(args_hash)
+        expect(Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last).to eq(args_hash)
       end
 
       it "works with non-.com addresses" do
         base = "url_path"
         args_hash = {"one" => "val_one", "two" => "val_two"}
-        expect(Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}")).to eq([base, args_hash])
+        expect(Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/#{base}?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}")).to eq([base, args_hash])
       end
 
       it "works with addresses with irregular characters" do
         access_token = "appid123a|fdcba"
-        base, args_hash = Koala::Facebook::GraphCollection.parse_page_url("http://facebook.com/foo?token=#{access_token}")
+        base, args_hash = Koala::Facebook::API::GraphCollection.parse_page_url("http://facebook.com/foo?token=#{access_token}")
         expect(args_hash["token"]).to eq(access_token)
       end
     end
@@ -123,29 +123,29 @@ describe Koala::Facebook::GraphCollection do
   describe ".evaluate" do
     it "returns the original result if it's provided a non-hash result" do
       result = []
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if it's provided a nil result" do
       result = nil
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if the result doesn't have a data key" do
       result = {"paging" => {}}
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns the original result if the result's data key isn't an array" do
       result = {"data" => {}, "paging" => {}}
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(result)
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(result)
     end
 
     it "returns a new GraphCollection of the result if it has an array data key and a paging key" do
       result = {"data" => [], "paging" => {}}
       expected = :foo
-      expect(Koala::Facebook::GraphCollection).to receive(:new).with(result, @api).and_return(expected)
-      expect(Koala::Facebook::GraphCollection.evaluate(result, @api)).to eq(expected)
+      expect(Koala::Facebook::API::GraphCollection).to receive(:new).with(result, @api).and_return(expected)
+      expect(Koala::Facebook::API::GraphCollection.evaluate(result, @api)).to eq(expected)
     end
   end
 

data/spec/cases/graph_error_checker_spec.rb

@@ -54,6 +54,12 @@ module Koala
             expect(error.response_body).to eq(body)
           end
 
+          it "returns a ClientError if the body is empty" do
+            body.replace("")
+            expect(error).to be_a(ClientError)
+            expect(error.response_body).to eq(body)
+          end
+
           it "adds error data from the body" do
             error_data = {
               "type" => "FB error type",
@@ -113,4 +119,3 @@ module Koala
     end
   end
 end
-

data/spec/cases/http_service/request_spec.rb

@@ -0,0 +1,240 @@
+require "spec_helper"
+
+module Koala
+  module HTTPService
+    RSpec.describe Request do
+      let(:path) { "/foo" }
+      let(:args) { {"a" => 2, "b" => 3, "access_token" => "a_token"} }
+      let(:verb) { "get" }
+      let(:options) { {an: :option} }
+      let(:request) { Request.new(path: path, args: args, verb: verb, options: options) }
+
+      shared_context post: true do
+        let(:verb) { "post" }
+      end
+
+      shared_context delete: true do
+        let(:verb) { "delete" }
+      end
+
+      shared_context put: true do
+        let(:verb) { "put" }
+      end
+
+      it "raises an ArgumentError if no verb is supplied" do
+        expect { Request.new(path: path) }.to raise_exception(ArgumentError)
+      end
+
+      it "raises an ArgumentError if no path is supplied" do
+        expect { Request.new(verb: verb) }.to raise_exception(ArgumentError)
+      end
+
+      describe "#verb" do
+        it "returns get for get" do
+          expect(Request.new(path: path, verb: "get").verb).to eq("get")
+        end
+
+        it "returns post for post" do
+          expect(Request.new(path: path, verb: "post").verb).to eq("post")
+        end
+
+        it "returns post for put" do
+          expect(Request.new(path: path, verb: "put").verb).to eq("post")
+        end
+
+        it "returns post for delete" do
+          expect(Request.new(path: path, verb: "delete").verb).to eq("post")
+        end
+      end
+
+      describe "#path" do
+        context "if there's no API version" do
+          it "returns the path" do
+            expect(request.path).to eq(path)
+          end
+        end
+
+        context "if there's an API version" do
+          shared_examples_for :including_the_version do
+            it "prefixes the version appropriately when the path starts with /" do
+              expect(Request.new(path: "/foo", verb: "get", options: options).path).to eq("/#{version}/foo")
+            end
+
+            it "prefixes the version appropriately when the path doesn't start with /" do
+              expect(Request.new(path: "foo", verb: "get", options: options).path).to eq("/#{version}/foo")
+            end
+          end
+
+          context "set by Koala.config" do
+            let(:version) { "v2.1" }
+
+            before :each do
+              allow(Koala.config).to receive(:api_version).and_return(version)
+            end
+
+            it_should_behave_like :including_the_version
+          end
+
+          context "set in options" do
+            let(:version) { "v2.1" }
+
+            let(:options) { {api_version: version} }
+
+            it_should_behave_like :including_the_version
+          end
+
+          context "for versions without a ." do
+            let(:version) { "v21" }
+
+            let(:options) { {api_version: version} }
+
+            it_should_behave_like :including_the_version
+          end
+        end
+      end
+
+      describe "#post_args" do
+        it "returns {} for get" do
+          expect(request.post_args).to eq({})
+        end
+
+        it "returns args for post", :post do
+          expect(request.post_args).to eq(args)
+        end
+
+        it "returns args + method: delete for delete", :delete do
+          expect(request.post_args).to eq(args.merge(method: "delete"))
+        end
+
+        it "returns args + method: put for put", :put do
+          expect(request.post_args).to eq(args.merge(method: "put"))
+        end
+
+        it "turns any UploadableIOs to UploadIOs" do
+          # technically this is done for all requests, but you don't send GET requests with files
+          upload_io = double("UploadIO")
+          u = Koala::HTTPService::UploadableIO.new("/path/to/stuff", "img/jpg")
+          allow(u).to receive(:to_upload_io).and_return(upload_io)
+          request = Request.new(path: path, verb: "post", args: {an_upload: u})
+          expect(request.post_args[:an_upload]).to eq(upload_io)
+        end
+      end
+
+      describe "#json?" do
+        it "returns false if the option for JSON isn't set" do
+          expect(request).not_to be_json
+        end
+
+        context "if JSON is set" do
+          let(:options) { {format: :json} }
+
+          it "returns true if it is" do
+            expect(request).to be_json
+          end
+        end
+      end
+
+      describe "#options" do
+        it "returns the options provided" do
+          expect(request.options).to include(options)
+        end
+
+        it "merges in any global options" do
+          global_options = {some: :opts}
+          HTTPService.http_options = global_options
+          results = request.options
+          HTTPService.http_options = {}
+          expect(results).to include(global_options)
+        end
+
+        it "overwrites any global options with equivalent ones" do
+          options = {foo: :bar}
+          HTTPService.http_options = {foo: 2}
+          results = Request.new(path: path, args: args, verb: verb, options: options).options
+          HTTPService.http_options = {}
+          expect(results).to include(options)
+        end
+
+        describe "get parameters" do
+          it "includes the parameters for a get " do
+            expect(request.options[:params]).to eq(args)
+          end
+
+          it "returns {} for post", :post do
+            expect(request.options[:params]).to eq({})
+          end
+
+          it "returns {} for delete", :delete do
+            expect(request.options[:params]).to eq({})
+          end
+
+          it "returns {} for put", :put do
+            expect(request.options[:params]).to eq({})
+          end
+        end
+
+        describe "ssl options" do
+          it "does nothing if there's no access token" do
+            request_options = Request.new(path: path, args: args.delete_if {|k, _v| k == "access_token"}, verb: verb, options: options).options
+            expect(request_options).not_to include(:ssl, :use_ssl)
+          end
+
+          context "if there is an access_token" do
+            it "includes the default SSL options" do
+              expect(request.options).to include(use_ssl: true, ssl: {verify: true})
+            end
+
+            it "incorporates any provided SSL options" do
+              new_ssl_options = {an: :option2}
+              request_options = Request.new(path: path, args: args, verb: verb, options: options.merge(ssl: new_ssl_options)).options
+              expect(request_options[:ssl]).to include(new_ssl_options)
+            end
+
+            it "overrides default SSL options with what's provided" do
+              new_ssl_options = {verify: :dunno}
+              request_options = Request.new(path: path, args: args, verb: verb, options: options.merge(ssl: new_ssl_options)).options
+              expect(request_options[:ssl]).to include(new_ssl_options)
+            end
+          end
+        end
+
+        describe "server" do
+          describe "with no options" do
+            it "returns the graph server by default" do
+              expect(request.server).to eq("https://graph.facebook.com")
+            end
+
+            it "uses another base server if specified" do
+              Koala.config.graph_server = "foo"
+              expect(request.server).to eq("https://foo")
+            end
+
+            context "if options[:use_ssl] is false (e.g. no access token)" do
+              let(:args) { {"a" => "b"} }
+
+              it "uses http" do
+                expect(request.server).to eq("http://graph.facebook.com")
+              end
+            end
+
+            context "if options[:beta]" do
+              let(:options) { {beta: true} }
+
+              it "returns https if options[:beta]" do
+                expect(request.server).to eq("https://graph.beta.facebook.com")
+              end
+            end
+
+            context "if options[:video]" do
+              let(:options) { {video: true} }
+
+              it "returns https if options[:video]" do
+                expect(request.server).to eq("https://graph-video.facebook.com")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end