rhoconnect-rb 0.1.0

data/.autotest

@@ -0,0 +1,3 @@
+require "autotest/bundler"
+require "autotest/fsevent"
+require "autotest/growl"

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+coverage

data/.rspec

@@ -0,0 +1,3 @@
+--format nested
+--color
+spec/**/*_spec.rb

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gemspec
+gem 'rake'
+
+group :test do
+  gem 'rspec', '~>2.5.0', :require => 'spec'
+  gem 'rcov', '~>0.9.8'
+  gem 'webmock'
+end

data/README.md

@@ -0,0 +1,50 @@
+rhoconnect-rb
+===
+
+A ruby client library for the [RhoSync](http://rhomobile.com/products/rhosync) App Integration Server.  
+
+Using rhoconnect-rb, your application's model data will transparently synchronize with a mobile application built using the [Rhodes framework](http://rhomobile.com/products/rhodes), or any of the available [RhoSync clients](http://rhomobile.com/products/rhosync/).  This client includes built-in support for [ActiveRecord](http://ar.rubyonrails.org/) and [DataMapper](http://datamapper.org/) models. 
+
+## Getting started
+
+Load the `rhoconnect-rb` library:
+
+	require 'rhoconnect-rb'
+
+Note, if you are using datamapper, install the `dm-serializer` library and require it in your application.  `rhoconnect-rb` depends on this utility to interact with RhoSync applications using JSON.
+	
+## Usage
+Now include Rhosync::Resource in a model that you want to synchronize with your mobile application:
+
+	class Product < ActiveRecord::Base
+	  include Rhosync::Resource
+	end
+	
+Or, if you are using DataMapper:
+
+	class Product
+	  include DataMapper::Resource
+	  include Rhosync::Resource
+	end
+	
+Next, your models will need to declare a partition key for `rhoconnect-rb`.  This partition key is used by `rhoconnect-rb` to uniquely identify the model dataset when it is stored in a RhoSync application.  It is typically an attribute on the model or related model.  `rhoconnect-rb` supports two types of partitions: 
+
+* :app - No unique key will be used, a shared dataset is used for all users.
+* lambda { some lambda } - Execute a lambda which returns the unique key string.
+
+For example, the `Product` model above might have a `belongs_to :user` relationship.  The partition identifying the username would be declared as:
+
+	class Product < ActiveRecord::Base
+	  include Rhosync::Resource
+	  
+	  belongs_to :user
+	
+	  partition lambda { self.user.username }
+	end
+	
+For more information about RhoSync partitions, please refer to the [RhoSync docs](http://docs.rhomobile.com/rhosync/source-adapters#data-partitioning).
+
+## Meta
+Created and maintained by Vladimir Tarasov and Lars Burgess.
+
+Released under the [MIT License](http://www.opensource.org/licenses/mit-license.php).

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-b", "-c", "-fd"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+desc "Run all specs with rcov"
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rspec_opts = ["-b", "-c", "-fd"]
+  t.rcov_opts =  ['--exclude', 'spec/*,gems/*']
+end
+
+task :default => :spec

data/config/routes.rb

@@ -0,0 +1,7 @@
+Rails.application.routes.draw do
+  match '/rhosync/authenticate' => Rhosync::Authenticate
+  match '/rhosync/query' => Rhosync::Query
+  match '/rhosync/create' => Rhosync::Create
+  match '/rhosync/update' => Rhosync::Update
+  match '/rhosync/delete' => Rhosync::Delete
+end

data/init.rb

@@ -0,0 +1 @@
+require 'rhoconnect-rb'

data/lib/rhoconnect-rb.rb

@@ -0,0 +1,7 @@
+require 'json'
+require 'rest_client'
+require 'rhosync/version'
+require 'rhosync/configuration'
+require 'rhosync/client'
+require 'rhosync/resource'
+require 'rhosync/endpoints'

data/lib/rhosync/client.rb

@@ -0,0 +1,88 @@
+require 'uri'
+
+module Rhosync
+  class Client
+    attr_accessor :uri, :token
+    
+    # allow configuration, uri or environment variable initialization
+    def initialize(params = {})
+      uri = params[:uri] || Rhosync.configuration.uri || ENV['RHOSYNC_URL']
+      raise ArgumentError.new("Please provide a :uri or set RHOSYNC_URL") unless uri
+      uri = URI.parse(uri)
+      
+      @token = params[:token] || Rhosync.configuration.token || uri.user
+      uri.user = nil; @uri = uri.to_s      
+      raise ArgumentError.new("Please provide a :token or set it in uri") unless @token
+      
+      RestClient.proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    end
+    
+    def create(source_name, partition, obj = {})
+      send_objects(:push_objects, source_name, partition, obj)
+    end
+    
+    def destroy(source_name, partition, obj = {})
+      send_objects(:push_deletes, source_name, partition, obj)
+    end
+    
+    # update, create, it doesn't matter :)
+    alias :update :create
+    
+    def set_auth_callback(callback)
+      process(:post, "/api/set_auth_callback", { :callback => callback })
+    end
+    
+    def set_query_callback(source_name, callback)
+      process(:post, "/api/set_query_callback", 
+        { 
+          :source_id => source_name,
+          :callback => callback 
+        }
+      )
+    end
+
+    protected 
+    
+    def validate_args(source_name, partition, obj = {}) # :nodoc:
+      raise ArgumentError.new("Missing object id for #{obj.inspect}") unless obj['id']
+      raise ArgumentError.new("Missing source_name.") unless source_name or source_name.empty?
+      raise ArgumentError.new("Missing partition for #{model}.") unless partition or partition.empty?
+    end
+    
+    def send_objects(action, source_name, partition, obj = {}) # :nodoc:
+      validate_args(source_name, partition, obj)
+      
+      process(:post, "/api/#{action}", 
+        {
+          :source_id => source_name,
+          :user_id => partition,
+          :objects => action == :push_deletes ? [obj['id'].to_s] : { obj['id'] => obj }
+        }
+      )
+    end
+    
+    def resource(path) # :nodoc:
+      RestClient::Resource.new(@uri)[path]
+    end
+    
+    def process(method, path, payload = nil) # :nodoc:
+      headers = api_headers
+      unless method == :get
+        payload  = payload.merge!(:api_token => @token).to_json
+        headers = api_headers.merge(:content_type => 'application/json')
+      end
+      args     = [method, payload, headers].compact
+      response = resource(path).send(*args)
+      response
+    end
+    
+    def api_headers   # :nodoc:
+      {
+        'User-Agent'           => Rhosync::VERSION,
+        'X-Ruby-Version'       => RUBY_VERSION,
+        'X-Ruby-Platform'      => RUBY_PLATFORM
+      }
+    end
+        
+  end
+end

data/lib/rhosync/configuration.rb

@@ -0,0 +1,38 @@
+module Rhosync
+  class Configuration
+    attr_accessor :uri, :token, :authenticate, :sync_time_as_int
+    
+    def initialize
+      @sync_time_as_int = true
+    end
+      
+  end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  # Configure RhoSync in an initializer:
+  # like config/initializers/rhosync.rb
+  #
+  # Setup the RhoSync uri and api token.  
+  # Use rhosync:get_token to get the token value.
+  #
+  #   config.uri   = "http://myrhosync.com"
+  #   config.token = "secrettoken"
+  #   config.authenticate = lambda { |credentials| 
+  #     User.authenticate(credentials) 
+  #   }
+  #
+  # @example
+  #   Rhosync.configure do |config|
+  #     config.uri   = "http://myrhosync.com"
+  #     config.token = "secrettoken"
+  #   end
+  def self.configure
+    self.configuration = Configuration.new
+    yield(configuration)
+  end
+end
+
+Rhosync.configure { }

data/lib/rhosync/endpoints.rb

@@ -0,0 +1,167 @@
+require 'json'
+
+module Rhosync
+  class EndpointHelpers
+    def self.authenticate(content_type, body)
+      code, params = 200, parse_params(content_type, body)
+      if Rhosync.configuration.authenticate
+        code = 401 unless Rhosync.configuration.authenticate.call(params)
+      end  
+      [code, {'Content-Type' => 'text/plain'}, [""]]
+    end
+    
+    def self.query(content_type, body)
+      params = parse_params(content_type, body)
+      action, c_type, result, records = :rhosync_query, 'application/json', {}, []
+      # Call resource rhosync_query class method
+      code, error = get_rhosync_resource(params['resource'], action) do |klass|
+        records = klass.send(action, params['partition'])
+      end
+      if code == 200
+        # Serialize records into hash of hashes
+        records.each do |record|
+          result[record.id.to_s] = record.normalized_attributes
+        end
+        result = result.to_json
+      else
+        result = error
+        c_type = 'text/plain'
+        # Log warning if something broke
+        warn error
+      end    
+      [code, {'Content-Type' => c_type}, [result]]
+    end
+    
+    def self.on_cud(action, content_type, body)
+      params = parse_params(content_type, body)
+      object_id = ""
+      code, error = get_rhosync_resource(params['resource'], action) do |klass|
+        object_id = klass.send("rhosync_receive_#{action}".to_sym,
+          params['partition'], params['attributes'])
+        object_id = object_id.to_s if object_id
+      end
+      [code, {'Content-Type' => "text/plain"}, [error || object_id]]
+    end
+    
+    def self.create(content_type, body)
+      self.on_cud(:create, content_type, body)
+    end
+    
+    def self.update(content_type, body)
+      self.on_cud(:update, content_type, body)  
+    end
+    
+    def self.delete(content_type, body)
+      self.on_cud(:delete, content_type, body)  
+    end
+    
+    private
+    
+    def self.get_rhosync_resource(resource_name, action)
+      code, error = 200, nil
+      begin
+        klass = Kernel.const_get(resource_name)
+        yield klass
+      rescue NoMethodError => ne
+        error = "error on method `#{action}` for #{resource_name}: #{ne.message}"
+        code = 404
+      rescue NameError
+        error = "Missing Rhosync::Resource #{resource_name}"
+        code = 404
+      # TODO: catch HaltException and Exception here, built-in source adapter will handle them
+      rescue Exception => e
+        error = e.message
+        code = 500
+      end
+      [code, error]
+    end
+    
+    def self.parse_params(content_type, params)
+      if content_type and content_type.match(/^application\/json/) and params and params.length > 2
+        JSON.parse(params)
+      else 
+        {}
+      end
+    end
+  end
+end
+
+# Detect if we're running inside of rails
+if defined? Rails
+  #if Rails::VERSION::STRING.to_i >= 3
+    class Engine < Rails::Engine; end
+  #end
+  
+  module Rhosync  
+    class BaseEndpoint
+      def self.call(env)
+        req = Rack::Request.new(env)
+        Rhosync::EndpointHelpers.send(self.to_s.downcase.split("::")[1].to_sym, req.content_type, req.body.read)
+      end
+    end
+    
+    class Authenticate < BaseEndpoint; end
+    
+    class Query < BaseEndpoint;  end
+    
+    class Create < BaseEndpoint; end
+    
+    class Update < BaseEndpoint; end
+    
+    class Delete < BaseEndpoint; end
+  end
+end
+
+
+# Detect if we're running inside of sinatra
+if defined? Sinatra
+  # Defines Sinatra routes
+  # This is automatically registered if you are using
+  # the 'classic' style sinatra application.  To use in a 
+  # classic application:
+  #
+  # require 'rubygems'
+  # require 'sinatra'
+  # require 'rhoconnect-rb'
+  #
+  # get '/' do
+  #  'hello world'
+  # end
+  #
+  # For modular sinatra applications, you will need to register
+  # the module inside your class. To use in a modular application:
+  #
+  # require 'sinatra/base'
+  # require 'rhoconnect-rb'
+  # 
+  # class Myapp < Sinatra::Base
+  #   register Sinatra::RhosyncEndpoints
+  #   get '/' do
+  #     'hello world'
+  #   end
+  # end
+  module Sinatra
+    module RhosyncHelpers
+      def call_helper(method,*args)
+        code, c_type, body = Rhosync::EndpointHelpers.send(method,*args)
+        content_type c_type['Content-Type']
+        status code
+        body[0]
+      end
+    end
+    
+    module RhosyncEndpoints
+      def self.registered(app)
+        # install our endpoint helpers
+        app.send(:include, RhosyncHelpers)
+
+        [:authenticate,:query,:create,:update,:delete].each do |endpoint|
+          app.post "/rhosync/#{endpoint}" do
+            call_helper(endpoint, request.env['CONTENT_TYPE'], request.body.read)
+          end
+        end
+      end
+    end
+    register RhosyncEndpoints
+  end
+end

data/lib/rhosync/resource.rb

@@ -0,0 +1,143 @@
+module Rhosync
+  module Resource
+    
+    def self.included(model)
+      model.extend(ClassMethods)
+      model.extend(HelperMethods)
+      
+      model.send(:include, InstanceMethods)
+      model.send(:include, Callbacks)
+    end
+    
+    
+    module ClassMethods
+      def partition(p)
+        @partition = p
+      end
+      
+      def get_partition
+        @partition.is_a?(Proc) ? @partition.call : @partition
+      end
+      
+      def rhosync_receive_create(partition, attributes)
+        instance = self.send(:new)
+        instance.send(:rhosync_apply_attributes, partition, attributes)
+        instance.skip_rhosync_callbacks = true
+        instance.save
+        instance.id #=> return object id
+      end
+      
+      def rhosync_receive_update(partition, attributes)
+        object_id = attributes.delete('id')
+        instance = self.send(is_datamapper? ? :get : :find, object_id)
+        instance.send(:rhosync_apply_attributes, partition, attributes)
+        instance.skip_rhosync_callbacks = true
+        instance.save
+        object_id
+      end
+      
+      def rhosync_receive_delete(partition, attributes)
+        object_id = attributes['id']
+        instance = self.send(is_datamapper? ? :get : :find, object_id)      
+        instance.skip_rhosync_callbacks = true
+        instance.destroy
+        object_id
+      end
+    end
+    
+    module InstanceMethods
+      attr_accessor :skip_rhosync_callbacks
+      
+      def rhosync_create
+        call_client_method(:create)
+      end
+      
+      def rhosync_destroy
+        call_client_method(:destroy)
+      end
+      
+      def rhosync_update
+        call_client_method(:update)
+      end
+      
+      def rhosync_query(partition)
+        #return all objects for this partition 
+      end
+      
+      # By default we ignore partition
+      # TODO: Document - this is user-facing function
+      def rhosync_apply_attributes(partition, attributes)
+        self.attributes = attributes
+      end
+      
+      # Return Rhosync-friendly attributes list
+      def normalized_attributes
+        attribs = self.attributes.dup
+        attribs.each do |key,value|
+          attribs[key] = Time.parse(value.to_s).to_i.to_s if value.is_a?(Time) or value.is_a?(DateTime)
+        end if Rhosync.configuration.sync_time_as_int
+        attribs    
+      end
+      
+      private
+        
+      def call_client_method(action)
+        unless self.skip_rhosync_callbacks
+          attribs = self.normalized_attributes
+          begin
+            Rhosync::Client.new.send(action, self.class.to_s, self.class.get_partition, attribs)
+          rescue RestClient::Exception => re
+            warn "#{self.class.to_s}: rhosync_#{action} returned error: #{re.message} - #{re.http_body}"
+          rescue Exception => e
+            warn "#{self.class.to_s}: rhosync_#{action} returned unexpected error: #{e.message}"
+          end
+        end
+      end
+      
+    end
+    
+    module Callbacks  
+        
+      def self.included(model)
+        model.class_eval do
+          install_callbacks
+        end
+      end
+    end
+  
+    module HelperMethods
+      
+      def install_callbacks
+        if is_datamapper?
+          # test for dm-serializer
+          if not is_defined?(DataMapper::Serialize)
+            raise "Rhosync::Resource requires dm-serializer to work with DataMapper. Install with `gem install dm-serializer` and add to your application."
+          end
+          after :create, :rhosync_create
+          after :destroy, :rhosync_destroy
+          after :update, :rhosync_update
+        elsif is_activerecord?
+          after_create :rhosync_create
+          after_destroy :rhosync_destroy
+          after_update :rhosync_update
+        else
+          raise "Rhosync::Resource only supports ActiveRecord or DataMapper at this time."  
+        end
+      end
+      
+      private
+      
+      def is_defined?(const) # :nodoc:
+        defined?(const)
+      end
+      
+      def is_datamapper? # :nodoc:
+        self.included_modules.include?(DataMapper::Resource) rescue false
+      end
+      
+      def is_activerecord? # :nodoc:
+        self.superclass == ActiveRecord::Base rescue false
+      end
+    end
+  end
+end

data/lib/rhosync/version.rb

@@ -0,0 +1,3 @@
+module Rhosync
+  VERSION = "0.1.0"
+end

data/rhoconnect-rb.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'rhosync/version'
+
+Gem::Specification.new do |s|
+  s.name        = "rhoconnect-rb"
+  s.version     = Rhosync::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Rhomobile"]
+  s.date        = Time.now.strftime('%Y-%m-%d')
+  s.email       = ["support@rhomobile.com"]
+  s.homepage    = %q{http://rhomobile.com}
+  s.summary     = %q{RhoSync rails plugin}
+  s.description = %q{RhoSync rails plugin}
+
+  s.rubyforge_project = nil  
+  s.add_dependency('rest-client', '~>1.6.1')
+  s.add_dependency('json', '~>1.4.6')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  
+end

data/spec/client_spec.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Rhosync::Client do
+  
+  context "on initialize" do
+    it "should initialize with RHOSYNC_URL environment var" do
+      ENV['RHOSYNC_URL'] = "http://token@test.rhosync.com"
+      c = Rhosync::Client.new
+      c.token.should == 'token'
+      c.uri.should == 'http://test.rhosync.com'
+      ENV.delete('RHOSYNC_URL')
+    end
+  
+    it "should initialize with :uri parameter" do
+      c = Rhosync::Client.new(:uri => "http://token@test.rhosync.com")
+      c.token.should == 'token'
+      c.uri.should == 'http://test.rhosync.com'
+    end
+  
+    it "should initialize with :token parameter" do
+      c = Rhosync::Client.new(:uri => "http://test.rhosync.com", :token => "token")
+      c.token.should == 'token'
+      c.uri.should == 'http://test.rhosync.com'
+    end
+    
+    it "should initialize with configure block" do
+      Rhosync.configure do |config|
+        config.uri = "http://test.rhosync.com"
+        config.token = "token"
+      end
+      begin
+        c = Rhosync::Client.new
+        c.token.should == 'token'
+        c.uri.should == 'http://test.rhosync.com'
+      ensure
+        Rhosync.configure do |config|
+          config.uri = nil
+          config.token = nil   
+        end
+      end
+    end
+  
+    it "should raise ArgumentError if uri is missing" do
+      lambda { Rhosync::Client.new }.should raise_error(ArgumentError, "Please provide a :uri or set RHOSYNC_URL")
+    end
+  
+    it "should raise ArugmentError if token is missing" do
+      lambda { 
+        Rhosync::Client.new(:uri => "http://test.rhosync.com") 
+      }.should raise_error(ArgumentError, "Please provide a :token or set it in uri")
+    end
+  end
+  
+  context "on create update destroy" do
+    before(:each) do
+      @client = Rhosync::Client.new(:uri => "http://token@test.rhosync.com")
+    end
+    
+    it "should create an object" do
+      stub_request(:post, "http://test.rhosync.com/api/push_objects").with(
+        :headers => {"Content-Type" => "application/json"}
+      ).to_return(:status => 200, :body => "done")
+      resp = @client.create("Person", "user1", 
+        {
+          'id' => 1,
+          'name' => 'user1'
+        }
+      )
+      resp.body.should == "done"
+      resp.code.should == 200
+    end
+    
+    it "should update an object" do
+      stub_request(:post, "http://test.rhosync.com/api/push_objects").with(
+        :headers => {"Content-Type" => "application/json"}
+      ).to_return(:status => 200, :body => "done")
+      resp = @client.update("Person", "user1", 
+        {
+          'id' => 1,
+          'name' => 'user1'
+        }
+      )
+      resp.body.should == "done"
+      resp.code.should == 200
+    end
+    
+    it "should destroy an object" do
+      stub_request(:post, "http://test.rhosync.com/api/push_deletes").with(
+        :headers => {"Content-Type" => "application/json"}
+      ).to_return(:status => 200, :body => "done")
+      resp = @client.destroy("Person", "user1", 
+        {
+          'id' => 1,
+          'name' => 'user1'
+        }
+      )
+      resp.body.should == "done"
+      resp.code.should == 200
+    end
+  end
+  
+  context "on set callbacks" do
+    before(:each) do
+      @client = Rhosync::Client.new(:uri => "http://token@test.rhosync.com")
+    end
+    
+    it "should set auth callback" do
+      stub_request(:post, "http://test.rhosync.com/api/set_auth_callback").with(
+        :headers => {"Content-Type" => "application/json"}
+      ).to_return(:status => 200, :body => "done")
+      resp = @client.set_auth_callback("http://example.com/callback")
+      resp.body.should == "done"
+      resp.code.should == 200
+    end
+    
+    it "should set query callback" do
+      stub_request(:post, "http://test.rhosync.com/api/set_query_callback").with(
+        :headers => {"Content-Type" => "application/json"}
+      ).to_return(:status => 200, :body => "done")
+      resp = @client.set_query_callback("Person", "http://example.com/callback")
+      resp.body.should == "done"
+      resp.code.should == 200
+    end
+  end
+end

data/spec/endpoints_spec.rb

@@ -0,0 +1,234 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Rhosync::EndpointHelpers do
+  
+  # Auth stub class
+  class AuthTest; end
+  class BrokenResource < ActiveRecord::Base
+    include Rhosync::Resource
+  end
+  
+  # Query stub class
+  class Product < ActiveRecord::Base
+    include Rhosync::Resource
+    def self.rhosync_query(partition)
+      [self.new]
+    end
+  end
+  
+  def setup_auth_test(success)
+    AuthTest.stub!(:do_auth).and_return(success)
+    AuthTest.should_receive(:do_auth).with(@creds)
+    
+    Rhosync.configure do |config|
+      config.uri = "http://test.rhosync.com"
+      config.token = "token"
+      config.authenticate = lambda {|credentials|
+        AuthTest.do_auth(credentials)
+      }  
+    end
+  end
+  
+  before(:all) do
+    @params = {'partition' => 'testuser', 'resource' => 'Product'}
+    @creds = {'user' => 'john', 'pass' => 'secret'}
+  end
+  
+  context "on Rails auth endpoint" do
+    before(:each) do
+      strio = mock("StringIO")
+      strio.stub!(:read).and_return(JSON.generate(@creds))
+      @env = mock("env")
+      @env.stub!(:body).and_return(strio)
+      @env.stub!(:content_type).and_return('application/json')
+      Rack::Request.stub!(:new).and_return(@env)
+    end
+    
+    it "should call configured authenticate block" do
+      setup_auth_test(true)
+      Rhosync::Authenticate.call(@env).should == [
+        200, {'Content-Type' => 'text/plain'}, [""]
+      ]
+    end
+    
+    it "should call configured authenticate block with 401" do
+      setup_auth_test(false)
+      Rhosync::Authenticate.call(@env).should == [
+        401, {'Content-Type' => 'text/plain'}, [""]
+      ]
+    end
+    
+    it "should return true if no authenticate block exists" do
+      Rhosync.configure do |config|
+        config.uri = "http://test.rhosync.com"
+        config.token = "token" 
+      end
+      Rhosync.configuration.authenticate.should be_nil
+      Rhosync::Authenticate.call(@env).should == [
+        200, {'Content-Type' => 'text/plain'}, [""]
+      ]
+    end
+    
+    it "should call authenticate block with empty params" do
+      Rhosync::EndpointHelpers.authenticate('text/plain', '').should == [
+        200, {"Content-Type"=>"text/plain"}, [""]
+      ]
+    end
+  end
+    
+  context "on Create/Update/Delete/Query endpoints" do
+    before(:each) do
+      @strio = mock("StringIO")
+      @env = mock("env")
+      @env.stub!(:content_type).and_return('application/json')
+    end
+    
+    it "should call query endpoint" do
+      @strio.stub!(:read).and_return(
+        {'partition' => 'testuser', 'resource' => 'Product'}.to_json
+      )
+      @env.stub!(:body).and_return(@strio)
+      Rack::Request.stub!(:new).and_return(@env)
+      code, content_type, body = Rhosync::Query.call(@env)
+      code.should == 200
+      content_type.should == { "Content-Type" => "application/json" }
+      JSON.parse(body[0]).should == { '1' => Product.new.normalized_attributes }
+    end
+    
+    it "should fail on missing Rhosync::Resource" do
+      @strio.stub!(:read).and_return(
+        {'partition' => 'testuser', 'resource' => 'Broken'}.to_json
+      )
+      @env.stub!(:body).and_return(@strio)
+      Rack::Request.stub!(:new).and_return(@env)
+      code, content_type, body = Rhosync::Query.call(@env)
+      code.should == 404
+      content_type.should == { "Content-Type" => "text/plain" }
+      body[0].should == "Missing Rhosync::Resource Broken"
+    end
+    
+    it "should fail on undefined rhosync_query method" do
+      @strio.stub!(:read).and_return(
+        {'partition' => 'testuser', 'resource' => 'BrokenResource'}.to_json
+      )
+      @env.stub!(:body).and_return(@strio)      
+      Rack::Request.stub!(:new).and_return(@env)
+      code, content_type, body = Rhosync::Query.call(@env)
+      code.should == 404
+      content_type.should == { "Content-Type" => "text/plain" }
+      body[0].should == "error on method `rhosync_query` for BrokenResource: undefined method `rhosync_query' for BrokenResource:Class" 
+    end
+    
+    it "should fail on unknown exception" do
+      @strio.stub!(:read).and_return(
+        {'partition' => 'testuser', 'resource' => 'Product'}.to_json
+      )
+      @env.stub!(:body).and_return(@strio)      
+      Rack::Request.stub!(:new).and_return(@env)
+      Product.stub!(:rhosync_receive_create).and_return { raise "error in create" }
+      code, content_type, body = Rhosync::Create.call(@env)
+      code.should == 500
+      content_type.should == { "Content-Type" => "text/plain" }
+      body[0].should == "error in create"
+    end
+    
+    it "should call create endpoint" do
+      params = {
+        'resource' => 'Product',
+        'partition' => 'app',
+        'attributes' => {
+          'name' => 'iphone',
+          'brand' => 'apple'
+        }
+      }
+      @strio.stub!(:read).and_return(params.to_json)
+      @env.stub!(:body).and_return(@strio)      
+      Rack::Request.stub!(:new).and_return(@env)
+      code, content_type, body = Rhosync::Create.call(@env)
+      code.should == 200
+      content_type.should == { "Content-Type" => "text/plain" }
+      body.should == ['1']
+    end
+    
+    it "should call update endpoint" do
+      params = {
+        'resource' => 'Product',
+        'partition' => 'app',
+        'attributes' => {
+          'id' => '123',
+          'name' => 'iphone',
+          'brand' => 'apple'
+        }
+      }
+      @strio.stub!(:read).and_return(params.to_json)
+      @env.stub!(:body).and_return(@strio)      
+      Rack::Request.stub!(:new).and_return(@env)
+      code, content_type, body = Rhosync::Update.call(@env)
+      code.should == 200
+      content_type.should == { "Content-Type" => "text/plain" }
+      body.should == ["123"]
+    end
+    
+    it "should call delete endpoint" do
+      params = {
+        'resource' => 'Product',
+        'partition' => 'app',
+        'attributes' => {
+          'id' => '123',
+          'name' => 'iphone',
+          'brand' => 'apple'
+        }
+      }
+      @strio.stub!(:read).and_return(params.to_json)
+      @env.stub!(:body).and_return(@strio)      
+      Rack::Request.stub!(:new).and_return(@env)
+      code, content_type, body = Rhosync::Delete.call(@env)
+      code.should == 200
+      content_type.should == { "Content-Type" => "text/plain" }
+      body.should == ["123"]
+    end
+      
+  end
+  
+  context "on Sinatra endpoints" do    
+    class EndpointTest
+      include Sinatra::RhosyncHelpers
+    end
+  
+    it "should register endpoints for authenticate and query" do
+      strio = mock("StringIO")
+      strio.stub!(:read).and_return(@creds.to_json)      
+      req = mock("request")
+      req.stub!(:body).and_return(strio)
+      req.stub!(:env).and_return('CONTENT_TYPE' => 'application/json')
+      Sinatra::RhosyncEndpoints.stub!(:request).and_return(req)
+      Sinatra::RhosyncEndpoints.stub!(:params).and_return(@params)
+      Rhosync::EndpointHelpers.stub!(:query)
+      app = mock("app")
+      app.stub!(:post).and_yield
+      app.should_receive(:post).exactly(5).times
+      app.should_receive(:include).with(Sinatra::RhosyncHelpers)
+      Sinatra::RhosyncEndpoints.should_receive(:call_helper).exactly(5).times
+      Sinatra::RhosyncEndpoints.registered(app)
+    end
+    
+    it "should call helper for authenticate" do
+      app = EndpointTest.new
+      app.should_receive(:status).with(200)
+      app.should_receive(:content_type).with('text/plain')
+      app.call_helper(
+        :authenticate, 'application/json', @creds.to_json
+      ).should == ""
+    end
+    
+    it "should call helper for query" do
+      app = EndpointTest.new
+      app.should_receive(:status).with(200)
+      app.should_receive(:content_type).with('application/json')
+      result = app.call_helper(
+        :query, 'application/json', @params.to_json
+      )
+      JSON.parse(result).should == { '1' => Product.new.normalized_attributes }
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Rhosync::Resource do
+  
+  context "on set partition" do
+    it "should set resource partition to :app" do
+      class TestModel1 < ActiveRecord::Base
+        include Rhosync::Resource
+      
+        partition :app
+      end
+    
+      TestModel1.get_partition.should == :app
+    end
+  
+    it "should set resource partition with lambda" do
+      class TestModel2 < ActiveRecord::Base
+        include Rhosync::Resource
+      
+        partition lambda{ 'helloworld' }
+      end
+    
+      TestModel2.get_partition.should == 'helloworld'
+    end
+  end
+  
+  context "on initialize" do
+    it "should raise exception if DataMapper or ActiveRecord::Base are missing" do
+      lambda { class TestModel3
+                 include Rhosync::Resource
+               end
+      }.should raise_error("Rhosync::Resource only supports ActiveRecord or DataMapper at this time.")
+    end
+    
+    it "should register callbacks for ActiveRecord::Base" do
+      class TestModel4 < ActiveRecord::Base
+        include Rhosync::Resource
+      end
+    
+      TestModel4.create_callback.should == :rhosync_create
+      TestModel4.destroy_callback.should == :rhosync_destroy
+      TestModel4.update_callback.should == :rhosync_update
+    end
+  
+    it "should register callbacks for DataMapper::Resource" do
+      class TestModel5
+        include DataMapper::Resource
+        include Rhosync::Resource
+      end
+        
+      TestModel5.rhosync_callbacks[:create].should == :rhosync_create
+      TestModel5.rhosync_callbacks[:destroy].should == :rhosync_destroy
+      TestModel5.rhosync_callbacks[:update].should == :rhosync_update
+    end
+    
+    it "should raise exception if dm-serializer is missing" do
+      class TestModel6
+        include DataMapper::Resource
+        include Rhosync::Resource
+      end
+      TestModel6.stub!(:is_defined?).and_return(false)
+      lambda { 
+        TestModel6.install_callbacks
+      }.should raise_error("Rhosync::Resource requires dm-serializer to work with DataMapper. Install with `gem install dm-serializer` and add to your application.")
+    end
+  end
+  
+  context "on create update delete" do
+    
+    it "should call create update delete hook" do
+      class TestModel7 < ActiveRecord::Base
+        include Rhosync::Resource
+        partition :app
+      end
+      client = mock('Rhosync::Client')
+      client.stub!(:send)
+      Rhosync::Client.stub!(:new).and_return(client)
+      [:create, :update, :destroy].each do |action|
+        client.should_receive(:send).with(
+          action, "TestModel7", :app, {"name"=>"John", "created_at"=>"1299636666", "updated_at"=>"1299636666", "id"=>1}
+        )
+        TestModel7.new.send("rhosync_#{action}".to_sym)
+      end
+    end
+    
+    it "should warn on RestClient::Exception" do
+      class TestModel8 < ActiveRecord::Base
+        include Rhosync::Resource
+        partition :app
+      end
+      client = mock('Rhosync::Client')
+      exception = RestClient::Exception.new(
+        RestClient::Response.create("error connecting to server", nil, nil), 500
+      )
+      exception.message = "Internal Server Error"
+      client.stub!(:send).and_return { raise exception }
+      Rhosync::Client.stub!(:new).and_return(client)
+      tm = TestModel8.new
+      tm.should_receive(:warn).with(
+        "TestModel8: rhosync_create returned error: Internal Server Error - error connecting to server"
+      )
+      tm.rhosync_create
+    end
+    
+    it "should warn on Exception" do
+      class TestModel8 < ActiveRecord::Base
+        include Rhosync::Resource
+        partition :app
+      end
+      client = mock('Rhosync::Client')
+      client.stub!(:send).and_return { raise Exception.new("error connecting to server") }
+      Rhosync::Client.stub!(:new).and_return(client)
+      tm = TestModel8.new
+      tm.should_receive(:warn).with("TestModel8: rhosync_create returned unexpected error: error connecting to server")
+      tm.rhosync_create
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec'
+require 'webmock/rspec'
+
+include WebMock::API
+
+# stub for rack
+module Rack
+  class Request; end
+end
+
+# stubs for rails engine
+module Rails 
+  class Engine; end
+end
+
+# stubs for sinatra
+module Sinatra
+  def self.register(mod); end
+  module RhosyncEndpoints
+    def self.content_type(c_type); end
+    def self.status(code); end
+  end
+end
+
+require 'rhoconnect-rb'
+
+
+# define ActiveRecord and DM here for testing
+module ActiveRecord
+  class Base
+    
+    def attributes
+      {
+        "name" => "John", 
+        "created_at" => Time.parse("Wed Mar 09 02:11:06 UTC 2011"),
+        "updated_at" => Time.parse("Wed Mar 09 02:11:06 UTC 2011"), 
+        "id" => 1
+      }
+    end
+    
+    def attributes=(attribs); end
+    
+    def id; 1 end
+    
+    def warn(*args)
+      Kernel.warn(args)
+    end
+    
+    def save; end
+    
+    def self.find(object_id)
+      self.new
+    end
+    
+    def destroy; end
+    
+    class << self
+      attr_accessor :create_callback,:destroy_callback,:update_callback
+      
+      def after_create(callback)
+        @create_callback = callback
+      end
+    
+      def after_destroy(callback)
+        @destroy_callback = callback
+      end
+    
+      def after_update(callback)
+        @update_callback = callback
+      end
+    end
+  end
+end
+
+module DataMapper
+  module Resource
+    
+    def attributes
+      {
+        :created_at => DateTime.parse("Wed Mar 09 02:11:06 UTC 2011"), 
+        :updated_at => DateTime.parse("Wed Mar 09 02:11:06 UTC 2011"),
+        :name => "John", 
+        :id => 1
+      }
+    end
+    
+    def self.included(model)
+      model.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      attr_accessor :rhosync_callbacks
+      
+      def after(action, callback)
+        @rhosync_callbacks ||= {}
+        @rhosync_callbacks[action] = callback
+      end
+    end
+  end
+  
+  module Serialize; end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: rhoconnect-rb
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Rhomobile
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 6
+        - 1
+        version: 1.6.1
+  version_requirements: *id001
+  name: rest-client
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  version_requirements: *id002
+  name: json
+  prerelease: false
+description: RhoSync rails plugin
+email: 
+- support@rhomobile.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- config/routes.rb
+- init.rb
+- lib/rhoconnect-rb.rb
+- lib/rhosync/client.rb
+- lib/rhosync/configuration.rb
+- lib/rhosync/endpoints.rb
+- lib/rhosync/resource.rb
+- lib/rhosync/version.rb
+- rhoconnect-rb.gemspec
+- spec/client_spec.rb
+- spec/endpoints_spec.rb
+- spec/resource_spec.rb
+- spec/spec_helper.rb
+homepage: http://rhomobile.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: RhoSync rails plugin
+test_files: 
+- spec/client_spec.rb
+- spec/endpoints_spec.rb
+- spec/resource_spec.rb
+- spec/spec_helper.rb