cotweet_koala 0.8.0.1

data/spec/koala/api_base_tests.rb

@@ -0,0 +1,80 @@
+class ApiBaseTests < Test::Unit::TestCase
+  describe "Koala API base class" do
+    before(:each) do
+      @service = Koala::Facebook::API.new  
+    end
+    
+    it "should not include an access token if none was given" do
+      Koala.should_receive(:make_request).with(
+        anything,
+        hash_not_including('access_token' => 1),
+        anything,
+        anything
+      ).and_return(Koala::Response.new(200, "", ""))
+      
+      @service.api('anything')
+    end
+    
+    it "should include an access token if given" do
+      token = 'adfadf'
+      service = Koala::Facebook::API.new token
+      
+      Koala.should_receive(:make_request).with(
+        anything,
+        hash_including('access_token' => token),
+        anything,
+        anything
+      ).and_return(Koala::Response.new(200, "", ""))
+      
+      service.api('anything')
+    end
+    
+    it "should get the attribute of a Koala::Response given by the http_component parameter" do
+      http_component = :method_name
+      
+      response = mock('Mock KoalaResponse', :body => '', :status => 200)
+      response.should_receive(http_component).and_return('')
+      
+      Koala.stub(:make_request).and_return(response)
+      
+      @service.api('anything', 'get', {}, :http_component => http_component)
+    end
+    
+    it "should return the body of the request as JSON if no http_component is given" do
+      response = stub('response', :body => 'body', :status => 200)
+      Koala.stub(:make_request).and_return(response)
+      
+      json_body = mock('JSON body')
+      JSON.stub(:parse).and_return([json_body])
+      
+      @service.api('anything').should == json_body
+    end
+    
+    it "should execute a block with the response body if passed one" do
+      body = '{}'
+      Koala.stub(:make_request).and_return(Koala::Response.new(200, body, {}))
+      
+      yield_test = mock('Yield Tester')
+      yield_test.should_receive(:pass)
+      
+      @service.api('anything') do |arg| 
+        yield_test.pass
+        arg.should == JSON.parse(body)
+      end
+    end
+    
+    it "should raise an API error if the HTTP response code is greater than or equal to 500" do
+      Koala.stub(:make_request).and_return(Koala::Response.new(500, 'response body', {}))
+      
+      lambda { @service.api('anything') }.should raise_exception(Koala::Facebook::APIError)
+    end
+    
+    it "should handle rogue true/false as responses" do
+      Koala.should_receive(:make_request).and_return(Koala::Response.new(200, 'true', {}))
+      @service.api('anything').should be_true
+      
+      Koala.should_receive(:make_request).and_return(Koala::Response.new(200, 'false', {}))
+      @service.api('anything').should be_false
+    end
+  end
+end

data/spec/koala/graph_and_rest_api/graph_and_rest_api_no_token_tests.rb

@@ -0,0 +1,10 @@
+class GraphAndRestAPINoTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAndRestAPI without an access token" do
+    before(:each) do
+      @api = Koala::Facebook::GraphAndRestAPI.new
+    end
+    
+    it_should_behave_like "Koala RestAPI without an access token"
+    it_should_behave_like "Koala GraphAPI without an access token"
+  end
+end

data/spec/koala/graph_and_rest_api/graph_and_rest_api_with_token_tests.rb

@@ -0,0 +1,11 @@
+class GraphAndRestAPIWithTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAndRestAPI without an access token" do
+    it_should_behave_like "live testing examples"
+    it_should_behave_like "Koala RestAPI with an access token"
+    it_should_behave_like "Koala GraphAPI with an access token"
+    
+    before(:each) do
+      @api = Koala::Facebook::GraphAndRestAPI.new(@token)
+    end
+  end
+end

data/spec/koala/graph_api/graph_api_no_access_token_tests.rb

@@ -0,0 +1,105 @@
+shared_examples_for "Koala GraphAPI without an access token" do
+  it "should get public data about a user" do
+    result = @api.get_object("koppel")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should
+  end
+
+  it "should not get private data about a user" do
+    result = @api.get_object("koppel")
+    # updated_time should be a pretty fixed test case
+    result["updated_time"].should be_nil
+  end
+
+  it "should get public data about a Page" do
+    result = @api.get_object("contextoptional")
+    # the results should have an ID and a name, among other things
+    (result["id"] && result["name"]).should
+  end
+
+  it "should not be able to get data about 'me'" do
+    lambda { @api.get_object("me") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  it "should be able to get multiple objects" do
+    results = @api.get_objects(["contextoptional", "naitik"])
+    results.length.should == 2
+  end
+
+  it "shouldn't be able to access connections from users" do
+    lambda { @api.get_connections("lukeshepard", "likes") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  it "should be able to access a user's picture" do
+    @api.get_picture("chris.baclig").should =~ /http\:\/\//
+  end
+
+  it "should be able to access a user's picture, given a picture type"  do
+    @api.get_picture("chris.baclig", {:type => 'large'}).should =~ /^http\:\/\//
+  end
+
+  it "should be able to access connections from public Pages" do
+    result = @api.get_connections("contextoptional", "likes")
+    result.should be_a(Array)
+  end
+
+  it "should not be able to put an object" do
+    lambda { @result = @api.put_object("lukeshepard", "feed", :message => "Hello, world") }.should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow put onto Luke Shepard's wall!" if @result
+  end
+
+  # these are not strictly necessary as the other put methods resolve to put_object, but are here for completeness
+  it "should not be able to post to a feed" do
+    (lambda do
+      attachment = {:name => "Context Optional", :link => "http://www.contextoptional.com/"}
+      @result = @api.put_wall_post("Hello, world", attachment, "contextoptional") 
+    end).should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow put onto Context Optional's wall!" if @result
+  end
+
+  it "should not be able to comment on an object" do
+    # random public post on the ContextOptional wall
+    lambda { @result = @api.put_comment("7204941866_119776748033392", "The hackathon was great!") }.should raise_error(Koala::Facebook::APIError)
+    puts "Error!  Object #{@result.inspect} somehow commented on post 7204941866_119776748033392!" if @result    
+  end
+
+  it "should not be able to like an object" do
+    lambda { @api.put_like("7204941866_119776748033392") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+
+  # DELETE
+  it "should not be able to delete posts" do 
+    # test post on the Ruby SDK Test application
+    lambda { @result = @api.delete_object("115349521819193_113815981982767") }.should raise_error(Koala::Facebook::APIError)
+  end
+
+  # SEARCH
+  it "should be able to search" do
+    result = @api.search("facebook")
+    result["data"].should be_an(Array)
+  end
+
+  # API
+  it "should never use the rest api server" do
+    Koala.should_receive(:make_request).with(
+      anything,
+      anything,
+      anything,
+      hash_not_including(:rest_api => true)
+    ).and_return(Koala::Response.new(200, "", {}))      
+    
+    @api.api("anything")
+  end
+end
+
+class FacebookNoAccessTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAPI without an access token" do
+    before :each do
+      @api = Koala::Facebook::GraphAPI.new
+    end  
+    
+    it_should_behave_like "Koala GraphAPI without an access token"
+  end
+end
+  

data/spec/koala/graph_api/graph_api_with_access_token_tests.rb

@@ -0,0 +1,139 @@
+shared_examples_for "Koala GraphAPI with an access token" do
+it "should get public data about a user" do
+      result = @api.get_object("koppel")
+      # the results should have an ID and a name, among other things
+      (result["id"] && result["name"]).should_not be_nil
+    end
+
+    it "should get private data about a user" do
+      result = @api.get_object("koppel")
+      # updated_time should be a pretty fixed test case
+      result["updated_time"].should_not be_nil
+    end
+
+    it "should get public data about a Page" do
+      result = @api.get_object("contextoptional")
+      # the results should have an ID and a name, among other things
+      (result["id"] && result["name"]).should
+    end
+  
+    it "should get data about 'me'" do
+      result = @api.get_object("me")
+      result["updated_time"].should
+    end
+  
+    it "should be able to get multiple objects" do
+      result = @api.get_objects(["contextoptional", "naitik"])
+      result.length.should == 2
+    end
+  
+    it "should be able to access a user's picture" do
+      @api.get_picture("chris.baclig").should =~ /http\:\/\//
+    end
+  
+    it "should be able to access a user's picture, given a picture type"  do
+      @api.get_picture("chris.baclig", {:type => 'large'}).should =~ /^http\:\/\//
+    end
+  
+    it "should be able to access connections from users" do
+      result = @api.get_connections("lukeshepard", "likes")
+      result.length.should > 0
+    end
+
+    it "should be able to access connections from public Pages" do
+      result = @api.get_connections("contextoptional", "likes")
+      result.should be_a(Array)
+    end
+    
+    # PUT
+    it "should be able to write an object to the graph" do
+      result = @api.put_wall_post("Hello, world, from the test suite!")
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+
+    # DELETE
+    it "should be able to delete posts" do 
+      result = @api.put_wall_post("Hello, world, from the test suite delete method!")
+      object_id_to_delete = result["id"]
+      delete_result = @api.delete_object(object_id_to_delete)
+      delete_result.should == true
+    end
+
+    # additional put tests
+    it "should be able to verify messages posted to a wall" do
+      message = "the cats are asleep"
+      put_result = @api.put_wall_post(message)
+      @temporary_object_id = put_result["id"]
+      get_result = @api.get_object(@temporary_object_id)
+      
+      # make sure the message we sent is the message that got posted
+      get_result["message"].should == message
+    end
+
+    it "should be able to post a message with an attachment to a feed" do
+      result = @api.put_wall_post("Hello, world, from the test suite again!", {:name => "Context Optional", :link => "http://www.contextoptional.com/"})
+      @temporary_object_id = result["id"]
+      @temporary_object_id.should_not be_nil
+    end
+    
+    it "should be able to verify a message with an attachment posted to a feed" do
+      attachment = {"name" => "Context Optional", "link" => "http://www.contextoptional.com/"}
+      result = @api.put_wall_post("Hello, world, from the test suite again!", attachment)
+      @temporary_object_id = result["id"]
+      get_result = @api.get_object(@temporary_object_id)
+
+      # make sure the result we fetch includes all the parameters we sent
+      it_matches = attachment.inject(true) {|valid, param| valid && (get_result[param[0]] == attachment[param[0]])}
+      it_matches.should == true 
+    end
+
+    it "should be able to comment on an object" do
+      result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
+      @temporary_object_id = result["id"]
+      
+      # this will be deleted when the post gets deleted 
+      comment_result = @api.put_comment(@temporary_object_id, "it's my comment!")
+      comment_result.should_not be_nil
+    end
+    
+    it "should be able to verify a comment posted about an object" do
+      message_text = "Hello, world, from the test suite, testing comments!"
+      result = @api.put_wall_post(message_text)
+      @temporary_object_id = result["id"]
+      
+      # this will be deleted when the post gets deleted 
+      comment_text = "it's my comment!"
+      comment_result = @api.put_comment(@temporary_object_id, comment_text)
+      get_result = @api.get_object(comment_result["id"])
+
+      # make sure the text of the comment matches what we sent
+      get_result["message"].should == comment_text
+    end
+
+    it "should be able to like an object" do
+      result = @api.put_wall_post("Hello, world, from the test suite, testing comments!")
+      @temporary_object_id = result["id"]
+      like_result = @api.put_like(@temporary_object_id)
+    end
+
+    # SEARCH
+    it "should be able to search" do
+      result = @api.search("facebook")
+      result["data"].should be_an(Array)
+    end
+
+    # API
+    # the above tests test this already, but we should consider additional api tests
+end
+
+class FacebookWithAccessTokenTests < Test::Unit::TestCase
+  describe "Koala GraphAPI with an access token" do
+    it_should_behave_like "live testing examples"
+    it_should_behave_like "Koala GraphAPI with an access token"
+    
+    before :each do
+      @api = Koala::Facebook::GraphAPI.new(@token)
+    end
+  end
+end

data/spec/koala/live_testing_data_helper.rb

@@ -0,0 +1,15 @@
+shared_examples_for "live testing examples" do
+    before :each do
+      @token = $testing_data["oauth_token"]
+      raise Exception, "Must supply access token to run FacebookWithAccessTokenTests!" unless @token
+    end
+    
+    after :each do 
+      # clean up any temporary objects
+      if @temporary_object_id
+        puts "\nCleaning up temporary object #{@temporary_object_id.to_s}"
+        result = @api.delete_object(@temporary_object_id)
+        raise "Unable to clean up temporary Graph object #{@temporary_object_id}!" unless result
+      end
+    end
+end

data/spec/koala/net_http_service_tests.rb

@@ -0,0 +1,181 @@
+require 'koala/http_services'
+  
+class NetHTTPServiceTests < Test::Unit::TestCase
+  module Bear
+    include Koala::NetHTTPService
+  end
+  
+  it "should define a make_request static module method" do
+    Bear.respond_to?(:make_request).should be_true
+  end
+
+  describe "when making a request" do
+    before(:each) do
+      # Setup stubs for make_request to execute without exceptions
+      @mock_http_response = stub('Net::HTTPResponse', :code => 1)
+      @mock_body = stub('Net::HTTPResponse body')
+      @http_request_result = [@mock_http_response, @mock_body]
+      
+      @http_yield_mock = mock('Net::HTTP start yielded object')
+      
+      @http_yield_mock.stub(:post).and_return(@http_request_result)
+      @http_yield_mock.stub(:get).and_return(@http_request_result)
+      
+      @http_mock = stub('Net::HTTP object', 'use_ssl=' => true, 'verify_mode=' => true)
+      @http_mock.stub(:start).and_yield(@http_yield_mock)
+      
+      Net::HTTP.stub(:new).and_return(@http_mock)
+    end
+  
+    it "should use POST if verb is not GET" do
+      @http_yield_mock.should_receive(:post).and_return(@mock_http_response)
+      @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+      
+      Bear.make_request('anything', {}, 'anything')
+    end
+    
+    it "should use port 443" do
+      Net::HTTP.should_receive(:new).with(anything, 443).and_return(@http_mock)
+      
+      Bear.make_request('anything', {}, 'anything')  
+    end
+    
+    it "should use SSL" do
+      @http_mock.should_receive('use_ssl=').with(true)
+      
+      Bear.make_request('anything', {}, 'anything')  
+    end
+    
+    it "should use the graph server by default" do
+      Net::HTTP.should_receive(:new).with(Koala::Facebook::GRAPH_SERVER, anything).and_return(@http_mock)
+      Bear.make_request('anything', {}, 'anything')  
+    end
+    
+    it "should use the REST server if the :rest_api option is true" do
+      Net::HTTP.should_receive(:new).with(Koala::Facebook::REST_SERVER, anything).and_return(@http_mock)
+      Bear.make_request('anything', {}, 'anything', :rest_api => true)  
+    end
+    
+    it "should turn off vertificate validaiton warnings" do
+      @http_mock.should_receive('verify_mode=').with(OpenSSL::SSL::VERIFY_NONE)
+      
+      Bear.make_request('anything', {}, 'anything')
+    end
+    
+    it "should start an HTTP connection" do
+      @http_mock.should_receive(:start).and_yield(@http_yield_mock)
+      Bear.make_request('anything', {}, 'anything')
+    end
+    
+    describe "via POST" do
+      it "should use Net::HTTP to make a POST request" do
+        @http_yield_mock.should_receive(:post).and_return(@http_request_result)
+        
+        Bear.make_request('anything', {}, 'post')
+      end
+      
+      it "should go to the specified path" do
+        path = mock('Path')
+        @http_yield_mock.should_receive(:post).with(path, anything).and_return(@http_request_result)
+        
+        Bear.make_request(path, {}, 'post')        
+      end
+      
+      it "should use encoded parameters" do
+        args = {}
+        params = mock('Encoded parameters')
+        Bear.should_receive(:encode_params).with(args).and_return(params)
+        
+        @http_yield_mock.should_receive(:post).with(anything, params).and_return(@http_request_result)
+        
+        Bear.make_request('anything', args, 'post')
+      end
+    end
+    
+    describe "via GET" do
+      it "should use Net::HTTP to make a GET request" do
+        @http_yield_mock.should_receive(:get).and_return(@http_request_result)
+        
+        Bear.make_request('anything', {}, 'get')
+      end
+      
+      it "should use the correct path, including arguments" do
+        path = mock('Path')
+        params = mock('Encoded parameters')
+        args = {}
+        
+        Bear.should_receive(:encode_params).with(args).and_return(params)
+        @http_yield_mock.should_receive(:get).with("#{path}?#{params}").and_return(@http_request_result)
+        
+        Bear.make_request(path, args, 'get')
+      end
+    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_http_response
+      end
+    end # describe return value
+  end # describe when making a request
+  
+  describe "when encoding parameters" do
+    it "should return an empty string if param_hash evaluates to false" do
+      Bear.encode_params(nil).should == ''
+    end
+    
+    it "should convert values to JSON if the value is not a String" do
+      val = 'json_value'
+      not_a_string = 'not_a_string'
+      not_a_string.stub(:class).and_return('NotAString')
+      not_a_string.should_receive(:to_json).and_return(val)
+      
+      string = "hi"
+      
+      args = {
+        not_a_string => not_a_string,
+        string => string
+      }
+      
+      result = Bear.encode_params(args)
+      result.split('&').find do |key_and_val|
+        key_and_val.match("#{not_a_string}=#{val}")
+      end.should be_true
+    end
+    
+    it "should escape all values" do
+      args = Hash[*(1..4).map {|i| [i.to_s, "Value #{i}($"]}.flatten]
+      
+      result = Bear.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        val.should == CGI.escape(args[key])
+      end
+    end
+    
+    it "should convert all keys to Strings" do
+      args = Hash[*(1..4).map {|i| [i, "val#{i}"]}.flatten]
+      
+      result = Bear.encode_params(args)
+      result.split('&').each do |key_val|
+        key, val = key_val.split('=')
+        key.should == args.find{|key_val_arr| key_val_arr.last == val}.first.to_s
+      end
+    end
+  end
+end