giggly 0.1.0

data/lib/giggly/rest/socialize.rb

@@ -0,0 +1,150 @@
+module Giggly
+  module Rest
+    class Socialize
+      
+      GIGYA_URL = "http://socialize.api.gigya.com/socialize."
+      
+      attr_accessor :request
+      
+      # Create a new socialize object by passing in a <tt>Giggly::Rest::Socialize</tt> object
+      # or by passing in a hash that will be used to initialize a new <tt>Giggly::Rest::Socialize</tt>.
+      # See the rdoc for Request to find details for a new connection hash.
+      # A <tt>Giggly::Rest::Socialize</tt> is used per user (because the Request object is).
+      # example:
+      #    @socialize = Giggly::Rest::Socialize.new(@connection)
+      def initialize(request)
+        @request = request and return if request.kind_of?(Giggly::Rest::Request)
+        @request = Giggly::Rest::Request.new(request)
+      end
+
+      # Disconnects the user from the provided network.
+      # Params::
+      # * +network+ array of networks to disconnect from, if emtpy user will be disconnected from all networks
+      # Allowed values for network are facebook, myspace, twitter and yahoo.
+      def disconnect(provider = nil)
+        validate_providers! %w[facebook yahoo myspace twitter], provider
+        perform_post :disconnect, :provider => (provider.join(',') if provider)
+      end
+      
+      # retrieves the friends of the current user
+      # Params::
+      # * +enabled_providers+ comma +separated+ list of providers to include.  (ONLY) 
+      # * +disabled_providers+ comma separated list of providers to exclude. (NOT)
+      # * +uids+ list of users to retrieve.
+      # * +detail_level+ 'basic' or 'extended'
+      # Returns::
+      # * +Array+ of +Giggly::User+ objects
+      def friends_info(options = {})
+        validate_providers! %w[facebook yahoo myspace twitter], options[:enabled_providers]
+        params = provider_hash(options)
+        params[:UIDs], params[:detailLevel] = options[:uids], options[:detailLevel]
+        
+        response = perform_post(:getFriendsInfo, params)
+        friends = []
+        response['friends']['friend'].each do |friend|
+          friends << Giggly::Friend.new(friend)
+        end
+        friends
+      end
+      
+      # get raw data from an individual provider about a user
+      # Params::
+      # * +provider+ the provider to retrieve the raw data from, only facebook and myspace are currently supported
+      # * +fields+ a array of provider specific fields to retrieve
+      # Returns::
+      # * +Hash+ of the raw data
+      def raw_data(provider, fields)
+        validate_providers! %w[facebook myspace], provider
+        perform_post :getRawData, {:provider => provider, :fields => fields.join(',')}
+      end
+      
+      # get the connection info for a session with a direct api provider
+      # this is useful to make calls to a specific provider (not via Socialize)
+      # for functions that are currently unsupported by Gigya Socialize
+      # Params::
+      # * +provider+ the provider to get the connection information for, 
+      #   * possible values are facebook, myspace, twitter, or yahoo
+      # * +padding_mode+ padding mode for the AES algorithm used in encryping some of the response parameters
+      #   * values are PKCS5, PKCS7 or ZEROS PKCS7 will be used as the default
+      # See http://wiki.gigya.com/030_Gigya_Socialize_API_2.0/030_API_reference/REST_API/socialize.getSessionInfo on decrypting
+      def session_info(provider, padding_mode = 'PKCS7')
+        validate_providers! %w[facebook yahoo myspace twitter], provider
+        # TODO: possibly decrypt response
+        Giggly::SessionInfo.new perform_post(:getSessionInfo, {:provider => provider, :paddingMode => padding_mode})
+      end
+      
+      # retrieves user information from gigya, including or excluding providers
+      # as indicated.  default usage includes all providers.  returns user.
+      # Params::
+      # * +providers+ an optional hash of arrays the has the keys of 
+      # * +enabled_providers+ an array of provider strings 
+      # * +disabled_providers+ an array of provider strings 
+      def user_info(providers = {})
+        Giggly::User.new perform_post(:getUserInfo, provider_hash(providers))
+      end
+      
+      # see: http://wiki.gigya.com/030_Gigya_Socialize_API_2.0/030_API_reference/REST_API/socialize.publishUserAction
+      # for how to create user_action_xml
+      def publish_user_action(user_action_xml, providers = {})
+        validate_providers! %w[facebook yahoo], providers[:enabled_providers]
+        perform_post :publishUserAction, {:userAction => user_action_xml}.merge(provider_hash(providers))
+      end
+      
+      # Sends a notification to a list of friends
+      # Params::
+      # * +recipients+ a string or array of uids to send the notification to
+      # * +subject+ the subject line of the notification
+      # * +body+ the body of the notification, do not use html, Gigya will autolink urls
+      # this will post to both facebook and twitter
+      def send_notification(recipients, subject, body)
+        recipients = recipients.is_a?(Array) ? recipients.join(',') : recipients
+        perform_post :sendNotification, :recipients => recipients, :subject => subject, :body => body
+      end
+      
+      # sets the status of a user for the given providers (or all of them if blank)
+      # Params::
+      # * +status+ the status to set for the user
+      # * +providers+ an optional hash of arrays the has the keys of 
+      # * +enabled_providers+ an array of provider strings 
+      # * +disabled_providers+ an array of provider strings
+      def set_status(status, providers = {})
+        validate_providers! %w[facebook yahoo myspace twitter], providers[:enabled_providers]
+        perform_post :setStatus, {:status => status}.merge(provider_hash(providers))
+      end
+      
+      # sets the status of a user for all providers
+      # Params::
+      # * +status+ the status to set for the user
+      # This method will return the status if it is successful, and raise an error on failure
+      # Use set status if you want to return the response object
+      # Its just in here because we think it looks cool and its convenient
+      def status=(status)
+        set_status status
+      end
+      
+      protected
+      
+        def perform_post(action, params = {})
+          params.reject! {|k,v| v.nil?}
+          @request.post "#{GIGYA_URL}#{action}", params
+        end
+        
+        def provider_hash(providers)
+          { :enabledProviders  => (providers[:enabled_providers].join(',') if providers[:enabled_providers]),
+            :disabledProviders => (providers[:disabled_providers].join(',') if providers[:disabled_providers]) }
+        end
+        
+        def validate_providers!(valid_providers, given_providers = nil)
+          return if given_providers.nil?
+          given_providers.each do |provider|
+            raise Giggly::Rest::Socialize::InvalidProvider.new(
+              "#{provider} is not a valid provider, please only use #{valid_providers.join(' ')}"
+            ) unless valid_providers.include? provider
+          end
+        end
+        
+        class InvalidProvider < StandardError; end
+      
+    end
+  end
+end

data/lib/giggly/session_info.rb

@@ -0,0 +1,11 @@
+module Giggly
+  class SessionInfo
+    
+    attr_reader :session
+    
+    def initialize(session)
+      @session = session
+    end
+    
+  end
+end

data/lib/giggly/user.rb

@@ -0,0 +1,24 @@
+module Giggly
+  class User
+    
+    attr_reader :data
+    
+    def initialize(data)
+      @data = data
+    end
+
+    def user_id
+      @data["UID"]
+    end
+
+    def [](value) 
+      @data[value.to_s]
+    end
+    
+    def method_missing(method, *args)
+      super unless @data[method.to_s]
+      @data[method.to_s]
+    end
+
+  end
+end

data/test/fake_socialize.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+require 'yaml'
+
+# sets up a socialize faker.
+#
+# example::
+# <tt>
+# FakeSocialize.setup_response("disconnect", :success)
+# </tt>
+class FakeSocialize
+  
+  @@responses ||= {}
+
+  def self.setup_response(method_ref, response_name)
+    reload_responses if @@responses.nil? || @@responses.empty?
+    response = @@responses[method_ref]
+    FakeWeb.register_uri(
+      response[:request_type], 
+      Regexp.new(Giggly::Rest::Socialize::GIGYA_URL + response[:method_name]), 
+      :body => response[response_name]
+    )
+    return response.merge({:response_key => "socialize.#{response[:method_name]}Response"})
+  end
+  
+  def self.reload_responses
+    responses = {}
+    Dir.new(File.join(File.dirname(__FILE__), 'responses')).each do |filename|
+      file_path = File.join(File.dirname(__FILE__), 'responses', filename)
+      next unless File.file?(file_path)
+      responses.merge!(YAML.load(File.read(file_path))) if File.file?(file_path) 
+    end
+    @@responses = responses 
+  end
+  
+  
+end
+

data/test/giggly/friend_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class Giggly::FriendTest < Test::Unit::TestCase
+  
+  context "A Giggly::Friend instance" do
+    
+    setup do
+      setup_giggly_rest
+      FakeSocialize.setup_response(:friends_info, :success)
+      @friends = @giggly.friends_info
+      @friend = @friends.first
+    end
+    
+    # this is overtesting
+    should "inherit from user" do
+      @friend.kind_of? Giggly::Friend
+      @friend.kind_of? Giggly::User
+      @friend.class.superclass.should == Giggly::User
+    end
+    
+  end
+  
+end

data/test/giggly/javascript/helper_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+# TODO
+
+#class Giggly::Javascript::Helper < Test::Unit::TestCase
+  
+#end

data/test/giggly/javascript/socialize_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class Giggly::Javascript::SocializeTest < Test::Unit::TestCase
+  
+  context "A Giggly::Javascript::Socialize instance" do
+    
+    setup do
+      @giggly = Giggly::Javascript::Socialize.new(:api_key => 'API_KEY', :enabled_providers => %w[facebook yahoo twitter])
+    end
+    
+    should "should have a config hash with no nil values" do
+      @giggly.to_config.should == {'APIKey' => 'API_KEY', 'enabledProviders'  => 'facebook,yahoo,twitter'}
+    end
+    
+    should "return the config as a string for javascript" do
+      @giggly.config_to_js.class.should == String
+      @giggly.config_to_js.should =~ /APIKey/
+      @giggly.config_to_js.should =~ /enabledProviders/
+    end
+    
+    should "return a script tag with the path to the giggly socialize js api file" do
+      @giggly.include_gigya_socialize =~ /giggly-socialize-min/
+    end
+    
+    should "allow a custom path to the giggly socialize api file" do
+      @giggly.include_gigya_socialize('/somewhere') =~ /somewhere/
+    end
+    
+    should "require the non minified giggly socialize api file if min is false" do
+      @giggly.include_gigya_socialize('/javascripts', false).should_not =~ /min\.js/
+    end
+    
+  end
+  
+end

data/test/giggly/rest/request_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class Giggly::Rest::RequestTest < Test::Unit::TestCase
+  
+  context "A Giggly::Rest::Request instance" do
+    setup do
+      @request = Giggly::Rest::Request.new(
+        :api_key => 'TEST_KEY',
+        :secret_key => 'SECRET_KEY',
+        :user_id    => 'GIGYA_USER_ID'
+      )
+    end
+    
+    # this is a sanity check for the signature method
+    # the signature is the test was generated using the signature method which we know
+    # currently works with gigya, see http://twitter.com/_ah/status/4567114726
+    # which was posted from irb using Giggly
+    should "create a valid signature" do
+      Time.stubs(:now).returns(1254940826)
+      params = @request.sign('POST', "#{Giggly::Rest::Socialize::GIGYA_URL}getUserInfo", {})
+      'olilJCSJzaBmzb9tsHH8LmJpYp0='.should == params['sig']
+    end
+    
+  end
+  
+end

data/test/giggly/rest/socialize_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+
+class Giggly::Rest::SocializeTest < Test::Unit::TestCase
+  
+  context "A Giggly::Rest::Socialize Instance" do
+    setup do
+      setup_giggly_rest
+    end
+    
+    should "disconnect the user" do
+      FakeSocialize.setup_response(:disconnect, :success)
+      response = @giggly.disconnect
+      response.should be_successful
+    end
+    
+    should "get friends info and return array of Giggly::Friend objects" do
+      FakeSocialize.setup_response(:friends_info, :success)
+      friends = @giggly.friends_info
+      assert friends.size > 0
+      friends.each do |friend|
+        friend.class.should == Giggly::Friend
+      end
+    end
+    
+    should "get raw data and return it as a string" do
+      FakeSocialize.setup_response(:raw_data, :success)
+      response = @giggly.raw_data('facebook', %w[birthday name])
+      response.should be_successful
+      response['data'].should == '[{"birthday":"May 31, 1972","name":"Bobo"}]'
+    end
+    
+    should "get the session info for the current gigya connection" do
+      FakeSocialize.setup_response(:session_info, :success)
+      session_info = @giggly.session_info('facebook')
+      session_info.class.should == Giggly::SessionInfo
+      session_info.session.should_not be_nil
+    end
+    
+    should "get the user's info as a user object" do
+      FakeSocialize.setup_response(:user_info, :success)
+      user = @giggly.user_info
+      user.class.should == Giggly::User
+    end
+    
+    should "published the user action" do
+      FakeSocialize.setup_response(:publish_user_action, :success)
+      response = @giggly.publish_user_action 'this would be valid xml in real life ^_^'
+      response.should be_successful
+    end
+    
+    should "set the users status via set_status" do
+      FakeSocialize.setup_response(:status=, :success)
+      response = @giggly.set_status 'the giggly gem is so awesome!', :enabled_providers => %w[facebook twitter]
+      response.should be_successful
+    end
+    
+    should "set the users status via status=" do
+      FakeSocialize.setup_response(:status=, :success)
+      status = 'the giggly gem is so awesome!'
+      response = @giggly.status = status
+      response.class.should == String
+      response.should == status
+    end
+    
+    should "raise an exception on failing to set the user's status in status=" do
+      FakeSocialize.setup_response(:status=, :failure)
+      lambda {@giggly.status = 'the giggly gem is so awesome!'}.should raise_error(Giggly::Rest::Unauthorized)
+    end
+    
+    should "raise an exception if an invalid provider is given" do
+      FakeSocialize.setup_response(:status=, :success) # just incase of failure
+      fail = lambda {@giggly.set_status 'Fail! #ftw', :enabled_providers => %w[twitter google]}
+      fail.should raise_error(Giggly::Rest::Socialize::InvalidProvider)
+    end
+    
+    should "throw an exception on failure" do
+      FakeSocialize.setup_response(:disconnect, :failure)
+      lambda {@giggly.disconnect}.should raise_error(Giggly::Rest::Unauthorized)
+    end
+    
+    should "send notification to users friends" do
+      FakeSocialize.setup_response(:send_notification, :success)
+      #response = @giggly.send_notification %w[_gigya_uid1 _gigya_uid2], 'this is a test', 'this is only a test'
+      response = @giggly.send_notification 'foo', 'bar', 'baz'
+      response.should be_successful
+    end
+    
+  end
+  
+end

data/test/giggly/user_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class Giggly::UserTest < Test::Unit::TestCase
+  
+  context "A Giggly::User instance" do
+    
+    setup do
+      setup_giggly_rest
+      FakeSocialize.setup_response(:user_info, :success)
+      @user = @giggly.user_info
+    end
+    
+    should "have data" do
+      @user.data.should_not be_nil
+    end
+    
+    should "have a user_id" do
+      @user.user_id.should_not be_nil
+      @user.user_id.should == '000000'
+    end
+    
+    should "allow access to top level items in the data hash via method calls" do
+      @user.should_not respond_to(:nickname)
+      @user.nickname.should == 'Bobo'
+      @user.data['nickname'].should == 'Bobo'
+    end
+    
+  end
+  
+end

data/test/responses/disconnect.yml

@@ -0,0 +1,19 @@
+:disconnect:
+    :method_name: "disconnect"
+    :request_type: :post
+    :success: >
+        <?xml version="1.0" encoding="utf-8" ?>
+        <socialize.disconnectResponse xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+        xsi:schemaLocation="urn:com:gigya:api http://socialize.api.gigya.com/schema/1.0.xsd" xmlns="urn:com:gigya:api">
+            <statusCode>200</statusCode>
+            <statusReason>OK</statusReason>
+        </socialize.disconnectResponse>
+    :failure: >
+        <?xml version="1.0" encoding="utf-8" ?>
+        <socialize.disconnectResponse xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+        xsi:schemaLocation="urn:com:gigya:api http://socialize.api.gigya.com/schema/1.0.xsd" xmlns="urn:com:gigya:api">
+            <statusCode>401</statusCode>
+            <statusReason>OK</statusReason>
+            <errorCode>123456</errorCode>
+            <description>FAIL</description>
+        </socialize.disconnectResponse>