redisted 0.0.1

data/spec/redisted/callbacks_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe "Callbacks" do
+  before :each do
+    $create_called=false
+    $update_called=false
+    $save_called=false
+    $destroy_called=false
+  end
+  class CallbackTest < Redisted::Base
+    field :name, type: :string
+    after_create :create_handler
+    def create_handler
+      $create_called=true
+    end
+    after_update do
+      $update_called=true
+    end
+    after_save do
+      $save_called=true
+    end
+    after_destroy :destroy_handler
+    def destroy_handler
+      $destroy_called=false
+    end
+  end
+  it "work on create" do
+    a=CallbackTest.new
+    $create_called.should be_false
+    a.save
+    $create_called.should be_true
+    $update_called.should be_false
+  end
+  it "work on update" do
+    a=CallbackTest.new
+    $create_called.should be_false
+    $update_called.should be_false
+    a.save
+    $create_called.should be_true
+    $update_called.should be_false
+    a.name="Test"
+    $create_called.should be_true
+    $update_called.should be_true
+  end
+  it "work on save" do
+    a=CallbackTest.create
+    $save_called=false
+    $save_called.should be_false
+    a.name="Test"
+    $save_called.should be_true
+  end
+  it "work on save (non-cached)" do
+    a=CallbackTest.create
+    $save_called=false
+    $save_called.should be_false
+    a.cache do
+      a.name="Test"
+      $save_called.should be_false
+    end
+    $save_called.should be_true
+  end
+  it "work on destroy" do
+    a=CallbackTest.create
+    $destroy_called=false
+    $destroy_called.should be_false
+    a.destroy
+    $destroy_called.should be_true
+  end
+  it "not work on delete" do
+    a=CallbackTest.create
+    $destroy_called=false
+    $destroy_called.should be_false
+    a.delete
+    $destroy_called.should be_false
+  end
+end

data/spec/redisted/delete_destroy_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "Delete/Destroy" do
+  class FieldTest < Redisted::Base
+    field :field1, type: :string
+    field :field2, type: :string
+    field :field3, type: :string
+  end
+  it "an object can be deleted" do
+    a=FieldTest.create({field1: "test1123", field2: "test1223"})
+    key="field_test:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1123")
+    $redis.hget(key,"field2").should ==("test1223")
+    a.delete
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+  end
+  it "an object can be destroyed" do
+    a=FieldTest.create({field1: "test1123", field2: "test1223"})
+    key="field_test:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1123")
+    $redis.hget(key,"field2").should ==("test1223")
+    a.destroy
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+  end
+  it "an object that was opened (not created) can be deleted" do
+    orig=FieldTest.create({field1: "test1123", field2: "test1223"})
+    a=FieldTest.find orig.id
+    a.id.should ==orig.id
+    key="field_test:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1123")
+    $redis.hget(key,"field2").should ==("test1223")
+    a.delete
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+  end
+  it "an object that was opened (not created) can be destroyed" do
+    orig=FieldTest.create({field1: "test1123", field2: "test1223"})
+    a=FieldTest.find orig.id
+    a.id.should ==orig.id
+    key="field_test:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1123")
+    $redis.hget(key,"field2").should ==("test1223")
+    a.destroy
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+  end
+end

data/spec/redisted/fields_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe "Fields" do
+  class FieldTest1 < Redisted::Base
+    field :field1, type: :string
+    field :field2, type: :string
+    field :field3, type: :string
+  end
+  class FieldTest2 < Redisted::Base
+    field :field1, type: :string
+    field :field2, type: :integer
+    field :field3, type: :string
+  end
+  it "can be added to a model using new as separate statements" do
+
+    a=FieldTest1.new
+    a.save
+    a.field1="test1"
+    a.field2="test2"
+    a.field3="test3"
+
+    key="field_test1:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1")
+    $redis.hget(key,"field2").should ==("test2")
+    $redis.hget(key,"field3").should ==("test3")
+  end
+  it "can be added to a model using create as separate statements" do
+    a=FieldTest1.create
+    a.field1="test1"
+    a.field2="test2"
+    a.field3="test3"
+
+    key="field_test1:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1")
+    $redis.hget(key,"field2").should ==("test2")
+    $redis.hget(key,"field3").should ==("test3")
+  end
+  it "can be added to a model using new as arguments" do
+    a=FieldTest1.new({field1: "test1", field2: "test2", field3: "test3"})
+    a.save
+
+    key="field_test1:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1")
+    $redis.hget(key,"field2").should ==("test2")
+    $redis.hget(key,"field3").should ==("test3")
+  end
+  it "can be added to a model using create as arguments" do
+
+    a=FieldTest1.create({field1: "test1", field2: "test2", field3: "test3"})
+
+    key="field_test1:#{a.id}"
+    $redis.hget(key,"field1").should ==("test1")
+    $redis.hget(key,"field2").should ==("test2")
+    $redis.hget(key,"field3").should ==("test3")
+  end
+  it "can be integers" do
+    a=FieldTest2.create
+    a.field2="456def"
+    a.save
+    a.field2.should ==456
+    key="field_test2:#{a.id}"
+    $redis.hget(key,"field2").should ==("456")
+  end
+  it "can be string" do
+    a=FieldTest2.create
+    a.field1="123abc"
+    a.save
+    a.field1.should =="123abc"
+    key="field_test2:#{a.id}"
+    $redis.hget(key,"field1").should ==("123abc")
+  end
+  it "can be datetime" do
+    now=DateTime.now
+    a=FieldTest2.create
+    a.field3=now
+    a.save
+    a.field3.should ==now
+    key="field_test2:#{a.id}"
+    $redis.hget(key,"field3").should ==now.to_s
+  end
+  it "can have their configuration read from the model's Class" do
+    field1_list=FieldTest1.fields
+    field2_list=FieldTest2.fields
+
+    field1_list[:field1].should_not be_nil
+    field1_list[:field1][:type].should ==:string
+    field1_list[:field2].should_not be_nil
+    field1_list[:field2][:type].should ==:string
+    field1_list[:field3].should_not be_nil
+    field1_list[:field3][:type].should ==:string # datetime...
+    field2_list[:field1].should_not be_nil
+    field2_list[:field1][:type].should ==:string
+    field2_list[:field2].should_not be_nil
+    field2_list[:field2][:type].should ==:integer
+    field2_list[:field3].should_not be_nil
+    field2_list[:field3][:type].should ==:string
+
+  end
+  it "can have their configuration read from an instance of the model" do
+    a1=FieldTest1.new
+    a2=FieldTest2.new
+    field1_list=a1.fields
+    field2_list=a2.fields
+
+    field1_list[:field1].should_not be_nil
+    field1_list[:field1][:type].should ==:string
+    field1_list[:field2].should_not be_nil
+    field1_list[:field2][:type].should ==:string
+    field1_list[:field3].should_not be_nil
+    field1_list[:field3][:type].should ==:string # datetime...
+    field2_list[:field1].should_not be_nil
+    field2_list[:field1][:type].should ==:string
+    field2_list[:field2].should_not be_nil
+    field2_list[:field2][:type].should ==:integer
+    field2_list[:field3].should_not be_nil
+    field2_list[:field3][:type].should ==:string
+  end
+end

data/spec/redisted/filter_index_spec.rb

@@ -0,0 +1,90 @@
+
+describe "Filter Index" do
+  it "creates filter index" do
+    class FilterIndex1 < Redisted::Base
+      field :name, type: :string
+      field :test_int, type: :integer
+      index :odd, includes: ->(elem){(elem.test_int%2)!=0}
+      index :even, includes: ->(elem){(elem.test_int%2)==0}
+      index :thrice, includes: ->(elem){(elem.test_int%3)==0}
+      index :asc, order: ->(elem){elem.test_int},fields: :test_int
+      index :desc, order: ->(elem){-elem.test_int},fields: :test_int
+    end
+    a=FilterIndex1.create({test_int: 3})
+    b=FilterIndex1.create({test_int: 4})
+    c=FilterIndex1.create({test_int: 2})
+    d=FilterIndex1.create({test_int: 9})
+    e=FilterIndex1.create({test_int: 1})
+    f=FilterIndex1.create({test_int: 6})
+
+    res=FilterIndex1.by_odd.by_asc.all
+    res.size.should ==3
+    res[0].id.to_i.should ==e.id
+    res[1].id.to_i.should ==a.id
+    res[2].id.to_i.should ==d.id
+
+    res=FilterIndex1.by_even.by_asc.all
+    res.size.should ==3
+    res[0].id.to_i.should ==c.id
+    res[1].id.to_i.should ==b.id
+    res[2].id.to_i.should ==f.id
+
+    res=FilterIndex1.by_even.by_desc.all
+    res.size.should ==3
+    res[0].id.to_i.should ==f.id
+    res[1].id.to_i.should ==b.id
+    res[2].id.to_i.should ==c.id
+
+    res=FilterIndex1.by_thrice.by_asc.all
+    res.size.should ==3
+    res[0].id.to_i.should ==a.id
+    res[1].id.to_i.should ==f.id
+    res[2].id.to_i.should ==d.id
+
+    res=FilterIndex1.by_thrice.by_odd.by_asc.all
+    res.size.should ==2
+    res[0].id.to_i.should ==a.id
+    res[1].id.to_i.should ==d.id
+
+    res=FilterIndex1.by_thrice.by_even.by_asc.all
+    res.size.should ==1
+    res[0].id.to_i.should ==f.id
+  end
+  it "allows incomplete filters to work" do
+    class FilterIndex2 < Redisted::Base
+      field :name, type: :string
+      field :test_int, type: :integer
+      index :odd, includes: ->(elem){(elem.test_int%2)!=0}
+      index :even, includes: ->(elem){(elem.test_int%2)==0}
+      index :thrice, includes: ->(elem){(elem.test_int%3)==0}
+      index :asc, order: ->(elem){elem.test_int},fields: :test_int
+      index :desc, order: ->(elem){-elem.test_int},fields: :test_int
+    end
+    a=FilterIndex2.create({test_int: 3})
+    b=FilterIndex2.create({test_int: 4})
+    c=FilterIndex2.create({test_int: 2})
+    d=FilterIndex2.create({test_int: 9})
+    e=FilterIndex2.create({test_int: 1})
+    f=FilterIndex2.create({test_int: 6})
+
+    aaa=FilterIndex2.by_odd
+    res=aaa.by_asc.all
+    res.size.should ==3
+    res[0].id.to_i.should ==e.id
+    res[1].id.to_i.should ==a.id
+    res[2].id.to_i.should ==d.id
+
+    aaa=FilterIndex2.scoped
+    res=aaa.by_thrice.by_asc.all
+    res.size.should ==3
+    res[0].id.to_i.should ==a.id
+    res[1].id.to_i.should ==f.id
+    res[2].id.to_i.should ==d.id
+
+    aaa=FilterIndex2.by_thrice.by_even.by_asc
+    res=aaa.all
+    res.size.should ==1
+    res[0].id.to_i.should ==f.id
+
+  end
+end

data/spec/redisted/find_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Find" do
+  class FieldTest < Redisted::Base
+    field :field1, type: :string
+    field :field2, type: :string
+    field :field3, type: :string
+  end
+  it "can find an object with a specific ID" do
+    orig=FieldTest.create({field1: "test1123", field2: "test1223"})
+    id=orig.id
+    obj=FieldTest.find id
+    obj.field1.should =="test1123"
+    obj.field2.should =="test1223"
+    orig.id.should ==obj.id
+    orig.object_id.should_not ==obj.object_id
+  end
+  it "can find an array objects with a list of IDs" do
+    orig1=FieldTest.create({field1: "test1123", field2: "test1223"})
+    orig2=FieldTest.create({field1: "test2123", field2: "test2223"})
+    orig3=FieldTest.create({field1: "test3123", field2: "test3223"})
+    objs=FieldTest.find [orig1.id,orig3.id,orig2.id]
+    objs[0].field1="test1123"
+    objs[0].field2="test1223"
+    objs[2].field1="test2123"
+    objs[2].field2="test2223"
+    objs[1].field1="test3123"
+    objs[1].field2="test3223"
+  end
+end

data/spec/redisted/match_index_spec.rb

@@ -0,0 +1,36 @@
+
+describe "Match Index" do
+  it "creates match index" do
+    class MatchIndex1 < Redisted::Base
+      field :name, type: :string
+      field :test_int, type: :string
+      field :provider, type: :string
+
+      index :provider, match: ->(elem){(elem.provider)}, fields: :provider,order: ->(elem){elem.test_int}
+    end
+    a=MatchIndex1.create({provider: "cable",test_int: 1})
+    b=MatchIndex1.create({provider: "satellite",test_int: 2})
+    c=MatchIndex1.create({provider: "cable",test_int: 3})
+    d=MatchIndex1.create({provider: "overair",test_int: 4})
+    e=MatchIndex1.create({provider: "satellite",test_int: 5})
+    f=MatchIndex1.create({provider: "cable",test_int: 6})
+    
+    res=MatchIndex1.by_provider("cable").all
+    res.size.should ==3
+    res[0].id.to_i.should ==a.id
+    res[1].id.to_i.should ==c.id
+    res[2].id.to_i.should ==f.id
+
+    res=MatchIndex1.by_provider("satellite").all
+    res.size.should ==2
+    res[0].id.to_i.should ==b.id
+    res[1].id.to_i.should ==e.id
+
+    res=MatchIndex1.by_provider("overair").all
+    res.size.should ==1
+    res[0].id.to_i.should ==d.id
+
+    res=MatchIndex1.by_provider("xxx").all
+    res.size.should ==0
+  end
+end

data/spec/redisted/persisted_fields_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+describe "Persisted Fields" do
+  class FieldTest1 < Redisted::Base
+    field :field1, type: :string
+    field :field2, type: :string
+    field :field3, type: :string
+  end
+  it "can be saved one value at a time" do
+    a=FieldTest1.create
+    key="field_test1:#{a.id}"
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.field1="test"
+    $redis.hget(key,"field1").should =="test"
+    $redis.hget(key,"field2").should be_nil
+    a.field2="test2"
+    $redis.hget(key,"field1").should =="test"
+    $redis.hget(key,"field2").should =="test2"
+    a.save
+    $redis.hget(key,"field1").should =="test"
+    $redis.hget(key,"field2").should =="test2"
+  end
+  it "can be cached and save them all in one redis call" do
+    a=FieldTest1.create
+    key="field_test1:#{a.id}"
+    a.cache do
+      $redis.hget(key,"field1").should be_nil
+      $redis.hget(key,"field2").should be_nil
+      a.field1="test"
+      $redis.hget(key,"field1").should be_nil
+      $redis.hget(key,"field2").should be_nil
+      a.field2="test2"
+      $redis.hget(key,"field1").should be_nil
+      $redis.hget(key,"field2").should be_nil
+    end
+    $redis.hget(key,"field1").should =="test"
+    $redis.hget(key,"field2").should =="test2"
+  end
+  it "can be cached and save them all in one redis call without using a block" do
+    a=FieldTest1.create
+    key="field_test1:#{a.id}"
+    a.cache
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.field1="test"
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.field2="test2"
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.save
+    $redis.hget(key,"field1").should =="test"
+    $redis.hget(key,"field2").should =="test2"
+  end
+  it "caches until first save" do
+    a=FieldTest1.new
+    a.field1="Test"
+    a.field2="Test2"
+    key="field_test1:#{a.id}"
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.save
+    key="field_test1:#{a.id}"
+    $redis.hget(key,"field1").should =="Test"
+    $redis.hget(key,"field2").should =="Test2"
+  end
+  it "can be configured to cache all until save" do
+    class FieldTest < Redisted::Base
+      always_cache_until_save
+      field :field1, type: :string
+      field :field2, type: :string
+    end
+    a=FieldTest.create
+    key="field_test:#{a.id}"
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.field1="test"
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.field2="test2"
+    $redis.hget(key,"field1").should be_nil
+    $redis.hget(key,"field2").should be_nil
+    a.save
+    $redis.hget(key,"field1").should =="test"
+    $redis.hget(key,"field2").should =="test2"
+  end
+  it "can be read one by one as needed" do
+    key="field_test1:12345"
+    $redis.hmset key,"field1","3","field2","4"
+    b=FieldTest1.find(12345)
+    b.field1.should =="3"
+    $redis.hmset key,"field1","5","field2","6"
+    b.field2.should =="6"
+  end
+  it "can have the cache flushed" do
+    key="field_test1:12345"
+    $redis.hmset key,"field1","3","field2","4"
+    b=FieldTest1.find(12345)
+    b.field1.should =="3"
+    $redis.hmset key,"field1","5","field2","6"
+    b.field1.should =="3"
+    b.field2.should =="6"
+    b.flush
+    b.field1.should =="5"
+    b.field2.should =="6"
+  end
+  it "are read only once then cached" do
+    key="field_test1:12345"
+    $redis.hmset key,"field1","3"
+    b=FieldTest1.find(12345)
+    b.field1.should =="3"
+    $redis.hmset key,"field1","5"
+    b.field1.should =="3"
+  end
+  it "can be read and cached all at once (at load)" do
+    class FieldTest < Redisted::Base
+      pre_cache_all
+      field :field1, type: :string
+      field :field2, type: :string
+      field :field3, type: :string
+    end
+    key="field_test:12345"
+    $redis.hmset key,"field1","3","field2","4","field3","5"
+    b=FieldTest.find(12345)
+    $redis.hmset key,"field1","6","field2","7","field3","8"
+    b.field1.should =="3"
+    b.field2.should =="4"
+    b.field3.should =="5"
+    b.flush
+    b.field1.should =="6"
+    b.field2.should =="7"
+    b.field3.should =="8"
+  end
+  it "can be automatically read and cached at object creation" do
+    class FieldTest < Redisted::Base
+      pre_cache_all when: :create
+      field :field1, type: :string
+      field :field2, type: :string
+      field :field3, type: :string
+    end
+    key="field_test:12345"
+    $redis.hmset key,"field1","3","field2","4","field3","5"
+    b=FieldTest.find(12345)
+    $redis.hmset key,"field1","6","field2","7","field3","8"
+    b.field1.should =="3"
+    b.field2.should =="4"
+    b.field3.should =="5"
+    b.flush
+    b.field1.should =="6"
+    b.field2.should =="7"
+    b.field3.should =="8"
+  end
+  it "can be automatically read and cached at first field read" do
+    class FieldTest < Redisted::Base
+      pre_cache_all when: :first_read
+      field :field1, type: :string
+      field :field2, type: :string
+      field :field3, type: :string
+    end
+    key="field_test:12345"
+    $redis.hmset key,"field1","3","field2","4","field3","5"
+    b=FieldTest.find(12345)
+    $redis.hmset key,"field1","6","field2","7","field3","8"
+    b.field1.should =="6"
+    $redis.hmset key,"field1","9","field2","10","field3","11"
+    b.field2.should =="7"
+    b.field3.should =="8"
+    b.flush
+    b.field1.should =="9"
+    b.field2.should =="10"
+    b.field3.should =="11"
+  end
+  it "can have autoamtic caching explicitely for all fields" do
+    class FieldTest < Redisted::Base
+      pre_cache_all when: :create, keys: :all
+      field :field1, type: :string
+      field :field2, type: :string
+      field :field3, type: :string
+    end
+    key="field_test:12345"
+    $redis.hmset key,"field1","3","field2","4","field3","5"
+    b=FieldTest.find(12345)
+    $redis.hmset key,"field1","6","field2","7","field3","8"
+    b.field1.should =="3"
+    b.field2.should =="4"
+    b.field3.should =="5"
+    b.flush
+    b.field1.should =="6"
+    b.field2.should =="7"
+    b.field3.should =="8"
+  end
+  it "can have automatic caching for some fields only" do
+    class FieldTest < Redisted::Base
+      pre_cache_all when: :create, keys: [:field1,:field3]
+      field :field1, type: :string
+      field :field2, type: :string
+      field :field3, type: :string
+    end
+    key="field_test:12345"
+    $redis.hmset key,"field1","3","field2","4","field3","5"
+    b=FieldTest.find(12345)
+    $redis.hmset key,"field1","6","field2","7","field3","8"
+    b.field1.should =="3"
+    b.field2.should =="7"
+    b.field3.should =="5"
+    b.flush
+    b.field1.should =="6"
+    b.field2.should =="7"
+    b.field3.should =="8"
+  end
+  it "can have automatic caching for all fields except specified fields" do
+    class FieldTest < Redisted::Base
+      pre_cache_all when: :create, except: [:field1,:field3]
+      field :field1, type: :string
+      field :field2, type: :string
+      field :field3, type: :string
+    end
+    key="field_test:12345"
+    $redis.hmset key,"field1","3","field2","4","field3","5"
+    b=FieldTest.find(12345)
+    $redis.hmset key,"field1","6","field2","7","field3","8"
+    b.field1.should =="6"
+    b.field2.should =="4"
+    b.field3.should =="8"
+    b.flush
+    b.field1.should =="6"
+    b.field2.should =="7"
+    b.field3.should =="8"
+  end
+
+  it "can populate an object via parameters to create" do
+    obj=FieldTest1.create({field1: "test111",field2: "test222"})
+    key="field_test1:#{obj.id}"
+    $redis.hget(key,"field1").should =="test111"
+    $redis.hget(key,"field2").should =="test222"
+  end
+end

data/spec/redisted/recalculate_index_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe "Recalculate Index" do
+  # TODO
+  it "todo"
+end