leancloud-ruby-client 0.1.0

data/test/middleware/better_retry_test.rb

@@ -0,0 +1,57 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+
+module Middleware
+  class BeterRetryTest < Faraday::TestCase
+    def setup
+      @times_called = 0
+    end
+
+    def conn(retry_options = {})
+      Faraday.new do |b|
+        b.use Faraday::BetterRetry, retry_options
+        b.adapter :test do |stub|
+          stub.post('/unstable') {
+            @times_called += 1
+            @explode.call @times_called
+          }
+        end
+      end
+    end
+
+    def test_unhandled_error
+      @explode = lambda {|n| raise "boom!" }
+      assert_raise(RuntimeError) { conn.post("/unstable") }
+      assert_equal 1, @times_called
+    end
+
+    def test_handled_error
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raise(Errno::ETIMEDOUT) { conn.post("/unstable") }
+      assert_equal 3, @times_called
+    end
+
+    def test_new_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raise(Errno::ETIMEDOUT) { conn(:max => 3).post("/unstable") }
+      assert_equal 4, @times_called
+    end
+
+    def test_interval
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      started  = Time.now
+      assert_raise(Errno::ETIMEDOUT) {
+        conn(:max => 2, :interval => 0.1).post("/unstable")
+      }
+      assert_in_delta 0.2, Time.now - started, 0.03
+    end
+
+    def test_custom_exceptions
+      @explode = lambda {|n| raise "boom!" }
+      assert_raise(RuntimeError) {
+        conn(:exceptions => StandardError).post("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+  end
+end

data/test/middleware/extend_parse_json_test.rb

@@ -0,0 +1,55 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+
+module Middleware
+  class ExtedParseJsonTest < Faraday::TestCase
+
+    def conn(retry_options = {})
+      Faraday.new do |b|
+        b.use Faraday::ExtendedParseJson
+        b.adapter :test do |stub|
+          stub.get('/invalid_json')     { [200, {}, 'something'] }
+          stub.get('/valid_json')       { [200, {}, {'var' => 1}.to_json] }
+          stub.get('/parse_error_code') { [403, {}, {'code' => AV::Protocol::ERROR_INTERNAL}.to_json] }
+          stub.get('/empty_response')   { [403, {}, ''] }
+          stub.get('/404')              { [404, {}, {}.to_json] }
+          stub.get('/500')              { [500, {}, {'text' => 'Internal Server Error'}.to_json] }
+        end
+      end
+    end
+
+    def test_invalid_json
+      assert_raise(Faraday::Error::ParsingError) { conn.get("/invalid_json") }
+    end
+
+    def test_valid_json
+      resp = conn.get("/valid_json")
+      assert_equal 200, resp.status
+      assert_equal ({'var' => 1}), resp.body
+    end
+
+    def test_empty_response
+      ex = assert_raise(AV::AVProtocolError) { conn.get("/empty_response") }
+      assert_match /403/, ex.to_s
+      assert_equal "HTTP Status 403 Body ", ex.error
+    end
+
+    def test_parse_error_code
+      ex = assert_raise(AV::AVProtocolError) { conn.get("/parse_error_code") }
+      assert_match /403/, ex.to_s
+      assert_equal AV::Protocol::ERROR_INTERNAL, ex.code
+    end
+
+    def test_404
+      ex = assert_raise(AV::AVProtocolError) { conn.get("/404") }
+      assert_match /404/, ex.to_s
+    end
+
+    def test_500
+      ex = assert_raise(AV::AVProtocolError) { conn.get("/500") }
+      assert_match /500/, ex.to_s
+      assert_match /Internal Server Error/, ex.to_s
+    end
+
+  end
+end

data/test/test_batch.rb

@@ -0,0 +1,132 @@
+require 'helper'
+
+class TestBatch < AVTestCase
+
+  def test_initialize
+    batch = AV::Batch.new
+    assert_equal batch.class, AV::Batch
+    assert_equal AV.client, batch.client
+
+    batch = AV::Batch.new(AV::Client.new)
+    assert_equal batch.class, AV::Batch
+    assert_not_equal AV.client, batch.client
+  end
+
+  def test_add_request
+    batch = AV::Batch.new
+    batch.add_request({
+      :method => "POST",
+      :path => "/1/classes/GameScore",
+      :body => {
+        :score => 1337,
+        :playerName => "Sean Plott"
+      }
+    })
+    batch.add_request({
+      :method => "POST",
+      :path => "/1/classes/GameScore",
+      :body => {
+        :score => 1338,
+        :playerName => "ZeroCool"
+      }
+    })
+    assert_equal batch.requests.class, Array
+    assert_equal batch.requests.length, 2
+    assert_equal batch.requests.first[:path], "/1/classes/GameScore"
+  end
+
+  def test_protocol_uri
+    uri = AV::Protocol.batch_request_uri
+    assert_equal uri, "/1.1/batch"
+  end
+
+  def test_run
+    VCR.use_cassette('test_batch_run', :record => :new_episodes) do
+      batch = AV::Batch.new
+      batch.add_request({
+        "method" => "POST",
+        "path" => "/1/classes/GameScore",
+        "body" => {
+          "score" => 1337,
+          "playerName" => "Sean Plott"
+        }
+      })
+      resp = batch.run!
+      assert_equal resp.length, batch.requests.length
+      assert resp.first["success"]
+      assert_equal resp.first["success"]["objectId"].class, String
+    end
+  end
+
+  def test_create_object
+    VCR.use_cassette('test_batch_create_object', :record => :new_episodes) do
+      objects = [1, 2, 3, 4, 5].map do |i|
+        p = AV::Object.new("BatchTestObject")
+        p["foo"] = "#{i}"
+        p
+      end
+      batch = AV::Batch.new
+      objects.each do |obj|
+        batch.create_object(obj)
+      end
+      resp = batch.run!
+      assert_equal Array, resp.class
+      assert_equal resp.first["success"]["objectId"].class, String
+    end
+  end
+
+  def test_update_object
+    VCR.use_cassette('test_batch_update_object', :record => :new_episodes) do
+      objects = [1, 2, 3, 4, 5].map do |i|
+        p = AV::Object.new("BatchTestObject")
+        p["foo"] = "#{i}"
+        p.save
+        p
+      end
+      objects.map do |obj|
+        obj["foo"] = "updated"
+      end
+      batch = AV::Batch.new
+      objects.each do |obj|
+        batch.update_object(obj)
+      end
+      resp = batch.run!
+      assert_equal Array, resp.class
+      assert_equal resp.first["success"]["updatedAt"].class, String
+    end
+  end
+
+  def test_update_nils_delete_keys
+    VCR.use_cassette('test_batch_update_nils_delete_keys', :record => :new_episodes) do
+      post = AV::Object.new("BatchTestObject")
+      post["foo"] = "1"
+      post.save
+
+      post["foo"] = nil
+      batch = AV::Batch.new
+      batch.update_object(post)
+      batch.run!
+
+      assert_false post.refresh.keys.include?("foo")
+    end
+  end
+
+  def test_delete_object
+    VCR.use_cassette('test_batch_delete_object', :record => :new_episodes) do
+      objects = [1, 2, 3, 4, 5].map do |i|
+        p = AV::Object.new("BatchTestObject")
+        p["foo"] = "#{i}"
+        p.save
+        p
+      end
+      batch = AV::Batch.new
+      objects.each do |obj|
+        batch.delete_object(obj)
+      end
+      resp = batch.run!
+      assert_equal Array, resp.class
+      assert_equal resp.first["success"], {}
+    end
+  end
+
+end

data/test/test_client.rb

@@ -0,0 +1,183 @@
+require 'helper'
+
+class TestClient < AVTestCase
+
+  def stubbed_client(&block)
+    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+      yield(stub)
+    end
+
+    client = AV.init(
+      :logger => Logger.new(STDERR).tap {
+        |l| l.level = Logger::ERROR
+      }
+    ) do |b|
+      b.adapter :test, stubs
+    end
+
+    [stubs, client]
+  end
+
+  def test_retries
+    VCR.use_cassette('test_retries', :record => :new_episodes) do
+
+      stubs, client = stubbed_client do |stub|
+        (@client.max_retries + 1).times do
+          stub.get('/') {[ 500, {}, {
+            'code' => AV::Protocol::ERROR_TIMEOUT}.to_json
+          ]}
+        end
+      end
+
+      assert_raise do
+        client.request('/')
+      end
+
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  def test_retries_json_error
+    VCR.use_cassette('test_retries_json_error', :record => :new_episodes) do
+      stubs, client = stubbed_client do |stub|
+        stub.get('/') {[ 500, {}, '<HTML>this is not json</HTML>' ]}
+        stub.get('/') {[ 200, {}, '{"foo":100}' ]}
+      end
+
+      assert_equal({ "foo" => 100 }, client.request('/'))
+
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  def test_retries_server_error
+    VCR.use_cassette('test_retries_server_error', :record => :new_episodes) do
+
+      stubs, client = stubbed_client do |stub|
+        stub.get('/') {[ 500, {}, '{}' ]}
+        stub.get('/') {[ 200, {}, '{"foo":100}' ]}
+      end
+
+      assert_equal({ "foo" => 100 }, client.request('/'))
+
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  def test_not_retries_404
+    VCR.use_cassette('test_retries_404', :record => :new_episodes) do
+
+      stubs, client = stubbed_client do |stub|
+        stub.get('/') {[ 404, {}, 'Not found' ]}
+        stub.get('/') {[ 200, {}, '{"foo":100}' ]}
+      end
+
+      assert_raise do
+        client.request('/')
+      end
+    end
+  end
+
+  def test_not_retries_404_with_correct_json
+    VCR.use_cassette('test_retries_404_correct', :record => :new_episodes) do
+
+      stubs, client = stubbed_client do |stub|
+        stub.get('/') {[ 404, {}, '{"foo":100}' ]}
+        stub.get('/') {[ 200, {}, '{"foo":100}' ]}
+      end
+
+      assert_raise do
+        client.request('/')
+      end
+    end
+  end
+
+  def test_empty_response
+    VCR.use_cassette('test_empty_response', :record => :new_episodes) do
+      stubs, client = stubbed_client do |stub|
+        stub.get('/') {[ 403, {}, 'nonparseable' ]}
+      end
+
+      # some json parsers return nil instead of raising
+      JSON.stubs(:parse).returns(nil)
+
+      begin
+        client.request('/')
+        raise "client error response should have raised"
+      rescue AV::AVProtocolError => e
+        assert_equal "HTTP Status 403 Body nonparseable", e.error
+      end
+
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  def test_simple_save
+    VCR.use_cassette('test_simple_save', :record => :new_episodes) do
+      test_save = AV::Object.new "TestSave"
+      test_save["foo"] = "bar"
+      test_save.save
+
+      assert_equal test_save["foo"], "bar"
+      assert_equal test_save[AV::Protocol::KEY_CREATED_AT].class, String
+      assert_equal test_save[AV::Protocol::KEY_OBJECT_ID].class, String
+    end
+  end
+
+  def test_update
+    VCR.use_cassette('test_update', :record => :new_episodes) do
+      foo = AV::Object.new "TestSave"
+      foo["age"] = 20
+      foo.save
+
+      assert_equal foo["age"], 20
+      assert_equal foo[AV::Protocol::KEY_UPDATED_AT], nil
+
+      foo["age"] = 40
+      orig = foo.dup
+      foo.save
+
+      assert_equal foo["age"], 40
+      assert_equal foo[AV::Protocol::KEY_UPDATED_AT].class, String
+
+      # only difference should be updatedAt
+      orig_assoc = orig.reject{|k,v| k == AV::Protocol::KEY_UPDATED_AT}.to_a
+      foo_assoc = foo.reject{|k,v| k == AV::Protocol::KEY_UPDATED_AT}.to_a
+      assert_equal foo_assoc, orig_assoc
+    end
+  end
+
+  def test_server_update
+    VCR.use_cassette('test_server_update', :record => :new_episodes) do
+      foo = AV::Object.new("TestSave").save
+      foo["name"] = 'john'
+      foo.save
+
+      bar = AV.get("TestSave",foo.id) # pull it from the server
+      assert_equal bar["name"], 'john'
+      bar["name"] = 'dave'
+      bar.save
+
+      bat = AV.get("TestSave",foo.id)
+      assert_equal bat["name"], 'dave'
+    end
+  end
+
+  def test_destroy
+    VCR.use_cassette('test_destroy', :record => :new_episodes) do
+      d = AV::Object.new "toBeDeleted"
+      d["foo"] = "bar"
+      d.save
+      d.parse_delete
+
+      assert_equal d.keys.length, 0
+    end
+  end
+
+  def test_get_missing
+    VCR.use_cassette('test_get_missing', :record => :new_episodes) do
+      e = assert_raise(AV::AVProtocolError) { AV.get("SomeClass", "someIdThatDoesNotExist") }
+      assert_equal "101: Class or object doesn't exists.: SomeClass:someIdThatDoesNotExist", e.message
+    end
+  end
+end

data/test/test_cloud.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class TestCloud < AVTestCase
+	# functions stored in test/cloud_functions/MyCloudCode
+	# see https://parse.com/docs/cloud_code_guide to learn how to use AV Cloud Code
+	#
+	# AV.Cloud.define('trivial', function(request, response) {
+  # 	response.success(request.params);
+	# });
+
+	def test_cloud_function_initialize
+		assert_not_equal nil, AV::Cloud::Function.new("trivial")
+	end
+
+    def test_request_sms
+      VCR.use_cassette('test_request_sms', :record => :new_episodes) do
+        assert_true AV::Cloud.request_sms :mobilePhoneNumber => "18668012283",:op => "test",:ttl => 5
+      end
+    end
+
+	def test_cloud_function
+		omit("this should automate the parse deploy command by committing that binary to the repo")
+
+		VCR.use_cassette('test_cloud_function', :record => :new_episodes) do
+			function = AV::Cloud::Function.new("trivial")
+			params = {"foo" => "bar"}
+			resp = function.call(params)
+			assert_equal resp, params
+		end
+	end
+end