koala 1.0.0 → 1.2.0

data/spec/support/mock_http_service.rb

@@ -3,22 +3,27 @@ require 'yaml'
 
 module Koala
   module MockHTTPService
-    # Mocks all HTTP requests for with koala_spec_with_mocks.rb
-    IS_MOCK = true # this lets our tests figure out if we want to stub methods
+    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)
-
+    TEST_DATA['search_time'] = (Time.now - 3600).to_s
+    
     # Useful in mock_facebook_responses.yml
     OAUTH_DATA = TEST_DATA['oauth_test_data']
     OAUTH_DATA.merge!({
-      'app_access_token' => Koala::MockHTTPService::ACCESS_TOKEN,
+      'app_access_token' => APP_ACCESS_TOKEN,
       'session_key' => "session_key",
       'multiple_session_keys' => ["session_key", "session_key_2"]
     })
@@ -30,66 +35,65 @@ module Koala
     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.included(base)
-      base.class_eval do
-
-        include Koala::HTTPService
-
-        def self.make_request(path, args, verb, options = {})
-          path = 'root' if path == '' || path == '/'
-          verb ||= 'get'
-          server = options[:rest_api] ? 'rest_api' : 'graph_api'
-          with_token = args.delete('access_token') == ACCESS_TOKEN ? 'with_token' : 'no_token'
+    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')
+      # Assume format is always JSON
+      args.delete('format')
 
-          # Create a hash key for the arguments
-          args = create_params_key(args)
+      # 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
+      begin
+        response = RESPONSES[server][path][args][verb][with_token]
 
-          response_object
-        end
+        # Raises an error of with_token/no_token key is missing
+        raise NoMethodError unless response
 
-        protected
-        def self.create_params_key(params_hash)
-          if params_hash.empty?
-            'no_args'
+        # create response class object
+        response_object = if response.is_a? String
+            Koala::Response.new(200, response, {})
           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('&')
+            Koala::Response.new(response["code"] || 200, response["body"] || "", response["headers"] || {})
           end
-        end
 
-      end # class_eval
-    end # included
+      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.encode_params(*args)
+      # use HTTPService's encode_params
+      HTTPService.encode_params(*args)
+    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
+end

data/spec/support/ordered_hash.rb

@@ -0,0 +1,205 @@
+module KoalaTest
+  # directly taken from Rails 3.1's OrderedHash
+  # see https://github.com/rails/rails/blob/master/activesupport/lib/active_support/ordered_hash.rb
+  
+  # The order of iteration over hashes in Ruby 1.8 is undefined. For example, you do not know the
+  # order in which +keys+ will return keys, or +each+ yield pairs. <tt>ActiveSupport::OrderedHash</tt>
+  # implements a hash that preserves insertion order, as in Ruby 1.9:
+  #
+  #   oh = ActiveSupport::OrderedHash.new
+  #   oh[:a] = 1
+  #   oh[:b] = 2
+  #   oh.keys # => [:a, :b], this order is guaranteed
+  #
+  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts with other implementations.
+  class OrderedHash < ::Hash #:nodoc:
+    def to_yaml_type
+      "!tag:yaml.org,2002:omap"
+    end
+
+    def encode_with(coder)
+      coder.represent_seq '!omap', map { |k,v| { k => v } }
+    end
+
+    def to_yaml(opts = {})
+      if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
+        return super
+      end
+
+      YAML.quick_emit(self, opts) do |out|
+        out.seq(taguri) do |seq|
+          each do |k, v|
+            seq.add(k => v)
+          end
+        end
+      end
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    # Hash is ordered in Ruby 1.9!
+    if RUBY_VERSION < '1.9'
+
+      # In MRI the Hash class is core and written in C. In particular, methods are
+      # programmed with explicit C function calls and polymorphism is not honored.
+      #
+      # For example, []= is crucial in this implementation to maintain the @keys
+      # array but hash.c invokes rb_hash_aset() originally. This prevents method
+      # reuse through inheritance and forces us to reimplement stuff.
+      #
+      # For instance, we cannot use the inherited #merge! because albeit the algorithm
+      # itself would work, our []= is not being called at all by the C code.
+
+      def initialize(*args, &block)
+        super
+        @keys = []
+      end
+
+      def self.[](*args)
+        ordered_hash = new
+
+        if (args.length == 1 && args.first.is_a?(Array))
+          args.first.each do |key_value_pair|
+            next unless (key_value_pair.is_a?(Array))
+            ordered_hash[key_value_pair[0]] = key_value_pair[1]
+          end
+
+          return ordered_hash
+        end
+
+        unless (args.size % 2 == 0)
+          raise ArgumentError.new("odd number of arguments for Hash")
+        end
+
+        args.each_with_index do |val, ind|
+          next if (ind % 2 != 0)
+          ordered_hash[val] = args[ind + 1]
+        end
+
+        ordered_hash
+      end
+
+      def initialize_copy(other)
+        super
+        # make a deep copy of keys
+        @keys = other.keys
+      end
+
+      def []=(key, value)
+        @keys << key unless has_key?(key)
+        super
+      end
+
+      def delete(key)
+        if has_key? key
+          index = @keys.index(key)
+          @keys.delete_at index
+        end
+        super
+      end
+
+      def delete_if
+        super
+        sync_keys!
+        self
+      end
+
+      def reject!
+        super
+        sync_keys!
+        self
+      end
+
+      def reject(&block)
+        dup.reject!(&block)
+      end
+
+      def keys
+        @keys.dup
+      end
+
+      def values
+        @keys.collect { |key| self[key] }
+      end
+
+      def to_hash
+        self
+      end
+
+      def to_a
+        @keys.map { |key| [ key, self[key] ] }
+      end
+
+      def each_key
+        return to_enum(:each_key) unless block_given?
+        @keys.each { |key| yield key }
+        self
+      end
+
+      def each_value
+        return to_enum(:each_value) unless block_given?
+        @keys.each { |key| yield self[key]}
+        self
+      end
+
+      def each
+        return to_enum(:each) unless block_given?
+        @keys.each {|key| yield [key, self[key]]}
+        self
+      end
+
+      alias_method :each_pair, :each
+
+      alias_method :select, :find_all
+
+      def clear
+        super
+        @keys.clear
+        self
+      end
+
+      def shift
+        k = @keys.first
+        v = delete(k)
+        [k, v]
+      end
+
+      def merge!(other_hash)
+        if block_given?
+          other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+        else
+          other_hash.each { |k, v| self[k] = v }
+        end
+        self
+      end
+
+      alias_method :update, :merge!
+
+      def merge(other_hash, &block)
+        dup.merge!(other_hash, &block)
+      end
+
+      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+      def replace(other)
+        super
+        @keys = other.keys
+        self
+      end
+
+      def invert
+        OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
+      end
+
+      def inspect
+        "#<OrderedHash #{super}>"
+      end
+
+      private
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
+        end
+    end
+  end
+end

data/spec/support/rest_api_shared_examples.rb

@@ -88,6 +88,29 @@ shared_examples_for "Koala RestAPI" do
       @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)
@@ -96,8 +119,7 @@ shared_examples_for "Koala RestAPI" do
     describe "when making a FQL request" do
       it "should call fql.query method" do
         @api.should_receive(:rest_call).with(
-          "fql.query",
-          anything
+          "fql.query", anything, anything
         ).and_return(Koala::Response.new(200, "2", {}))
 
         @api.fql_query stub('query string')
@@ -107,23 +129,94 @@ shared_examples_for "Koala RestAPI" do
         query = stub('query string')
 
         @api.should_receive(:rest_call).with(
-          anything,
-          hash_including("query" => query)
+          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 = @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}")
     result.size.should == 1
-    result.first['first_name'].should == 'Chris'
+    result.first['first_name'].should == KoalaTest.user2_name
+  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 = #{KoalaTest.user2_id}",
+      :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
+    )
+    result.size.should == 2
+    result["query1"].first['first_name'].should == KoalaTest.user2_name
+    result["query2"].first['first_name'].should == KoalaTest.user1_name
   end
 
   it "should be able to access protected information via FQL" do
@@ -131,17 +224,28 @@ shared_examples_for "Koala RestAPI with an access token" do
 
     # 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)
+    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}")
 
     result.size.should == 1
-    # we assume that you have read_stream permissions, so we can test against that
-    # (should we keep this?)
+    # 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
 
 
@@ -149,13 +253,33 @@ 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"
+      result = @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}")
+      result.size.should == 1
+      result.first['first_name'].should == KoalaTest.user2_name
+    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 = #{KoalaTest.user2_id}",
+        :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
+      )
+      result.size.should == 2
+      result["query1"].first['first_name'].should == KoalaTest.user2_name
+      result["query2"].first['first_name'].should == KoalaTest.user1_name
     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)
+      lambda { @api.fql_query("select read_stream from permissions where uid = #{KoalaTest.user2_id}") }.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
+end

data/spec/support/uploadable_io_shared_examples.rb

@@ -36,15 +36,9 @@ shared_examples_for "MIME::Types can't return results" do
       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)
+    it "should throw an exception" do
       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
 
@@ -73,4 +67,4 @@ shared_examples_for "determining a mime type" do
 
     it_should_behave_like "MIME::Types can't return results"
   end
-end
+end