parse-ruby-client 0.1.3 → 0.1.4

data/lib/parse/protocol.rb

@@ -58,6 +58,9 @@ module Parse
     KEY_OP          = "__op"
     KEY_INCREMENT   = "Increment"
     KEY_DECREMENT   = "Decrement"
+    KEY_DELETE      = "Delete"
+
+    DELETE_OP       = { KEY_OP => KEY_DELETE }
 
     # The JSON key used to identify the datatype of a special value.
     KEY_TYPE        = "__type"
@@ -66,7 +69,7 @@ module Parse
     # increment/decrement API call.
     KEY_AMOUNT      = "amount"
 
-	RESERVED_KEYS = [ KEY_CLASS_NAME, KEY_CREATED_AT, KEY_OBJECT_ID, KEY_UPDATED_AT]
+  RESERVED_KEYS = [ KEY_CLASS_NAME, KEY_CREATED_AT, KEY_OBJECT_ID, KEY_UPDATED_AT]
 
     # Other Constants
     # ----------------------------------------
@@ -111,6 +114,8 @@ module Parse
 
     KEY_USER_SESSION_TOKEN = "sessionToken"
 
+    CLOUD_FUNCTIONS_PATH = "functions"
+
     # URI Helpers
     # ----------------------------------------
 
@@ -144,5 +149,9 @@ module Parse
     def Protocol.push_uri
       "/#{VERSION}/push"
     end
+
+    def Protocol.cloud_function_uri(function_name)
+      "/#{VERSION}/#{CLOUD_FUNCTIONS_PATH}/#{function_name}"
+    end
   end
 end

data/lib/parse/push.rb

@@ -28,6 +28,7 @@ module Parse
 
       if @where
         body.merge!({ :where => @where })
+        body.delete :channel
       end
 
       body.merge!({ :expiration_time_interval => @expiration_time_interval }) if @expiration_time_interval

data/lib/parse/query.rb

@@ -83,6 +83,7 @@ module Parse
     def in_query(field, query)
       query_hash = {Parse::Protocol::KEY_CLASS_NAME => query.class_name, "where" => query.where}
       add_constraint(field, "$inQuery" => query_hash)
+      self
     end
 
     def count

data/parse-ruby-client.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parse-ruby-client"
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alan deLevie", "Adam Alpern"]
-  s.date = "2012-09-20"
+  s.date = "2012-10-09"
   s.description = "A simple Ruby client for the parse.com REST API"
   s.email = "adelevie@gmail.com"
   s.extra_rdoc_files = [
@@ -25,8 +25,24 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "example.rb",
+    "fixtures/vcr_cassettes/test_cloud_function.yml",
+    "fixtures/vcr_cassettes/test_created_at.yml",
+    "fixtures/vcr_cassettes/test_deep_parse.yml",
+    "fixtures/vcr_cassettes/test_destroy.yml",
+    "fixtures/vcr_cassettes/test_get.yml",
+    "fixtures/vcr_cassettes/test_new_object.yml",
+    "fixtures/vcr_cassettes/test_nils_delete_keys.yml",
+    "fixtures/vcr_cassettes/test_object_id.yml",
+    "fixtures/vcr_cassettes/test_parse_delete.yml",
+    "fixtures/vcr_cassettes/test_pointer.yml",
+    "fixtures/vcr_cassettes/test_server_update.yml",
+    "fixtures/vcr_cassettes/test_simple_save.yml",
+    "fixtures/vcr_cassettes/test_update.yml",
+    "fixtures/vcr_cassettes/test_updated_at.yml",
+    "fixtures/vcr_cassettes/test_user_save.yml",
     "lib/parse-ruby-client.rb",
     "lib/parse/client.rb",
+    "lib/parse/cloud.rb",
     "lib/parse/datatypes.rb",
     "lib/parse/error.rb",
     "lib/parse/object.rb",
@@ -40,8 +56,10 @@ Gem::Specification.new do |s|
     "pkg/parse-ruby-client-0.0.2.gem",
     "pkg/parse-ruby-client-1-0.0.1.gem",
     "pkg/parse-ruby-client.gem",
+    "test/cloud_functions/MyCloudCode/cloud/main.js",
     "test/helper.rb",
     "test/test_client.rb",
+    "test/test_cloud.rb",
     "test/test_datatypes.rb",
     "test/test_init.rb",
     "test/test_object.rb",
@@ -60,32 +78,35 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<patron>, [">= 0"])
-      s.add_runtime_dependency(%q<vcr>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.1.5"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
       s.add_development_dependency(%q<test-unit>, ["= 2.5.0"])
       s.add_development_dependency(%q<mocha>, ["= 0.12.0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<webmock>, [">= 0"])
+      s.add_development_dependency(%q<vcr>, [">= 0"])
     else
       s.add_dependency(%q<patron>, [">= 0"])
-      s.add_dependency(%q<vcr>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.1.5"])
       s.add_dependency(%q<shoulda>, [">= 0"])
       s.add_dependency(%q<test-unit>, ["= 2.5.0"])
       s.add_dependency(%q<mocha>, ["= 0.12.0"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
       s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<webmock>, [">= 0"])
+      s.add_dependency(%q<vcr>, [">= 0"])
     end
   else
     s.add_dependency(%q<patron>, [">= 0"])
-    s.add_dependency(%q<vcr>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.1.5"])
     s.add_dependency(%q<shoulda>, [">= 0"])
     s.add_dependency(%q<test-unit>, ["= 2.5.0"])
     s.add_dependency(%q<mocha>, ["= 0.12.0"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
     s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<webmock>, [">= 0"])
+    s.add_dependency(%q<vcr>, [">= 0"])
   end
 end
 

data/test/cloud_functions/MyCloudCode/cloud/main.js

@@ -0,0 +1,4 @@
+Parse.Cloud.define('trivial', function(request, response) {
+	console.log(request);
+  response.success(request.params);
+});

data/test/helper.rb

@@ -10,6 +10,14 @@ end
 require 'test/unit'
 require 'shoulda'
 require 'mocha'
+require 'vcr'
+require 'webmock/test_unit'
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'fixtures/vcr_cassettes'
+  c.hook_into :webmock # or :fakeweb
+  c.allow_http_connections_when_no_cassette = true
+end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))

data/test/test_client.rb

@@ -6,56 +6,64 @@ class TestClient < Test::Unit::TestCase
   end
 
   def test_simple_save
-    test_save = Parse::Object.new "TestSave"
-    test_save["foo"] = "bar"
-    test_save.save
+    VCR.use_cassette('test_simple_save', :record => :new_episodes) do
+      test_save = Parse::Object.new "TestSave"
+      test_save["foo"] = "bar"
+      test_save.save
 
-    assert_equal test_save["foo"], "bar"
-    assert_equal test_save[Parse::Protocol::KEY_CREATED_AT].class, String
-    assert_equal test_save[Parse::Protocol::KEY_OBJECT_ID].class, String
+      assert_equal test_save["foo"], "bar"
+      assert_equal test_save[Parse::Protocol::KEY_CREATED_AT].class, String
+      assert_equal test_save[Parse::Protocol::KEY_OBJECT_ID].class, String
+    end
   end
 
   def test_update
-    foo = Parse::Object.new "TestSave"
-    foo["age"] = 20
-    foo.save
+    VCR.use_cassette('test_update', :record => :new_episodes) do
+      foo = Parse::Object.new "TestSave"
+      foo["age"] = 20
+      foo.save
 
-    assert_equal foo["age"], 20
-    assert_equal foo[Parse::Protocol::KEY_UPDATED_AT], nil
+      assert_equal foo["age"], 20
+      assert_equal foo[Parse::Protocol::KEY_UPDATED_AT], nil
 
-    foo["age"] = 40
-    orig = foo.dup
-    foo.save
+      foo["age"] = 40
+      orig = foo.dup
+      foo.save
 
-    assert_equal foo["age"], 40
-    assert_equal foo[Parse::Protocol::KEY_UPDATED_AT].class, String
+      assert_equal foo["age"], 40
+      assert_equal foo[Parse::Protocol::KEY_UPDATED_AT].class, String
 
-    # only difference should be updatedAt
-    orig_assoc = orig.reject{|k,v| k == Parse::Protocol::KEY_UPDATED_AT}.to_a
-    foo_assoc = foo.reject{|k,v| k == Parse::Protocol::KEY_UPDATED_AT}.to_a
-    assert_equal foo_assoc, orig_assoc
+      # only difference should be updatedAt
+      orig_assoc = orig.reject{|k,v| k == Parse::Protocol::KEY_UPDATED_AT}.to_a
+      foo_assoc = foo.reject{|k,v| k == Parse::Protocol::KEY_UPDATED_AT}.to_a
+      assert_equal foo_assoc, orig_assoc
+    end
   end
 
   def test_server_update
-    foo = Parse::Object.new("TestSave").save
-    foo["name"] = 'john'
-    foo.save
+    VCR.use_cassette('test_server_update', :record => :new_episodes) do
+      foo = Parse::Object.new("TestSave").save
+      foo["name"] = 'john'
+      foo.save
 
-    bar = Parse.get("TestSave",foo.id) # pull it from the server
-    assert_equal bar["name"], 'john'
-    bar["name"] = 'dave'
-    bar.save
+      bar = Parse.get("TestSave",foo.id) # pull it from the server
+      assert_equal bar["name"], 'john'
+      bar["name"] = 'dave'
+      bar.save
 
-    bat = Parse.get("TestSave",foo.id)
-    assert_equal bat["name"], 'dave'
+      bat = Parse.get("TestSave",foo.id)
+      assert_equal bat["name"], 'dave'
+    end
   end
 
   def test_destroy
-    d = Parse::Object.new "toBeDeleted"
-    d["foo"] = "bar"
-    d.save
-    d.parse_delete
+    VCR.use_cassette('test_destroy', :record => :new_episodes) do
+      d = Parse::Object.new "toBeDeleted"
+      d["foo"] = "bar"
+      d.save
+      d.parse_delete
 
-    assert_equal d.keys.length, 0
+      assert_equal d.keys.length, 0
+    end
   end
 end

data/test/test_cloud.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+Parse.init
+
+class TestCloud < Test::Unit::TestCase
+	# functions stored in test/cloud_functions/MyCloudCode
+	# see https://parse.com/docs/cloud_code_guide to learn how to use Parse Cloud Code
+	#
+	# Parse.Cloud.define('trivial', function(request, response) {
+  # 	response.success(request.params);
+	# });
+
+	def setup
+    Parse.init
+	end
+
+	def test_cloud_function_initialize
+		assert_not_equal nil, Parse::Cloud::Function.new("trivial")
+	end
+
+	def test_cloud_function
+		VCR.use_cassette('test_cloud_function', :record => :new_episodes) do
+			function = Parse::Cloud::Function.new("trivial")
+			params = {"foo" => "bar"}
+			resp = function.call(params)
+			assert_equal resp, params
+		end
+	end
+end

data/test/test_object.rb

@@ -6,73 +6,97 @@ class TestObject < Test::Unit::TestCase
   end
 
   def test_new?
-  	post = Parse::Object.new "Post"
-  	assert_equal post.new?, true
-  	post.save
-  	assert_equal post.new?, false
+    VCR.use_cassette('test_new_object', :record => :new_episodes) do
+    	post = Parse::Object.new "Post"
+    	assert_equal post.new?, true
+    	post.save
+    	assert_equal post.new?, false
+    end
   end
 
-  def test_id
-    post = Parse::Object.new "Post"
-    assert_equal post.id, nil
-    post["title"] = "hello world"
-    post.save
-    assert_equal post.id.class, String
+  def test_object_id
+    VCR.use_cassette('test_object_id', :record => :new_episodes) do
+      post = Parse::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
-    post = Parse::Object.new "Post"
-    assert_nil post.pointer
+    VCR.use_cassette('test_pointer', :record => :new_episodes) do    
+      post = Parse::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
+      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_created_at
-    post = Parse::Object.new "Post"
-    assert_equal post.created_at, nil
-    post.save
-    assert_equal post.created_at.class, DateTime
+    VCR.use_cassette('test_created_at', :record => :new_episodes) do
+      post = Parse::Object.new "Post"
+      assert_equal post.created_at, nil
+      post.save
+      assert_equal post.created_at.class, DateTime
+    end
   end
 
   def test_updated_at
-    post = Parse::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
+    VCR.use_cassette('test_updated_at', :record => :new_episodes) do
+      post = Parse::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
-    post = Parse::Object.new "Post"
-    post.save
-    assert_equal post.id.class, String
+    VCR.use_cassette('test_parse_delete', :record => :new_episodes) do
+      post = Parse::Object.new "Post"
+      post.save
+      assert_equal post.id.class, String
 
-    q = Parse.get("Post", post.id)
-    assert_equal q.id, post.id
+      q = Parse.get("Post", post.id)
+      assert_equal q.id, post.id
 
-    post.parse_delete
+      post.parse_delete
 
-    assert_raise Parse::ParseError do
-      q = Parse.get("Post", post.id)
+      assert_raise Parse::ParseError do
+        q = Parse.get("Post", post.id)
+      end
     end
   end
 
   def test_deep_parse
-    other = Parse::Object.new "Post"
-    other.save
-    post = Parse::Object.new "Post"
-    post["other"] = other.pointer
-    post.save
+    VCR.use_cassette('test_deep_parse', :record => :new_episodes) do
+      other = Parse::Object.new "Post"
+      other.save
+      post = Parse::Object.new "Post"
+      post["other"] = other.pointer
+      post.save
 
-    q = Parse.get("Post", post.id)
-    assert_equal Parse::Pointer, q["other"].class
-    assert_equal other.pointer, q["other"]
+      q = Parse.get("Post", post.id)
+      assert_equal Parse::Pointer, q["other"].class
+      assert_equal other.pointer, q["other"]
+    end
   end
 
+  def test_nils_delete_keys
+    VCR.use_cassette('test_nils_delete_keys', :record => :new_episodes) do
+      post = Parse::Object.new "Post"
+      post["title"] = "hello"
+      post.save    
+      post["title"] = nil
+      post.save
+      assert_false post.refresh.keys.include?("title")
+    end
+  end
 end

data/test/test_push.rb

@@ -6,21 +6,19 @@ class TestPush < Test::Unit::TestCase
     Parse.init
   end
 
-  def test_save
+  def test_save_without_where
     data = {:foo => 'bar',
             :alert => 'message'}
     pf_push = Parse::Push.new(data, "some_chan")
     pf_push.type = 'ios'
 
     query = Parse::Query.new(Parse::Protocol::CLASS_INSTALLATION).eq('deviceToken', 'baz')
-    pf_push.where = query.where
 
     Parse::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])
       assert has_entries('foo' => 'bar', 'alert' => 'message').matches?([hash['data']])
-      assert has_entries('deviceToken' => 'baz').matches?([hash['where']])
       assert_nil query
       true
     end.returns({}.to_json)
@@ -29,4 +27,23 @@ class TestPush < Test::Unit::TestCase
   end
 
 
+  def test_save_with_where_removes_channel
+    data = {:foo => 'bar',
+            :alert => 'message'}
+    pf_push = Parse::Push.new(data, "some_chan")
+    pf_push.type = 'ios'
+
+    query = Parse::Query.new(Parse::Protocol::CLASS_INSTALLATION).eq('deviceToken', 'baz')
+    pf_push.where = query.where
+
+    Parse::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']])
+      true
+    end.returns({}.to_json)
+
+    pf_push.save
+  end
+
 end