edh 0.1

data/spec/cases/multipart_request_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe EDH::HTTPService::MultipartRequest do
+  it "is a subclass of Faraday::Request::Multipart" do
+    EDH::HTTPService::MultipartRequest.superclass.should == Faraday::Request::Multipart
+  end
+  
+  it "defines mime_type as multipart/form-data" do
+    EDH::HTTPService::MultipartRequest.mime_type.should == 'multipart/form-data'
+  end
+  
+  describe "#process_request?" do
+    before :each do
+      @env = {}
+      @multipart = EDH::HTTPService::MultipartRequest.new
+      @multipart.stub(:request_type).and_return("")
+    end
+    
+    # no way to test the call to super, unfortunately
+    it "returns true if env[:body] is a hash with at least one hash in its values" do
+      @env[:body] = {:a => {:c => 2}}
+      @multipart.process_request?(@env).should be_true
+    end
+
+    it "returns true if env[:body] is a hash with at least one array in its values" do
+      @env[:body] = {:a => [:c, 2]}
+      @multipart.process_request?(@env).should be_true
+    end
+
+    it "returns true if env[:body] is a hash with mixed objects in its values" do
+      @env[:body] = {:a => [:c, 2], :b => {:e => :f}}
+      @multipart.process_request?(@env).should be_true
+    end
+
+    it "returns false if env[:body] is a string" do
+      @env[:body] = "my body"
+      @multipart.process_request?(@env).should be_false
+    end
+
+    it "returns false if env[:body] is a hash without an array or hash value" do
+      @env[:body] = {:a => 3}
+      @multipart.process_request?(@env).should be_false
+    end    
+  end
+  
+  describe "#process_params" do
+    before :each do
+      @parent = Faraday::Request::Multipart.new
+      @multipart = EDH::HTTPService::MultipartRequest.new 
+      @block = lambda {|k, v| "#{k}=#{v}"}     
+    end
+    
+    it "is identical to the parent for requests without a prefix" do
+      hash = {:a => 2, :c => "3"}
+      @multipart.process_params(hash, &@block).should == @parent.process_params(hash, &@block)
+    end
+    
+    it "replaces encodes [ and ] if the request has a prefix" do
+      hash = {:a => 2, :c => "3"}
+      prefix = "foo"
+      # process_params returns an array
+      @multipart.process_params(hash, prefix, &@block).join("&").should == @parent.process_params(hash, prefix, &@block).join("&").gsub(/\[/, "%5B").gsub(/\]/, "%5D")
+    end
+  end
+  
+end

data/spec/cases/utils_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe EDH::Utils do
+  describe ".logger" do
+    it "has an accessor for logger" do
+      EDH::Utils.methods.map(&:to_sym).should include(:logger)
+      EDH::Utils.methods.map(&:to_sym).should include(:logger=)
+    end
+    
+    it "defaults to the standard ruby logger with level set to ERROR" do |variable|
+      EDH::Utils.logger.should be_kind_of(Logger)
+      EDH::Utils.logger.level.should == Logger::ERROR
+    end
+    
+    logger_methods = [:debug, :info, :warn, :error, :fatal]
+    
+    logger_methods.each do |logger_method|
+      it "should delegate #{logger_method} to the attached logger" do
+        EDH::Utils.logger.should_receive(logger_method)
+        EDH::Utils.send(logger_method, "Test #{logger_method} message")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+if RUBY_VERSION == '1.9.2' && RUBY_PATCHLEVEL < 290 && RUBY_ENGINE != "macruby"
+  # In Ruby 1.9.2 versions before patchlevel 290, the default Psych
+  # parser has an issue with YAML merge keys, which
+  #
+  # Anyone using an earlier version will see missing mock response
+  # errors when running the test suite similar to this:
+  #
+  # RuntimeError:
+  #   Missing a mock response for graph_api: /me/videos: source=[FILE]: post: with_token
+  #   API PATH: /me/videos?source=[FILE]&format=json&access_token=*
+  #
+  # For now, it seems the best fix is to just downgrade to the old syck YAML parser
+  # for these troubled versions.
+  #
+  # See https://github.com/tenderlove/psych/issues/8 for more details
+  YAML::ENGINE.yamler = 'syck'
+end
+
+# load the library
+require 'edh'
+
+# Support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# set up our testing environment
+# load testing data and (if needed) create test users or validate real users
+EDHTest.setup_test_environment!

data/spec/support/custom_matchers.rb

@@ -0,0 +1,28 @@
+# Verifies that two URLs are equal, ignoring the order of the query string parameters
+RSpec::Matchers.define :match_url do |url|
+  match do |original_url|
+    base, query_string = url.split("?")
+    original_base, original_query_string = original_url.split("?")
+    query_hash = query_to_params(query_string)
+    original_query_hash = query_to_params(original_query_string)
+
+    # the base URLs need to match
+    base.should == original_base
+    
+    # the number of parameters should match (avoid one being a subset of the other)
+    query_hash.values.length.should == original_query_hash.values.length
+    
+    # and ensure all the keys and values match
+    query_hash.each_pair do |key, value|
+      original_query_hash[key].should == value
+    end
+  end
+  
+  def query_to_params(query_string)
+    query_string.split("&").inject({}) do |hash, segment|
+      k, v = segment.split("=")
+      hash[k] = v
+      hash
+    end
+  end
+end

data/spec/support/edh_test.rb

@@ -0,0 +1,185 @@
+# small helper method for live testing
+module EDHTest
+
+  class << self
+    attr_accessor :oauth_token, :app_id, :secret, :app_access_token, :code, :session_key
+    attr_accessor :search_time
+    attr_accessor :test_user_api
+  end
+
+  # Test setup
+
+  def self.setup_test_environment!
+    setup_rspec
+
+    unless ENV['LIVE']
+      # By default the EDH specs are run using stubs for HTTP requests,
+      # so they won't fail due to Passport-imposed rate limits or server timeouts.
+      #
+      # However as a result they are more brittle since
+      # we are not testing the latest responses from the Passport servers.
+      # To be certain all specs pass with the current Passport services,
+      # run LIVE=true bundle exec rake spec.
+      EDH.http_service = EDH::MockHTTPService
+      EDHTest.setup_test_data(EDH::MockHTTPService::TEST_DATA)
+    else
+      # Runs EDH specs through the Passport servers
+      # using data for a real app
+
+      # allow live tests with different adapters
+      adapter = ENV['ADAPTER'] || "typhoeus" # use Typhoeus by default if available
+      begin
+        require adapter
+        require 'typhoeus/adapters/faraday' if adapter.to_s == "typhoeus"
+        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 = EDHTest.oauth_token
+        EDHTest.setup_test_users
+      else
+        EDHTest.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 = EDHTest.oauth_token
+        EDH::Utils.stub(:deprecate) # never fire deprecation warnings
+      end
+
+      config.after :each do
+        # if we're working with a real user, clean up any objects posted to Passport
+        # no need to do so for test users, since they get deleted at the end
+        if @temporary_object_id && EDHTest.real_user?
+          raise "Unable to locate API when passed temporary object to delete!" unless @api
+
+          # wait 10ms to allow Passport 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 Passport 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)
+    # 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_stream, user_photos, user_videos, read_insights"
+  end
+
+  def self.setup_test_users
+    print "Setting up test users..."
+    @test_user_api = EDH::Passport::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
+        EDHTest.create_test_users
+      end
+
+      config.after :suite do
+        # after each test module, delete the test users to avoid cluttering up the application
+        EDHTest.destroy_test_users
+      end
+    end
+
+    puts "done."
+  end
+
+  def self.create_test_users
+    begin
+      @live_testing_user = @test_user_api.create(true, EDHTest.testing_permissions, :name => EDHTest.user1_name)
+      @live_testing_friend = @test_user_api.create(true, EDHTest.testing_permissions, :name => EDHTest.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 = EDH::Passport::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_api)
+  end
+
+  def self.test_user?
+    !!@test_user_api
+  end
+
+  def self.mock_interface?
+    EDH.http_service == EDH::MockHTTPService
+  end
+
+  # Data for testing
+  def self.user1
+    # user ID, either numeric or username
+    test_user? ? @live_testing_user["id"] : "koppel"
+  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"] : "lukeshepard"
+  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 EDH and its users.  (#{rand(10000).to_i})"}
+  end
+end

data/spec/support/mock_http_service.rb

@@ -0,0 +1,124 @@
+require 'erb'
+require 'yaml'
+
+module EDH
+  module MockHTTPService
+    include EDH::HTTPService
+
+    # fix our specs to use ok_json, so we always get the same results from to_json
+    MultiJson.use :ok_json
+
+    # Mocks all HTTP requests for with edh_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 = {}
+    TEST_DATA['search_time'] = (Time.now - 3600).to_s
+
+    RESPONSES = {}
+    def self.make_request(path, args, verb, options = {})
+      if response = match_response(path, args, verb, options)
+        # create response class object
+        response_object = if response.is_a? String
+          EDH::HTTPService::Response.new(200, response, {})
+        else
+          EDH::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
+        # Passport's servers for the actual data
+        # (Don't forget to replace ACCESS_TOKEN with a real access token)
+        data_trace = [path, args, verb, options] * ': '
+
+        args = args == 'no_args' ? '' : "#{args}&"
+        args += 'format=json'
+
+        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
+
+    # For a given query, see if our mock responses YAML has a resopnse for it.
+    def self.match_response(path, args, verb, options = {})
+      server = 'rest_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) ? MultiJson.load(v) : v
+        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
+
+    # Passport 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) ? MultiJson.decode(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