leancloud-ruby-client 0.1.1 → 0.2.0

data/test/helper.rb

@@ -27,7 +27,6 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'leancloud-ruby-client'
 
-YAML::ENGINE.yamler='syck' # get ascii strings as strings in fixtures
 
 VCR.configure do |c|
   c.cassette_library_dir = 'fixtures/vcr_cassettes'
@@ -43,15 +42,14 @@ VCR.configure do |c|
     end
   end
 
-  filter_sensitive_header(c, AV::Protocol::HEADER_APP_ID)
-  filter_sensitive_header(c, AV::Protocol::HEADER_API_KEY)
-  filter_sensitive_header(c, AV::Protocol::HEADER_MASTER_KEY)
-  filter_sensitive_header(c, AV::Protocol::HEADER_SESSION_TOKEN)
+  filter_sensitive_header(c, LC::Protocol::HEADER_APP_ID)
+  filter_sensitive_header(c, LC::Protocol::HEADER_API_KEY)
+  filter_sensitive_header(c, LC::Protocol::HEADER_SESSION_TOKEN)
 end
 
-class AVTestCase < Test::Unit::TestCase
+class LCTestCase < Test::Unit::TestCase
   def setup
-    @client = AV.init(:logger => Logger.new(STDERR).tap{|l| l.level = Logger::ERROR})
+    @client = LC.init(:logger => Logger.new(STDERR).tap{|l| l.level = Logger::ERROR})
   end
 end
 

data/test/test_batch.rb

@@ -1,19 +1,19 @@
 require 'helper'
 
-class TestBatch < AVTestCase
+class TestBatch < LCTestCase
 
   def test_initialize
-    batch = AV::Batch.new
-    assert_equal batch.class, AV::Batch
-    assert_equal AV.client, batch.client
+    batch = LC::Batch.new
+    assert_equal batch.class, LC::Batch
+    assert_equal LC.client, batch.client
 
-    batch = AV::Batch.new(AV::Client.new)
-    assert_equal batch.class, AV::Batch
-    assert_not_equal AV.client, batch.client
+    batch = LC::Batch.new(LC::Client.new)
+    assert_equal batch.class, LC::Batch
+    assert_not_equal LC.client, batch.client
   end
 
   def test_add_request
-    batch = AV::Batch.new
+    batch = LC::Batch.new
     batch.add_request({
       :method => "POST",
       :path => "/1/classes/GameScore",
@@ -36,13 +36,13 @@ class TestBatch < AVTestCase
   end
 
   def test_protocol_uri
-    uri = AV::Protocol.batch_request_uri
+    uri = LC::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 = LC::Batch.new
       batch.add_request({
         "method" => "POST",
         "path" => "/1/classes/GameScore",
@@ -61,11 +61,11 @@ class TestBatch < AVTestCase
   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 = LC::Object.new("BatchTestObject")
         p["foo"] = "#{i}"
         p
       end
-      batch = AV::Batch.new
+      batch = LC::Batch.new
       objects.each do |obj|
         batch.create_object(obj)
       end
@@ -78,7 +78,7 @@ class TestBatch < AVTestCase
   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 = LC::Object.new("BatchTestObject")
         p["foo"] = "#{i}"
         p.save
         p
@@ -86,7 +86,7 @@ class TestBatch < AVTestCase
       objects.map do |obj|
         obj["foo"] = "updated"
       end
-      batch = AV::Batch.new
+      batch = LC::Batch.new
       objects.each do |obj|
         batch.update_object(obj)
       end
@@ -98,12 +98,12 @@ class TestBatch < AVTestCase
 
   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 = LC::Object.new("BatchTestObject")
       post["foo"] = "1"
       post.save
 
       post["foo"] = nil
-      batch = AV::Batch.new
+      batch = LC::Batch.new
       batch.update_object(post)
       batch.run!
 
@@ -114,12 +114,12 @@ class TestBatch < AVTestCase
   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 = LC::Object.new("BatchTestObject")
         p["foo"] = "#{i}"
         p.save
         p
       end
-      batch = AV::Batch.new
+      batch = LC::Batch.new
       objects.each do |obj|
         batch.delete_object(obj)
       end

data/test/test_client.rb

@@ -1,13 +1,13 @@
 require 'helper'
 
-class TestClient < AVTestCase
+class TestClient < LCTestCase
 
   def stubbed_client(&block)
     stubs = Faraday::Adapter::Test::Stubs.new do |stub|
       yield(stub)
     end
 
-    client = AV.init(
+    client = LC.init(
       :logger => Logger.new(STDERR).tap {
         |l| l.level = Logger::ERROR
       }
@@ -24,7 +24,7 @@ class TestClient < AVTestCase
       stubs, client = stubbed_client do |stub|
         (@client.max_retries + 1).times do
           stub.get('/') {[ 500, {}, {
-            'code' => AV::Protocol::ERROR_TIMEOUT}.to_json
+            'code' => LC::Protocol::ERROR_TIMEOUT}.to_json
           ]}
         end
       end
@@ -104,7 +104,7 @@ class TestClient < AVTestCase
       begin
         client.request('/')
         raise "client error response should have raised"
-      rescue AV::AVProtocolError => e
+      rescue LC::LCProtocolError => e
         assert_equal "HTTP Status 403 Body nonparseable", e.error
       end
 
@@ -114,58 +114,58 @@ class TestClient < AVTestCase
 
   def test_simple_save
     VCR.use_cassette('test_simple_save', :record => :new_episodes) do
-      test_save = AV::Object.new "TestSave"
+      test_save = LC::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
+      assert_equal test_save[LC::Protocol::KEY_CREATED_AT].class, String
+      assert_equal test_save[LC::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 = LC::Object.new "TestSave"
       foo["age"] = 20
       foo.save
 
       assert_equal foo["age"], 20
-      assert_equal foo[AV::Protocol::KEY_UPDATED_AT], nil
+      assert_equal foo[LC::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
+      assert_equal foo[LC::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
+      orig_assoc = orig.reject{|k,v| k == LC::Protocol::KEY_UPDATED_AT}.to_a
+      foo_assoc = foo.reject{|k,v| k == LC::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 = LC::Object.new("TestSave").save
       foo["name"] = 'john'
       foo.save
 
-      bar = AV.get("TestSave",foo.id) # pull it from the server
+      bar = LC.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)
+      bat = LC.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 = LC::Object.new "toBeDeleted"
       d["foo"] = "bar"
       d.save
       d.parse_delete
@@ -176,7 +176,7 @@ class TestClient < AVTestCase
 
   def test_get_missing
     VCR.use_cassette('test_get_missing', :record => :new_episodes) do
-      e = assert_raise(AV::AVProtocolError) { AV.get("SomeClass", "someIdThatDoesNotExist") }
+      e = assert_raise(LC::LCProtocolError) { LC.get("SomeClass", "someIdThatDoesNotExist") }
       assert_equal "101: Class or object doesn't exists.: SomeClass:someIdThatDoesNotExist", e.message
     end
   end

data/test/test_cloud.rb

@@ -1,21 +1,21 @@
 require 'helper'
 
-class TestCloud < AVTestCase
+class TestCloud < LCTestCase
 	# functions stored in test/cloud_functions/MyCloudCode
-	# see https://parse.com/docs/cloud_code_guide to learn how to use AV Cloud Code
+	# see https://parse.com/docs/cloud_code_guide to learn how to use LC Cloud Code
 	#
-	# AV.Cloud.define('trivial', function(request, response) {
+	# LC.Cloud.define('trivial', function(request, response) {
   # 	response.success(request.params);
 	# });
 
 	def test_cloud_function_initialize
-		assert_not_equal nil, AV::Cloud::Function.new("trivial")
+		assert_not_equal nil, LC::Cloud::Function.new("trivial")
 	end
 
     def test_request_sms
       VCR.use_cassette('test_request_sms', :record => :new_episodes) do
-        assert_equal (AV::Cloud.request_sms :mobilePhoneNumber => "18668012283",:op => "test",:ttl => 5), {}
-        puts AV::Cloud.verify_sms_code('18668012283', '123456').inspect
+        assert_equal (LC::Cloud.request_sms :mobilePhoneNumber => "186xxxxxxx",:op => "test",:ttl => 5), {}
+        puts LC::Cloud.verify_sms_code('186xxxxxxx', '123456').inspect
       end
     end
 
@@ -23,7 +23,7 @@ class TestCloud < AVTestCase
 		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")
+			function = LC::Cloud::Function.new("trivial")
 			params = {"foo" => "bar"}
 			resp = function.call(params)
 			assert_equal resp, params

data/test/test_datatypes.rb

@@ -3,33 +3,33 @@ require 'helper'
 class TestDatatypes < Test::Unit::TestCase
   def test_pointer
     data = {
-      AV::Protocol::KEY_CLASS_NAME => "DatatypeTestClass",
-      AV::Protocol::KEY_OBJECT_ID => "12345abcd"
+      LC::Protocol::KEY_CLASS_NAME => "DatatypeTestClass",
+      LC::Protocol::KEY_OBJECT_ID => "12345abcd"
     }
-    p = AV::Pointer.new data
+    p = LC::Pointer.new data
 
-    assert_equal p.to_json, "{\"__type\":\"Pointer\",\"#{AV::Protocol::KEY_CLASS_NAME}\":\"DatatypeTestClass\",\"#{AV::Protocol::KEY_OBJECT_ID}\":\"12345abcd\"}"
+    assert_equal p.to_json, "{\"__type\":\"Pointer\",\"#{LC::Protocol::KEY_CLASS_NAME}\":\"DatatypeTestClass\",\"#{LC::Protocol::KEY_OBJECT_ID}\":\"12345abcd\"}"
   end
 
   def test_pointer_make
-    p = AV::Pointer.make("SomeClass", "someId")
+    p = LC::Pointer.make("SomeClass", "someId")
     assert_equal "SomeClass", p.class_name
     assert_equal "someId", p.id
   end
 
   def test_date
     date_time = Time.at(0).to_datetime
-    parse_date = AV::Date.new(date_time)
+    parse_date = LC::Date.new(date_time)
 
     assert_equal date_time, parse_date.value
     assert_equal "1970-01-01T00:00:00.000Z", JSON.parse(parse_date.to_json)["iso"]
     assert_equal 0, parse_date <=> parse_date
-    assert_equal 0, AV::Date.new(date_time) <=> AV::Date.new(date_time)
+    assert_equal 0, LC::Date.new(date_time) <=> LC::Date.new(date_time)
 
-    post = AV::Object.new("Post")
+    post = LC::Object.new("Post")
     post["time"] = parse_date
     post.save
-    q = AV.get("Post", post.id)
+    q = LC.get("Post", post.id)
 
     # time zone from parse is utc so string formats don't compare equal,
     # also floating points vary a bit so only equality after rounding to millis is guaranteed
@@ -38,32 +38,32 @@ class TestDatatypes < Test::Unit::TestCase
 
   def test_date_with_bad_data
     assert_raise do
-      AV::Date.new(2014)
+      LC::Date.new(2014)
     end
     assert_raise do
-      AV::Date.new(nil)
+      LC::Date.new(nil)
     end
   end
 
   def test_date_with_time
     time = Time.parse("01/01/2012 23:59:59")
-    assert_equal time, AV::Date.new(time).to_time
+    assert_equal time, LC::Date.new(time).to_time
   end
 
   def test_bytes
     data = {
       "base64" => Base64.encode64("testing bytes!")
     }
-    byte = AV::Bytes.new data
+    byte = LC::Bytes.new data
 
     assert_equal byte.value, "testing bytes!"
-    assert_equal JSON.parse(byte.to_json)[AV::Protocol::KEY_TYPE], AV::Protocol::TYPE_BYTES
+    assert_equal JSON.parse(byte.to_json)[LC::Protocol::KEY_TYPE], LC::Protocol::TYPE_BYTES
     assert_equal JSON.parse(byte.to_json)["base64"], Base64.encode64("testing bytes!")
   end
 
   def test_increment
     amount = 5
-    increment = AV::Increment.new amount
+    increment = LC::Increment.new amount
 
     assert_equal increment.to_json, "{\"__op\":\"Increment\",\"amount\":#{amount}}"
   end
@@ -74,16 +74,16 @@ class TestDatatypes < Test::Unit::TestCase
       "longitude" => 40.0,
       "latitude" => -30.0
     }
-    gp = AV::GeoPoint.new data
+    gp = LC::GeoPoint.new data
 
     assert_equal JSON.parse(gp.to_json)["longitude"], data["longitude"]
     assert_equal JSON.parse(gp.to_json)["latitude"], data["latitude"]
-    assert_equal JSON.parse(gp.to_json)[AV::Protocol::KEY_TYPE], AV::Protocol::TYPE_GEOPOINT
+    assert_equal JSON.parse(gp.to_json)[LC::Protocol::KEY_TYPE], LC::Protocol::TYPE_GEOPOINT
 
-    post = AV::Object.new("Post")
+    post = LC::Object.new("Post")
     post["location"] = gp
     post.save
-    q = AV.get("Post", post.id)
+    q = LC.get("Post", post.id)
     assert_equal gp, q["location"]
   end
 
@@ -92,14 +92,14 @@ class TestDatatypes < Test::Unit::TestCase
   # ----------------------------
   #def test_file
   #  data = {"name" => "test/parsers.png"}
-  #  file = AV::File.new(data)
+  #  file = LC::File.new(data)
     # assert_equal JSON.parse(file.to_json)["name"], data["name"]
-    # assert_equal JSON.parse(file.to_json)[AV::Protocol::KEY_TYPE], AV::Protocol::TYPE_FILE
+    # assert_equal JSON.parse(file.to_json)[LC::Protocol::KEY_TYPE], LC::Protocol::TYPE_FILE
 
-  #  post = AV::Object.new("Post")
+  #  post = LC::Object.new("Post")
   #  post["avatar"] = file
   #  post.save
-  #  q = AV.get("Post", post.id)
+  #  q = LC.get("Post", post.id)
   #  assert_equal file.parse_filename, q["avatar"].parse_filename
   #end
 end

data/test/test_file.rb

@@ -1,10 +1,10 @@
 require 'helper'
 
-class TestFile < AVTestCase
+class TestFile < LCTestCase
 
   def test_file_save
     VCR.use_cassette('test_text_file_save', :record => :new_episodes) do
-      tf = AV::File.new({
+      tf = LC::File.new({
         :body => "Hello World!",
         :local_filename => "hello.txt",
         :content_type => "text/plain"
@@ -22,7 +22,7 @@ class TestFile < AVTestCase
 
   def test_image_save
     #VCR.use_cassette('test_image_file_save', :record => :new_episodes) do
-      tf = AV::File.new({
+      tf = LC::File.new({
         :body => IO.read("test/parsers.jpg"),
         :local_filename => "parsers.jpg",
         :content_type => "image/jpeg"
@@ -39,7 +39,7 @@ class TestFile < AVTestCase
 
   def test_associate_with_object
     #VCR.use_cassette('test_image_file_associate_with_object', :record => :new_episodes) do
-      tf = AV::File.new({
+      tf = LC::File.new({
         :body => IO.read("test/parsers.jpg"),
         :local_filename => "parsers.jpg",
         :content_type => "image/jpeg"
@@ -52,7 +52,7 @@ class TestFile < AVTestCase
       assert tf.body
       assert tf.to_json
 
-      object = AV::Object.new("ShouldHaveFile")
+      object = LC::Object.new("ShouldHaveFile")
       object["photo"] = tf
       object.save
 

data/test/test_init.rb

@@ -1,14 +1,14 @@
 require 'helper'
 
-#AV.init :application_id => $LC_APPLICATION_ID, :api_key => $LC_APPLICATION_KEY
+#LC.init :application_id => $LC_APPLICATION_ID, :api_key => $LC_APPLICATION_KEY
 
 class TestInit < Test::Unit::TestCase
   def setup
-    AV.destroy
+    LC.destroy
   end
   
   def test_no_api_keys_error
-    fake = AV::Object.new "shouldNeverExist"
+    fake = LC::Object.new "shouldNeverExist"
     fake["foo"] = "bar"
     
     begin
@@ -18,6 +18,6 @@ class TestInit < Test::Unit::TestCase
     end
     
     assert_equal error_triggered, true
-    assert_equal fake[AV::Protocol::KEY_OBJECT_ID], nil
+    assert_equal fake[LC::Protocol::KEY_OBJECT_ID], nil
   end
 end