leancloud-ruby-client 0.1.0

data/test/test_datatypes.rb

@@ -0,0 +1,105 @@
+require 'helper'
+
+class TestDatatypes < Test::Unit::TestCase
+  def test_pointer
+    data = {
+      AV::Protocol::KEY_CLASS_NAME => "DatatypeTestClass",
+      AV::Protocol::KEY_OBJECT_ID => "12345abcd"
+    }
+    p = AV::Pointer.new data
+
+    assert_equal p.to_json, "{\"__type\":\"Pointer\",\"#{AV::Protocol::KEY_CLASS_NAME}\":\"DatatypeTestClass\",\"#{AV::Protocol::KEY_OBJECT_ID}\":\"12345abcd\"}"
+  end
+
+  def test_pointer_make
+    p = AV::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)
+
+    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)
+
+    post = AV::Object.new("Post")
+    post["time"] = parse_date
+    post.save
+    q = AV.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
+    assert_equal parse_date.to_time.utc.to_datetime.iso8601(3), q["time"].to_time.utc.to_datetime.iso8601(3)
+  end
+
+  def test_date_with_bad_data
+    assert_raise do
+      AV::Date.new(2014)
+    end
+    assert_raise do
+      AV::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
+  end
+
+  def test_bytes
+    data = {
+      "base64" => Base64.encode64("testing bytes!")
+    }
+    byte = AV::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)["base64"], Base64.encode64("testing bytes!")
+  end
+
+  def test_increment
+    amount = 5
+    increment = AV::Increment.new amount
+
+    assert_equal increment.to_json, "{\"__op\":\"Increment\",\"amount\":#{amount}}"
+  end
+
+  def test_geopoint
+    # '{"location": {"__type":"GeoPoint", "latitude":40.0, "longitude":-30.0}}'
+    data = {
+      "longitude" => 40.0,
+      "latitude" => -30.0
+    }
+    gp = AV::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
+
+    post = AV::Object.new("Post")
+    post["location"] = gp
+    post.save
+    q = AV.get("Post", post.id)
+    assert_equal gp, q["location"]
+  end
+
+
+  # deprecating -  see test_file.rb for new implementation
+  # ----------------------------
+  #def test_file
+  #  data = {"name" => "test/parsers.png"}
+  #  file = AV::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
+
+  #  post = AV::Object.new("Post")
+  #  post["avatar"] = file
+  #  post.save
+  #  q = AV.get("Post", post.id)
+  #  assert_equal file.parse_filename, q["avatar"].parse_filename
+  #end
+end

data/test/test_file.rb

@@ -0,0 +1,67 @@
+require 'helper'
+
+class TestFile < AVTestCase
+
+  def test_file_save
+    VCR.use_cassette('test_text_file_save', :record => :new_episodes) do
+      tf = AV::File.new({
+        :body => "Hello World!",
+        :local_filename => "hello.txt",
+        :content_type => "text/plain"
+      })
+      tf.save
+
+      assert tf.local_filename
+      assert tf.url
+      assert tf.parse_filename
+      assert tf.body
+      assert tf.to_json
+      assert_equal String, tf.body.class
+    end
+  end
+
+  def test_image_save
+    #VCR.use_cassette('test_image_file_save', :record => :new_episodes) do
+      tf = AV::File.new({
+        :body => IO.read("test/parsers.jpg"),
+        :local_filename => "parsers.jpg",
+        :content_type => "image/jpeg"
+      })
+      tf.save
+
+      assert tf.local_filename
+      assert tf.url
+      assert tf.parse_filename
+      assert tf.body
+      assert tf.to_json
+    #end
+  end
+
+  def test_associate_with_object
+    #VCR.use_cassette('test_image_file_associate_with_object', :record => :new_episodes) do
+      tf = AV::File.new({
+        :body => IO.read("test/parsers.jpg"),
+        :local_filename => "parsers.jpg",
+        :content_type => "image/jpeg"
+      })
+      tf.save
+
+      assert tf.local_filename
+      assert tf.url
+      assert tf.parse_filename
+      assert tf.body
+      assert tf.to_json
+
+      object = AV::Object.new("ShouldHaveFile")
+      object["photo"] = tf
+      object.save
+
+      assert object["photo"]
+      assert object["objectId"]
+
+      object.refresh.save
+    #end
+  end
+
+
+end

data/test/test_init.rb

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

data/test/test_init_from_cloud_code.rb

@@ -0,0 +1,8 @@
+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
+	end
+end

data/test/test_installation.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+class TestInstallation < AVTestCase
+  def test_retrieving_installation_data
+    installation_data = {
+      "appIdentifier"=>"net.project_name",
+      "appName"=>"AV Project",
+      "appVersion"=>"35",
+      "badge"=>9,
+      "channels"=>["", "channel1"],
+      "deviceToken"=> "123",
+      "deviceType"=>"ios",
+      "installationId"=>"345",
+      "parseVersion"=>"1.3.0",
+      "timeZone"=>"Europe/Chisinau",
+      "createdAt"=>"2014-09-18T15:04:18.602Z",
+      "updatedAt"=>"2014-09-19T12:17:48.509Z",
+      "objectId"=>"987"
+    }
+
+    VCR.use_cassette('test_get_installation') do
+      installation = AV::Installation.get "987"
+      assert_equal installation_data, installation
+    end
+  end
+
+  def test_changing_channels
+    installation = AV::Installation.new "987"
+    installation.channels = ["", "my-channel"]
+    assert_equal ["", "my-channel"], installation["channels"]
+  end
+
+  def test_changing_badges
+    installation = AV::Installation.new "987"
+    installation.badge = 5
+    assert_equal 5, installation["badge"]
+  end
+
+  def test_updating_installation_data
+    installation = AV::Installation.new "987"
+    installation.channels = ["", "my-channel"]
+    installation.badge = 5
+
+    VCR.use_cassette('test_save_installation') do
+      result = installation.save
+      assert_not_empty result["updatedAt"]
+    end
+  end
+end

data/test/test_model.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class TestModelObject < AV::Model
+end
+
+class TestModel < AVTestCase
+
+  def test_new
+    VCR.use_cassette('test_new_model', :record => :new_episodes) do
+      tmo = TestModelObject.new
+      assert_equal tmo.new?, true
+      tmo.save
+      assert_equal tmo.new?, false
+    end
+  end
+
+  def test_superclass
+    tmo = TestModelObject
+    assert_equal tmo.superclass, AV::Model
+    assert_equal tmo.superclass.superclass, AV::Object
+  end
+end

data/test/test_object.rb

@@ -0,0 +1,295 @@
+require 'helper'
+
+class TestObject < AVTestCase
+
+  def test_new?
+    VCR.use_cassette('test_new_object', :record => :new_episodes) do
+    	post = AV::Object.new "Post"
+    	assert_equal post.new?, true
+    	post.save
+    	assert_equal post.new?, false
+    end
+  end
+
+  def test_object_id
+    #VCR.use_cassette('test_object_id', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      assert_equal post.id, nil
+      post["title"] = "hello world"
+      post.save
+      assert_equal post.id.class, String
+    #end
+  end
+
+  def test_pointer
+    VCR.use_cassette('test_pointer', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      assert_nil post.pointer
+
+      post.save
+      pointer = post.pointer
+      assert_equal pointer.class_name, post.class_name
+      assert_equal pointer.parse_object_id, post.parse_object_id
+    end
+  end
+
+  def test_equality
+    VCR.use_cassette('test_equality', :record => :new_episodes) do
+      foo_1 = AV::Object.new("Foo")
+      foo_2 = AV::Object.new("Foo")
+
+      assert foo_1 != foo_2
+      assert foo_1 == foo_1
+
+      foo_1.save
+      assert foo_1 != foo_2
+      assert foo_2 != foo_1
+      assert foo_1.pointer != foo_2
+      assert foo_2 != foo_1.pointer
+      foo_2.save
+
+      assert foo_1 == foo_1
+      assert foo_1 != foo_2
+
+      assert foo_1 == foo_1.pointer
+      assert foo_1.pointer == foo_1
+
+      other_foo_1 = AV.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"
+      assert_equal post.created_at, nil
+      post.save
+      assert_equal post.created_at.class, DateTime
+    end
+  end
+
+  def test_updated_at
+    VCR.use_cassette('test_updated_at', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      assert_equal post.updated_at, nil
+      post["title"] = "hello"
+      post.save
+      assert_equal post.updated_at, nil
+      post["title"] = "hello 2"
+      post.save
+      assert_equal post.updated_at.class, DateTime
+    end
+  end
+
+  def test_parse_delete
+    VCR.use_cassette('test_parse_delete', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      post.save
+      assert_equal post.id.class, String
+
+      q = AV.get("Post", post.id)
+      assert_equal q.id, post.id
+
+      post.parse_delete
+
+      q = AV.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.save
+      post = AV::Object.new "Post"
+      post["other"] = other.pointer
+      post.save
+
+      q = AV.get("Post", post.id)
+      assert_equal AV::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}})
+      assert_equal Hash, post['ACL'].class
+      post.save
+      #assert_equal Hash, post.refresh['ACL'].class
+
+      post = AV.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"
+    hash = { 'post' => [post] }
+    parsed = JSON.parse(hash.to_json)
+    assert_equal "Post", parsed['post'][0][AV::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)
+      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['array'] = [1, 2]
+      assert other.as_json['date']['iso']
+    end
+  end
+
+  def test_nils_delete_keys
+    VCR.use_cassette('test_nils_delete_keys', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      post["title"] = "hello"
+      post.save
+      post["title"] = nil
+      post.save
+      assert_false post.refresh.keys.include?("title")
+    end
+  end
+
+  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")
+      assert_raise{post.save}
+    end
+  end
+
+  def test_boolean_values_as_json
+    post = AV::Object.new "Post"
+    post["read"] = false
+    post["published"] = true
+    safe_json_hash = JSON.parse post.safe_hash.to_json
+    assert_equal false, safe_json_hash["read"]
+    assert_equal true, safe_json_hash["published"]
+  end
+
+  def test_saving_boolean_values
+    VCR.use_cassette('test_saving_boolean_values', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      post["read"] = false
+      post["published"] = true
+      post.save
+      retrieved_post = AV::Query.new("Post")
+        .eq("objectId", post["objectId"]).get.first
+      assert_equal false, retrieved_post["read"]
+      assert_equal true, retrieved_post["published"]
+    end
+  end
+
+  def test_array_add
+    VCR.use_cassette('test_array_add', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      post.array_add("chapters", "hello")
+      assert_equal ["hello"], post["chapters"]
+      post.save
+      assert_equal ["hello"], post["chapters"]
+
+      post.array_add("chapters", "goodbye")
+      assert_equal ["hello", "goodbye"], post["chapters"]
+      post.save
+      assert_equal ["hello", "goodbye"], post["chapters"]
+    end
+  end
+
+  def test_array_add_pointerizing
+    VCR.use_cassette('test_array_add_pointerizing', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+
+      comment = AV::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
+      assert_equal "great post!", post['comments'][0]['text']
+      #post.save
+      assert_equal "great post!", post['comments'][0]['text']
+    end
+  end
+
+  def test_array_add_unique
+    VCR.use_cassette('test_array_add_unique', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      post.save
+
+      comment = AV::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
+    end
+  end
+
+  def test_decrement
+    VCR.use_cassette('test_decrement', :record => :new_episodes) do
+      post = AV::Object.new "Post", 'count' => 1
+      post.save
+
+      post.decrement('count')
+      assert_equal 0, post['count']
+    end
+  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")
+
+    VCR.use_cassette('test_array_add_relation', :record => :new_episodes) do
+      post = AV::Object.new "Post"
+      post.save
+
+      comment = AV::Object.new "Comment"
+      comment.save
+
+      post.array_add_relation("comments", comment.pointer)
+      post.save
+
+      q = AV::Query.new("Comment")
+      q.related_to("comments", post.pointer)
+      comments = q.get
+      assert_equal comments.first["objectId"], comment["objectId"]
+    end
+  end
+
+  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.save
+
+      foo = AV::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.save
+
+      assert_equal "foobar", foo['bar']['foobar']
+      assert_equal "foobar", foo['bars'][0]['foobar']
+
+      bar = foo['bar']
+      bar['baz'] = 'baz'
+      bar.save
+
+      assert_equal 'baz', bar['baz']
+    end
+  end
+end