tyler_koala 1.2.0beta

data/spec/support/rest_api_shared_examples.rb

@@ -0,0 +1,285 @@
+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 "uses get by default" do
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        "get",
+        anything
+      )
+
+      @api.rest_call('anything')
+    end
+
+    it "allows you to specify other http methods as the last argument" do
+      method = 'bar'
+      @api.should_receive(:api).with(
+        anything,
+        anything,
+        method,
+        anything
+      )
+
+      @api.rest_call('anything', {}, {}, method)
+    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, 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), anything
+        )
+
+        @api.fql_query(query)
+      end
+
+      it "should pass on any other arguments provided" do
+        args = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
+        @api.fql_query("a query", args)
+      end
+
+      it "should pass on any http options provided" do
+        opts = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
+        @api.fql_query("a query", {}, opts)
+      end
+    end
+
+    describe "when making a FQL-multiquery request" do
+      it "should call fql.multiquery method" do
+        @api.should_receive(:rest_call).with(
+          "fql.multiquery", anything, anything
+        ).and_return({})
+
+        @api.fql_multiquery 'query string'
+      end
+
+      it "should pass a queries argument" do
+        queries = stub('query string')
+        queries_json = "some JSON"
+        MultiJson.stub(:encode).with(queries).and_return(queries_json)
+
+        @api.should_receive(:rest_call).with(
+          anything,
+          hash_including(:queries => queries_json),
+          anything
+        )
+
+        @api.fql_multiquery(queries)
+      end
+
+      it "simplifies the response format" do
+        raw_results = [
+          {"name" => "query1", "fql_result_set" => [1, 2, 3]},
+          {"name" => "query2", "fql_result_set" => [:a, :b, :c]}
+        ]
+        expected_results = {
+          "query1" => [1, 2, 3],
+          "query2" => [:a, :b, :c]
+        }
+
+        @api.stub(:rest_call).and_return(raw_results)
+        results = @api.fql_multiquery({:query => true})
+        results.should == expected_results
+      end
+
+      it "should pass on any other arguments provided" do
+        args = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, hash_including(args), anything)
+        @api.fql_multiquery("a query", args)
+      end
+
+      it "should pass on any http options provided" do
+        opts = {:a => 2}
+        @api.should_receive(:rest_call).with(anything, anything, hash_including(opts))
+        @api.fql_multiquery("a query", {}, opts)
+      end
+    end
+  end
+end
+
+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 = #{KoalaTest.user2_id}")
+    result.size.should == 1
+    result.first['first_name'].should == KoalaTest.user2_name
+  end
+
+  it "should be able to access public information via FQL.multiquery" do
+    result = @api.fql_multiquery(
+      :query1 => "select first_name from user where uid = #{KoalaTest.user2_id}",
+      :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
+    )
+    result.size.should == 2
+    result["query1"].first['first_name'].should == KoalaTest.user2_name
+    result["query2"].first['first_name'].should == KoalaTest.user1_name
+  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::API.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've verified that you have read_stream permissions, so we can test against that
+    result.first["read_stream"].should == 1
+  end
+
+
+  it "should be able to access protected information via FQL.multiquery" do
+    result = @api.fql_multiquery(
+      :query1 => "select post_id from stream where source_id = me()",
+      :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
+      :query3 => "select uid, name from user where uid in (select fromid from #query2)"
+    )
+    result.size.should == 3
+    result.keys.should include("query1", "query2", "query3")
+  end
+
+end
+
+
+shared_examples_for "Koala RestAPI without an access token" do
+  # FQL_QUERY
+  describe "when making a FQL request" do
+    it "should be able to access public information via FQL" do
+      result = @api.fql_query("select first_name from user where uid = #{KoalaTest.user2_id}")
+      result.size.should == 1
+      result.first['first_name'].should == KoalaTest.user2_name
+    end
+
+    it "should be able to access public information via FQL.multiquery" do
+      result = @api.fql_multiquery(
+        :query1 => "select first_name from user where uid = #{KoalaTest.user2_id}",
+        :query2 => "select first_name from user where uid = #{KoalaTest.user1_id}"
+      )
+      result.size.should == 2
+      result["query1"].first['first_name'].should == KoalaTest.user2_name
+      result["query2"].first['first_name'].should == KoalaTest.user1_name
+    end
+
+    it "should not be able to access protected information via FQL" do
+      lambda { @api.fql_query("select read_stream from permissions where uid = #{KoalaTest.user2_id}") }.should raise_error(Koala::Facebook::APIError)
+    end
+
+    it "should not be able to access protected information via FQL.multiquery" do
+      lambda {
+        @api.fql_multiquery(
+          :query1 => "select post_id from stream where source_id = me()",
+          :query2 => "select fromid from comment where post_id in (select post_id from #query1)",
+          :query3 => "select uid, name from user where uid in (select fromid from #query2)"
+        )
+      }.should raise_error(Koala::Facebook::APIError)
+    end
+  end
+end

data/spec/support/uploadable_io_shared_examples.rb

@@ -0,0 +1,70 @@
+shared_examples_for "MIME::Types can't return results" do
+  {
+    "jpg" => "image/jpeg",
+    "jpeg" => "image/jpeg",
+    "png" => "image/png",
+    "gif" => "image/gif"
+  }.each_pair do |extension, mime_type|
+    it "should properly get content types for #{extension} using basic analysis" do
+      path = "filename.#{extension}"
+      if @koala_io_params[0].is_a?(File)
+        @koala_io_params[0].stub!(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+      Koala::UploadableIO.new(*@koala_io_params).content_type.should == mime_type
+    end
+
+    it "should get content types for #{extension} using basic analysis with file names with more than one dot" do
+      path = "file.name.#{extension}"
+      if @koala_io_params[0].is_a?(File)
+        @koala_io_params[0].stub!(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+      Koala::UploadableIO.new(*@koala_io_params).content_type.should == mime_type
+    end
+  end
+
+  describe "if the MIME type can't be determined" do
+    before :each do
+      path = "badfile.badextension"
+      if @koala_io_params[0].is_a?(File)
+        @koala_io_params[0].stub!(:path).and_return(path)
+      else
+        @koala_io_params[0] = path
+      end
+    end
+
+    it "should throw an exception" do
+      lambda { Koala::UploadableIO.new(*@koala_io_params) }.should raise_exception(Koala::KoalaError)
+    end
+  end
+end
+
+shared_examples_for "determining a mime type" do
+  describe "if MIME::Types is available" do
+    it "should return an UploadIO with MIME::Types-determined type if the type exists" do
+      type_result = ["type"]
+      Koala::MIME::Types.stub(:type_for).and_return(type_result)
+      Koala::UploadableIO.new(*@koala_io_params).content_type.should == type_result.first
+    end
+  end
+
+  describe "if MIME::Types is unavailable" do
+    before :each do
+      # fake that MIME::Types doesn't exist
+      Koala::MIME::Types.stub(:type_for).and_raise(NameError)
+    end
+    it_should_behave_like "MIME::Types can't return results"
+  end
+
+  describe "if MIME::Types can't find the result" do
+    before :each do
+      # fake that MIME::Types doesn't exist
+      Koala::MIME::Types.stub(:type_for).and_return([])
+    end
+
+    it_should_behave_like "MIME::Types can't return results"
+  end
+end

metadata

@@ -0,0 +1,221 @@
+--- !ruby/object:Gem::Specification 
+name: tyler_koala
+version: !ruby/object:Gem::Version 
+  hash: 31098177
+  prerelease: 5
+  segments: 
+  - 1
+  - 2
+  - 0
+  - beta
+  version: 1.2.0beta
+platform: ruby
+authors: 
+- Alex Koppel, Chris Baclig, Rafi Jacoby, Context Optional
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: multi_json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: faraday
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 7
+        - 4
+        version: 0.7.4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: faraday-stack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 1
+        - 3
+        version: 0.1.3
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 5
+        version: "2.5"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id005
+description: Koala is a lightweight, flexible Ruby SDK for Facebook.  It allows read/write access to the social graph via the Graph and REST APIs, as well as support for realtime updates and OAuth and Facebook Connect authentication.  Koala is fully tested and supports Net::HTTP and Typhoeus connections out of the box and can accept custom modules for other services.
+email: alex@alexkoppel.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- readme.md
+- CHANGELOG
+files: 
+- .autotest
+- .gitignore
+- .travis.yml
+- CHANGELOG
+- Gemfile
+- LICENSE
+- Manifest
+- Rakefile
+- autotest/discover.rb
+- koala.gemspec
+- lib/koala.rb
+- lib/koala/batch_operation.rb
+- lib/koala/graph_api.rb
+- lib/koala/graph_batch_api.rb
+- lib/koala/graph_collection.rb
+- lib/koala/http_service.rb
+- lib/koala/oauth.rb
+- lib/koala/realtime_updates.rb
+- lib/koala/rest_api.rb
+- lib/koala/test_users.rb
+- lib/koala/uploadable_io.rb
+- lib/koala/utils.rb
+- readme.md
+- spec/cases/api_base_spec.rb
+- spec/cases/error_spec.rb
+- spec/cases/graph_and_rest_api_spec.rb
+- spec/cases/graph_api_batch_spec.rb
+- spec/cases/graph_api_spec.rb
+- spec/cases/http_service_spec.rb
+- spec/cases/koala_spec.rb
+- spec/cases/oauth_spec.rb
+- spec/cases/realtime_updates_spec.rb
+- spec/cases/rest_api_spec.rb
+- spec/cases/test_users_spec.rb
+- spec/cases/uploadable_io_spec.rb
+- spec/cases/utils_spec.rb
+- spec/fixtures/beach.jpg
+- spec/fixtures/cat.m4v
+- spec/fixtures/facebook_data.yml
+- spec/fixtures/mock_facebook_responses.yml
+- spec/spec_helper.rb
+- spec/support/graph_api_shared_examples.rb
+- spec/support/json_testing_fix.rb
+- spec/support/koala_test.rb
+- spec/support/mock_http_service.rb
+- spec/support/ordered_hash.rb
+- spec/support/rest_api_shared_examples.rb
+- spec/support/uploadable_io_shared_examples.rb
+has_rdoc: true
+homepage: http://github.com/arsduo/koala
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Koala
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A lightweight, flexible library for Facebook with support for the Graph API, the REST API, realtime updates, and OAuth authentication.
+test_files: 
+- spec/cases/api_base_spec.rb
+- spec/cases/error_spec.rb
+- spec/cases/graph_and_rest_api_spec.rb
+- spec/cases/graph_api_batch_spec.rb
+- spec/cases/graph_api_spec.rb
+- spec/cases/http_service_spec.rb
+- spec/cases/koala_spec.rb
+- spec/cases/oauth_spec.rb
+- spec/cases/realtime_updates_spec.rb
+- spec/cases/rest_api_spec.rb
+- spec/cases/test_users_spec.rb
+- spec/cases/uploadable_io_spec.rb
+- spec/cases/utils_spec.rb
+- spec/fixtures/beach.jpg
+- spec/fixtures/cat.m4v
+- spec/fixtures/facebook_data.yml
+- spec/fixtures/mock_facebook_responses.yml
+- spec/spec_helper.rb
+- spec/support/graph_api_shared_examples.rb
+- spec/support/json_testing_fix.rb
+- spec/support/koala_test.rb
+- spec/support/mock_http_service.rb
+- spec/support/ordered_hash.rb
+- spec/support/rest_api_shared_examples.rb
+- spec/support/uploadable_io_shared_examples.rb