koala 0.4 → 3.7.0

data/spec/support/koala_test.rb

@@ -0,0 +1,251 @@
+# 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, :search_time
+    attr_accessor :test_user_api
+    attr_accessor :vcr_oauth_token
+  end
+
+  # Test setup
+
+  def self.setup_test_environment!
+    setup_rspec
+
+    if live?
+      # 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)
+
+      activate_adapter!
+
+      Koala.http_service.http_options[:beta] = true if ENV["beta"] || ENV["BETA"]
+
+      # 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
+    else
+      # 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.
+      activate_vcr!
+      Koala.http_service = Koala::MockHTTPService
+      KoalaTest.setup_test_data(Koala::MockHTTPService::TEST_DATA)
+    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
+        allow(Koala::Utils).to receive(:deprecate) # never fire deprecation warnings
+        # Clean up Koala config
+        Koala.reset_config
+      end
+
+      config.after :each do
+        # if we're working with a real user, clean up any objects posted to Facebook
+        # no need to do so for test users, since they get deleted at the end
+        if @temporary_object_id && KoalaTest.real_user?
+          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
+
+  # If we're running live tests against the Facebook API, don't use the VCR
+  # fixtures. (Another alternative would be to rerecord those fixtures, but we
+  # don't necessarily want to do that.
+  def self.with_vcr_unless_live(name)
+    if live?
+      yield
+    else
+      begin
+        # if we're using VCR, we don't want to use the mock service, which was
+        # an early implementation of the same type of tool
+        old_adapter = Koala.http_service
+        Koala.http_service = Koala::HTTPService
+        activate_adapter!
+        VCR.use_cassette(name) do
+          yield
+        end
+      ensure
+        Koala.http_service = old_adapter
+      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"].to_s
+    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"]
+
+    # fix the search time so it can be used in the mock responses
+    self.search_time = data["search_time"] || (Time.now - 3600).to_s
+  end
+
+  def self.testing_permissions
+    "read_stream, publish_actions, user_photos, user_videos, read_insights"
+  end
+
+  def self.setup_test_users
+    print "Setting up test users..."
+    @test_user_api = Koala::Facebook::TestUsers.new(:app_id => self.app_id, :secret => self.secret)
+
+    RSpec.configure do |config|
+      config.before :suite do
+        # before each test module, create two test users with specific names and befriend them
+        KoalaTest.create_test_users
+      end
+
+      config.after :suite do
+        # after each test module, delete the test users to avoid cluttering up the application
+        KoalaTest.destroy_test_users
+      end
+    end
+
+    puts "done."
+  end
+
+  def self.create_test_users
+    begin
+      @live_testing_user = @test_user_api.create(true, KoalaTest.testing_permissions, :name => KoalaTest.user1_name)
+      @live_testing_friend = @test_user_api.create(true, KoalaTest.testing_permissions, :name => KoalaTest.user2_name)
+      @test_user_api.befriend(@live_testing_user, @live_testing_friend)
+      self.oauth_token = @live_testing_user["access_token"]
+    rescue Exception => e
+      Kernel.warn("Problem creating test users! #{e.message}")
+      raise
+    end
+  end
+
+  def self.destroy_test_users
+    [@live_testing_user, @live_testing_friend].each do |u|
+      puts "Unable to delete test user #{u.inspect}" if u && !(@test_user_api.delete(u) rescue false)
+    end
+  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.get_connect("me", "permissions")["data"]
+
+    # live testing depends on insights calls failing
+    if perms.keys.include?("read_insights") || (perms.keys & testing_permissions) != testing_permissions
+      puts "failed!\n" # put a new line after the print above
+      raise ArgumentError, "Your access token must have #{testing_permissions.join(", ")}, and lack read_insights.  You have: #{perms.inspect}"
+    end
+    puts "done!"
+  end
+
+  # Info about the testing environment
+  def self.real_user?
+    !(mock_interface? || @test_user_api)
+  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
+    # user ID, either numeric or username
+    test_user? ? @live_testing_user["id"] : "barackobama"
+  end
+
+  def self.user1_id
+    # numerical ID, used for FQL
+    # (otherwise the two IDs are interchangeable)
+    test_user? ? @live_testing_user["id"] : 2905623
+  end
+
+  def self.user1_name
+    "Alex"
+  end
+
+  def self.user2
+    # see notes for user1
+    test_user? ? @live_testing_friend["id"] : "koppel"
+  end
+
+  def self.user2_id
+    # see notes for user1
+    test_user? ? @live_testing_friend["id"] : 2901279
+  end
+
+  def self.user2_name
+    "Luke"
+  end
+
+  def self.page
+    "facebook"
+  end
+
+  def self.app_properties
+    mock_interface? ? {"desktop" => 0} : {"description" => "A test framework for Koala and its users.  (#{rand(10000).to_i})"}
+  end
+
+  def self.live?
+    ENV['LIVE']
+  end
+
+  def self.activate_vcr!
+    require 'vcr'
+
+    VCR.configure do |c|
+      c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+      c.hook_into :webmock # or :fakeweb
+      c.ignore_hosts 'codeclimate.com' # Allow test coverage to be reported
+    end
+  end
+
+  def self.activate_adapter!
+    unless @adapter_activation_attempted
+      # allow live tests with different adapters
+      adapter = ENV['ADAPTER'] || "typhoeus" # use Typhoeus by default if available
+      begin
+        # JRuby doesn't support typhoeus on Travis
+        unless defined? JRUBY_VERSION
+          require adapter
+          require "faraday/#{adapter}"
+          Faraday.default_adapter = adapter.to_sym
+        end
+      rescue => e
+        puts "Unable to load adapter #{adapter}, using Net::HTTP. #{e.class} #{e.message}"
+      ensure
+        @adapter_activation_attempted = true
+      end
+    end
+  end
+end

data/spec/support/mock_http_service.rb

@@ -0,0 +1,140 @@
+require 'erb'
+require 'yaml'
+
+module Koala
+  module MockHTTPService
+    include Koala::HTTPService
+
+    # 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' => 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.safe_load(ERB.new(IO.read(mock_response_file_path)).result(binding), [], [], true)
+
+    def self.make_request(request)
+      if response = match_response(request.raw_path, request.raw_args, request.raw_verb, request.raw_options)
+        # create response class object
+        response_object = if response.is_a? String
+          Koala::HTTPService::Response.new(200, response, {})
+        else
+          Koala::HTTPService::Response.new(response["code"] || 200, response["body"] || "", response["headers"] || {})
+        end
+      else
+        # 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 = [request.raw_path, request.raw_args, request.raw_verb, request.raw_options] * ': '
+
+        args = request.raw_args == 'no_args' ? '' : "#{request.raw_args}&"
+        args += 'format=json'
+
+        raise "Missing a mock response for #{data_trace}\nAPI PATH: #{[request.path, request.raw_args].join('?')}"
+      end
+
+      response_object
+    end
+
+    def self.encode_params(*args)
+      # use HTTPService's encode_params
+      HTTPService.encode_params(*args)
+    end
+
+    protected
+
+    # For a given query, see if our mock responses YAML has a resopnse for it.
+    def self.match_response(path, args, verb, options = {})
+      server = 'graph_api'
+      path = 'root' if path == '' || path == '/'
+      verb = (verb || 'get').to_s
+      token = args.delete('access_token')
+      with_token = (token == ACCESS_TOKEN || token == APP_ACCESS_TOKEN) ? 'with_token' : 'no_token'
+
+      if endpoint = RESPONSES[server][path]
+        # see if we have a match for the arguments
+        if arg_match = endpoint.find {|query, v| decode_query(query) == massage_args(args)}
+          # we have a match for the server/path/arguments
+          # so if it's the right verb and authentication, we're good
+          # arg_match will be [query, hash_response]
+          arg_match.last[verb][with_token]
+        end
+      end
+    end
+
+    # Since we're comparing the arguments with data in a yaml file, we need to
+    # massage them slightly to get to the format we expect.
+    def self.massage_args(arguments)
+      args = arguments.inject({}) do |hash, (k, v)|
+        # ensure our args are all stringified
+        value = if v.is_a?(String)
+          should_json_decode?(v) ? JSON.parse(v) : v
+        elsif v.is_a?(Koala::HTTPService::UploadableIO)
+          # obviously there are no files in the yaml
+          "[FILE]"
+        else
+          v
+        end
+        # make sure all keys are strings
+        hash.merge(k.to_s => value)
+      end
+
+      # Assume format is always JSON
+      args.delete('format')
+
+      # if there are no args, return the special keyword no_args
+      args.empty? ? "no_args" : args
+    end
+
+    # Facebook sometimes requires us to encode JSON values in an HTTP query
+    # param. This complicates test matches, since we get into JSON-encoding
+    # issues (what order keys are written into).  To avoid string comparisons
+    # and the hacks required to make it work, we decode the query into a
+    # Ruby object.
+    def self.decode_query(string)
+      if string == "no_args"
+        string
+      else
+        # we can't use Faraday's decode_query because that CGI-unencodes, which
+        # will remove +'s in restriction strings
+        string.split("&").reduce({}) do |hash, component|
+          k, v = component.split("=", 2) # we only care about the first =
+          value = should_json_decode?(v) ? JSON.parse(v) : v.to_s rescue v.to_s
+          # some special-casing, unfortunate but acceptable in this testing
+          # environment
+          value = nil if value.empty?
+          value = true if value == "true"
+          value = false if value == "false"
+          hash.merge(k => value)
+        end
+      end
+    end
+
+    # We want to decode JSON because it may not be encoded in the same order
+    # all the time -- different Rubies may create a strings with equivalent
+    # content but different order.  We want to compare the objects.
+    def self.should_json_decode?(v)
+      v.match(/^[\[\{]/)
+    end
+  end
+end

data/spec/support/uploadable_io_shared_examples.rb

@@ -0,0 +1,70 @@
+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)
+        allow(@koala_io_params[0]).to receive(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+      expect(Koala::HTTPService::UploadableIO.new(*@koala_io_params).content_type).to eq(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)
+        allow(@koala_io_params[0]).to receive(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+      expect(Koala::HTTPService::UploadableIO.new(*@koala_io_params).content_type).to eq(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)
+        allow(@koala_io_params[0]).to receive(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+    end
+
+    it "should throw an exception" do
+      expect { Koala::HTTPService::UploadableIO.new(*@koala_io_params) }.to raise_exception(Koala::KoalaError)
+    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"]
+      allow(Koala::MIME::Types).to receive(:type_for).and_return(type_result)
+      expect(Koala::HTTPService::UploadableIO.new(*@koala_io_params).content_type).to eq(type_result.first)
+    end
+  end
+
+  describe "if MIME::Types is unavailable" do
+    before :each do
+      # fake that MIME::Types doesn't exist
+      allow(Koala::MIME::Types).to receive(: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
+      allow(Koala::MIME::Types).to receive(:type_for).and_return([])
+    end
+
+    it_should_behave_like "MIME::Types can't return results"
+  end
+end