leancloud-ruby-client 0.1.1 → 0.2.0

data/test/test_init_from_cloud_code.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 class TestInitFromCloudCode < Test::Unit::TestCase
 	def test_init
-		client = AV.init_from_cloud_code("test/config/global.json")
-		assert_equal AV::Client, client.class
+		client = LC.init_from_cloud_code("test/config/global.json")
+		assert_equal LC::Client, client.class
 	end
 end

data/test/test_installation.rb

@@ -1,10 +1,10 @@
 require 'helper'
 
-class TestInstallation < AVTestCase
+class TestInstallation < LCTestCase
   def test_retrieving_installation_data
     installation_data = {
       "appIdentifier"=>"net.project_name",
-      "appName"=>"AV Project",
+      "appName"=>"LC Project",
       "appVersion"=>"35",
       "badge"=>9,
       "channels"=>["", "channel1"],
@@ -19,25 +19,25 @@ class TestInstallation < AVTestCase
     }
 
     VCR.use_cassette('test_get_installation') do
-      installation = AV::Installation.get "987"
+      installation = LC::Installation.get "987"
       assert_equal installation_data, installation
     end
   end
 
   def test_changing_channels
-    installation = AV::Installation.new "987"
+    installation = LC::Installation.new "987"
     installation.channels = ["", "my-channel"]
     assert_equal ["", "my-channel"], installation["channels"]
   end
 
   def test_changing_badges
-    installation = AV::Installation.new "987"
+    installation = LC::Installation.new "987"
     installation.badge = 5
     assert_equal 5, installation["badge"]
   end
 
   def test_updating_installation_data
-    installation = AV::Installation.new "987"
+    installation = LC::Installation.new "987"
     installation.channels = ["", "my-channel"]
     installation.badge = 5
 

data/test/test_model.rb

@@ -1,9 +1,9 @@
 require 'helper'
 
-class TestModelObject < AV::Model
+class TestModelObject < LC::Model
 end
 
-class TestModel < AVTestCase
+class TestModel < LCTestCase
 
   def test_new
     VCR.use_cassette('test_new_model', :record => :new_episodes) do
@@ -16,7 +16,7 @@ class TestModel < AVTestCase
 
   def test_superclass
     tmo = TestModelObject
-    assert_equal tmo.superclass, AV::Model
-    assert_equal tmo.superclass.superclass, AV::Object
+    assert_equal tmo.superclass, LC::Model
+    assert_equal tmo.superclass.superclass, LC::Object
   end
 end

data/test/test_object.rb

@@ -1,10 +1,10 @@
 require 'helper'
 
-class TestObject < AVTestCase
+class TestObject < LCTestCase
 
   def test_new?
     VCR.use_cassette('test_new_object', :record => :new_episodes) do
-    	post = AV::Object.new "Post"
+    	post = LC::Object.new "Post"
     	assert_equal post.new?, true
     	post.save
     	assert_equal post.new?, false
@@ -13,7 +13,7 @@ class TestObject < AVTestCase
 
   def test_object_id
     #VCR.use_cassette('test_object_id', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       assert_equal post.id, nil
       post["title"] = "hello world"
       post.save
@@ -23,7 +23,7 @@ class TestObject < AVTestCase
 
   def test_pointer
     VCR.use_cassette('test_pointer', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       assert_nil post.pointer
 
       post.save
@@ -35,8 +35,8 @@ class TestObject < AVTestCase
 
   def test_equality
     VCR.use_cassette('test_equality', :record => :new_episodes) do
-      foo_1 = AV::Object.new("Foo")
-      foo_2 = AV::Object.new("Foo")
+      foo_1 = LC::Object.new("Foo")
+      foo_2 = LC::Object.new("Foo")
 
       assert foo_1 != foo_2
       assert foo_1 == foo_1
@@ -54,14 +54,14 @@ class TestObject < AVTestCase
       assert foo_1 == foo_1.pointer
       assert foo_1.pointer == foo_1
 
-      other_foo_1 = AV.get("Foo", foo_1.id)
+      other_foo_1 = LC.get("Foo", foo_1.id)
       assert foo_1 == other_foo_1
     end
   end
 
   def test_created_at
     VCR.use_cassette('test_created_at', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       assert_equal post.created_at, nil
       post.save
       assert_equal post.created_at.class, DateTime
@@ -70,7 +70,7 @@ class TestObject < AVTestCase
 
   def test_updated_at
     VCR.use_cassette('test_updated_at', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       assert_equal post.updated_at, nil
       post["title"] = "hello"
       post.save
@@ -83,65 +83,65 @@ class TestObject < AVTestCase
 
   def test_parse_delete
     VCR.use_cassette('test_parse_delete', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post.save
       assert_equal post.id.class, String
 
-      q = AV.get("Post", post.id)
+      q = LC.get("Post", post.id)
       assert_equal q.id, post.id
 
       post.parse_delete
 
-      q = AV.get("Post", post.id)
+      q = LC.get("Post", post.id)
       assert_true q.empty?
     end
   end
 
   def test_deep_parse
     VCR.use_cassette('test_deep_parse', :record => :new_episodes) do
-      other = AV::Object.new "Post"
+      other = LC::Object.new "Post"
       other.save
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post["other"] = other.pointer
       post.save
 
-      q = AV.get("Post", post.id)
-      assert_equal AV::Pointer, q["other"].class
+      q = LC.get("Post", post.id)
+      assert_equal LC::Pointer, q["other"].class
       assert_equal other.pointer, q["other"]
     end
   end
 
   def test_acls_arent_objects
     VCR.use_cassette('test_acls_arent_objects', :record => :new_episodes) do
-      post = AV::Object.new("Post", "ACL" => {"*" => {"read"=>true}})
+      post = LC::Object.new("Post", "ACL" => {"*" => {"read"=>true}})
       assert_equal Hash, post['ACL'].class
       post.save
       #assert_equal Hash, post.refresh['ACL'].class
 
-      post = AV.get("Post", post.id)
+      post = LC.get("Post", post.id)
       #assert_equal Hash, post['ACL'].class
     end
   end
 
   def test_to_json_uses_rest_api_hash
-    post = AV::Object.new "Post"
+    post = LC::Object.new "Post"
     hash = { 'post' => [post] }
     parsed = JSON.parse(hash.to_json)
-    assert_equal "Post", parsed['post'][0][AV::Protocol::KEY_CLASS_NAME]
+    assert_equal "Post", parsed['post'][0][LC::Protocol::KEY_CLASS_NAME]
   end
 
   def test_deep_as_json
     VCR.use_cassette('test_deep_as_json', :record => :new_episodes) do
-      other = AV::Object.new "Post"
-      other['date'] = AV::Date.new(DateTime.now)
+      other = LC::Object.new "Post"
+      other['date'] = LC::Date.new(DateTime.now)
       assert other.as_json['date']['iso']
     end
   end
 
   def test_deep_as_json_with_array
     VCR.use_cassette('test_deep_as_json', :record => :new_episodes) do
-      other = AV::Object.new "Post"
-      other['date'] = AV::Date.new(DateTime.now)
+      other = LC::Object.new "Post"
+      other['date'] = LC::Date.new(DateTime.now)
       other['array'] = [1, 2]
       assert other.as_json['date']['iso']
     end
@@ -149,7 +149,7 @@ class TestObject < AVTestCase
 
   def test_nils_delete_keys
     VCR.use_cassette('test_nils_delete_keys', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post["title"] = "hello"
       post.save
       post["title"] = nil
@@ -160,14 +160,14 @@ class TestObject < AVTestCase
 
   def test_saving_nested_objects
     VCR.use_cassette('test_saving_nested_objects', :record => :new_episodes) do
-      post = AV::Object.new "Post"
-      post["comment"] = AV::Object.new("Comment", "text" => "testing")
+      post = LC::Object.new "Post"
+      post["comment"] = LC::Object.new("Comment", "text" => "testing")
       assert_raise{post.save}
     end
   end
 
   def test_boolean_values_as_json
-    post = AV::Object.new "Post"
+    post = LC::Object.new "Post"
     post["read"] = false
     post["published"] = true
     safe_json_hash = JSON.parse post.safe_hash.to_json
@@ -177,11 +177,11 @@ class TestObject < AVTestCase
 
   def test_saving_boolean_values
     VCR.use_cassette('test_saving_boolean_values', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post["read"] = false
       post["published"] = true
       post.save
-      retrieved_post = AV::Query.new("Post")
+      retrieved_post = LC::Query.new("Post")
         .eq("objectId", post["objectId"]).get.first
       assert_equal false, retrieved_post["read"]
       assert_equal true, retrieved_post["published"]
@@ -190,7 +190,7 @@ class TestObject < AVTestCase
 
   def test_array_add
     VCR.use_cassette('test_array_add', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post.array_add("chapters", "hello")
       assert_equal ["hello"], post["chapters"]
       post.save
@@ -205,16 +205,16 @@ class TestObject < AVTestCase
 
   def test_array_add_pointerizing
     VCR.use_cassette('test_array_add_pointerizing', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
 
-      comment = AV::Object.new("Comment", "text" => "great post!")
+      comment = LC::Object.new("Comment", "text" => "great post!")
       comment.save
       post.array_add("comments", comment)
       assert_equal "great post!", post['comments'][0]['text']
       post.save
       assert_equal "great post!", post['comments'][0]['text']
 
-      post = AV::Query.new("Post").eq("objectId", post.id).tap { |q| q.include = 'comments' }.get.first
+      post = LC::Query.new("Post").eq("objectId", post.id).tap { |q| q.include = 'comments' }.get.first
       assert_equal "great post!", post['comments'][0]['text']
       #post.save
       assert_equal "great post!", post['comments'][0]['text']
@@ -223,23 +223,23 @@ class TestObject < AVTestCase
 
   def test_array_add_unique
     VCR.use_cassette('test_array_add_unique', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post.save
 
-      comment = AV::Object.new("Comment", "text" => "great post!")
+      comment = LC::Object.new("Comment", "text" => "great post!")
       comment.save
 
       post.array_add_unique("comments", comment)
       assert_equal "great post!", post['comments'][0]['text']
       post.save
       assert_equal comment, post['comments'][0]
-      assert post['comments'][0].instance_of?(AV::Pointer) # save returns array pointerized
+      assert post['comments'][0].instance_of?(LC::Pointer) # save returns array pointerized
     end
   end
 
   def test_decrement
     VCR.use_cassette('test_decrement', :record => :new_episodes) do
-      post = AV::Object.new "Post", 'count' => 1
+      post = LC::Object.new "Post", 'count' => 1
       post.save
 
       post.decrement('count')
@@ -248,19 +248,19 @@ class TestObject < AVTestCase
   end
 
   def test_array_add_relation
-    omit("broken test, saving Post results in AVProtocolError: 111: can't add a relation to an non-relation field")
+    omit("broken test, saving Post results in LCProtocolError: 111: can't add a relation to an non-relation field")
 
     VCR.use_cassette('test_array_add_relation', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post.save
 
-      comment = AV::Object.new "Comment"
+      comment = LC::Object.new "Comment"
       comment.save
 
       post.array_add_relation("comments", comment.pointer)
       post.save
 
-      q = AV::Query.new("Comment")
+      q = LC::Query.new("Comment")
       q.related_to("comments", post.pointer)
       comments = q.get
       assert_equal comments.first["objectId"], comment["objectId"]
@@ -269,16 +269,16 @@ class TestObject < AVTestCase
 
   def test_save_with_sub_objects
     VCR.use_cassette('test_save_with_sub_objects', :record => :new_episodes) do
-      bar = AV::Object.new("Bar", "foobar" => "foobar")
+      bar = LC::Object.new("Bar", "foobar" => "foobar")
       bar.save
 
-      foo = AV::Object.new("Foo", "bar" => bar, "bars" => [bar])
+      foo = LC::Object.new("Foo", "bar" => bar, "bars" => [bar])
       foo.save
 
       assert_equal "foobar", foo['bar']['foobar']
       assert_equal "foobar", foo['bars'][0]['foobar']
 
-      foo = AV::Query.new("Foo").eq("objectId", foo.id).tap { |q| q.include = 'bar,bars' }.get.first
+      foo = LC::Query.new("Foo").eq("objectId", foo.id).tap { |q| q.include = 'bar,bars' }.get.first
 
       #foo.save
 

data/test/test_push.rb

@@ -1,16 +1,16 @@
 require 'helper'
 
-class TestPush < AVTestCase
+class TestPush < LCTestCase
 
   def test_save_without_where
     data = {:foo => 'bar',
             :alert => 'message'}
-    pf_push = AV::Push.new(data, "some_chan")
+    pf_push = LC::Push.new(data, "some_chan")
     pf_push.type = 'ios'
 
-    query = AV::Query.new(AV::Protocol::CLASS_INSTALLATION).eq('deviceToken', 'baz')
+    query = LC::Query.new(LC::Protocol::CLASS_INSTALLATION).eq('deviceToken', 'baz')
 
-    AV::Client.any_instance.expects(:request).with do |uri, method, body, query|
+    LC::Client.any_instance.expects(:request).with do |uri, method, body, query|
       hash = JSON.parse(body)
       assert_equal :post, method
       assert has_entries('type' => 'ios', 'channel' => "some_chan").matches?([hash])
@@ -26,13 +26,13 @@ class TestPush < AVTestCase
   def test_save_with_where_removes_channel
     data = {:foo => 'bar',
             :alert => 'message'}
-    pf_push = AV::Push.new(data, "some_chan")
+    pf_push = LC::Push.new(data, "some_chan")
     pf_push.type = 'ios'
 
-    query = AV::Query.new(AV::Protocol::CLASS_INSTALLATION).eq('deviceToken', 'baz')
+    query = LC::Query.new(LC::Protocol::CLASS_INSTALLATION).eq('deviceToken', 'baz')
     pf_push.where = query.where
 
-    AV::Client.any_instance.expects(:request).with do |uri, method, body, query|
+    LC::Client.any_instance.expects(:request).with do |uri, method, body, query|
       hash = JSON.parse(body)
       assert_false has_entries('channel' => "some_chan").matches?([hash])
       assert has_entries('deviceToken' => 'baz').matches?([hash['where']])

data/test/test_query.rb

@@ -1,16 +1,16 @@
 require 'helper'
 
-class TestQuery < AVTestCase
+class TestQuery < LCTestCase
 
-  EMPTY_QUERY_RESPONSE = {AV::Protocol::KEY_RESULTS => []}
+  EMPTY_QUERY_RESPONSE = {LC::Protocol::KEY_RESULTS => []}
 
   def test_get
     VCR.use_cassette('test_get', :record => :new_episodes) do
-      post = AV::Object.new "Post"
+      post = LC::Object.new "Post"
       post["title"] = "foo"
       post.save
 
-      q = AV.get("Post", post.id)
+      q = LC.get("Post", post.id)
 
       assert_equal q.id, post.id
       assert_equal q["title"], post["title"]
@@ -23,7 +23,7 @@ class TestQuery < AVTestCase
     # I'd rather test this one method than pointlessly test many others.
     # Thus is life.
 
-    q = AV::Query.new "TestQuery"
+    q = LC::Query.new "TestQuery"
     q.add_constraint("points", 5)
     assert_equal q.where["points"], 5
     q.add_constraint("player", { "$regex" => "regex voodoo"})
@@ -31,8 +31,8 @@ class TestQuery < AVTestCase
   end
 
   def test_related_to
-    q = AV::Query.new "Comment"
-    pointer = AV::Pointer.new(class_name: "Post", parse_object_id: '1234')
+    q = LC::Query.new "Comment"
+    pointer = LC::Pointer.new(class_name: "Post", parse_object_id: '1234')
     q.related_to("comments", pointer)
 
     assert_not_nil q.where["$relatedTo"]
@@ -41,7 +41,7 @@ class TestQuery < AVTestCase
   end
 
   def test_eq
-    q = AV::Query.new "TestQuery"
+    q = LC::Query.new "TestQuery"
     q.eq("points", 5)
     assert_equal q.where, {"points" => 5}
     q.eq("player", "michael@jordan.com")
@@ -50,33 +50,33 @@ class TestQuery < AVTestCase
 
   def test_eq_pointerize
     VCR.use_cassette('test_eq_pointerize', :record => :new_episodes) do
-      foo = AV::Object.new("Foo")
+      foo = LC::Object.new("Foo")
       foo.save
-      bar = AV::Object.new("Bar", "foo" => foo.pointer, "bar" => "bar")
+      bar = LC::Object.new("Bar", "foo" => foo.pointer, "bar" => "bar")
       bar.save
 
-      assert_equal "bar", AV::Query.new("Bar").eq("foo", foo.pointer).get.first["bar"]
-      assert_equal "bar", AV::Query.new("Bar").eq("foo", foo).get.first["bar"]
+      assert_equal "bar", LC::Query.new("Bar").eq("foo", foo.pointer).get.first["bar"]
+      assert_equal "bar", LC::Query.new("Bar").eq("foo", foo).get.first["bar"]
     end
   end
 
   def test_limit_skip
     VCR.use_cassette('test_limit_skip', :record => :new_episodes) do
-      q = AV::Query.new "TestQuery"
+      q = LC::Query.new "TestQuery"
       q.limit = 2
       q.skip = 3
       query_matcher = has_entries(:limit =>  2, :skip => 3)
-      AV::Client.any_instance.expects(:request).with(anything, :get, nil, query_matcher).returns(EMPTY_QUERY_RESPONSE)
+      LC::Client.any_instance.expects(:request).with(anything, :get, nil, query_matcher).returns(EMPTY_QUERY_RESPONSE)
       q.get
     end
   end
 
   def test_count
     VCR.use_cassette('test_count', :record => :new_episodes) do
-      q = AV::Query.new "TestQuery"
+      q = LC::Query.new "TestQuery"
       q.count = true
       query_matcher = has_entries(:count => true)
-      AV::Client.any_instance.expects(:request).with(anything, :get, nil, query_matcher).returns(EMPTY_QUERY_RESPONSE.merge("count" => 1000))
+      LC::Client.any_instance.expects(:request).with(anything, :get, nil, query_matcher).returns(EMPTY_QUERY_RESPONSE.merge("count" => 1000))
       results = q.get
       assert_equal 1000, results['count']
     end
@@ -84,16 +84,16 @@ class TestQuery < AVTestCase
 
   def test_include
     VCR.use_cassette('test_include', :record => :new_episodes) do
-      post_1 = AV::Object.new "Post"
+      post_1 = LC::Object.new "Post"
       post_1['title'] = 'foo'
       post_1.save
 
-      post_2 = AV::Object.new "Post"
+      post_2 = LC::Object.new "Post"
       post_2['title'] = 'bar'
       post_2['other'] = post_1.pointer
       post_2.save
 
-      q = AV::Query.new "Post"
+      q = LC::Query.new "Post"
       q.eq('objectId', post_2.parse_object_id)
       q.include = 'other'
 
@@ -103,16 +103,16 @@ class TestQuery < AVTestCase
 
   def test_or
     #VCR.use_cassette('test_or', :record => :new_episodes) do
-      foo = AV::Object.new "Post"
+      foo = LC::Object.new "Post"
       foo["random"] = rand
       foo.save
-      foo_query = AV::Query.new("Post").eq("random", foo["random"])
+      foo_query = LC::Query.new("Post").eq("random", foo["random"])
       assert_equal 1, foo_query.get.size
 
-      bar = AV::Object.new "Post"
+      bar = LC::Object.new "Post"
       bar["random"] = rand
       bar.save
-      bar_query = AV::Query.new("Post").eq("random", bar["random"])
+      bar_query = LC::Query.new("Post").eq("random", bar["random"])
       assert_equal 1, foo_query.get.size
 
       query = foo_query.or(bar_query)
@@ -121,8 +121,8 @@ class TestQuery < AVTestCase
   end
 
   def test_in_query
-    outer_query = AV::Query.new "Outer"
-    inner_query = AV::Query.new "Inner"
+    outer_query = LC::Query.new "Outer"
+    inner_query = LC::Query.new "Inner"
     inner_query.eq("foo", "bar")
     outer_query.in_query("inner", inner_query)
     assert_equal({"inner"=>{"$inQuery"=>{"className"=>"Inner", "where"=>{"foo"=>"bar"}}}}, outer_query.where)
@@ -130,23 +130,23 @@ class TestQuery < AVTestCase
 
   def test_large_value_in_xget
     VCR.use_cassette('test_xget', :record => :new_episodes) do
-      post = AV::Object.new("Post")
+      post = LC::Object.new("Post")
       post['title']= 'foo'
       post.save
 
-      other_post = AV::Object.new("Post")
+      other_post = LC::Object.new("Post")
       other_post['title']= 'foo'
       other_post.save
 
-      assert_equal [post], AV::Query.new("Post").value_in("objectId", [post.id] + 100.times.map { "x" }).get
+      assert_equal [post], LC::Query.new("Post").value_in("objectId", [post.id] + 100.times.map { "x" }).get
     end
   end
 
   def test_bad_response
     VCR.use_cassette('test_bad_response', :record => :new_episodes) do
-      AV::Client.any_instance.expects(:request).returns("crap")
+      LC::Client.any_instance.expects(:request).returns("crap")
       assert_raises do
-        AV::Query.new("Post").get
+        LC::Query.new("Post").get
       end
     end
   end
@@ -155,42 +155,42 @@ class TestQuery < AVTestCase
     VCR.use_cassette('test_contains_all', :record => :new_episodes) do
 
       #ensure cacti from the previous test to not hang around
-      q = AV::Query.new "Cactus"
+      q = LC::Query.new "Cactus"
       cacti = q.get
       cacti.each do |cactus|
         cactus.parse_delete
       end
       #end ensure
 
-      cactus = AV::Object.new "Cactus"
+      cactus = LC::Object.new "Cactus"
       cactus['array'] = [1, 2, 5, 6, 7]
       cactus.save
 
-      second_cactus = AV::Object.new "Cactus"
+      second_cactus = LC::Object.new "Cactus"
       second_cactus['array'] = [3, 4, 5, 6]
       second_cactus.save
 
-      contains_query = AV::Query.new("Cactus").contains_all('array', [5, 6])
+      contains_query = LC::Query.new("Cactus").contains_all('array', [5, 6])
       assert_equal 2, contains_query.get.size
 
-      with_one_query = AV::Query.new("Cactus").contains_all('array', [1,5,6])
+      with_one_query = LC::Query.new("Cactus").contains_all('array', [1,5,6])
       assert_equal 1, with_one_query.get.size
       assert_equal [cactus], with_one_query.get
 
-      with_four_query = AV::Query.new("Cactus").contains_all('array', [4,5,6])
+      with_four_query = LC::Query.new("Cactus").contains_all('array', [4,5,6])
       assert_equal 1, with_four_query.get.size
       assert_equal [second_cactus], with_four_query.get
 
-      with_nine_query = AV::Query.new("Cactus").contains_all('array', [9])
+      with_nine_query = LC::Query.new("Cactus").contains_all('array', [9])
       assert_equal 0, with_nine_query.get.size
     end
   end
 
   def test_cql
     VCR.use_cassette('test_cql', :record => :new_episodes) do
-      post = AV::Object.new 'Post',:title => 'foo'
+      post = LC::Object.new 'Post',:title => 'foo'
       post.save
-      ret = AV::Query.do_cloud_query('select *,count(*) from Post')
+      ret = LC::Query.do_cloud_query('select *,count(*) from Post')
       assert_true ret[:count] > 0
       assert_true ret[:results].size>0
     end