tyler_koala 1.2.0beta

data/spec/support/json_testing_fix.rb

@@ -0,0 +1,42 @@
+# when testing across Ruby versions, we found that JSON string creation inconsistently ordered keys
+# which is a problem because our mock testing service ultimately matches strings to see if requests are mocked
+# this fix solves that problem by ensuring all hashes are created with a consistent key order every time
+module MultiJson
+  self.engine = :ok_json
+
+  class << self
+    def encode_with_ordering(object)
+      # if it's a hash, recreate it with k/v pairs inserted in sorted-by-key order
+      # (for some reason, REE fails if we don't assign the ternary result as a local variable
+      # separately from calling encode_original)
+      encode_original(sort_object(object))
+    end
+
+    alias_method :encode_original, :encode
+    alias_method :encode, :encode_with_ordering
+  
+    def decode_with_ordering(string)
+      sort_object(decode_original(string))
+    end
+
+    alias_method :decode_original, :decode
+    alias_method :decode, :decode_with_ordering
+    
+    private 
+  
+    def sort_object(object)
+      if object.is_a?(Hash)
+        sort_hash(object)
+      elsif object.is_a?(Array)
+        object.collect {|item| item.is_a?(Hash) ? sort_hash(item) : item}
+      else
+        object
+      end
+    end
+  
+    def sort_hash(unsorted_hash)
+      sorted_hash = KoalaTest::OrderedHash.new(sorted_hash)
+      unsorted_hash.keys.sort {|a, b| a.to_s <=> b.to_s}.inject(sorted_hash) {|hash, k| hash[k] = unsorted_hash[k]; hash}
+    end
+  end
+end

data/spec/support/koala_test.rb

@@ -0,0 +1,163 @@
+# small helper method for live testing
+module KoalaTest
+
+  class << self
+    attr_accessor :oauth_token, :app_id, :secret, :app_access_token, :code, :session_key
+    attr_accessor :oauth_test_data, :subscription_test_data
+  end
+    
+  # Test setup
+  
+  def self.setup_test_environment!
+    setup_rspec
+    
+    unless ENV['LIVE']
+      # By default the Koala specs are run using stubs for HTTP requests,
+      # so they won't 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.
+      # To be certain all specs pass with the current Facebook services, 
+      # run LIVE=true bundle exec rake spec.
+      Koala.http_service = Koala::MockHTTPService
+      KoalaTest.setup_test_data(Koala::MockHTTPService::TEST_DATA)
+    else
+      # Runs Koala specs through the Facebook servers
+      # using data for a real app
+      live_data = YAML.load_file(File.join(File.dirname(__FILE__), '../fixtures/facebook_data.yml'))
+      KoalaTest.setup_test_data(live_data)
+
+      # allow live tests with different adapters
+      adapter = ENV['ADAPTER'] || "typhoeus"# use Typhoeus by default if available
+      begin
+        require adapter
+        Faraday.default_adapter = adapter.to_sym
+      rescue LoadError
+        puts "Unable to load adapter #{adapter}, using Net::HTTP."
+      end
+
+      # use a test user unless the developer wants to test against a real profile
+      unless token = KoalaTest.oauth_token
+        KoalaTest.setup_test_users
+      else
+        KoalaTest.validate_user_info(token)
+      end
+    end
+  end
+  
+  def self.setup_rspec
+    # set up a global before block to set the token for tests
+    # set the token up for
+    RSpec.configure do |config|
+      config.before :each do
+        @token = KoalaTest.oauth_token
+        Koala::Utils.stub(:deprecate) # never fire deprecation warnings
+      end
+
+      config.after :each do
+        # clean up any objects posted to Facebook
+        if @temporary_object_id && !KoalaTest.mock_interface?
+          api = @api || (@test_users ? @test_users.graph_api : nil)
+          raise "Unable to locate API when passed temporary object to delete!" unless api
+
+          # wait 10ms to allow Facebook to propagate data so we can delete it
+          sleep(0.01)
+
+          # clean up any objects we've posted
+          result = (api.delete_object(@temporary_object_id) rescue false)
+          # if we errored out or Facebook returned false, track that
+          puts "Unable to delete #{@temporary_object_id}: #{result} (probably a photo or video, which can't be deleted through the API)" unless result
+        end
+      end
+    end
+  end
+
+  def self.setup_test_data(data)
+    # make data accessible to all our tests
+    self.oauth_test_data = data["oauth_test_data"]
+    self.subscription_test_data = data["subscription_test_data"]
+    self.oauth_token = data["oauth_token"]
+    self.app_id = data["oauth_test_data"]["app_id"]
+    self.app_access_token = data["oauth_test_data"]["app_access_token"]
+    self.secret = data["oauth_test_data"]["secret"]
+    self.code = data["oauth_test_data"]["code"]
+    self.session_key = data["oauth_test_data"]["session_key"]
+  end
+
+  def self.testing_permissions
+    "read_stream, publish_stream, user_photos, user_videos, read_insights"
+  end
+  
+  def self.setup_test_users
+    # note: we don't have to delete the two test users explicitly, since the test user specs do that for us
+    # technically, this is a point of brittleness and would break if the tests were run out of order
+    # however, for now we can live with it since it would slow tests way too much to constantly recreate our test users
+    print "Setting up test users..."
+    @test_user_api = Koala::Facebook::TestUsers.new(:app_id => self.app_id, :secret => self.secret)
+
+    # create two test users with specific names and befriend them
+    @live_testing_user = @test_user_api.create(true, testing_permissions, :name => user1_name)
+    @live_testing_friend = @test_user_api.create(true, testing_permissions, :name => user2_name)
+    @test_user_api.befriend(@live_testing_user, @live_testing_friend)
+    self.oauth_token = @live_testing_user["access_token"]
+
+    puts "done."
+  end
+
+  def self.validate_user_info(token)
+    print "Validating permissions for live testing..."
+    # make sure we have the necessary permissions
+    api = Koala::Facebook::API.new(token)
+    perms = api.fql_query("select #{testing_permissions} 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
+  
+  # Info about the testing environment
+  def self.real_user?
+    !(mock_interface? || @test_user)
+  end
+
+  def self.test_user?
+    !!@test_user_api
+  end
+
+  def self.mock_interface?
+    Koala.http_service == Koala::MockHTTPService
+  end
+
+  # Data for testing
+  def self.user1
+    test_user? ? @live_testing_user["id"] : "koppel"
+  end
+
+  def self.user1_id
+    test_user? ? @live_testing_user["id"] : 2905623
+  end
+
+  def self.user1_name
+    "Alex"
+  end
+
+  def self.user2
+    test_user? ? @live_testing_friend["id"] : "lukeshepard"
+  end
+
+  def self.user2_id
+    test_user? ? @live_testing_friend["id"] : 2901279
+  end
+
+  def self.user2_name
+    "Luke"
+  end
+
+  def self.page
+    "contextoptional"
+  end
+
+end

data/spec/support/mock_http_service.rb

@@ -0,0 +1,98 @@
+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.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

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