redis-model-extension 0.3.8 → 0.4.0

data/test/redis_model_parts/test_redis_key.rb

@@ -0,0 +1,119 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class RedisKeyTest < Test::Unit::TestCase
+  context "Redis key" do
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+      @time = Time.now
+      @args = {
+        "integer" => 12345, 
+        :string => "foo", 
+        :symbol => :bar, 
+        :boolean => true, 
+        :array => [1,2,3], 
+        :hash => {"foo"=>"bar", "test" => 2}, 
+        :time => @time, 
+        :date => Date.today
+      }
+      @test_model = TestRedisModel.new(@args)
+    end 
+
+    should "generate right search key" do
+      @test_model.string = nil
+      assert_equal @test_model.redis_key, "#{TestRedisModel.to_s.underscore}:key:*"
+      assert_equal TestRedisModel.generate_key(@args.merge({:string => nil})), "#{TestRedisModel.to_s.underscore}:key:*"
+    end  
+
+         
+    should "generate right key" do
+      assert_equal @test_model.redis_key, "#{TestRedisModel.to_s.underscore}:key:foo"
+      assert_equal TestRedisModel.generate_key(@args), "#{TestRedisModel.to_s.underscore}:key:foo"
+    end  
+
+    should "generate right key alias" do
+      assert_equal @test_model.redis_alias_key(:token), "#{TestRedisModel.to_s.underscore}:alias:token:bar"
+      assert_equal TestRedisModel.generate_alias_key(:token, @args), "#{TestRedisModel.to_s.underscore}:alias:token:bar"
+    end  
+
+    context "invalid setting" do
+      should "raise ArgumentError on nonexisting field" do
+        assert_raises ArgumentError do
+          class RedisKeyNonExistingKeyRedisModel
+            include RedisModelExtension
+            redis_field :string,  :string
+            redis_key :unknown
+          end
+        end
+      end
+
+      should "raise ArgumentError on using Array as redis key" do
+        assert_raises ArgumentError do
+          class RedisKeyNonExistingKeyRedisModel
+            include RedisModelExtension
+            redis_field :array,  :array
+            redis_key :array
+          end
+        end
+      end
+
+      should "raise ArgumentError on using Hash as redis key" do
+        assert_raises ArgumentError do
+          class RedisKeyNonExistingKeyRedisModel
+            include RedisModelExtension
+            redis_field :array,  :array
+            redis_key :array
+          end
+        end
+      end
+
+    end
+
+    context "normalization" do
+      should "downcase" do
+        class DowncaseRedisModel
+          include RedisModelExtension
+          redis_field :string,  :string
+          redis_key :string
+          redis_key_normalize :downcase
+        end
+        model = DowncaseRedisModel.new(:string => "FoO")
+        assert_equal model.redis_key, "#{DowncaseRedisModel.to_s.underscore}:key:foo"
+      end
+
+      should "transliterate" do
+        class TransliterateRedisModel
+          include RedisModelExtension
+          redis_field :string,  :string
+          redis_key :string
+          redis_key_normalize :transliterate
+        end
+        model = TransliterateRedisModel.new(:string => "FoOšČ")
+        assert_equal model.redis_key, "#{TransliterateRedisModel.to_s.underscore}:key:FoOsC"
+      end
+
+      should "downcase & transliterate" do
+        class DowncaseTransliterateRedisModel
+          include RedisModelExtension
+          redis_field :string,  :string
+          redis_key :string
+          redis_key_normalize :transliterate
+          redis_key_normalize :downcase
+        end
+        model = DowncaseTransliterateRedisModel.new(:string => "FoOšČ")
+        assert_equal model.redis_key, "#{DowncaseTransliterateRedisModel.to_s.underscore}:key:foosc"
+      end
+
+      should "downcase & transliterate in one setting" do
+        class DowncaseTransliterateOneRedisModel
+          include RedisModelExtension
+          redis_field :string,  :string
+          redis_key :string
+          redis_key_normalize :transliterate, :downcase
+        end
+        model = DowncaseTransliterateOneRedisModel.new(:string => "FoOšČ")
+        assert_equal model.redis_key, "#{DowncaseTransliterateOneRedisModel.to_s.underscore}:key:foosc"
+      end
+
+    end
+  end
+end

data/test/redis_model_parts/test_save_destroy.rb

@@ -0,0 +1,102 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class SaveDestroyTest < Test::Unit::TestCase
+  context "Save, Update & Destroy" do
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+      @time = Time.now
+      @args = {
+        "integer" => 12345, 
+        :string => "foo", 
+        :symbol => :bar, 
+        :boolean => true, 
+        :array => [1,2,3], 
+        :hash => {"foo"=>"bar", "test" => 2}, 
+        :time => @time, 
+        :date => Date.today,
+        :float => 12.54,
+      }
+      @test_model = TestRedisModel.new(@args)
+    end 
+    
+    context "create" do
+      should "be saved" do
+        assert test_model = TestRedisModel.create(@args), "should be saved"
+        assert !test_model.errors.any?, "no erros"
+      end
+    end
+
+    context "saving" do
+      setup do
+        @test_model.save
+      end
+      
+      should "be saved and then change of variable included in key should rename it in redis!" do
+        assert_equal RedisModelExtension::Database.redis.keys("*").size, 2 #including key and alias
+        @test_model.symbol = :changed_symbol
+        @test_model.string = "change_of_string"
+        @test_model.save
+        assert_equal RedisModelExtension::Database.redis.keys("*").size, 2 #including key and alias
+      end
+
+      should "have same elements after get" do
+        @getted_model = TestRedisModel.get(@args)
+        assert_equal @getted_model.integer, @test_model.integer
+        assert_equal @getted_model.string, @test_model.string
+        assert_equal @getted_model.symbol, @test_model.symbol
+        assert_equal @getted_model.boolean, @test_model.boolean
+      end
+
+      should "have same elements after get and to_arg" do
+        @getted_model = TestRedisModel.get(@args)
+        assert_same_elements @getted_model.to_arg.to_json.split(","), @args.to_json.split(",")
+      end
+
+    end
+
+    context "updating" do
+      setup do
+        @new_args = {:integer => 123457, :string => "bar", :symbol => :foo, :boolean => false}
+      end
+
+      should "change attributes" do
+        @test_model.update @new_args
+        assert_equal @test_model.integer, @new_args[:integer]
+        assert_equal @test_model.string, @new_args[:string]
+        assert_equal @test_model.symbol, @new_args[:symbol]
+        assert_equal @test_model.boolean, @new_args[:boolean]
+      end
+
+      should "ignore unknown attributes and other normaly update" do
+        @test_model.update @new_args.merge(:unknown => "attribute")
+        assert_equal @test_model.integer, @new_args[:integer]
+        assert_equal @test_model.string, @new_args[:string]
+        assert_equal @test_model.symbol, @new_args[:symbol]
+        assert_equal @test_model.boolean, @new_args[:boolean]
+      end
+
+    end
+
+    context "destroy" do
+    
+      setup do
+        @test_model.save
+        @redis_key = @test_model.redis_key
+      end
+      
+      should "remove key and aliases" do
+        before =  RedisModelExtension::Database.redis.keys("*").size
+        @test_model.destroy!
+        assert_equal RedisModelExtension::Database.redis.keys("*").size, before-2 #including key and alias
+      end
+
+      should "not be found" do
+        assert test = TestRedisModel.get(@args)
+        test.destroy!
+        assert_equal TestRedisModel.exists?(@args), false, "Should not exists"
+      end
+    
+    end
+
+  end
+end

data/test/redis_model_parts/test_validation.rb

@@ -0,0 +1,72 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class ValidationTest < Test::Unit::TestCase
+  context "Validation" do
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+      @time = Time.now
+      @args = {
+        "integer" => 12345, 
+        :string => "foo", 
+        :symbol => :bar, 
+        :boolean => true, 
+        :array => [1,2,3], 
+        :hash => {"foo"=>"bar", "test" => 2}, 
+        :time => @time, 
+        :date => Date.today
+      }
+      @test_model = TestRedisModel.new(@args)
+    end 
+
+    context "class" do     
+      
+      should "validate redis_key" do
+        assert TestRedisModel.valid_key?(:string => "test")
+        assert !TestRedisModel.valid_key?(:string => nil)
+        assert !TestRedisModel.valid_key?()
+      end
+
+      should "validate redis_alias_key" do
+        assert TestRedisModel.valid_alias_key?(:token, :symbol => :test)
+        assert !TestRedisModel.valid_alias_key?(:token, :symbol => nil)
+        assert !TestRedisModel.valid_alias_key?(:token)
+      end
+
+    end
+
+    context "instance" do
+
+      should "validate alias key" do
+        assert @test_model.valid_alias_key?(:token)
+      end
+
+      should "validate key" do
+        assert @test_model.valid_key?
+      end
+
+      should "return errors after valid?" do
+        test = TestRedisModel.new()
+        assert !test.valid?, "shouldn't be valid"
+        assert_equal test.errors.messages.size, 2, "should have 2 errors (2 required fields)" 
+        assert_equal test.error.messages.size, 2, "error should be asliased to errors" 
+      end
+
+      should "return errors and be aliased to error" do
+        test = TestRedisModel.new()
+        assert !test.valid?, "shouldn't be valid"
+        assert_equal test.error, test.errors
+      end
+
+      should "not raise exeption on invalid initialize" do
+        assert_nothing_raised { TestRedisModel.new() }
+      end
+
+      should "return false on save" do
+        test_model = TestRedisModel.new()
+        assert !test_model.save, "return false on save"
+        assert test_model.errors.any?, "have any error"
+      end
+
+    end
+  end
+end

data/test/redis_model_parts/test_variable_types.rb

@@ -0,0 +1,91 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class VariableTypesTest < Test::Unit::TestCase
+  context "Definition & Types of variables" do
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+
+      @time = Time.now
+      @args = {
+        "integer" => 12345, 
+        :string => "foo", 
+        :symbol => :bar, 
+        :boolean => true, 
+        :array => [1,2,3], 
+        :hash => {"foo"=>"bar", "test" => 2}, 
+        :time => @time, 
+        :date => Date.today,
+        :float => 12.43,
+      }
+      @test_model = TestRedisModel.new(@args)
+      @test_model_partial = TestRedisModel.new(:integer => 12345, :string => "foo")
+    end 
+    
+    context "on invalid type" do 
+      should "return not modified value" do
+        assert_equal @test_model.value_transform("Test", :unknown_type), "Test", "Value transform"
+        assert_equal @test_model.value_parse("Test", :unknown_type), "Test", "Value parse"
+        assert_equal @test_model.value_to_redis(:unknown_field_name, "Test"), "Test", "Value to redis"
+      end
+    end
+
+    should "get valid arguments" do
+      assert_equal @test_model.integer, 12345
+      assert_equal @test_model.string, "foo"
+      assert_equal @test_model.symbol, :bar
+      assert_equal @test_model.boolean, true
+      assert_equal @test_model.array, [1,2,3]
+      assert_equal @test_model.hash, {"foo"=>"bar", "test" => 2}
+      assert_equal @test_model.time, @time
+      assert_equal @test_model.date, Date.today
+      assert_equal @test_model.float, 12.43
+    end
+    
+    should "return default value when value is nil" do
+      assert_equal @test_model_partial.symbol, :default
+    end
+
+    should "return valid exists?" do
+      assert_equal @test_model.integer?, true
+      assert_equal @test_model.string?, true
+      assert_equal @test_model.symbol?, true
+      assert_equal @test_model.boolean?, true
+      assert_equal @test_model.array?, true
+      assert_equal @test_model.hash?, true
+      assert_equal @test_model.time?, true
+      assert_equal @test_model.date?, true
+      assert_equal @test_model.float?, true
+      
+      assert_equal @test_model_partial.integer?, true
+      assert_equal @test_model_partial.string?, true
+      assert_equal @test_model_partial.symbol?, true, "should be set by default value"
+      assert_equal @test_model_partial.boolean?, false
+      assert_equal @test_model_partial.hash?, false
+      assert_equal @test_model_partial.array?, false
+      assert_equal @test_model_partial.time?, false
+      assert_equal @test_model_partial.date?, false
+      assert_equal @test_model_partial.float?, false
+    end
+    
+    should "be assign new values" do
+      @test_model.integer = 54321
+      @test_model.string = "bar"
+      @test_model.symbol = :foo
+      @test_model.boolean = false
+      @test_model.array = [4,5,6]
+      @test_model.hash = {"bar" => "foo"}
+      @test_model.time = @time-100
+      @test_model.date = Date.today-10
+      @test_model.float = 25.43
+      assert_equal @test_model.integer, 54321
+      assert_equal @test_model.string, "bar"
+      assert_equal @test_model.symbol, :foo
+      assert_equal @test_model.boolean, false
+      assert_equal @test_model.array, [4,5,6]
+      assert_equal @test_model.hash, {"bar" => "foo"}
+      assert_equal @test_model.time, @time-100
+      assert_equal @test_model.date, Date.today-10
+      assert_equal @test_model.float, 25.43
+    end
+  end
+end

data/test/test_redis-model-extension.rb

@@ -1,186 +1,11 @@
 # -*- encoding : utf-8 -*-
 require 'helper'
 class RedisModelTest < Test::Unit::TestCase
-  context "RedisModel" do
-    setup do
-      RedisModelExtension::Database.redis.flushdb
-      
-      class TestRedisModel
-        REDIS_MODEL_CONF = {
-           :fields => { 
-             :integer => :to_i,
-             :boolean => :to_bool,
-             :string => :to_s,
-             :symbol => :to_sym,
-            }, 
-            :required => [:integer, :string],
-            :redis_key => [:string],
-            :redis_aliases => {
-              :token => [:symbol]
-            }
-         }
-         include RedisModel
-         initialize_redis_model_methods REDIS_MODEL_CONF
-      end
-      @args = {:integer => 12345, :string => "foo", :symbol => :bar, :boolean => true}
-      @test_model = TestRedisModel.new(@args)
-      @test_model_partial = TestRedisModel.new(:integer => 12345, :string => "foo")
-    end 
-    
-    context "define methods" do
-      should "be accessible" do
-        assert @test_model.respond_to?(:integer)
-        assert @test_model.respond_to?(:boolean)
-        assert @test_model.respond_to?(:string)
-        assert @test_model.respond_to?(:symbol)
-      end
-      
-      should "get valid arguments" do
-        assert_equal @test_model.integer, 12345
-        assert_equal @test_model.string, "foo"
-        assert_equal @test_model.symbol, :bar
-        assert_equal @test_model.boolean, true
-      end
-      
-      should "return valid exists?" do
-        assert_equal @test_model.integer?, true
-        assert_equal @test_model.string?, true
-        assert_equal @test_model.symbol?, true
-        assert_equal @test_model.boolean?, true
-        
-        assert_equal @test_model_partial.integer?, true
-        assert_equal @test_model_partial.string?, true
-        assert_equal @test_model_partial.symbol?, false
-        assert_equal @test_model_partial.boolean?, false
-      end
-      
-      should "be assign new values" do
-        @test_model.integer = 54321
-        @test_model.string = "bar"
-        @test_model.symbol = :foo
-        @test_model.boolean = false
-        assert_equal @test_model.integer, 54321
-        assert_equal @test_model.string, "bar"
-        assert_equal @test_model.symbol, :foo
-        assert_equal @test_model.boolean, false
-      end
-    end
-         
-    context "redis key" do
-      should "generate right key" do
-        assert_equal @test_model.redis_key, "#{TestRedisModel.to_s.underscore}:key:foo"
-        assert_equal TestRedisModel.generate_key(@args), "#{TestRedisModel.to_s.underscore}:key:foo"
-      end  
-      should "generate right key alias" do
-        assert_equal @test_model.redis_alias_key(:token), "#{TestRedisModel.to_s.underscore}:alias:token:bar"
-        assert_equal TestRedisModel.generate_alias_key(:token, @args), "#{TestRedisModel.to_s.underscore}:alias:token:bar"
-      end  
-    end
-    
-    context "after initialize" do 
-      should "clear input arguments" do
-        test_model = TestRedisModel.new(@args.merge({:foor => :bar, :not_in_fields => "foo"}))
-        assert_same_elements test_model.args, @args
-      end
-    end
-    
-    context "validation" do
-
-      should "return errors after valid?" do
-        test = TestRedisModel.new()
-        assert !test.valid?, "shouldn't be valid"
-        assert_equal test.errors.size, 2, "should have 2 errors (2 required fields)" 
-      end
-
-      should "be able to add custom error (ex. in initialize)" do
-        test = TestRedisModel.new()
-        test.error << "my custom error"
-        assert !test.valid?, "shouldn't be valid"
-        assert_equal test.errors.size, 3, "should have 3 errors (2 required fields + 1 custom error)" 
-        assert_equal test.error.size, test.errors.size, "error and errors should be same (only as backup)" 
-      end
-
-      should "not raise exeption on invalid initialize" do
-        assert_nothing_raised { TestRedisModel.new() }
-      end
-
-      should "raise exeption on save" do
-        test_model = TestRedisModel.new()
-        assert_raises ArgumentError do
-          test_model.save
-        end
-      end
-    end
-    
-    context "updating" do
-      setup do
-        @new_args = {:integer => 123457, :string => "bar", :symbol => :foo, :boolean => false}
-      end
+  context "Redis Model" do
 
-      should "change attributes" do
-        @test_model.update @new_args
-        assert_equal @test_model.integer, @new_args[:integer]
-        assert_equal @test_model.string, @new_args[:string]
-        assert_equal @test_model.symbol, @new_args[:symbol]
-        assert_equal @test_model.boolean, @new_args[:boolean]
-      end
-
-      should "ignore unknown attributes and other normaly update" do
-        @test_model.update @new_args.merge(:unknown => "attribute")
-        assert_equal @test_model.integer, @new_args[:integer]
-        assert_equal @test_model.string, @new_args[:string]
-        assert_equal @test_model.symbol, @new_args[:symbol]
-        assert_equal @test_model.boolean, @new_args[:boolean]
-      end
-
-    end
-
-    context "saving" do
-      setup do
-        @test_model.save
-      end
-      
-      should "be saved and then change of variable included in key should rename it in redis!" do
-        assert_equal RedisModelExtension::Database.redis.keys("*").size, 2 #including key and alias
-        @test_model.string = "change_of_strging"
-        @test_model.save
-        assert_equal RedisModelExtension::Database.redis.keys("*").size, 2 #including key and alias
-      end
-
-      should "have same elements after get" do
-        @getted_model = TestRedisModel.get(@args)
-        assert_equal @getted_model.integer, @test_model.integer
-        assert_equal @getted_model.string, @test_model.string
-        assert_equal @getted_model.symbol, @test_model.symbol
-        assert_equal @getted_model.boolean, @test_model.boolean
-      end
-
-      should "have same elements after get and to_arg" do
-        @getted_model = TestRedisModel.get(@args)
-        assert_equal @getted_model.to_arg, @args
-      end
-            
-      context "alias" do
-        should "be getted by alias" do
-          @getted_model = TestRedisModel.get_by_alias(:token ,@args)
-          assert_equal @getted_model.integer, @test_model.integer
-          assert_equal @getted_model.string, @test_model.string
-          assert_equal @getted_model.symbol, @test_model.symbol
-          assert_equal @getted_model.boolean, @test_model.boolean
-        end
-        
-        should "be getted after change in alias" do
-          getted_model = TestRedisModel.get_by_alias(:token ,@args)
-          getted_model.symbol = "Test_token"
-          getted_model.save
-          assert_equal getted_model.integer, TestRedisModel.get_by_alias(:token ,:symbol => "Test_token").integer
-        end
-      end
-    end
-    
     context "without rejected nil values on save" do
       should "save nil values" do
-        class NilTestRedisModel
+        class NilTestOldRedisModel
           REDIS_MODEL_CONF = {
              :fields => { 
                :integer => :to_i,
@@ -190,34 +15,47 @@ class RedisModelTest < Test::Unit::TestCase
               :redis_key => [:string],
               :redis_aliases => {},
               :reject_nil_values => false
-           }
-           include RedisModel
-           initialize_redis_model_methods REDIS_MODEL_CONF
+          }
+          include RedisModel
+          initialize_redis_model_methods REDIS_MODEL_CONF
         end
-        args = {integer: 100, string: "test"}
-        nil_test_model = NilTestRedisModel.new(args)
 
-        #on initialize
-        assert_equal nil_test_model.integer, 100
-        assert_equal nil_test_model.string, "test"
-        nil_test_model.save
-
-        #after find
-        founded = NilTestRedisModel.get(args)
-        assert_equal founded.integer, 100
-        assert_equal founded.string, "test"
+        class NilTestRedisModel
+          include RedisModelExtension
+          redis_field :integer, :integer
+          redis_field :string, :string
+          redis_key :string
+          redis_save_fields_with_nil true
+        end
 
-        #set integer to nil
-        founded.integer = nil
-        assert_equal founded.integer, nil
-        #perform save
-        founded.save
+        [NilTestOldRedisModel, NilTestRedisModel].each do |klass|
+          args = {integer: 100, string: "test"}
+          nil_test_model = klass.new(args)
+
+          #on initialize
+          assert_equal nil_test_model.integer, 100, "For #{klass} should have integer = 100"
+          assert_equal nil_test_model.string, "test", "For #{klass} should have string = test"
+          nil_test_model.save
+
+          #after find
+          founded = klass.get(args)
+          assert_equal founded.integer, 100, "After get for #{klass} should have integer = 100"
+          assert_equal founded.string, "test", "After get for #{klass} should have string = test"
+
+          #set integer to nil
+          founded.integer = nil
+          assert_equal founded.integer, nil, "After get and save for #{klass} should have integer = nil"
+          #perform save
+          founded.save
+
+          #after second find
+          founded = klass.get(args)
+          assert_equal founded.integer, nil, "After 2nd get for #{klass} should have integer = nil"
+          assert_equal founded.string, "test", "After 2nd get for #{klass} should have string = test"
+        end
 
-        #after second find
-        founded = NilTestRedisModel.get(args)
-        assert_equal founded.integer, nil
-        assert_equal founded.string, "test"
       end
     end
+    
   end
 end

data/test/test_string_to_bool.rb

@@ -0,0 +1,30 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class StringToBoolTest < Test::Unit::TestCase
+  context "String to_bool" do
+
+    should "return true" do
+      assert "true".to_bool, "true"
+      assert "1".to_bool, "1"
+      assert "t".to_bool, "t"
+      assert "y".to_bool, "y"
+      assert "yes".to_bool, "yes"
+    end
+
+    should "return false" do
+      assert ! "false".to_bool, "false"
+      assert ! "0".to_bool, "0"
+      assert ! "f".to_bool, "f"
+      assert ! "no".to_bool, "no"
+      assert ! "n".to_bool, "n"
+      assert ! "".to_bool, "blank string"
+    end
+
+    should "raise exception on unknown" do
+      assert_raises ArgumentError do
+        "unknown string".to_bool
+      end
+    end
+
+  end
+end