rhoconnect 3.0.0.beta1

data/spec/spec_helper.rb

@@ -0,0 +1,231 @@
+require 'rubygems'
+require 'webmock/rspec'
+require 'rspec'
+require 'rhoconnect'
+include Rhoconnect
+ENV['RACK_ENV'] = 'test'
+
+ERROR = '0_broken_object_id' unless defined? ERROR
+
+# Monkey patch to fix the following issue:
+# /Library/Ruby/Gems/1.8/gems/rspec-core-2.5.1/lib/rspec/core/shared_example_group.rb:45:
+# in `ensure_shared_example_group_name_not_taken': Shared example group '...' already exists (ArgumentError)
+module RSpec
+  module Core
+    module SharedExampleGroup
+    private
+      def ensure_shared_example_group_name_not_taken(name)
+      end
+    end
+  end
+end
+
+module TestHelpers
+  def get_testapp_path
+    File.expand_path(File.join(File.dirname(__FILE__),'apps','rhotestapp'))
+  end
+  
+  def get_emptyapp_path
+    File.expand_path(File.join(File.dirname(__FILE__),'apps','emptyapp'))
+  end
+  
+  def do_post(url,params)
+    post url, params.to_json, {'CONTENT_TYPE'=>'application/json'}
+  end
+  
+  def bulk_data_docname(app_id,user_id)
+    if user_id == "*"
+      File.join(app_id,app_id)
+    else
+      File.join(app_id,user_id,user_id)
+    end
+  end
+  
+  def dump_db_data(store)
+    puts "*"*50 
+    puts "DATA DUMP"
+    puts "*"*50
+    store.db.keys('*').sort.each do |key|
+      next if not key =~ /md|cd/ 
+      line = ""
+      line << "#{key}: "
+      type = store.db.type key
+      if type == 'set'
+        if not key =~ /sources|clients|users/
+          line << "#{store.get_data(key).inspect}"
+        else
+          line << "#{store.db.smembers(key).inspect}"
+        end  
+      else
+        line << "#{store.db.get key}"
+      end
+      puts line
+    end
+    puts "*"*50
+  end
+  
+  def add_client_id(data)
+    res = Marshal.load(Marshal.dump(data))
+    res.each { |key,value| value['rhomobile.rhoclient'] = @c.id.to_s }
+  end
+
+  def add_error_object(data,error_message,error_name='wrongname')
+    error = {'an_attribute'=>error_message,'name'=>error_name} 
+    data.merge!({ERROR=>error})
+    data
+  end
+  
+  def delete_data_directory
+    FileUtils.rm_rf(Rhoconnect.data_directory)
+  end
+  
+  def json_clone(data)
+    JSON.parse(data.to_json)
+  end
+      
+  def set_state(state)
+    state.each do |dockey,data|
+      if data.is_a?(Hash) or data.is_a?(Array)
+        Store.put_data(dockey,data)
+      else
+        Store.put_value(dockey,data)
+      end
+    end
+  end
+  
+  def set_test_data(dockey,data,error_message=nil,error_name='wrongname')
+    if error_message
+      error = {'an_attribute'=>error_message,'name'=>error_name} 
+      data.merge!({ERROR=>error})
+    end  
+    Store.put_data(dockey,data)
+    data
+  end
+  
+  def verify_result(result)
+    result.keys.sort.each do |dockey|
+      expected = result[dockey]
+      begin
+        if expected.is_a?(Hash)
+          Store.get_data(dockey).should == expected
+        elsif expected.is_a?(Array)
+          Store.get_data(dockey,Array).should == expected
+        else
+          Store.get_value(dockey).should == expected
+        end
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        message = "\nVerifying `#{dockey}`\n\n" + e.to_s
+        Kernel::raise(RSpec::Expectations::ExpectationNotMetError.new(message))
+      end
+    end
+  end
+  
+  def validate_db(bulk_data,data)
+    validate_db_file(bulk_data.dbfile,bulk_data.sources.members,data)  
+  end
+    
+  def validate_db_file(dbfile,sources,data)  
+    db = DBAdapter.instance.get_connection(dbfile)    
+    sources.each do |source_name|
+      s = Source.load(source_name,{:app_id => APP_NAME,:user_id => @u.login})
+      return false unless validate_db_by_name(db,s,data[s.name])
+    end 
+    true 
+  end
+  
+  def validate_db_by_name(db,s,data)
+    db.execute("select source_id,name,sync_priority,partition,
+      sync_type,source_attribs,metadata,schema,blob_attribs,associations
+      from sources where name='#{s.name}'").each do |row|
+      
+      return false if row[0].to_s != s.source_id.to_s
+      return false if row[1] != s.name
+      return false if row[2].to_s != s.priority.to_s
+      return false if row[3] != s.partition_type.to_s
+      return false if row[4] != s.sync_type.to_s
+      return false if row[5] != (s.schema ? "" : get_attrib_counter(data))
+      return false if row[6] != s.get_value(:metadata)
+      return false if row[7] != s.schema
+      return false if row[8] != s.blob_attribs
+      return false if row[9] != s.has_many
+    end
+
+    data = json_clone(data)
+    if s.schema
+      schema = JSON.parse(s.schema)
+      columns = ['object']
+      schema['property'].each do |key,value|
+        columns << key
+      end
+      db.execute("select #{columns.join(',')} from #{s.name}").each do |row|
+        obj = data[row[0]]
+        columns.each_index do |i|
+          next if i == 0
+          return false if row[i] != obj[columns[i]]
+        end
+        data.delete(row[0])
+      end
+    else
+      db.execute("select * from object_values where source_id=#{s.source_id}").each do |row|
+        object = data[row[2]]
+        return false if object.nil? or object[row[1]] != row[3] or row[0].to_s != s.source_id.to_s
+        object.delete(row[1])
+        data.delete(row[2]) if object.empty?
+      end
+    end
+    data.empty?
+  end
+  
+  def get_attrib_counter(data)
+    counter = {}
+    data.each do |object_name,object|
+      object.each do |attrib,value|
+        counter[attrib] = counter[attrib] ? counter[attrib] + 1 : 1
+      end
+    end
+    BulkDataJob.refs_to_s(counter)
+  end
+  
+  def mock_metadata_method(adapters, &block)
+    adapters.each do |klass|
+      klass.class_eval "def metadata; {'foo'=>'bar'}.to_json; end"
+    end
+    yield
+    adapters.each do |klass|
+      klass.class_eval "def metadata; end"
+    end
+  end
+  
+  def mock_schema_method(adapters, &block)
+    adapters.each do |klass|
+      klass.class_eval 'def schema
+        {
+          "property" => {
+            "name" => "string",
+            "brand" => "string"
+          },
+          "version" => "1.0"
+        }.to_json
+      end'
+    end
+    yield
+    adapters.each do |klass|
+      klass.class_eval "def schema; end"
+    end
+  end
+  
+  def unzip_file(file,file_dir)
+    Zip::ZipFile.open(file) do |zip_file|
+      zip_file.each do |f|
+        f_path = File.join(file_dir,f.name)
+        FileUtils.mkdir_p(File.dirname(f_path))
+        zip_file.extract(f, f_path) { true }
+      end
+    end
+  end
+
+  def get_sha1(str)
+    Digest::SHA1.hexdigest(str)
+  end    
+     
+end #TestHelpers

data/spec/stats/middleware_spec.rb

@@ -0,0 +1,53 @@
+require 'rhoconnect'
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+STATS_RECORD_RESOLUTION = 2 unless defined? STATS_RECORD_RESOLUTION
+STATS_RECORD_SIZE = 8 unless defined? STATS_RECORD_SIZE
+
+include Rhoconnect
+include Rhoconnect::Stats
+
+describe "Middleware" do
+  
+  before(:each) do
+    @now = 10.0
+    Store.db.flushdb
+    app = mock('app')
+    app.stub!(:call)
+    @middleware_new_routes = Middleware.new(app)
+    Store.stub!(:lock).and_yield
+  end
+  
+  it "should compute http average" do
+    Time.stub!(:now).and_return { @now += 0.3; @now }
+    env = {
+      'rack.request.query_hash' => {
+        'source_name' => 'SampleAdapter'
+      },
+      'REQUEST_METHOD' => 'GET',
+      'PATH_INFO' => '/api/application/query'
+    }
+    10.times { @middleware_new_routes.call(env) }
+    metric = 'http:GET:/api/application/query:SampleAdapter'
+    Record.key(metric).should == "stat:#{metric}"
+
+    # FIXME:
+    # The conversion algorithm (float to string) currently checks two precisions. 
+    # In Ruby 1.9, it tries 16 digits and if that's not enough it then uses 17. 
+    # In 1.8, it's the same but with 15 and 16.
+    if RUBY_VERSION =~ /1.9/      
+      Record.range(metric, 0, -1).should == [
+        "2.0,0.6000000000000014:12", 
+        "2.0,0.6000000000000014:14", 
+        "2.0,0.6000000000000014:16", 
+        "2.0,0.6000000000000014:18"
+      ]
+    else
+      Record.range(metric, 0, -1).should == [
+        "2.0,0.600000000000002:12", 
+        "2.0,0.600000000000002:14", 
+        "2.0,0.600000000000002:16", 
+        "2.0,0.600000000000002:18"
+      ]
+    end
+  end  
+end

data/spec/stats/record_spec.rb

@@ -0,0 +1,92 @@
+require 'rhoconnect'
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+STATS_RECORD_RESOLUTION = 2 unless defined? STATS_RECORD_RESOLUTION
+STATS_RECORD_SIZE = 8 unless defined? STATS_RECORD_SIZE
+
+include Rhoconnect
+include Rhoconnect::Stats
+
+describe "Record" do
+  
+  before(:each) do
+    @now = 9
+    Store.db.flushdb
+    Store.stub!(:lock).and_yield
+  end
+  
+  it "should add metric to the record and trim record size" do
+    Time.stub!(:now).and_return { @now += 1; @now }
+    10.times { Record.add('foo') }
+    Store.db.zrange('stat:foo', 0, -1).should == ["2:12", "2:14", "2:16", "2:18"]
+  end
+  
+  it "should add single record" do
+    Time.stub!(:now).and_return { @now += 1; @now }
+    Record.add('foo')
+    Store.db.zrange('stat:foo', 0, -1).should == ["1:10"]
+  end
+  
+  it "should return type of metric" do
+    Record.add('foo')
+    Record.rtype('foo').should == 'zset'
+  end
+  
+  it "should set string metric" do
+    Record.set_value('foo', 'bar')
+    Store.db.get('stat:foo').should == 'bar'
+  end
+  
+  it "should get string metric" do
+    Store.db.set('stat:foo', 'bar')
+    Record.get_value('foo').should == 'bar'
+  end
+  
+  it "should get keys" do
+    Record.add('foo')
+    Record.add('bar')
+    Record.keys.sort.should == ['bar','foo']
+  end
+  
+  it "should add absolute metric value" do
+    Time.stub!(:now).and_return { @now += 1; @now }
+    time = 0
+    4.times do 
+      Record.save_average('foo',time)
+      time += 1
+    end
+    Store.db.zrange('stat:foo', 0, -1).should == ["2.0,1.0:10", "2.0,5.0:12"]
+  end
+  
+  it "should update metric" do
+    Rhoconnect.stats = true
+    Time.stub!(:now).and_return { @now += 1; @now }
+    4.times do
+      Record.update('foo') do
+        # something interesting
+      end
+    end
+    Store.db.zrange('stat:foo', 0, -1).should == ["1,1.0:14", "1,1.0:18", "1,1.0:20"]
+    Rhoconnect.stats = false
+  end
+  
+  it "should get range of metric values" do
+    Time.stub!(:now).and_return { @now += 1; @now }
+    10.times { Record.add('foo') }
+    Record.range('foo', 0, 1).should == ["2:12", "2:14"]
+  end
+  
+  it "should reset metric" do
+    Time.stub!(:now).and_return { @now += 1; @now }
+    10.times { Record.add('foo') }
+    Store.db.zrange('stat:foo', 0, -1).should == ["2:12", "2:14", "2:16", "2:18"]
+    Record.reset('foo')
+    Store.db.zrange('stat:foo', 0, -1).should == []
+  end
+  
+  it "should reset all metrics" do
+    Record.add('foo')
+    Record.add('bar')
+    Record.reset_all
+    Store.db.keys('stat:*').should == []
+  end
+end

data/spec/store_spec.rb

@@ -0,0 +1,251 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+require File.join(File.dirname(__FILE__), 'support', 'shared_examples')
+
+describe "Store" do
+  it_behaves_like "SharedRhoconnectHelper", :rhoconnect_data => true do
+    describe "store methods" do
+      it "should create db class method" do
+        Store.db.class.name.should match(/Redis/)
+      end
+
+      it "should set redis connection" do
+        Store.db = nil
+        Store.db = 'localhost:6379'
+        Store.db.client.host.should == 'localhost'
+        Store.db.client.port.should == 6379
+      end
+
+      it "should create default redis connection" do
+        Store.db = nil
+        Store.db.class.name.should match(/Redis/)
+      end
+
+      it "should assign redis to existing redis" do
+        Store.db = Redis.new(:timeout => 60)
+        Store.db.client.timeout.should == 60
+      end
+
+      it "should create redis connection based on ENV" do
+        ENV[REDIS_URL] = 'redis://localhost:6379'
+        Redis.should_receive(:connect).with(:url => 'redis://localhost:6379').and_return { Redis.new }
+        Store.db = nil
+        Store.db.should_not == nil
+        ENV.delete(REDIS_URL)
+      end
+
+      it "should add simple data to new set" do
+        Store.put_data(@s.docname(:md),@data).should == true
+        Store.get_data(@s.docname(:md)).should == @data
+      end
+
+      it "should set_data and get_data" do
+        Store.set_data('foo', @data)
+        Store.get_data('foo').should == @data
+      end
+
+      it "should put_data with simple data" do
+        data = { '1' => { 'hello' => 'world' } }
+        Store.put_data('mydata', data)
+        Store.get_data('mydata').should == data
+      end
+
+      it "should add simple array data to new set" do
+        @data = ['1','2','3']
+        Store.put_data(@s.docname(:md),@data).should == true
+        Store.get_data(@s.docname(:md),Array).sort.should == @data
+      end
+
+      it "should replace simple data to existing set" do
+        new_data,new_data['3'] = {},{'name' => 'Droid','brand' => 'Google'}
+        Store.put_data(@s.docname(:md),@data).should == true
+        Store.put_data(@s.docname(:md),new_data)
+        Store.get_data(@s.docname(:md)).should == new_data
+      end
+
+      it "should put_value and get_value" do
+        Store.put_value('foo','bar')
+        Store.get_value('foo').should == 'bar'
+      end
+
+      it "should incr a key" do
+        Store.incr('foo').should == 1
+      end
+
+      it "should decr a key" do
+        Store.set_value('foo', 10)
+        Store.decr('foo').should == 9
+      end
+
+      it "should return true/false if element ismember of a set" do
+        Store.put_data('foo',['a'])
+        Store.ismember?('foo','a').should == true
+
+        Store.ismember?('foo','b').should == false
+      end
+
+      it "should return attributes modified in doc2" do
+        Store.put_data(@s.docname(:md),@data).should == true
+        Store.get_data(@s.docname(:md)).should == @data
+
+        @product3['price'] = '59.99'
+        expected = { '3' => { 'price' => '59.99' } }
+        @data1,@data1['1'],@data1['2'],@data1['3'] = {},@product1,@product2,@product3
+
+        Store.put_data(@c.docname(:cd),@data1)
+        Store.get_data(@c.docname(:cd)).should == @data1
+        Store.get_diff_data(@s.docname(:md),@c.docname(:cd)).should == [expected,1]
+      end
+
+      it "should return attributes modified and missed in doc2" do
+        Store.put_data(@s.docname(:md),@data).should == true
+        Store.get_data(@s.docname(:md)).should == @data
+
+        @product2['price'] = '59.99'
+        expected = { '2' => { 'price' => '99.99' },'3' => @product3 }
+        @data1,@data1['1'],@data1['2'] = {},@product1,@product2
+
+        Store.put_data(@c.docname(:cd),@data1)
+        Store.get_data(@c.docname(:cd)).should == @data1
+        Store.get_diff_data(@c.docname(:cd),@s.docname(:md)).should == [expected,2]
+      end  
+
+      it "should ignore reserved attributes" do
+        @newproduct = {
+          'name' => 'iPhone',
+          'brand' => 'Apple',
+          'price' => '199.99',
+          'id' => 1234,
+          'attrib_type' => 'someblob'
+        }
+
+        @data1 = {'1'=>@newproduct,'2'=>@product2,'3'=>@product3}
+
+        Store.put_data(@s.docname(:md),@data1).should == true
+        Store.get_data(@s.docname(:md)).should == @data
+      end
+
+      it "should flash_data" do
+        Store.put_data(@s.docname(:md),@data)
+        Store.flash_data(@s.docname(:md))
+        Store.get_data(@s.docname(:md)).should == {}
+      end
+
+      it "should get_keys" do
+        expected = ["doc1:1:1:1:source1", "doc1:1:1:1:source2"]
+        Store.put_data(expected[0],@data)
+        Store.put_data(expected[1],@data)
+        Store.get_keys('doc1:1:1:1:*').sort.should == expected
+      end
+
+      if defined?(JRUBY_VERSION)
+        # FIXME:
+        it "should lock document" do
+          doc = "locked_data"
+          m_lock = Store.get_lock(doc)
+          t = Thread.new do
+            Store.db = Redis.new
+            t_lock = Store.get_lock(doc)
+            Store.put_data(doc,{'1'=>@product1},true)
+            Store.release_lock(doc,t_lock) 
+          end
+          Store.put_data(doc,{'2'=>@product2},true)
+          Store.get_data(doc).should == {'2'=>@product2}
+          Store.release_lock(doc,m_lock)
+          t.join
+          m_lock = Store.get_lock(doc)
+          Store.get_data(doc).should == {'1'=>@product1,'2'=>@product2}
+        end
+      else
+        it "should lock document" do
+          doc = "locked_data"
+          m_lock = Store.get_lock(doc)
+          pid = Process.fork do
+            Store.db = Redis.new
+            t_lock = Store.get_lock(doc)
+            Store.put_data(doc,{'1'=>@product1},true)
+            Store.release_lock(doc,t_lock) 
+            Process.exit(0)
+          end
+          Store.put_data(doc,{'2'=>@product2},true)
+          Store.get_data(doc).should == {'2'=>@product2}
+          Store.release_lock(doc,m_lock)
+          Process.waitpid(pid)
+          m_lock = Store.get_lock(doc)
+          Store.get_data(doc).should == {'1'=>@product1,'2'=>@product2}
+        end
+      end
+
+      it "should lock key for timeout" do
+        doc = "locked_data"
+        lock = Time.now.to_i+3
+        Store.db.set "lock:#{doc}", lock
+        Store.should_receive(:sleep).at_least(:once).with(1).and_return { sleep 1; Store.release_lock(doc,lock); }
+        Store.get_lock(doc,4)
+      end
+
+      it "should raise exception if lock expires" do
+        doc = "locked_data"
+        Store.get_lock(doc)
+        lambda { sleep 2; Store.get_lock(doc,4,true) }.should raise_error(StoreLockException,"Lock \"lock:locked_data\" expired before it was released")
+      end
+
+      it "should raise lock expires exception on global setting" do
+        doc = "locked_data"
+        Store.get_lock(doc)
+        Rhoconnect.raise_on_expired_lock = true
+        lambda { sleep 2; Store.get_lock(doc,4) }.should raise_error(StoreLockException,"Lock \"lock:locked_data\" expired before it was released")
+        Rhoconnect.raise_on_expired_lock = false
+      end
+
+      it "should acquire lock if it expires" do
+       	doc = "locked_data"
+       	Store.get_lock(doc)
+       	sleep 2
+       	Store.get_lock(doc,1).should > Time.now.to_i
+      end
+
+      it "should use global lock duration" do
+        doc = "locked_data"
+        Rhoconnect.lock_duration = 2
+       	Store.get_lock(doc)
+       	Store.should_receive(:sleep).exactly(3).times.with(1).and_return { sleep 1 }
+        Store.get_lock(doc)
+       	Rhoconnect.lock_duration = nil
+      end
+
+      it "should lock document in block" do
+        doc = "locked_data"
+        Store.lock(doc,0) do
+          Store.put_data(doc,{'2'=>@product2})
+          Store.get_data(doc).should == {'2'=>@product2}
+        end
+      end
+
+      it "should create clone of set" do
+        set_state('abc' => @data)
+        Store.clone('abc','def')
+        verify_result('abc' => @data,'def' => @data)
+      end
+
+      it "should rename a key" do
+        set_state('key1' => @data)
+        Store.rename('key1','key2')
+        verify_result('key1' => {}, 'key2' => @data)
+      end
+
+      it "should not fail to rename if key doesn't exist" do
+        Store.rename('key1','key2')
+        Store.db.exists('key1').should be_false
+        Store.db.exists('key2').should be_false      
+      end
+
+      it "should raise ArgumentError on put_data with invalid data" do
+        foobar = {'foo'=>'bar'}
+        expect { 
+          Store.put_data('somedoc',{'foo'=>'bar'}) 
+        }.to raise_exception(ArgumentError, "Invalid value object: #{foobar['foo'].inspect}. Hash is expected.")
+      end
+
+    end
+  end  
+end