rest-more 0.7.0

data/test/client/facebook/test_page.rb

@@ -0,0 +1,106 @@
+
+require 'rest-core/test'
+
+describe RestCore::Facebook do
+  after do
+    WebMock.reset!
+    RR.verify
+  end
+
+  should 'get the next/prev page' do
+    rg = RestCore::Facebook.new(:site => '', :cache => false)
+    %w[next previous].each{ |type|
+      kind = "#{type}_page"
+      rg.send(kind, {})              .should.eq nil
+      rg.send(kind, {'paging' => []}).should.eq nil
+      rg.send(kind, {'paging' => {}}).should.eq nil
+
+      stub_request(:get, 'zzz').to_return(:body => '["ok"]')
+      rg.send(kind, {'paging' => {type => 'zzz'}}).should.eq ['ok']
+    }
+  end
+
+  should 'merge all pages into one' do
+    rg = RestCore::Facebook.new(:site => '', :cache => false)
+    %w[next previous].each{ |type|
+      kind = "#{type}_page"
+      data = {'paging' => {type => 'zzz'}, 'data' => ['z']}
+
+      # invalid pages or just the page itself
+      (-1..1).each{ |page|
+        rg.for_pages(data, page, {}, kind).should == data
+      }
+
+      (2..4).each{ |pages|
+        # merge data
+        stub_request(:get, 'zzz').to_return(:body => '{"data":["y"]}')
+        rg.for_pages(data, pages, {}, kind).should.eq({'data' => %w[z y]})
+
+        # this data cannot be merged
+        stub_request(:get, 'zzz').to_return(:body => '{"data":"y"}')
+        rg.for_pages(data, pages, {}, kind).should.eq({'data' => %w[z]})
+      }
+
+      stub_request(:get, 'zzz').to_return(:body =>
+        '{"paging":{"'+type+'":"yyy"},"data":["y"]}')
+      stub_request(:get, 'yyy').to_return(:body => '{"data":["x"]}')
+
+      rg.for_pages(data, 3, {}, kind).should.eq({'data' => %w[z y x]})
+    }
+  end
+
+  should 'for_pages with callback' do
+    rg = RestCore::Facebook.new(:site => '', :cache => false)
+    %w[next previous].each{ |type|
+      kind = "#{type}_page"
+      data = {'paging' => {type => 'zzz'}, 'data' => ['z']}
+
+      # invalid pages or just the page itself
+      nils = 0
+      ranges = -1..1
+      ranges.each{ |page|
+        rg.for_pages(data, page, {}, kind){ |r|
+          if r
+            r.should.eq data
+          else
+            nils += 1
+          end
+        }.should.eq data
+      }
+      nils.should.eq ranges.to_a.size
+
+      (2..4).each{ |pages|
+        # merge data
+        stub_request(:get, 'zzz').to_return(:body => '{"data":["y"]}')
+        expects = [{'data' => %w[y]}, nil]
+        rg.for_pages(data, pages, {}, kind){ |r|
+          r.should.eq expects.shift
+        }.should.eq({'data' => %w[z y]})
+        expects.empty?.should.eq true
+
+        # this data cannot be merged
+        stub_request(:get, 'zzz').to_return(:body => '{"data":"y"}')
+        expects = [{'data' => 'y'}, nil]
+        rg.for_pages(data, pages, {}, kind){ |r|
+          r.should.eq expects.shift
+        }.should.eq({'data' => %w[z]})
+        expects.empty?.should.eq true
+      }
+
+      stub_request(:get, 'zzz').to_return(:body =>
+        '{"paging":{"'+type+'":"yyy"},"data":["y"]}')
+      stub_request(:get, 'yyy').to_return(:body => '{"data":["x"]}')
+
+      expects = [{'data' => %w[y]}, {'data' => %w[x]}, nil]
+      rg.for_pages(data, 3, {}, kind){ |rr|
+        if rr
+          r = rr.dup
+          r.delete('paging')
+        else
+          r = rr
+        end
+        r.should.eq expects.shift
+      }.should.eq({'data' => %w[z y x]})
+    }
+  end
+end

data/test/client/facebook/test_parse.rb

@@ -0,0 +1,166 @@
+
+require 'rest-core/test'
+
+describe RestCore::Facebook do
+
+  should 'return nil if parse error, but not when call data directly' do
+    rg = RestCore::Facebook.new
+    rg.parse_cookies!({}).should.eq nil
+    rg.data              .should.eq({})
+  end
+
+  should 'parse if fbs contains json as well' do
+    algorithm = 'HMAC-SHA256'
+    user      = '{"country"=>"us", "age"=>{"min"=>21}}'
+    data      = {'algorithm' => algorithm, 'user' => user}
+    rg        = RestCore::Facebook.new(:data => data, :secret => 'secret')
+    sig       = rg.send(:calculate_sig, data)
+    rg.parse_fbs!("\"#{rg.fbs}\"").should.eq data.merge('sig' => sig)
+  end
+
+  should 'extract correct access_token or fail checking sig' do
+    access_token = '1|2-5|f.'
+    app_id       = '1829'
+    secret       = app_id.reverse
+    sig          = '398262caea8442bd8801e8fba7c55c8a'
+    fbs          = "access_token=#{CGI.escape(access_token)}&expires=0&" \
+                   "secret=abc&session_key=def-456&sig=#{sig}&uid=3"
+
+    check = lambda{ |token, fbs1|
+      http_cookie =
+        "__utma=123; __utmz=456.utmcsr=(d)|utmccn=(d)|utmcmd=(n); " \
+        "fbs_#{app_id}=#{fbs1}"
+
+      rg  = RestCore::Facebook.new(:app_id => app_id, :secret => secret)
+      rg.parse_rack_env!('HTTP_COOKIE' => http_cookie).
+                      should.kind_of?(token ? Hash : NilClass)
+      rg.access_token.should.eq token
+
+      rg.parse_rack_env!('HTTP_COOKIE' => nil).should.eq nil
+      rg.data.should.eq({})
+
+      rg.parse_cookies!({"fbs_#{app_id}" => fbs1}).
+                      should.kind_of?(token ? Hash : NilClass)
+      rg.access_token.should.eq token
+
+      rg.parse_fbs!(fbs1).
+                      should.kind_of?(token ? Hash : NilClass)
+      rg.access_token.should.eq token
+    }
+    check.call(access_token, fbs)
+    check.call(access_token, "\"#{fbs}\"")
+    fbs << '&inject=evil"'
+    check.call(nil, fbs)
+    check.call(nil, "\"#{fbs}\"")
+  end
+
+  should 'not pass if there is no secret, prevent from forgery' do
+    rg = RestCore::Facebook.new
+    rg.parse_fbs!('"feed=me&sig=bddd192cf27f22c05f61c8bea24fa4b7"').
+      should.eq nil
+  end
+
+  should 'parse json correctly' do
+    rg = RestCore::Facebook.new
+
+    rg.parse_json!('bad json')    .should.eq nil
+    rg.parse_json!('{"no":"sig"}').should.eq nil
+    rg.parse_json!('{"feed":"me","sig":"bddd192cf27f22c05f61c8bea24fa4b7"}').
+      should.eq nil
+
+    rg = RestCore::Facebook.new(:secret => 'bread')
+    rg.parse_json!('{"feed":"me","sig":"20393e7823730308938a86ecf1c88b14"}').
+      should.eq({'feed' => 'me', 'sig' => "20393e7823730308938a86ecf1c88b14"})
+    rg.data.empty?.should.eq false
+    rg.parse_json!('bad json')
+    rg.data.empty?.should.eq true
+  end
+
+  describe 'signed_request' do
+    def encode str
+      [str].pack('m').tr("\n=", '').tr('+/', '-_')
+    end
+
+    def setup_sr secret, data, sig=nil
+      json_encoded = encode(RestCore::JsonDecode.json_encode(data))
+      sig ||= OpenSSL::HMAC.digest('sha256', secret, json_encoded)
+      "#{encode(sig)}.#{json_encoded}"
+    end
+
+    should 'parse invalid' do
+      RC::Facebook.new.parse_signed_request!('bad').should.eq nil
+    end
+
+    should 'parse' do
+      secret = 'aloha'
+      rg = RestCore::Facebook.new(:secret => secret)
+      rg.parse_signed_request!(setup_sr(secret, {'ooh' => 'dir',
+                                                 'moo' => 'bar'}))
+      rg.data['ooh'].should.eq 'dir'
+      rg.data['moo'].should.eq 'bar'
+
+      rg.parse_signed_request!(setup_sr(secret, {'ooh' => 'dir',
+                                                 'moo' => 'bar'}, 'wrong')).
+                                               should.eq nil
+      rg.data                                 .should.eq({})
+    end
+
+    should 'fbsr and cookies with fbsr' do
+      secret       = 'lulala'
+      code         = 'lalalu'
+      access_token = 'lololo'
+      user_id      = 123
+      app_id       = 456
+      rg           = RestCore::Facebook.new(:secret => secret,
+                                            :app_id => app_id)
+      mock(rg).authorize!(hash_including(:code => code)){
+        rg.data = {'access_token' => access_token}
+      }.times(2)
+
+      check = lambda{
+        rg.data['code']        .should.eq code
+        rg.data['access_token'].should.eq access_token
+        rg.data['user_id']     .should.eq user_id
+      }
+
+      rg.parse_fbsr!(setup_sr(secret, 'code' => code, 'user_id' => user_id))
+      check.call
+      rg.data = nil
+      rg.data.should.eq({})
+
+      rg.parse_cookies!("fbsr_#{app_id}" =>
+        setup_sr(secret, 'code' => code, 'user_id' => user_id))
+      check.call
+    end
+  end
+
+  should 'fallback to ruby-hmac if Digest.new raise an runtime error' do
+    key, data = 'top', 'secret'
+    digest = OpenSSL::HMAC.digest('sha256', key, data)
+    mock(OpenSSL::HMAC).digest('sha256', key, data){ raise 'boom' }
+    RestCore::Hmac.sha256(key, data).should.eq digest
+  end
+
+  should 'generate correct fbs with correct sig' do
+    RestCore::Facebook.new(:access_token => 'fake', :secret => 's').fbs.
+      should.eq \
+      "access_token=fake&sig=#{Digest::MD5.hexdigest('access_token=fakes')}"
+  end
+
+  should 'parse fbs from facebook response which lacks sig...' do
+    rg = RestCore::Facebook.new(:access_token => 'a', :secret => 'z')
+    rg.parse_fbs!(rg.fbs)                           .should.kind_of?(Hash)
+    rg.data.empty?.should.eq false
+    rg.parse_fbs!(rg.fbs.sub(/sig\=\w+/, 'sig=abc')).should.eq nil
+    rg.data.empty?.should.eq true
+  end
+
+  should 'generate correct fbs with additional parameters' do
+    rg = RestCore::Facebook.new(:access_token => 'a', :secret => 'z')
+    rg.data['expires'] = '1234'
+    rg.parse_fbs!(rg.fbs).should.kind_of?(Hash)
+    rg.access_token      .should.eq 'a'
+    rg.data['expires']   .should.eq '1234'
+  end
+
+end

data/test/client/facebook/test_serialize.rb

@@ -0,0 +1,43 @@
+
+require 'rest-core/test'
+
+describe RestCore::Facebook do
+  after do
+    WebMock.reset!
+    RR.verify
+  end
+
+  should 'be serialized with lighten' do
+    engines = begin
+                require 'psych'
+                YAML::ENGINE.yamler = 'psych' # TODO: probably a bug?
+                [Psych, YAML, Marshal]
+              rescue LoadError
+                [YAML, Marshal]
+              end
+
+    # sorry, it is marshal in 1.8 is broken
+    if defined?(RUBY_ENGINE)
+      if RUBY_ENGINE  == 'ruby' && RUBY_VERSION == '1.8.7'
+        engines.pop # REE 1.8.7
+      end
+    else
+      engines.pop # MRI 1.8.7
+    end
+
+    engines.each{ |engine|
+      test = lambda{ |obj| engine.load(engine.dump(obj)) }
+        rg = RestCore::Facebook.new(:log_handler => lambda{})
+      lambda{ test[rg] }.should.raise(TypeError)
+      test[rg.lighten].should.eq rg.lighten
+      lambda{ test[rg] }.should.raise(TypeError)
+      rg.lighten!
+      test[rg.lighten].should.eq rg
+    }
+  end
+
+  should 'lighten takes options to change attributes' do
+    RestCore::Facebook.new.lighten(:timeout => 100    ).timeout.should.eq 100
+    RestCore::Facebook.new.lighten(:lang    => 'zh-TW').lang.should.eq 'zh-TW'
+  end
+end

data/test/client/facebook/test_timeout.rb

@@ -0,0 +1,22 @@
+
+require 'rest-core/test'
+
+describe RestCore::Facebook do
+  after do
+    WebMock.reset!
+    RR.verify
+  end
+
+  should 'respect timeout' do
+    stub_request(:get, 'https://graph.facebook.com/me').
+      to_return(:body => '{}')
+    mock.proxy(Timeout).timeout(numeric)
+    RestCore::Facebook.new.get('me').should.eq({})
+  end
+
+  should 'override timeout' do
+    mock(Timeout).timeout(99){ {RestCore::Facebook::RESPONSE_BODY => true} }
+    RestCore::Facebook.new(:timeout => 1).get('me', {}, :timeout => 99).
+      should.eq true
+  end
+end

data/test/client/flurry/test_metrics.rb

@@ -0,0 +1,83 @@
+
+require 'rest-core/test'
+
+require 'time'
+
+describe RestCore::Flurry do
+  after do
+    WebMock.reset!
+    RR.verify
+  end
+
+  before do
+    startDate = '2011-08-23'
+    endDate   = '2011-09-19'
+    @flurry = RestCore::Flurry.new
+    stub(Time).now{ Time.parse(endDate, nil) }
+    stub_request(:get,
+      "http://api.flurry.com/appMetrics/ActiveUsers?" \
+      "startDate=#{startDate}&endDate=#{endDate}").
+      to_return(:body =>
+        '{"@startDate":"2011-08-23",
+          "@metric":"ActiveUsersByDay",
+          "@endDate":"2011-09-19",
+          "@version":"1.0",
+          "@generatedDate":"9/19/11 5:54 AM",
+          "day":
+            [{"@value":"34722","@date":"2011-08-23"},
+             {"@value":"33560","@date":"2011-08-24"},
+             {"@value":"34392","@date":"2011-08-25"},
+             {"@value":"37737","@date":"2011-08-26"},
+             {"@value":"41332","@date":"2011-08-27"},
+             {"@value":"40456","@date":"2011-08-28"},
+             {"@value":"34950","@date":"2011-08-29"},
+             {"@value":"34076","@date":"2011-08-30"},
+             {"@value":"32096","@date":"2011-08-31"},
+             {"@value":"31558","@date":"2011-09-01"},
+             {"@value":"33467","@date":"2011-09-02"},
+             {"@value":"39306","@date":"2011-09-03"},
+             {"@value":"40233","@date":"2011-09-04"},
+             {"@value":"37777","@date":"2011-09-05"},
+             {"@value":"35829","@date":"2011-09-06"},
+             {"@value":"35960","@date":"2011-09-07"},
+             {"@value":"34871","@date":"2011-09-08"},
+             {"@value":"36683","@date":"2011-09-09"},
+             {"@value":"44077","@date":"2011-09-10"},
+             {"@value":"45057","@date":"2011-09-11"},
+             {"@value":"37750","@date":"2011-09-12"},
+             {"@value":"35223","@date":"2011-09-13"},
+             {"@value":"34918","@date":"2011-09-14"},
+             {"@value":"37587","@date":"2011-09-15"},
+             {"@value":"40972","@date":"2011-09-16"},
+             {"@value":"45412","@date":"2011-09-17"},
+             {"@value":"43920","@date":"2011-09-18"},
+             {"@value":"6516","@date":"2011-09-19"}]}')
+
+    @active_users =
+      [["2011-09-19",  6516], ["2011-09-18", 43920], ["2011-09-17", 45412],
+       ["2011-09-16", 40972], ["2011-09-15", 37587], ["2011-09-14", 34918],
+       ["2011-09-13", 35223], ["2011-09-12", 37750], ["2011-09-11", 45057],
+       ["2011-09-10", 44077], ["2011-09-09", 36683], ["2011-09-08", 34871],
+       ["2011-09-07", 35960], ["2011-09-06", 35829], ["2011-09-05", 37777],
+       ["2011-09-04", 40233], ["2011-09-03", 39306], ["2011-09-02", 33467],
+       ["2011-09-01", 31558], ["2011-08-31", 32096], ["2011-08-30", 34076],
+       ["2011-08-29", 34950], ["2011-08-28", 40456], ["2011-08-27", 41332],
+       ["2011-08-26", 37737], ["2011-08-25", 34392], ["2011-08-24", 33560],
+       ["2011-08-23", 34722]]
+
+    @weekly = [244548, 270227, 248513, 257149]
+  end
+
+  should 'metrics("ActiveUsers")' do
+    @flurry.metrics('ActiveUsers', {}, :weeks => 4).should.eq @active_users
+
+  end
+
+  should 'weekly(metrics("ActiveUsers"))' do
+    @flurry.weekly(@active_users).should.eq @weekly
+  end
+
+  should 'sum(weekly(metrics("ActiveUsers")))' do
+    @flurry.sum(@weekly).should.eq [1020437, 775889, 505662, 257149]
+  end
+end

data/test/client/twitter/test_api.rb

@@ -0,0 +1,37 @@
+
+require 'rest-core/test'
+
+describe RestCore::Twitter do
+  after do
+    WebMock.reset!
+    RR.verify
+  end
+
+  should 'get right' do
+    stub_request(:get, 'https://api.twitter.com/me').
+      to_return(:body => '{"status": "OK"}')
+
+    RestCore::Twitter.new.get('me').should.eq({'status' => 'OK'})
+  end
+
+  def check status, klass
+    stub_request(:delete, 'https://api.twitter.com/123').to_return(
+      :body => '{}', :status => status)
+
+    lambda{
+      RestCore::Twitter.new.delete('123')
+    }.should.raise(klass)
+
+    WebMock.reset!
+  end
+
+  should 'raise exception when encountering error' do
+    [401, 402, 403].each{ |status|
+      check(status, RestCore::Twitter::Error)
+    }
+
+    [500, 502, 503].each{ |status|
+      check(status, RestCore::Twitter::Error::ServerError)
+    }
+  end
+end