rhosync 2.0.0.beta1

data/spec/model_spec.rb

@@ -0,0 +1,269 @@
+# Taken from http://github.com/voloko/redis-model
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+describe Rhosync::Model do
+  
+  context "DSL" do
+    class TestDSL < Rhosync::Model
+      field :foo
+      list  :bar
+      set   :sloppy
+    end
+  
+    before(:each) do
+      @x = TestDSL.with_key(1)
+    end
+  
+    it "should define rw accessors for field" do
+      @x.should respond_to(:foo)
+      @x.should respond_to(:foo=)
+    end
+  
+    it "should define r accessor for list" do
+      @x.should respond_to(:bar)
+    end
+  
+    it "should define r accessor for set" do
+      @x.should respond_to(:sloppy)
+    end
+  
+    it "should raise error on invalid type" do
+      lambda do
+        class TestInvalidType < Rhosync::Model
+          field :invalid, :invalid_type
+        end
+      end.should raise_error(ArgumentError, 'Unknown type invalid_type for field invalid')
+    end
+  end
+  
+  context "field type cast" do
+    class TestType < Rhosync::Model
+      field :foo_string, :string
+      field :foo_json,   :json
+      field :foo_date,   :datetime
+      field :foo_int,    :int
+      field :foo_float,  :float
+      
+      list  :list_date,  :datetime
+      set   :set_date,   :datetime      
+    end
+    
+    class TestValidateType < Rhosync::Model
+      field :v_field, :string
+      validates_presence_of :v_field
+    end
+    
+    class TestLoadType < Rhosync::Model
+      field :something, :string
+      attr_accessor :foo
+    end
+  
+    before(:each) do
+      @xRedisMock = Spec::Mocks::Mock.new
+      @yRedisMock = Spec::Mocks::Mock.new
+      @x = TestType.with_key(1)
+      @y = TestType.with_key(1)
+      @x.stub!(:redis).and_return(@xRedisMock)
+      @y.stub!(:redis).and_return(@yRedisMock)
+    end
+    
+    it "should create with string id" do
+      @x = TestType.create(:id => 'test')
+      @x.id.should == 'test'
+    end
+    
+    it "should create with auto-increment id" do
+      @x = TestType.create
+      @x1 = TestType.create
+      @x1.id.should == @x.id + 1
+    end
+    
+    it "should raise ArgumentError on create with duplicate id" do
+      @x = TestType.create(:id => 'test1')
+      lambda { TestType.create(:id => 'test1') }.should 
+        raise_error(ArgumentError, "Record already exists for 'test1'")
+    end
+    
+    it "should validate_presence_of v_field" do
+      lambda { TestValidateType.create(:id => 'test2') }.should
+        raise_error(ArgumentError, "Missing required field 'v_field'")
+    end
+    
+    it "should load with attributes set" do
+      TestLoadType.create(:id => 'test2')
+      @x = TestLoadType.load('test2',{:foo => 'bar'})
+      @x.foo.should == 'bar'
+    end
+  
+    it "should save string as is" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_string', 'xxx')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_string').and_return('xxx')
+      @x.foo_string = 'xxx'
+      @y.foo_string.should be_instance_of(String)
+    end
+  
+    it "should marshal integer fields" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_int', '12')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_int').and_return('12')
+      @x.foo_int = 12
+      @y.foo_int.should be_kind_of(Integer)
+      @y.foo_int.should == 12
+    end
+  
+    it "should marshal float fields" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_float', '12.1')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_float').and_return('12.1')
+      @x.foo_float = 12.1
+      @y.foo_float.should be_kind_of(Float)
+      @y.foo_float.should == 12.1
+    end
+  
+    it "should marshal datetime fields" do
+      time = DateTime.now
+      str  = time.strftime('%FT%T%z')
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_date', str)
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_date').and_return(str)
+      @x.foo_date = time
+      @y.foo_date.should be_kind_of(DateTime)
+      @y.foo_date.should.to_s == time.to_s
+    end
+  
+    it "should marshal json structs" do
+      data = {'foo' => 'bar', 'x' => 2}
+      str  = JSON.dump(data)
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_json', str)
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_json').and_return(str)
+      @x.foo_json = data
+      @y.foo_json.should be_kind_of(Hash)
+      @y.foo_json.should.inspect == data.inspect
+    end
+    
+    it "should return nil for empty fields" do
+      @xRedisMock.should_receive(:[]).with('test_type:1:foo_date').and_return(nil)
+      @x.foo_date.should be_nil
+    end
+    
+    it "should marshal list values" do
+      data = DateTime.now
+      str  = data.strftime('%FT%T%z')
+      
+      @xRedisMock.should_receive('rpush').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lset').with('test_type:1:list_date', 1, str)
+      @xRedisMock.should_receive('exists').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lrem').with('test_type:1:list_date', 0, str)
+      @xRedisMock.should_receive('lpush').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lrange').with('test_type:1:list_date', 0, 1).and_return([str])
+      @xRedisMock.should_receive('rpop').with('test_type:1:list_date').and_return(str)
+      @xRedisMock.should_receive('lpop').with('test_type:1:list_date').and_return(str)
+      @xRedisMock.should_receive('lindex').with('test_type:1:list_date', 0).and_return(str)
+      @x.list_date << data
+      @x.list_date[1] = data
+      @x.list_date.include?(data)
+      @x.list_date.remove(0, data)
+      @x.list_date.push_head(data)
+      @x.list_date[0].should be_kind_of(DateTime)
+      @x.list_date[0, 1][0].should be_kind_of(DateTime)
+      @x.list_date.pop_tail.should be_kind_of(DateTime)
+      @x.list_date.pop_head.should be_kind_of(DateTime)
+    end
+    
+    it "should marshal set values" do
+      data = DateTime.now
+      str  = data.strftime('%FT%T%z')
+
+      @xRedisMock.should_receive('sadd').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('srem').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('sismember').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('smembers').with('test_type:1:set_date').and_return([str])
+      @xRedisMock.should_receive('sinter').with('test_type:1:set_date', 'x').and_return([str])
+      @xRedisMock.should_receive('sunion').with('test_type:1:set_date', 'x').and_return([str])
+      @xRedisMock.should_receive('sdiff').with('test_type:1:set_date', 'x', 'y').and_return([str])
+      @x.set_date << data
+      @x.set_date.delete(data)
+      @x.set_date.include?(data)
+      @x.set_date.members[0].should be_kind_of(DateTime)
+      @x.set_date.intersect('x')[0].should be_kind_of(DateTime)
+      @x.set_date.union('x')[0].should be_kind_of(DateTime)
+      @x.set_date.diff('x', 'y')[0].should be_kind_of(DateTime)
+    end
+
+  end
+  
+  context "increment/decrement" do
+    class TestIncrements < Rhosync::Model
+      field :foo, :integer
+      field :bar, :string
+      field :baz, :float
+    end
+    
+    before do
+      @redisMock = Spec::Mocks::Mock.new
+      @x = TestIncrements.with_key(1)
+      @x.stub!(:redis).and_return(@redisMock)
+    end
+    
+    it "should send INCR when #increment! is called on an integer" do
+      @redisMock.should_receive(:incr).with("test_increments:1:foo", 1)
+      @x.increment!(:foo)
+    end
+    
+    it "should send DECR when #decrement! is called on an integer" do
+      @redisMock.should_receive(:decr).with("test_increments:1:foo", 1)
+      @x.decrement!(:foo)
+    end
+    
+    it "should raise an ArgumentError when called on non-integers" do
+      [:bar, :baz].each do |f|
+        lambda{@x.increment!(f)}.should raise_error(ArgumentError)
+        lambda{@x.decrement!(f)}.should raise_error(ArgumentError)
+      end
+    end
+  end
+  
+  context "redis commands" do
+    class TestCommands < Rhosync::Model
+      field :foo
+      list  :bar
+      set   :sloppy
+    end
+    
+    before(:each) do
+      @redisMock = Spec::Mocks::Mock.new
+      @x = TestCommands.with_key(1)
+      @x.stub!(:redis).and_return(@redisMock)
+    end
+  
+    it "should send GET on field read" do
+      @redisMock.should_receive(:[]).with('test_commands:1:foo')
+      @x.foo
+    end
+  
+    it "should send SET on field write" do
+      @redisMock.should_receive(:[]=).with('test_commands:1:foo', 'bar')
+      @x.foo = 'bar'
+    end
+  
+    it "should send RPUSH on list <<" do
+      @redisMock.should_receive(:rpush).with('test_commands:1:bar', 'bar')
+      @x.bar << 'bar'
+    end
+  
+    it "should send SADD on set <<" do
+      @redisMock.should_receive(:sadd).with('test_commands:1:sloppy', 'bar')
+      @x.sloppy << 'bar'
+    end
+    
+    it "should delete separate fields" do
+      @redisMock.should_receive(:del).with('test_commands:1:foo')
+      @x.delete :foo
+    end
+    
+    it "should delete all field" do
+      @redisMock.should_receive(:del).with('test_commands:1:foo')
+      @redisMock.should_receive(:del).with('test_commands:1:rho__id')
+      @redisMock.should_receive(:del).with('test_commands:1:bar')
+      @redisMock.should_receive(:del).with('test_commands:1:sloppy')
+      @x.delete
+    end
+  end
+end

data/spec/perf/bulk_data_perf_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__),'perf_spec_helper')
+
+describe "BulkData Performance" do
+  it_should_behave_like "SourceAdapterHelper"
+  it_should_behave_like "PerfSpecHelper"
+  
+  before(:each) do
+    basedir = File.join(File.dirname(__FILE__),'..','apps','rhotestapp')
+    Rhosync.bootstrap(basedir) do |rhosync|
+      rhosync.vendor_directory = File.join(basedir,'..','vendor')
+    end
+  end
+  
+  after(:each) do
+    delete_data_directory
+  end
+  
+  it "should generate sqlite bulk data for 1000 objects (6000 attributes)" do
+    start = start_timer
+    @data = get_test_data(1000)
+    start = lap_timer('generate data',start)
+    set_state('test_db_storage' => @data)
+    start = lap_timer('set_state masterdoc',start)
+    data = BulkData.create(:name => bulk_data_docname(@a.id,@u.id),
+      :state => :inprogress,
+      :app_id => @a.id,
+      :user_id => @u.id,
+      :sources => [@s_fields[:name]])
+    BulkDataJob.perform("data_name" => data.name)
+    lap_timer('BulkDataJob.perform duration',start)
+  end
+end

data/spec/perf/perf_spec_helper.rb

@@ -0,0 +1,51 @@
+require 'faker'
+
+describe "PerfSpecHelper", :shared => true do
+  
+  def get_test_data(num=1000)
+    file = File.join("spec","testdata","#{num}-data.txt")
+    data = nil
+    if File.exists?(file)
+      data = open(file, 'r') {|f| Marshal.load(f)}
+    else
+      data = generate_fake_data(num)
+      f = File.new(file, 'w')
+      f.write Marshal.dump(data)
+      f.close
+    end
+    data
+  end
+  
+  private
+
+  PREFIX = ["Account", "Administrative", "Advertising", "Assistant", "Banking", "Business Systems", 
+    "Computer", "Distribution", "IT", "Electronics", "Environmental", "Financial", "General", "Head", 
+    "Laboratory", "Maintenance", "Medical", "Production", "Quality Assurance", "Software", "Technical", 
+    "Chief", "Senior"] unless defined? PREFIX
+  SUFFIX = ["Clerk", "Analyst", "Manager", "Supervisor", "Plant Manager", "Mechanic", "Technician", "Engineer", 
+    "Director", "Superintendent", "Specialist", "Technologist", "Estimator", "Scientist", "Foreman", "Nurse", 
+    "Worker", "Helper", "Intern", "Sales", "Mechanic", "Planner", "Recruiter", "Officer", "Superintendent",
+    "Vice President", "Buyer", "Production Supervisor", "Chef", "Accountant", "Executive"] unless defined? SUFFIX
+  
+  def title
+    prefix = PREFIX[rand(PREFIX.length)]
+    suffix = SUFFIX[rand(SUFFIX.length)]
+
+    "#{prefix} #{suffix}"
+  end
+
+  def generate_fake_data(num=1000)
+    res = {}
+    num.times do |n|
+      res[n.to_s] = {
+        "FirstName" => Faker::Name.first_name,
+        "LastName" => Faker::Name.last_name,
+        "Email" =>  Faker::Internet.free_email,
+        "Company" => Faker::Company.name,
+        "JobTitle" => title,
+        "Phone1" => Faker::PhoneNumber.phone_number
+      }
+    end
+    res
+  end
+end

data/spec/perf/store_perf_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+require File.join(File.dirname(__FILE__),'perf_spec_helper')
+
+describe "Rhosync Performance" do
+  it_should_behave_like "SourceAdapterHelper"
+  it_should_behave_like "PerfSpecHelper"
+
+  it "should process get/put for 1000 records (6000 elements)" do
+    @data = get_test_data(1000)
+    start = start_timer
+    Store.put_data('mdoc',@data).should == true
+    start = lap_timer('put_data duration',start)
+    Store.get_data('mdoc').should == @data
+    lap_timer('get_data duration',start)
+  end
+
+  it "should process single attribute update 1000-record doc" do
+    @data = get_test_data(1000)
+    @data1 = get_test_data(1000)
+    @data1['950']['Phone1'] = 'This is changed'
+    expected = {'950' => {'Phone1' => 'This is changed'}}
+    Store.put_data('mdoc',@data).should == true
+    Store.put_data('cdoc',@data1).should == true
+    start = start_timer
+    Store.get_diff_data('mdoc','cdoc').should == [expected,1]
+    lap_timer('get_diff_data duration', start)
+  end
+end

data/spec/ping/blackberry_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe "Ping Blackberry" do
+  it_should_behave_like "SpecBootstrapHelper"
+  it_should_behave_like "SourceAdapterHelper"
+  
+  before do
+    @params = {"user_id" => @u.id, "api_token" => @api_token,
+      "sources" => [@s.name], "message" => 'hello world', 
+      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',
+      "device_pin" => @c.device_pin, "device_port" => @c.device_port}
+    post = mock('post')
+    post.stub!(:new).and_return(post)
+    post.stub!(:body=)
+    Net::HTTP::Post.stub!(:new).and_return(post)
+    
+    @http = mock('http')
+    @http.stub!(:request)
+    @http.stub!(:start).and_yield(@http)
+    Net::HTTP.stub!(:new).and_return(@http)
+  end
+  
+  it "should ping blackberry" do
+    Blackberry.ping(@params)
+  end
+  
+  it "should ping blackberry with connection error" do
+    error = 'Connection refused'
+    @http.stub!(:request).and_return { raise SocketError.new(error) }
+    Blackberry.should_receive(:log).once.with("Error while sending ping: #{error}")
+    lambda { Blackberry.ping(@params) }.should raise_error(SocketError,error)
+  end
+  
+  it "should compute pap_message" do
+    expected = <<PAP
+--asdlfkjiurwghasf
+Content-Type: application/xml; charset=UTF-8
+  
+<?xml version="1.0"?>
+<!DOCTYPE pap PUBLIC "-//WAPFORUM//DTD PAP 2.0//EN" 
+  "http://www.wapforum.org/DTD/pap_2.0.dtd" 
+  [<?wap-pap-ver supported-versions="2.0"?>]>
+<pap>
+<push-message push-id="pushID:RAND_ID" ppg-notify-requested-to="http://localhost:7778">
+
+<address address-value="WAPPUSH=0%3A100/TYPE=USER@rim.net"/>
+<quality-of-service delivery-method="preferconfirmed"/>
+</push-message>
+</pap>
+--asdlfkjiurwghasf
+Content-Type: text/plain
+
+do_sync=SampleAdapter
+show_popup=hello world
+vibrate=5
+
+--asdlfkjiurwghasf-- 
+PAP
+    actual = Blackberry.pap_message(@params).gsub!(/pushID\:\d+/,'pushID:RAND_ID')
+    actual.gsub!(/\r|\n|\s/,"").should == expected.gsub!(/\r|\n|\s/,"")
+  end
+end

data/spec/ping/iphone_spec.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe "Ping Iphone" do
+  it_should_behave_like "SpecBootstrapHelper"
+  it_should_behave_like "SourceAdapterHelper"
+  
+  before do
+    @params = {"user_id" => @u.id, "api_token" => @api_token,
+      "sources" => [@s.name], "message" => 'hello world', 
+      "vibrate" => '5', "badge" => '5', "sound" => 'hello.mp3',
+      "device_pin" => @c.device_pin, "device_port" => @c.device_port}
+    ssl_ctx = mock("ssl_ctx")
+    ssl_ctx.stub!(:key=).and_return('key')
+    ssl_ctx.stub!(:cert=).and_return('cert')
+    OpenSSL::SSL::SSLContext.stub!(:new).and_return(ssl_ctx)
+    OpenSSL::PKey::RSA.stub!(:new)
+    OpenSSL::X509::Certificate.stub!(:new)
+    
+    tcp_socket = mock("tcp_socket")
+    tcp_socket.stub!(:close)
+    TCPSocket.stub!(:new).and_return(tcp_socket)
+    
+    @ssl_socket = mock("ssl_socket")
+    @ssl_socket.stub!(:sync=)
+    @ssl_socket.stub!(:connect)
+    @ssl_socket.stub!(:write)
+    @ssl_socket.stub!(:close)
+    OpenSSL::SSL::SSLSocket.stub!(:new).and_return(@ssl_socket)
+  end
+  
+  # TODO: This should really test SSLSocket.write
+  it "should ping iphone" do
+    Iphone.ping(@params)
+  end
+  
+  it "should compute apn_message" do
+    expected = <<-eos
+\000\000 \253\315\000g{"aps":{"vibrate":"5","badge":5,"sound":"hello.mp3","alert":"hello world"},"do_sync":["SampleAdapter"]}
+eos
+    Iphone.apn_message(@params).should == expected.strip!
+  end
+  
+  it "should raise SocketError if socket fails" do
+    error = 'socket error'
+    @ssl_socket.stub!(:write).and_return { raise SocketError.new(error) }
+    Iphone.should_receive(:log).once.with("Error while sending ping: #{error}")
+    lambda { Iphone.ping(@params) }.should raise_error(SocketError,error)
+  end
+  
+end

data/spec/read_state_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+describe "ReadState" do
+  it_should_behave_like "SpecBootstrapHelper"
+  it_should_behave_like "SourceAdapterHelper"
+
+  it "should create refresh with correct id" do
+    @r.id.should == "#{@a_fields[:name]}:#{@u_fields[:login]}:#{@s_fields[:name]}"
+  end
+  
+  it "should create refresh with default fields" do
+    @r.refresh_time.should <= Time.now.to_i
+  end
+  
+  it "should load refresh with params" do
+    @r1 = ReadState.load(:app_id => @a_fields[:name],
+      :user_id => @u_fields[:login],:source_name => @s_fields[:name])
+    @r1.refresh_time.should <= Time.now.to_i
+  end
+  
+  it "should delete read_state from db" do
+    ReadState.delete(@a_fields[:name])
+    Store.db.keys("read_state*").should == []
+  end
+end

data/spec/rhosync_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__),'spec_helper')
+
+describe "Rhosync" do
+  it_should_behave_like "RhosyncHelper"
+  it_should_behave_like "TestappHelper"
+  
+  it "should bootstrap Rhosync with block" do
+    Rhosync.bootstrap(get_testapp_path) do |rhosync|
+      rhosync.vendor_directory = 'foo'
+    end
+    path = get_testapp_path
+    File.expand_path(Rhosync.base_directory).should == path
+    File.expand_path(Rhosync.app_directory).should == path
+    File.expand_path(Rhosync.data_directory).should == File.join(path,'data')
+    Rhosync.vendor_directory.should == 'foo'
+    Rhosync.blackberry_bulk_sync.should == false
+    Rhosync.environment.should == :development  
+    App.is_exist?(@test_app_name).should be_true
+  end
+  
+  it "should bootstrap Rhosync with RHO_ENV provided" do
+    ENV['RHO_ENV'] = 'production'
+    Rhosync.bootstrap(get_testapp_path)
+    Rhosync.environment.should == :production
+    ENV.delete('RHO_ENV')
+  end
+  
+  it "should bootstrap with existing app" do
+    app = App.create(:name => @test_app_name)
+    App.should_receive(:load).once.with(@test_app_name).and_return(app)
+    Rhosync.bootstrap(get_testapp_path)
+  end
+
+  it "should bootstrap app with no sources" do
+    app = App.create(:name => @test_app_name)
+    Rhosync.stub!(:get_config).and_return(
+      { Rhosync.environment.to_sym => { :licensefile => 'settings/license.key' } }
+    )
+    App.should_receive(:load).twice.with(@test_app_name).and_return(app)
+    Rhosync.bootstrap(get_testapp_path)
+    App.load(@test_app_name).sources.members.should == []
+  end
+end