koala 1.0.0.beta → 1.1.0

data/spec/koala/rest_api/rest_api_tests.rb

@@ -1,118 +0,0 @@
-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 "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
-        ).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)
-        )
-
-        @api.fql_query(query)
-      end
-    end
-  end
-end

data/spec/koala/rest_api/rest_api_with_access_token_tests.rb

@@ -1,38 +0,0 @@
-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 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 assume that you have read_stream permissions, so we can test against that
-    # (should we keep this?)
-    result.first["read_stream"].should == 1
-  end
-end
-
-class FacebookRestAPIWithAccessTokenTests < Test::Unit::TestCase
-  describe "Koala RestAPI with an access token" do
-    include LiveTestingDataHelper
-
-    before :each do
-      @api = Koala::Facebook::RestAPI.new(@token)
-    end
-
-    it_should_behave_like "Koala RestAPI"
-    it_should_behave_like "Koala RestAPI with an access token"
-  end
-end

data/spec/koala/typhoeus_service_tests.rb

@@ -1,156 +0,0 @@
-require 'koala/http_services'
-class TyphoeusServiceTests < Test::Unit::TestCase
-  module Bear
-    include Koala::TyphoeusService
-  end
-
-  describe "TyphoeusService module holder class Bear" do
-    before :each do
-      # reset the always_use_ssl parameter
-      Bear.always_use_ssl = nil
-    end
-
-    it "should define a make_request static module method" do
-      Bear.respond_to?(:make_request).should be_true
-    end
-
-    it "should include the Koala::HTTPService module defining common features" do
-      Bear.included_modules.include?(Koala::HTTPService).should be_true
-    end
-
-    describe "when making a request" do
-      before(:each) do
-        # Setup stubs for make_request to execute without exceptions
-        @mock_body = stub('Typhoeus response body')
-        @mock_headers_hash = stub({:value => "headers hash"})
-        @mock_http_response = stub(Typhoeus::Response, :code => 1, :headers_hash => @mock_headers_hash, :body => @mock_body)
-
-        # Typhoeus is an included module, so we stub methods on Bear itself
-        Bear.stub(:post).and_return(@mock_http_response)
-        Bear.stub(:get).and_return(@mock_http_response)
-      end
-
-      it "should use POST if verb is not GET" do
-        Bear.should_receive(:post).and_return(@mock_http_response)
-        Bear.make_request('anything', {}, 'anything')
-      end
-
-      it "should use GET if that verb is specified" do
-        Bear.should_receive(:get).and_return(@mock_http_response)
-        Bear.make_request('anything', {}, 'get')
-      end
-
-      describe "the connection" do
-        it "should use SSL if the request has an access token" do
-          Bear.should_receive(:post).with(/https\:/, anything)
-
-          Bear.make_request('anything', {"access_token" => "123"}, 'anything')
-        end
-
-        it "should use SSL if always_use_ssl is true, even if there's no token" do
-          Bear.should_receive(:post).with(/https\:/, anything)
-
-          Bear.always_use_ssl = true
-          Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should use SSL if the :use_ssl option is provided, even if there's no token" do
-          Bear.should_receive(:post).with(/https\:/, anything)
-
-          Bear.always_use_ssl = true
-          Bear.make_request('anything', {}, 'anything', :use_ssl => true)
-        end
-
-        it "should not use SSL if always_use_ssl is false and there's no token" do
-          Bear.should_receive(:post).with(/http\:/, anything)
-
-          Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should use the graph server by default" do
-          Bear.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
-
-          Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should use the REST server if the :rest_api option is true" do
-          Bear.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
-
-          Bear.make_request('anything', {}, 'anything', :rest_api => true)
-        end
-      end
-
-      it "should pass the arguments to Typhoeus under the :params key" do
-        args = {:a => 2}
-        Bear.should_receive(:post).with(anything, hash_including(:params => args))
-
-        Bear.make_request('anything', args, "post")
-      end
-
-      it "should add the method to the arguments if the method isn't get or post" do
-        method = "telekenesis"
-        Bear.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
-
-        Bear.make_request('anything', {}, method)
-      end
-
-      it "should pass :typhoeus_options to Typhoeus if provided" do
-        t_options = {:a => :b}
-        Bear.should_receive(:post).with(anything, hash_including(t_options))
-
-        Bear.make_request("anything", {}, "post", :typhoeus_options => t_options)
-      end
-
-      it "should include the path in the request" do
-        path = "/a/b/c/1"
-        Bear.should_receive(:post).with(Regexp.new(path), anything)
-
-        Bear.make_request(path, {}, "post")
-      end
-
-      describe "the returned value" do
-        before(:each) do
-          @response = Bear.make_request('anything', {}, 'anything')
-        end
-
-        it "should return a Koala::Response object" do
-          @response.class.should == Koala::Response
-        end
-
-        it "should return a Koala::Response with the right status" do
-          @response.status.should == @mock_http_response.code
-        end
-
-        it "should reutrn a Koala::Response with the right body" do
-          @response.body.should == @mock_body
-        end
-
-        it "should return a Koala::Response with the Net::HTTPResponse object as headers" do
-          @response.headers.should == @mock_headers_hash
-        end
-      end # describe return value
-    end
-    
-    describe "with file upload" do
-      it "should include an interface to NetHTTPService called NetHTTPInterface" do
-        # we should be able to access it
-        lambda { Koala::TyphoeusService::NetHTTPInterface }.should_not raise_exception(Exception)
-        Koala::TyphoeusService::NetHTTPInterface.included_modules.include?(Koala::NetHTTPService).should be_true
-      end
-      
-      it "should call the NetHTTPInterface if multipart is required" do
-        method = "any_method"
-        args = {}
-        verb = "get"
-        options = {}
-
-        Bear.stub(:params_require_multipart?).and_return(true)
-        Koala::TyphoeusService::NetHTTPInterface.should_receive(:make_request).with(method, args, verb, options)
-
-        Bear.make_request(method, args, verb, options)
-      end
-      
-      # for live tests, run the Graph API tests with Typhoues, which will run file uploads
-    end
-  end
-end

data/spec/koala_spec.rb

@@ -1,18 +0,0 @@
-require 'koala_spec_helper'
-require 'mock_http_service'
-
-# Runs Koala specs 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

data/spec/koala_spec_helper.rb

@@ -1,70 +0,0 @@
-if defined?(RUBY_VERSION) && RUBY_VERSION =~ /1\.9/
-  require 'test/unit'
-  require 'rspec'
-
-  Rspec.configure do |c|
-    c.mock_with :rspec
-  end
-
-else
-  # Ruby 1.8.x
-  require 'test/unit'
-  require 'rubygems'
-
-  require 'spec/test/unit'
-end
-
-# load the libraries
-require 'koala'
-
-# load testing data libraries
-require 'koala/live_testing_data_helper'
-
-# API tests
-require 'koala/api_base_tests'
-
-require 'koala/graph_api/graph_api_tests'
-require 'koala/graph_api/graph_collection_tests'
-require 'koala/graph_api/graph_api_no_access_token_tests'
-require 'koala/graph_api/graph_api_with_access_token_tests'
-
-require 'koala/rest_api/rest_api_tests'
-require 'koala/rest_api/rest_api_no_access_token_tests'
-require 'koala/rest_api/rest_api_with_access_token_tests'
-
-require 'koala/graph_and_rest_api/graph_and_rest_api_no_token_tests'
-require 'koala/graph_and_rest_api/graph_and_rest_api_with_token_tests'
-
-# OAuth tests
-require 'koala/oauth/oauth_tests'
-
-# Subscriptions tests
-require 'koala/realtime_updates/realtime_updates_tests'
-
-# Test users tests
-require 'koala/test_users/test_users_tests'
-
-# Services tests
-require 'koala/net_http_service_tests'
-begin
-  require 'koala/typhoeus_service_tests'
-rescue LoadError
-  puts "Typhoeus tests will not be run because Typhoeus is not installed."
-end
-
-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)
-    uid = api.get_object("me")["id"]
-    perms = api.fql_query("select read_stream, publish_stream, user_photos from permissions where uid = #{uid}")[0]
-    perms.each_pair do |perm, value| 
-      unless value == 1
-        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.  You have: #{perms.inspect}"
-      end
-    end
-    puts "done!"
-  end
-end

data/spec/koala_spec_without_mocks.rb

@@ -1,19 +0,0 @@
-require 'koala_spec_helper'
-
-# 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__), 'facebook_data.yml')) rescue {}
-
-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"]

data/spec/mock_http_service.rb

@@ -1,96 +0,0 @@
-require 'erb'
-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
-
-    # Mocked values to be included in TEST_DATA used in specs
-    ACCESS_TOKEN = '*'
-    OAUTH_CODE = 'OAUTHCODE'
-    
-    # Loads testing data
-    TEST_DATA = YAML.load_file(File.join(File.dirname(__FILE__), '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' => Koala::MockHTTPService::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__), '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'
-          
-          # 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
-        
-        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?(File) || is_valid_file_hash?(arr[1])
-              arr.join('=')
-            end.join('&')
-          end
-        end
-        
-      end # class_eval
-    end # included
-  end
-end