koala 1.1.0 → 1.2.0beta1

data/spec/cases/http_services/typhoeus_service_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-
-Deer = Koala::TyphoeusService
-
-describe "TyphoeusService" do
-
-  describe "TyphoeusService module holder class Deer" do
-    before :each do
-      # reset global settings
-      Deer.always_use_ssl = Deer.proxy = Deer.timeout = nil
-    end
-
-    it "should define a make_request static module method" do
-      Deer.respond_to?(:make_request).should be_true
-    end
-
-    it "should include the Koala::HTTPService module defining common features" do
-      Deer.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 Deer itself
-        Typhoeus::Request.stub(:post).and_return(@mock_http_response)
-        Typhoeus::Request.stub(:get).and_return(@mock_http_response)
-      end
-
-      it "should use POST if verb is not GET" do
-        Typhoeus::Request.should_receive(:post).and_return(@mock_http_response)
-        Deer.make_request('anything', {}, 'anything')
-      end
-
-      it "should use GET if that verb is specified" do
-        Typhoeus::Request.should_receive(:get).and_return(@mock_http_response)
-        Deer.make_request('anything', {}, 'get')
-      end
-
-      describe "the connection" do
-        it "should use SSL if the request has an access token" do
-          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
-
-          Deer.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
-          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
-
-          Deer.always_use_ssl = true
-          Deer.make_request('anything', {}, 'anything')
-        end
-
-        it "should use SSL if the :use_ssl option is provided, even if there's no token" do
-          Typhoeus::Request.should_receive(:post).with(/https\:/, anything)
-
-          Deer.always_use_ssl = true
-          Deer.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
-          Typhoeus::Request.should_receive(:post).with(/http\:/, anything)
-
-          Deer.make_request('anything', {}, 'anything')
-        end
-
-        it "should use the graph server by default" do
-          Typhoeus::Request.should_receive(:post).with(Regexp.new(Koala::Facebook::GRAPH_SERVER), anything)
-
-          Deer.make_request('anything', {}, 'anything')
-        end
-
-        it "should use the REST server if the :rest_api option is true" do
-          Typhoeus::Request.should_receive(:post).with(Regexp.new(Koala::Facebook::REST_SERVER), anything)
-
-          Deer.make_request('anything', {}, 'anything', :rest_api => true)
-        end
-      end
-
-      it "should pass the arguments to Typhoeus under the :params key" do
-        args = {:a => 2}
-        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => args))
-
-        Deer.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"
-        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => {:method => method}))
-
-        Deer.make_request('anything', {}, method)
-      end
-
-      it "should pass :typhoeus_options to Typhoeus if provided" do
-        t_options = {:a => :b}
-        Typhoeus::Request.should_receive(:post).with(anything, hash_including(t_options))
-
-        Deer.make_request("anything", {}, "post", :typhoeus_options => t_options)
-      end
-
-      it "should pass proxy and timeout :typhoeus_options to Typhoeus if set globally" do
-        Deer.proxy = "http://defaultproxy"
-        Deer.timeout = 20
-
-        t_options = {:proxy => "http://defaultproxy", :timeout => 20}
-        Typhoeus::Request.should_receive(:post).with(anything, hash_including(t_options))
-
-        Deer.make_request("anything", {}, "post")
-      end
-
-      # for live tests, run the Graph API tests with Typhoues, which will run file uploads
-      it "should pass any files directly on to Typhoues" do
-        args = {:file => File.new(__FILE__, "r")}
-        Typhoeus::Request.should_receive(:post).with(anything, hash_including(:params => args)).and_return(Typhoeus::Response.new)
-        Deer.make_request("anything", args, :post)
-      end
-
-      it "should include the path in the request" do
-        path = "/a/b/c/1"
-        Typhoeus::Request.should_receive(:post).with(Regexp.new(path), anything)
-
-        Deer.make_request(path, {}, "post")
-      end
-
-      describe "the returned value" do
-        before(:each) do
-          @response = Deer.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 Typhoeus headers as headers" do
-          @response.headers.should == @mock_headers_hash
-        end
-      end # describe return value
-    end
-  end
-end

data/spec/support/live_testing_data_helper.rb

@@ -1,40 +0,0 @@
-module LiveTestingDataHelper
-  # in RSpec 2, included example groups no longer share any hooks or state with outside examples
-  # even if in the same block
-  # so we have to use a module to provide setup and teardown hooks for live testing
-
-  def self.included(base)
-    base.class_eval do
-      before :each do
-        @token = $testing_data["oauth_token"]
-        raise Exception, "Must supply access token to run FacebookWithAccessTokenTests!" unless @token
-        # track temporary objects created
-        @temporary_object_ids = []
-      end
-
-      after :each do
-        # clean up any temporary objects
-        @temporary_object_ids << @temporary_object_id if @temporary_object_id
-        count = @temporary_object_ids.length
-        errors = []
-
-        if count > 0
-          @temporary_object_ids.each do |id|
-            # get our API
-            api = @api || (@test_users ? @test_users.graph_api : nil)
-            raise "Unable to locate API when passed temporary object to delete!" unless api
-
-            # delete the object
-            result = (api.delete_object(id) rescue false)
-            # if we errored out or Facebook returned false, track that
-            errors << id unless result
-          end
-
-          unless errors.length == 0
-            puts "cleaned up #{count - errors.length} objects, but errored out on the following:\n #{errors.join(", ")}"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/setup_mocks_or_live.rb

@@ -1,51 +0,0 @@
-# small helper method for live testing
-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)
-    perms = api.fql_query("select read_stream, publish_stream, user_photos, user_videos, read_insights 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
-end
-
-
-unless ENV['LIVE']
-  # By default the Koala specs are run 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
-else
-  # 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__), '../fixtures/facebook_data.yml'))
-
-  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"]
-end