koala 0.9.0 → 1.0.0

data/spec/koala/graph_api/graph_api_no_access_token_tests.rb

@@ -1,114 +0,0 @@
-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", "photos")
-    result.should be_a(Array)
-  end
-  
-  # paging
-  # see also graph_collection_tests
-  it "should make a request for a page when provided a specific set of page params" do
-    query = [1, 2]
-    @api.should_receive(:graph_call).with(*query)
-    @api.get_page(query)
-  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.length.should be_an(Integer)
-  end
-
-  it_should_behave_like "Koala GraphAPI with GraphCollection"
-  
-  # 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

@@ -1,150 +0,0 @@
-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", "photos")
-      result.should be_a(Array)
-    end
-    
-    # paging
-    # see also graph_collection_tests
-    it "should make a request for a page when provided a specific set of page params" do
-      query = [1, 2]
-      @api.should_receive(:graph_call).with(*query)
-      @api.get_page(query)
-    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.length.should be_an(Integer)
-    end
-
-    # API
-    # the above tests test this already, but we should consider additional api tests
-
-    it_should_behave_like "Koala GraphAPI with GraphCollection"
-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/graph_api/graph_collection_tests.rb

@@ -1,104 +0,0 @@
-# GraphCollection
-shared_examples_for "Koala GraphAPI with GraphCollection" do
-  
-  it "should create an array-like object" do
-    call = @api.graph_call("contextoptional/photos")
-    Koala::Facebook::GraphCollection.new(call, @api).should be_an(Array)
-  end
-  
-  describe "when getting a collection" do
-    # GraphCollection methods    
-    it "should get a GraphCollection when getting connections" do
-      @result = @api.get_connections("contextoptional", "photos")
-      @result.should be_a(Koala::Facebook::GraphCollection)
-    end
-    
-    it "should return nil if the get_collections call fails with nil" do
-      # this happens sometimes
-      @api.should_receive(:graph_call).and_return(nil)
-      @api.get_connections("contextoptional", "photos").should be_nil
-    end
-
-    it "should get a GraphCollection when searching" do
-      result = @api.search("facebook")
-      result.should be_a(Koala::Facebook::GraphCollection)
-    end
-
-    it "should return nil if the search call fails with nil" do
-      # this happens sometimes
-      @api.should_receive(:graph_call).and_return(nil)
-      @api.search("facebook").should be_nil
-    end
-    
-    it "should get a GraphCollection when paging through results" do
-      @results = @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}])
-      @results.should be_a(Koala::Facebook::GraphCollection)
-    end
-    
-    it "should return nil if the page call fails with nil" do
-      # this happens sometimes
-      @api.should_receive(:graph_call).and_return(nil)
-      @api.get_page(["search", {"q"=>"facebook", "limit"=>"25", "until"=>"2010-09-23T21:17:33+0000"}]).should be_nil
-    end
-    
-    # GraphCollection attributes
-    describe "the GraphCollection" do
-      before(:each) do
-        @result = @api.get_connections("contextoptional", "photos")
-      end
-          
-      it "should have a read-only paging attribute" do
-        lambda { @result.paging }.should_not raise_error
-        lambda { @result.paging = "paging" }.should raise_error(NoMethodError)
-      end
-  
-      describe "when getting a whole page" do
-        before(:each) do
-          @second_page = stub("page of Fb graph results")
-          @base = stub("base")
-          @args = stub("args")
-          @page_of_results = stub("page of results")
-        end
-    
-        it "should return the previous page of results" do
-          @result.should_receive(:previous_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_return(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-      
-          @result.previous_page(@api).should == @page_of_results
-        end
-    
-        it "should return the next page of results" do
-          @result.should_receive(:next_page_params).and_return([@base, @args])
-          @api.should_receive(:graph_call).with(@base, @args).and_return(@second_page)
-          Koala::Facebook::GraphCollection.should_receive(:new).with(@second_page, @api).and_return(@page_of_results)
-      
-          @result.next_page.should == @page_of_results        
-        end
-    
-        it "should return nil it there are no other pages" do
-          %w{next previous}.each do |this|
-            @result.should_receive("#{this}_page_params".to_sym).and_return(nil)
-            @result.send("#{this}_page", @api).should == nil
-          end
-        end
-      end
-  
-      describe "when parsing page paramters" do
-        before(:each) do
-          @graph_collection = Koala::Facebook::GraphCollection.new({"data" => []}, Koala::Facebook::GraphAPI.new)
-        end
-    
-        it "should return the base as the first array entry" do
-          base = "url_path"
-          @graph_collection.parse_page_url("anything.com/#{base}?anything").first.should == base 
-        end
-    
-        it "should return the arguments as a hash as the last array entry" do
-          args_hash = {"one" => "val_one", "two" => "val_two"}
-          @graph_collection.parse_page_url("anything.com/anything?#{args_hash.map {|k,v| "#{k}=#{v}" }.join("&")}").last.should == args_hash
-        end
-      end
-    end
-  end
-end

data/spec/koala/live_testing_data_helper.rb

@@ -1,15 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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 adding a / if it doesn't exist" 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