fogli 0.1.0

data/lib/fogli/util/options.rb

@@ -0,0 +1,32 @@
+module Fogli
+  module Util
+    module Options
+      # Verifies that an options hash has all the required keys and
+      # also merges it with a defaults hash if given. This is an
+      # internal helper method.
+      #
+      # @param [Hash] options
+      # @param [Array] required Array of required keys.
+      # @param [Hash] defaults
+      # @return [Hash]
+      def verify_options(data, options=nil)
+        data ||= {}
+        options ||= {}
+        options[:valid_keys] ||= options[:default].keys if options[:default]
+
+        # Merge in the default data and remove any invalid keys if
+        # valid keys are specified.
+        ops = options[:default] || {}
+        ops.merge!(data)
+        ops.reject! { |k,v| !options[:valid_keys].include?(k) } if options[:valid_keys]
+
+        if options[:required_keys]
+          required = ops.reject { |k,v| !options[:required_keys].include?(k) || v.nil? }
+          raise ArgumentError.new("Missing required options: #{options[:required_keys].inspect}") if required.length != options[:required_keys].length
+        end
+
+        ops
+      end
+    end
+  end
+end

data/lib/fogli/video.rb

@@ -0,0 +1,7 @@
+module Fogli
+  class Video < FacebookObject
+    property :from, :message, :description, :length, :created_time
+
+    connection :comments, :class => :Comment
+  end
+end

data/test/fogli/facebook_graph_test.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class FacebookGraphTest < Test::Unit::TestCase
+  setup do
+    @klass = Fogli::FacebookGraph
+  end
+
+  context "requesting" do
+    teardown do
+      Fogli.access_token = nil
+    end
+
+    [:get, :post, :delete, :head].each do |method|
+      should "properly request #{method} type" do
+        @klass.expects(:request).with(method, "/foo", {}).once
+        @klass.send(method, "/foo", {})
+      end
+
+      should "properly have a raw request for #{method} type" do
+        RestClient.expects(method).with("/foo", {}).once
+        @klass.send("raw_#{method}".to_sym, "/foo", {})
+      end
+    end
+
+    should "use http by default" do
+      RestClient.expects(:get).with("http://#{@klass::GRAPH_DOMAIN}/foo", {}).once
+      @klass.request(:get, "/foo")
+    end
+
+    should "use https if an access token is set" do
+      Fogli.access_token = "foo"
+      RestClient.expects(:get).with("https://#{@klass::GRAPH_DOMAIN}/foo?access_token=foo", {}).once
+      @klass.request(:get, "/foo")
+    end
+
+    should "append parameters for GET/DELETE" do
+      params = { "foo" => "bar baz" }
+      RestClient.expects(:get).with("http://#{@klass::GRAPH_DOMAIN}/foo?foo=bar+baz", {}).once
+      @klass.request(:get, "/foo", params)
+    end
+
+    should "convert params to strings for GET/DELETE" do
+      params = { :limit => 1 }
+      RestClient.expects(:get).with("http://#{@klass::GRAPH_DOMAIN}/foo?limit=1", {}).once
+      @klass.request(:get, "/foo", params)
+    end
+
+    should "pass params into function for POST" do
+      params = { :foo => :baz }
+      RestClient.expects(:post).with("http://#{@klass::GRAPH_DOMAIN}/foo", params).once
+      @klass.request(:post, "/foo", params)
+    end
+  end
+
+  context "error checking" do
+    def response(data)
+      response = mock("response")
+      response.stubs(:headers).returns({:content_type => "text/plain"})
+      response.stubs(:body).returns(data)
+      response.stubs(:code).returns(200)
+      response
+    end
+
+    should "return the data if the data is fine" do
+      data = { "foo" => "bar" }
+
+      assert_equal data, @klass.error_check { response(data) }
+    end
+
+    should "raise an exception if the data represents an error" do
+      data = { "error" => { "type" => "foo", "message" => "baz" }}
+      assert_raises(Fogli::Exception) do
+        @klass.error_check { response(data) }
+      end
+    end
+
+    should "raise an exception for a 500 response code" do
+      resp = response({})
+      resp.stubs(:code).returns(500)
+      assert_raises(Fogli::Exception) do
+        @klass.error_check { resp }
+      end
+    end
+
+    should "catch exceptions with responses" do
+      data = { "foo" => "bar" }
+      result = @klass.error_check do
+        e = RestClient::Exception.new
+        e.response = response(data)
+        raise e
+      end
+    end
+  end
+
+  context "parsing response" do
+    setup do
+      @headers = {}
+      @body = "[1]"
+
+      @response = mock("response")
+      @response.stubs(:headers).returns(@headers)
+      @response.stubs(:body).returns(@body)
+    end
+
+    should "simply return if the content-type is text/plain" do
+      @headers[:content_type] = "text/plain; foo=bar"
+      assert_equal @body, @klass.parse_response(@response)
+    end
+
+    should "parse JSON otherwise" do
+      @headers[:content_type] = "anything"
+      result= @klass.parse_response(@response)
+      assert result.is_a?(Array)
+      assert_equal 1, result[0]
+    end
+
+    should "return the raw body if a JSON parse error occurs" do
+      @headers[:content_type] = "whatever"
+      @body = "true"
+      @response.stubs(:body).returns(@body)
+      assert_equal @body, @klass.parse_response(@response)
+    end
+  end
+end

data/test/fogli/facebook_object/connection_proxy_test.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class FacebookObjectConnectionProxyTest < Test::Unit::TestCase
+  setup do
+    @klass = Fogli::FacebookObject::ConnectionProxy
+
+    @parent = Fogli::FacebookObject.new
+    @connection_name = "friends"
+    @connection_options = { :class => :FacebookObject }
+    @instance = @klass.new(@parent, @connection_name, @connection_options)
+  end
+
+  context "loading" do
+    setup do
+      # Make sure no actual HTTP requests go through
+      @parent.stubs(:get)
+      @scope = Fogli::FacebookObject::ConnectionScope.new(@instance)
+    end
+
+    should "get the connection with the scope options and parse the data" do
+      @parent.expects(:get).with("/#{@connection_name}", @scope.options).once.returns(nil)
+      assert_equal({"data"=>[]}, @instance.load(@scope))
+    end
+  end
+
+  context "parsing data" do
+    should "instantiate for each data item" do
+      data = {"data" => [{"id"=>"1"},{"id"=>"2"}]}
+      @instance.stubs(:connection_class).returns(Fogli::FacebookObject)
+      result = @instance.parse_data(data)
+      assert_equal data["data"].length, result["data"].length
+      assert_equal "1", result["data"][0].id
+    end
+  end
+
+  context "connection class" do
+    should "just return the class if specified" do
+      @connection_options[:class] = :User
+      assert_equal Fogli::User, @instance.connection_class
+    end
+  end
+end

data/test/fogli/facebook_object/connection_scope_test.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class FacebookObjectConnectionScopeTest < Test::Unit::TestCase
+  setup do
+    @klass = Fogli::FacebookObject::ConnectionScope
+
+    @proxy = Fogli::FacebookObject::ConnectionProxy.new(Fogli::FacebookObject.new,
+                                                        :foo,
+                                                        {:class => :Post})
+    @options = {}
+    @instance = @klass.new(@proxy, @options)
+  end
+
+  context "each" do
+    setup do
+      @instance.clear_cache
+    end
+
+    def stub_data(*values)
+      { "data" => values }
+    end
+
+    should "load the initial data if its not yet loaded" do
+      @instance.expects(:load!).once
+      @instance.each {}
+    end
+
+    should "load as page end is reached" do
+      @instance.expects(:load!).once.returns(false)
+
+      data = [stub_data(1,2,3), stub_data(4,5,6)]
+      @instance.instance_variable_set(:@_data, data)
+      result = @instance.inject(0) do |acc, i|
+        acc + i
+      end
+
+      assert_equal 21, result
+    end
+
+    should "limit the data to the specified amount" do
+      data = [stub_data(1,2,3), stub_data(4,5,6), stub_data(7)]
+      @instance.options[:limit] = 2
+      @instance.instance_variable_set(:@_data, data)
+      result = @instance.inject(0) { |a,i| a + 1 }
+      assert_equal 2, result
+    end
+  end
+
+  context "loading" do
+    setup do
+      @instance.clear_cache
+    end
+
+    should "default the fields to all of the parent's if not specified" do
+      assert @instance.options[:fields].nil? # sanity check
+      @proxy.expects(:load).with() do |scope|
+        assert scope.options[:fields]
+        assert_equal Fogli::Post.properties.keys.join(","), scope.options[:fields]
+        true
+      end
+
+      @instance.load!
+    end
+
+    should "load the first page if data hasn't been loaded yet" do
+      data = mock("data")
+      @proxy.expects(:load).with(@instance).returns(data)
+      assert @instance.load!
+      assert_equal data, @instance._data.first
+    end
+
+    should "load the next page if the data has already been loaded and has next page" do
+      data = { "paging" => { "next" => "foo" } }
+      raw = { "data" => [] }
+      @proxy.stubs(:load).returns(data)
+      @instance.load!
+      Fogli::FacebookGraph.expects(:raw_get).with(data["paging"]["next"]).once.returns(raw)
+      @proxy.expects(:parse_data).with(raw).returns(raw)
+      assert @instance.load!
+      assert_equal raw, @instance._data.last
+    end
+
+    should "return false if no next page is available" do
+      data = { "paging" => { } }
+      @proxy.stubs(:load).returns(data)
+      @instance.load!
+      Fogli::FacebookGraph.expects(:raw_get).never
+      assert !@instance.load!
+    end
+  end
+end

data/test/fogli/facebook_object/connections_test.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class FacebookObjectConnectionsTest < Test::Unit::TestCase
+  class FOCTestClass
+    include Fogli::FacebookObject::Connections
+  end
+
+  setup do
+    @klass = FOCTestClass
+  end
+
+  context "class methods" do
+    context "defining connections" do
+      teardown do
+        @klass.connections.clear
+      end
+
+      should "be able to define a connection" do
+        @klass.connection(:foo, :class => :bar)
+        assert @klass.connections.keys.include?(:foo)
+      end
+
+      should "be able to define multiple connections" do
+        @klass.connection(:foo, :bar, :class => :foo)
+        assert @klass.connections.keys.include?(:foo)
+        assert @klass.connections.keys.include?(:bar)
+      end
+
+      should "raise an exception if a class is not specified" do
+        assert_raises(ArgumentError) {
+          @klass.connection(:foo)
+        }
+      end
+
+      should "be able to define options" do
+        @klass.connection(:foo, :class => :baz)
+        assert @klass.connections.keys.include?(:foo)
+        assert_equal :baz, @klass.connections[:foo][:class]
+      end
+
+      should "propagate connections" do
+        @subklass = Class.new(@klass)
+        @klass.connection(:foo, :class => :bar)
+        assert !@subklass.connections.keys.include?(:foo)
+        @klass.propagate_connections(@subklass)
+        assert @subklass.connections.keys.include?(:foo)
+      end
+    end
+  end
+end

data/test/fogli/facebook_object/properties_test.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class FacebookObjectPropertiesTest < Test::Unit::TestCase
+  class FOPTestClass
+    include Fogli::FacebookObject::Properties
+  end
+
+  setup do
+    @klass = FOPTestClass
+  end
+
+  context "class methods" do
+    context "defining properties" do
+      setup do
+        @property_klass = @klass
+      end
+
+      teardown do
+        @property_klass.properties.clear
+      end
+
+      should "be able to define a property" do
+        @property_klass.property(:foo)
+        assert @property_klass.properties.keys.include?(:foo)
+      end
+
+      should "be able to define multiple properties" do
+        @property_klass.property(:foo, :bar)
+        assert @property_klass.properties.keys.include?(:foo)
+        assert @property_klass.properties.keys.include?(:bar)
+      end
+
+      should "be able to define options" do
+        @property_klass.property(:foo, :bar => :baz)
+        assert @property_klass.properties.keys.include?(:foo)
+        assert_equal :baz, @property_klass.properties[:foo][:bar]
+      end
+
+      should "propagate properties" do
+        @subklass = Class.new(@property_klass)
+        @property_klass.property :foo
+        assert !@subklass.properties.keys.include?(:foo)
+        @property_klass.propagate_properties(@subklass)
+        assert @subklass.properties.keys.include?(:foo)
+      end
+    end
+  end
+
+  context "with an instance" do
+    setup do
+      @klass.property :id
+      @instance = @klass.new
+    end
+
+    teardown do
+      @klass.properties.clear
+    end
+
+    should "set the properties based on the hash data" do
+      @instance.populate_properties({"id" => "foo"})
+      assert_equal "foo", @instance.id
+    end
+
+    should "set the properties based on the hash data [symbol]" do
+      @instance.populate_properties({:id => "foo"})
+      assert_equal "foo", @instance.id
+    end
+
+    should "detect and store NamedObjects" do
+      @instance.populate_properties({"id" => {"name" => "foo"}})
+      assert @instance.property_values[:id].is_a?(Fogli::NamedObject)
+    end
+
+    should "read NamedObject's names when reading a property" do
+      @instance.populate_properties({"id" => {"name" => "foo"}})
+      assert_equal "foo", @instance.id
+    end
+  end
+end

data/test/fogli/facebook_object/scope_methods_test.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ScopeMethodsTest < Test::Unit::TestCase
+  setup do
+    @module = Fogli::FacebookObject::ScopeMethods
+  end
+
+  context "scope methods" do
+    setup do
+      @klass = Class.new
+      @klass.send(:include, @module)
+      @instance = @klass.new
+    end
+
+    [:limit, :offset, :until, :since].each do |scope|
+      should "return a new connection scope for #{scope}" do
+        value = "#{scope}_foo"
+        result = @instance.send(scope, value)
+        assert_equal value, result.options[scope]
+        assert_equal @instance, result.proxy
+      end
+    end
+
+    should "initialize a scope for fields" do
+      tests = [
+               ["name,birthday,location"],
+               [:name, :birthday, :location],
+               [["name", :birthday], :location],
+               [["name"], [[[:birthday]], :location]]
+              ]
+
+      tests.each do |args|
+        scope = @instance.fields(*args)
+        assert_equal "name,birthday,location", scope.options[:fields]
+      end
+    end
+  end
+
+
+  context "scope initializer args" do
+    context "not a connection scope" do
+      setup do
+        @klass = Class.new
+        @klass.send(:include, @module)
+        @instance = @klass.new
+      end
+
+      should "return the proxy if not a connection scope" do
+        proxy, options = @instance._scope_initializer_args(:foo, :bar)
+        assert_equal @instance, proxy
+        assert_equal({:foo => :bar}, options)
+      end
+    end
+
+    context "in a connection scope" do
+      setup do
+        @proxy = mock("proxy")
+        @options = { :foo => :bar }
+        @instance = Fogli::FacebookObject::ConnectionScope.new(@proxy, @options)
+      end
+
+      should "return the proxy and merged options" do
+        proxy, options = @instance._scope_initializer_args(:bar, :baz)
+        assert_equal @proxy, proxy
+        assert_equal(@options.merge(:bar => :baz), options)
+      end
+    end
+  end
+end