koala 1.0.0.beta → 1.1.0

data/spec/support/mock_http_service.rb

@@ -0,0 +1,96 @@
+require 'erb'
+require 'yaml'
+
+module Koala
+  module MockHTTPService
+    include Koala::HTTPService
+
+    # fix our specs to use ok_json, so we always get the same results from to_json
+    MultiJson.engine = :ok_json
+
+    # Mocks all HTTP requests for with koala_spec_with_mocks.rb
+    # Mocked values to be included in TEST_DATA used in specs
+    ACCESS_TOKEN = '*'
+    APP_ACCESS_TOKEN = "**"
+    OAUTH_CODE = 'OAUTHCODE'
+
+    # Loads testing data
+    TEST_DATA = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'fixtures', 'facebook_data.yml'))
+    TEST_DATA.merge!('oauth_token' => Koala::MockHTTPService::ACCESS_TOKEN)
+    TEST_DATA['oauth_test_data'].merge!('code' => Koala::MockHTTPService::OAUTH_CODE)
+
+    # Useful in mock_facebook_responses.yml
+    OAUTH_DATA = TEST_DATA['oauth_test_data']
+    OAUTH_DATA.merge!({
+      'app_access_token' => APP_ACCESS_TOKEN,
+      'session_key' => "session_key",
+      'multiple_session_keys' => ["session_key", "session_key_2"]
+    })
+    APP_ID = OAUTH_DATA['app_id']
+    SECRET = OAUTH_DATA['secret']
+    SUBSCRIPTION_DATA = TEST_DATA["subscription_test_data"]
+
+    # Loads the mock response data via ERB to substitue values for TEST_DATA (see oauth/access_token)
+    mock_response_file_path = File.join(File.dirname(__FILE__), '..', 'fixtures', 'mock_facebook_responses.yml')
+    RESPONSES = YAML.load(ERB.new(IO.read(mock_response_file_path)).result(binding))
+
+    def self.make_request(path, args, verb, options = {})
+      path = 'root' if path == '' || path == '/'
+      verb ||= 'get'
+      server = options[:rest_api] ? 'rest_api' : 'graph_api'
+      token = args.delete('access_token') 
+      with_token = (token == ACCESS_TOKEN || token == APP_ACCESS_TOKEN) ? 'with_token' : 'no_token'
+
+      # Assume format is always JSON
+      args.delete('format')
+
+      # Create a hash key for the arguments
+      args = create_params_key(args)
+
+      begin
+        response = RESPONSES[server][path][args][verb][with_token]
+
+        # Raises an error of with_token/no_token key is missing
+        raise NoMethodError unless response
+
+        # create response class object
+        response_object = if response.is_a? String
+            Koala::Response.new(200, response, {})
+          else
+            Koala::Response.new(response["code"] || 200, response["body"] || "", response["headers"] || {})
+          end
+
+      rescue NoMethodError
+        # Raises an error message with the place in the data YML
+        # to place a mock as well as a URL to request from
+        # Facebook's servers for the actual data
+        # (Don't forget to replace ACCESS_TOKEN with a real access token)
+        data_trace = [server, path, args, verb, with_token] * ': '
+
+        args = args == 'no_args' ? '' : "#{args}&"
+        args += 'format=json'
+        args += "&access_token=#{ACCESS_TOKEN}" if with_token
+
+        raise "Missing a mock response for #{data_trace}\nAPI PATH: #{[path, args].join('?')}"
+      end
+
+      response_object
+    end
+
+    def self.mock?
+      true
+    end
+
+    protected
+    def self.create_params_key(params_hash)
+      if params_hash.empty?
+        'no_args'
+      else
+        params_hash.sort{ |a,b| a[0].to_s <=> b[0].to_s}.map do |arr|
+          arr[1] = '[FILE]' if arr[1].kind_of?(Koala::UploadableIO)
+          arr.join('=')
+        end.join('&')
+      end
+    end
+  end
+end

data/spec/support/rest_api_shared_examples.rb

@@ -0,0 +1,285 @@
+shared_examples_for "Koala RestAPI" do
+  # REST_CALL
+  describe "when making a rest request" do
+    it "should use the proper path" do
+      method = stub('methodName')
+      @api.should_receive(:api).with(
+        "method/#{method}",
+        anything,
+        anything,
+        anything
+      )
+
+      @api.rest_call(method)
+    end
+
+    it "should always use the rest api" do
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        anything,
+        hash_including(:rest_api => true)
+      )
+
+      @api.rest_call('anything')
+    end
+
+    it "should set the read_only option to true if the method is listed in the read-only list" do
+      method = Koala::Facebook::RestAPI::READ_ONLY_METHODS.first
+
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        anything,
+        hash_including(:read_only => true)
+      )
+
+      @api.rest_call(method)
+    end
+
+    it "should set the read_only option to false if the method is not inthe read-only list" do
+      method = "I'm not a read-only method"
+
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        anything,
+        hash_including(:read_only => false)
+      )
+
+      @api.rest_call(method)
+    end
+
+
+    it "should take an optional hash of arguments" do
+      args = {:arg1 => 'arg1'}
+
+      @api.should_receive(:api).with(
+        anything,
+        hash_including(args),
+        anything,
+        anything
+      )
+
+      @api.rest_call('anything', args)
+    end
+
+    it "should always ask for JSON" do
+      @api.should_receive(:api).with(
+        anything,
+        hash_including('format' => 'json'),
+        anything,
+        anything
+      )
+
+      @api.rest_call('anything')
+    end
+
+    it "should pass any options provided to the API" do
+      options = {:a => 2}
+
+      @api.should_receive(:api).with(
+        anything,
+        hash_including('format' => 'json'),
+        anything,
+        hash_including(options)
+      )
+
+      @api.rest_call('anything', {}, options)
+    end
+    
+    it "uses get by default" do
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        "get",
+        anything
+      )
+
+      @api.rest_call('anything')
+    end
+    
+    it "allows you to specify other http methods as the last argument" do
+      method = 'bar'
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        method,
+        anything
+      )
+
+      @api.rest_call('anything', {}, {}, method)
+    end
+
+    it "should throw an APIError if the result hash has an error key" do
+      Koala.stub(:make_request).and_return(Koala::Response.new(500, {"error_code" => "An error occurred!"}, {}))
+      lambda { @api.rest_call("koppel", {}) }.should raise_exception(Koala::Facebook::APIError)
+    end
+
+    describe "when making a FQL request" do
+      it "should call fql.query method" do
+        @api.should_receive(:rest_call).with(
+          "fql.query", anything, anything
+        ).and_return(Koala::Response.new(200, "2", {}))
+
+        @api.fql_query stub('query string')
+      end
+
+      it "should pass a query argument" do
+        query = stub('query string')
+
+        @api.should_receive(:rest_call).with(
+          anything, hash_including(:query => query), anything
+        )
+
+        @api.fql_query(query)
+      end
+      
+      it "should pass on any other arguments provided" do
+        args = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
+        @api.fql_query("a query", args)
+      end
+      
+      it "should pass on any http options provided" do
+        opts = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
+        @api.fql_query("a query", {}, opts)
+      end
+    end
+    
+    describe "when making a FQL-multiquery request" do
+      it "should call fql.multiquery method" do
+        @api.should_receive(:rest_call).with(
+          "fql.multiquery", anything, anything
+        ).and_return({})
+
+        @api.fql_multiquery 'query string'
+      end
+
+      it "should pass a queries argument" do
+        queries = stub('query string')
+        queries_json = "some JSON"
+        MultiJson.stub(:encode).with(queries).and_return(queries_json)
+        
+        @api.should_receive(:rest_call).with(
+          anything,
+          hash_including(:queries => queries_json),
+          anything
+        )
+
+        @api.fql_multiquery(queries)
+      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]
+        }
+        
+        @api.stub(:rest_call).and_return(raw_results)
+        results = @api.fql_multiquery({:query => true})
+        results.should == expected_results
+      end
+      
+      it "should pass on any other arguments provided" do
+        args = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
+        @api.fql_multiquery("a query", args)
+      end
+      
+      it "should pass on any http options provided" do
+        opts = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
+        @api.fql_multiquery("a query", {}, opts)
+      end
+    end
+  end
+end
+
+shared_examples_for "Koala RestAPI with an access token" do
+  # FQL
+  it "should be able to access public information via FQL" do
+    result = @api.fql_query('select first_name from user where uid = 216743')
+    result.size.should == 1
+    result.first['first_name'].should == 'Chris'
+  end
+
+  it "should be able to access public information via FQL.multiquery" do
+    result = @api.fql_multiquery(
+      :query1 => 'select first_name from user where uid = 216743',
+      :query2 => 'select first_name from user where uid = 2905623'
+    )
+    result.size.should == 2
+    result["query1"].first['first_name'].should == 'Chris'
+    result["query2"].first['first_name'].should == 'Alex'
+  end
+
+  it "should be able to 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::GraphAPI.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}")
+
+    result.size.should == 1
+    # we've verified that you have read_stream permissions, so we can test against that
+    result.first["read_stream"].should == 1
+  end
+  
+  
+  it "should be able to 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)"
+    )
+    result.size.should == 3 
+    result.keys.should include("query1", "query2", "query3")
+  end
+
+end
+
+
+shared_examples_for "Koala RestAPI without an access token" do
+  # FQL_QUERY
+  describe "when making a FQL request" do
+    it "should be able to access public information via FQL" do
+      @result = @api.fql_query("select first_name from user where uid = 216743")
+      @result.size.should == 1
+      @result.first["first_name"].should == "Chris"
+    end
+    
+    it "should be able to access public information via FQL.multiquery" do
+      result = @api.fql_multiquery(
+        :query1 => 'select first_name from user where uid = 216743',
+        :query2 => 'select first_name from user where uid = 2905623'
+      )
+      result.size.should == 2
+      result["query1"].first['first_name'].should == 'Chris'
+      result["query2"].first['first_name'].should == 'Alex'
+    end
+
+    it "should not be able to access protected information via FQL" do
+      lambda { @api.fql_query("select read_stream from permissions where uid = 216743") }.should raise_error(Koala::Facebook::APIError)
+    end
+    
+    it "should not be able to access protected information via FQL.multiquery" do
+      lambda { 
+        @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)"
+        ) 
+      }.should raise_error(Koala::Facebook::APIError)
+    end
+  end
+end

data/spec/support/setup_mocks_or_live.rb

@@ -0,0 +1,51 @@
+# small helper method for live testing
+module KoalaTest
+  def self.validate_user_info(token)
+    print "Validating permissions for live testing..."
+    # make sure we have the necessary permissions
+    api = Koala::Facebook::GraphAndRestAPI.new(token)
+    perms = api.fql_query("select read_stream, publish_stream, user_photos, user_videos, read_insights from permissions where uid = me()")[0]
+    perms.each_pair do |perm, value|
+      if value == (perm == "read_insights" ? 1 : 0) # live testing depends on insights calls failing 
+        puts "failed!\n" # put a new line after the print above
+        raise ArgumentError, "Your access token must have the read_stream, publish_stream, and user_photos permissions, and lack read_insights.  You have: #{perms.inspect}"
+      end
+    end
+    puts "done!"
+  end
+end
+
+
+unless ENV['LIVE']
+  # By default the Koala specs are run using stubs for HTTP requests
+  #
+  # Valid OAuth token and code are not necessary to run these
+  # specs.  Because of this, specs do not fail due to Facebook
+  # imposed rate-limits or server timeouts.
+  #
+  # However as a result they are more brittle since
+  # we are not testing the latest responses from the Facebook servers.
+  # Therefore, to be certain all specs pass with the current
+  # Facebook services, run koala_spec_without_mocks.rb.
+  Koala.http_service = Koala::MockHTTPService
+
+  $testing_data = Koala::MockHTTPService::TEST_DATA
+else
+  # Runs Koala specs through the Facebook servers
+  #
+  # Note that you need a valid OAuth token and code for these
+  # specs to run.  See facebook_data.yml for more information.
+
+  # load testing data (see note in readme.md)
+  $testing_data = YAML.load_file(File.join(File.dirname(__FILE__), '../fixtures/facebook_data.yml'))
+
+  unless $testing_data["oauth_token"]
+    puts "Access token tests will fail until you store a valid token in facebook_data.yml"
+  end
+
+  unless $testing_data["oauth_test_data"] && $testing_data["oauth_test_data"]["code"] && $testing_data["oauth_test_data"]["secret"]
+    puts "OAuth code tests will fail until you store valid data for the user's OAuth code and the app secret in facebook_data.yml"
+  end
+  
+  KoalaTest.validate_user_info $testing_data["oauth_token"]
+end

data/spec/support/uploadable_io_shared_examples.rb

@@ -0,0 +1,76 @@
+shared_examples_for "MIME::Types can't return results" do
+  {
+    "jpg" => "image/jpeg",
+    "jpeg" => "image/jpeg",
+    "png" => "image/png",
+    "gif" => "image/gif"
+  }.each_pair do |extension, mime_type|
+    it "should properly get content types for #{extension} using basic analysis" do
+      path = "filename.#{extension}"
+      if @koala_io_params[0].is_a?(File)
+        @koala_io_params[0].stub!(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+      Koala::UploadableIO.new(*@koala_io_params).content_type.should == mime_type
+    end
+
+    it "should get content types for #{extension} using basic analysis with file names with more than one dot" do
+      path = "file.name.#{extension}"
+      if @koala_io_params[0].is_a?(File)
+        @koala_io_params[0].stub!(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+      Koala::UploadableIO.new(*@koala_io_params).content_type.should == mime_type
+    end
+  end
+
+  describe "if the MIME type can't be determined" do
+    before :each do
+      path = "badfile.badextension"
+      if @koala_io_params[0].is_a?(File)
+        @koala_io_params[0].stub!(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+    end
+
+    it "should throw an exception if the MIME type can't be determined and the HTTP service requires content type" do
+      Koala.stub!(:multipart_requires_content_type?).and_return(true)
+      lambda { Koala::UploadableIO.new(*@koala_io_params) }.should raise_exception(Koala::KoalaError)
+    end
+
+    it "should just have @content_type == nil if the HTTP service doesn't require content type" do
+      Koala.stub!(:multipart_requires_content_type?).and_return(false)
+      Koala::UploadableIO.new(*@koala_io_params).content_type.should be_nil
+    end
+  end
+end
+
+shared_examples_for "determining a mime type" do
+  describe "if MIME::Types is available" do
+    it "should return an UploadIO with MIME::Types-determined type if the type exists" do
+      type_result = ["type"]
+      Koala::MIME::Types.stub(:type_for).and_return(type_result)
+      Koala::UploadableIO.new(*@koala_io_params).content_type.should == type_result.first
+    end
+  end
+
+  describe "if MIME::Types is unavailable" do
+    before :each do
+      # fake that MIME::Types doesn't exist
+      Koala::MIME::Types.stub(:type_for).and_raise(NameError)
+    end
+    it_should_behave_like "MIME::Types can't return results"
+  end
+
+  describe "if MIME::Types can't find the result" do
+    before :each do
+      # fake that MIME::Types doesn't exist
+      Koala::MIME::Types.stub(:type_for).and_return([])
+    end
+
+    it_should_behave_like "MIME::Types can't return results"
+  end
+end