redis-model-extension 0.3.8 → 0.4.0

data/test/redis_model_old/test_redis_model_old_config.rb

@@ -0,0 +1,218 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class RedisModelOldConfigTest < Test::Unit::TestCase
+  context "Old RedisModel config" do
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+
+      @args = {"integer" => 12345, :string => "foo", :symbol => :bar, :boolean => true, :array => [1,2,3], :hash => {"foo"=>"bar", "test" => 2}}
+      @test_model = TestOldRedisModel.new(@args)
+      @test_model_partial = TestOldRedisModel.new(:integer => 12345, :string => "foo")
+    end 
+    
+    should "have same configuration" do
+      assert_equal TestOldRedisModel.conf, TestOldRedisModel::REDIS_MODEL_CONF, "Same configuration"
+    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
+        assert_equal @test_model.array, [1,2,3]
+        assert_equal @test_model.hash, {"foo"=>"bar", "test" => 2}
+      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_partial.integer?, true
+        assert_equal @test_model_partial.string?, true
+        assert_equal @test_model_partial.symbol?, false
+        assert_equal @test_model_partial.boolean?, false
+        assert_equal @test_model_partial.hash?, false
+        assert_equal @test_model_partial.array?, 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"}
+        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"}
+      end
+    end
+         
+    context "redis key" do
+      should "generate right key" do
+        assert_equal @test_model.redis_key, "#{TestOldRedisModel.to_s.underscore}:key:foo"
+        assert_equal TestOldRedisModel.generate_key(@args), "#{TestOldRedisModel.to_s.underscore}:key:foo"
+      end  
+      should "generate right key alias" do
+        assert_equal @test_model.redis_alias_key(:token), "#{TestOldRedisModel.to_s.underscore}:alias:token:bar"
+        assert_equal TestOldRedisModel.generate_alias_key(:token, @args), "#{TestOldRedisModel.to_s.underscore}:alias:token:bar"
+      end  
+    end
+    
+    context "after initialize" do 
+      should "clear input arguments" do
+        test_model = TestOldRedisModel.new(@args.merge({:foor => :bar, :not_in_fields => "foo"}))
+        assert_same_elements test_model.args, @args.symbolize_keys!
+      end
+    end
+    
+    context "validation" do
+
+      should "return errors after valid?" do
+        test = TestOldRedisModel.new()
+        assert !test.valid?, "shouldn't be valid"
+        assert_equal test.errors.messages.size, 2, "should have 2 error (2 required field)" 
+      end
+
+      should "not raise exeption on invalid initialize" do
+        assert_nothing_raised { TestOldRedisModel.new() }
+      end
+
+      should "return false on save" do
+        test_model = TestOldRedisModel.new()
+        assert !test_model.save, "return false on save"
+        assert test_model.errors.any?, "have any error"
+      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 "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 = TestOldRedisModel.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 = TestOldRedisModel.get(@args)
+        assert_same_elements @getted_model.to_arg.to_json.split(","), @args.to_json.split(",")
+      end
+            
+      context "alias" do
+        should "be getted by alias" do
+          @getted_model = TestOldRedisModel.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 = TestOldRedisModel.get_by_alias(:token ,@args)
+          getted_model.symbol = "Test_token"
+          getted_model.save
+          assert_equal getted_model.integer, TestOldRedisModel.get_by_alias(:token ,:symbol => "Test_token").integer
+        end
+      end
+    end
+    
+    context "without rejected nil values on save" do
+      setup do
+        class NilTestOldRedisModel
+          REDIS_MODEL_CONF = {
+             :fields => { 
+               :integer => :to_i,
+               :string => :to_s,
+              }, 
+              :required => [:string],
+              :redis_key => [:string],
+              :redis_aliases => {},
+              :reject_nil_values => false
+           }
+           include RedisModel
+           initialize_redis_model_methods REDIS_MODEL_CONF
+        end
+        @args = {integer: 100, string: "test"}
+        @nil_test_model = NilTestOldRedisModel.new(@args)
+      end
+
+      should "save nil values" do
+        #on initialize
+        assert_equal @nil_test_model.integer, 100
+        assert_equal @nil_test_model.string, "test"
+        @nil_test_model.save
+
+        #after find
+        founded = NilTestOldRedisModel.get(@args)
+        assert_equal founded.integer, 100
+        assert_equal founded.string, "test"
+
+        #set integer to nil
+        founded.integer = nil
+        assert_equal founded.integer, nil
+        #perform save
+        founded.save
+
+        #after second find
+        founded = NilTestOldRedisModel.get(@args)
+        assert_equal founded.integer, nil
+        assert_equal founded.string, "test"
+
+      end
+
+      should "have same configuration" do
+        assert_equal NilTestOldRedisModel.conf, NilTestOldRedisModel::REDIS_MODEL_CONF, "Same configuration"
+      end
+    end
+  end
+end

data/test/redis_model_parts/test_attributes.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class AttributesTest < Test::Unit::TestCase
+  context "Attributes" do
+    setup do
+      @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.32,
+      }
+      @test_model = TestRedisModel.new(@args)
+    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.symbolize_keys
+      end
+    end
+
+    should "should create valid to_json" do
+      #keys in json are in different order, just spliting by separator (comma) and then validating
+      assert_same_elements @test_model.to_json.split(","), @args.to_json.split(",")
+    end
+
+  end
+end

data/test/redis_model_parts/test_autoincrement_id.rb

@@ -0,0 +1,86 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class RedisModelAutoincrementTest < Test::Unit::TestCase
+  context "Autoincrement" do
+
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+      @args = {
+        name: "Author",
+        email: "ondrej@bartas.cz"
+      }
+    end
+
+    context "without redis_key specified" do
+    
+      should "have redis_key with id" do
+        assert_equal AutoincrementNotSet.redis_key_config, [:id]
+        assert AutoincrementNotSet.new.respond_to?(:id), "get method"
+        assert AutoincrementNotSet.new.respond_to?(:"id?"), "exists? method"
+        assert !AutoincrementNotSet.new.respond_to?(:"id="), "set method"
+      end
+
+      should "be valid?" do
+        assert AutoincrementNotSet.new(@args).valid?
+      end
+
+    end
+
+    context "with redis_key specified" do
+    
+      should "have redis_key with id" do
+        assert_equal AutoincrementSetRedisKey.redis_key_config, [:id]
+        assert AutoincrementSetRedisKey.new.respond_to?(:id), "get method"
+        assert AutoincrementSetRedisKey.new.respond_to?(:"id?"), "exists? method"
+        assert !AutoincrementSetRedisKey.new.respond_to?(:"id="), "set method"
+      end
+
+      should "be valid?" do
+        assert AutoincrementSetRedisKey.new(@args).valid?
+      end
+
+      should "after save have id" do
+        saved_instance = AutoincrementSetRedisKey.new(@args)
+        saved_instance.save
+        assert_equal saved_instance.id, 1, "Should be first id 1"
+      end
+
+      should "be incremented" do
+        assert_equal AutoincrementSetRedisKey.create(@args).id, 1, "First should have id 1"
+        assert_equal AutoincrementSetRedisKey.create(@args).id, 2, "First should have id 2"
+        assert_equal AutoincrementSetRedisKey.create(@args).id, 3, "First should have id 3"
+        assert_equal AutoincrementSetRedisKey.create(@args).id, 4, "First should have id 4"
+      end
+
+      should "be getted by directly id" do
+        saved_instance = AutoincrementSetRedisKey.new(@args)
+        saved_instance.save
+        assert getted_instance = AutoincrementSetRedisKey.get(saved_instance.id), "should be getted by id: #{saved_instance.id}"
+        assert_same_elements getted_instance.to_arg.to_json.split(","), saved_instance.to_arg.to_json.split(",")
+      end
+
+      should "be founded by directly id" do
+        saved_instance = AutoincrementSetRedisKey.new(@args)
+        saved_instance.save
+        assert getted_instances = AutoincrementSetRedisKey.find(saved_instance.id), "should be getted by id: #{saved_instance.id}"
+        assert_equal getted_instances.size, 1, "should be array with one element"
+        getted_instance = getted_instances.first
+        assert_same_elements getted_instance.to_arg.to_json.split(","), saved_instance.to_arg.to_json.split(",")
+      end
+
+      should "not enable to set id unless id exists" do
+        assert_raises ArgumentError do
+          AutoincrementSetRedisKey.new(@args.merge(:id => 10))
+        end
+        saved_instance = AutoincrementSetRedisKey.new(@args)
+        saved_instance.save
+        assert_nothing_raised do
+          AutoincrementSetRedisKey.new(@args.merge(:id => saved_instance.id))
+        end
+      end
+
+    end
+
+
+  end
+end

data/test/redis_model_parts/test_dynamic_alias.rb

@@ -0,0 +1,147 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class DynamicAliasTest < Test::Unit::TestCase
+  context "Dynamic alias" do
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+      @args = { 
+        :name => "Foo", 
+        :items => {
+          :bar => "test",
+          :foobar => "test2",
+        },
+        :items_order => [:foobar, :bar],
+      }
+      @dynamic_alias = DynamicAlias.new(@args)
+    end 
+
+    context "class" do    
+      context "redis key" do
+
+        should "be merged alias key + custom key" do
+          assert_equal DynamicAlias.generate_alias_key(:items_with_name, @args), "dynamic_alias:alias:items_with_name:Foo:test2:test"
+        end
+
+        should "validate redis_alias_key" do
+          assert DynamicAlias.valid_alias_key?(:items_with_name, @args), "full valid args"
+          assert !DynamicAlias.valid_alias_key?(:items_with_name, :name => "Test"), "only main fields"
+          assert !DynamicAlias.valid_alias_key?(:items_with_name, :items_order => [:foobar]), "only fields order"
+          assert !DynamicAlias.valid_alias_key?(:items_with_name, :items_order => [:foobar], :items => {foobar: "test"}), "only fields order & items"
+          assert !DynamicAlias.valid_alias_key?(:items_with_name), "no args"
+        end
+
+      end
+    end
+
+    context "instance" do    
+      context "redis key" do
+
+        should "return valid key" do
+          assert_equal DynamicAlias.new(@args).redis_alias_key(:items_with_name), "dynamic_alias:alias:items_with_name:Foo:test2:test"
+        end
+
+        should "validate key" do
+          dyn_alias = DynamicAlias.new(@args)
+          assert_equal dyn_alias.valid_alias_key?(:items_with_name), true
+          dyn_alias.items_order = nil
+          assert_equal dyn_alias.valid_alias_key?(:items_with_name), false
+        end
+
+      end
+    end
+    
+    context "saving & destroy" do
+      setup do
+        @dynamic_alias.save
+        @redis_key = @dynamic_alias.redis_key
+        @redis_dynamic_alias_key = @dynamic_alias.redis_alias_key(:items_with_name)
+      end
+      
+      should "be saved and then change of variable included in key should rename it in redis!" do
+        before = RedisModelExtension::Database.redis.keys("*").size
+        assert @dynamic_alias.alias_exists?(:items_with_name), "Dynamic alias should exists"
+        @dynamic_alias.name = "change_of_string"
+        @dynamic_alias.save
+        assert_equal RedisModelExtension::Database.redis.keys("*").size, before, "after update there should be same number of keys" #including key and alias
+      end
+  
+      should "remove key and aliases" do
+        before =  RedisModelExtension::Database.redis.keys("*").size
+        @dynamic_alias.destroy!
+        assert_equal RedisModelExtension::Database.redis.keys("*").size, before-2 #including key and alias
+      end
+
+      should "destroy!" do
+        pp RedisModelExtension::Database.redis.keys("*")
+        @dynamic_alias.destroy!
+        assert_equal @dynamic_alias.exists?, false, "Should not exists"
+        assert_equal DynamicAlias.exists?(@args.merge(:id => @dynamic_alias.id)), false, "Should not exist by class method"
+      end
+    
+    end
+
+
+    context "find & get" do
+      
+      setup do
+        @dynamic_alias.save
+      end
+
+      should "be getted by dynamic alias" do
+        @getted_model = DynamicAlias.get_by_alias(:items_with_name, @args)
+        assert_not_nil @getted_model, "Should return model"
+        assert_equal @getted_model.name, @dynamic_alias.name
+        assert_same_elements @getted_model.items.to_json.split(","), @dynamic_alias.items.to_json.split(",")
+      end
+
+      should "be getted by get_by_name_of_alias" do
+        @getted_model = DynamicAlias.get_by_items_with_name(@args)
+        assert_not_nil @getted_model, "Should return model"
+        assert_equal @getted_model.name, @dynamic_alias.name
+        assert_same_elements @getted_model.items.to_json.split(","), @dynamic_alias.items.to_json.split(",")
+      end
+
+      should "be find by dynamic alias" do
+        @getted_models = DynamicAlias.find_by_alias(:items_with_name, :items => {:bar => "test"})
+        assert_equal @getted_models.size, 1, "Should be only one with alias" 
+
+        @getted_models = DynamicAlias.find_by_alias(:items_with_name, @args)
+        assert_equal @getted_models.size, 1, "Should be find by get by alias full args" 
+        
+        @getted_model = @getted_models.first
+        assert_equal @getted_model.name, @dynamic_alias.name
+        assert_same_elements @getted_model.items.to_json.split(","), @dynamic_alias.items.to_json.split(",")
+      end
+
+      should "be found by find_by_name_of_alias" do
+        @getted_models = DynamicAlias.find_by_items_with_name(:items => {:bar => "test"})
+        assert_equal @getted_models.size, 1, "Should be only one with alias" 
+
+        @getted_models = DynamicAlias.find_by_items_with_name(@args)
+        assert_equal @getted_models.size, 1, "Should be find by get by alias full args" 
+        
+        @getted_model = @getted_models.first
+        assert_equal @getted_model.name, @dynamic_alias.name
+        assert_same_elements @getted_model.items.to_json.split(","), @dynamic_alias.items.to_json.split(",")
+      end
+    
+      should "be find all by dynamic alias" do
+        @getted_models = DynamicAlias.find_by_alias(:items_with_name ,{})
+        assert_equal @getted_models.size, 1, "Should be only one with alias" 
+        @getted_model = @getted_models.first
+        assert_equal @getted_model.name, @dynamic_alias.name
+        assert_same_elements @getted_model.items.to_json.split(","), @dynamic_alias.items.to_json.split(",")
+      end
+    
+      should "be getted after change in alias" do
+        @getted_model = DynamicAlias.get_by_alias(:items_with_name ,@args)
+        assert_not_nil @getted_model, "Should return model"
+        @getted_model.items[:bar] = "Test_bar"
+        @getted_model.save
+
+        assert_equal DynamicAlias.get_by_alias(:items_with_name ,@getted_model.to_arg).name, @getted_model.name
+      end
+    end
+
+  end
+end

data/test/redis_model_parts/test_get_find.rb

@@ -0,0 +1,111 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class GetFindTest < Test::Unit::TestCase
+  context "Get & Find" 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.32
+      }
+      @test_model = TestRedisModel.new(@args)
+      @test_model.save
+    end 
+ 
+     context "main object" do
+
+      should "be getted by redis_key" do
+        @getted_model = TestRedisModel.get_by_redis_key(@test_model.redis_key)
+        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 "return nil on triyng to get model by redis key without all valid variables (or nonexisting)" do
+        @test_model.string = nil
+        assert_nil TestRedisModel.get_by_redis_key(@test_model.redis_key)
+      end
+
+      should "be find by all" do
+        @getted_models = TestRedisModel.all
+        assert_equal @getted_models.size, 1, "Should be only one" 
+      end
+
+      should "be find by args" do
+        @getted_models = TestRedisModel.find(:string => @args[:string])
+        assert_equal @getted_models.size, 1, "Should be only one" 
+      end
+
+      should "be find by args zero" do
+        @getted_models = TestRedisModel.find(:string => "nonexisting string")
+        assert_equal @getted_models, [], "Should be empty array" 
+      end
+
+    end
+
+    context "alias" do
+      should "exists" do
+        assert @test_model.alias_exists?(:token)
+      end
+
+      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 find by alias" do
+        @getted_models = TestRedisModel.find_by_alias(:token, :symbol => :bar)
+        assert_equal @getted_models.size, 1, "Should be only one with alias" 
+        @getted_model = @getted_models.first
+        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 find by find_by_alias_name" do
+        @getted_models = TestRedisModel.find_by_token(:symbol => :bar)
+        assert_equal @getted_models.size, 1, "Should be only one with alias" 
+        @getted_model = @getted_models.first
+        assert_equal @getted_model.integer, @test_model.integer
+      end
+    
+      should "be find all by alias" do
+        @getted_models = TestRedisModel.find_by_alias(:token ,{})
+        assert_equal @getted_models.size, 1, "Should be only one with alias" 
+        @getted_model = @getted_models.first
+        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 find all by find_by_name_of_alais" do
+        @getted_models = TestRedisModel.find_by_token({})
+        assert_equal @getted_models.size, 1, "Should be only one with alias" 
+        @getted_model = @getted_models.first
+        assert_equal @getted_model.integer, @test_model.integer
+      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
+end

data/test/redis_model_parts/test_hooks.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class HooksTest < Test::Unit::TestCase
+  context "Hooks" do
+
+    should "fire before_create hooks" do
+      WithCallbacks.any_instance.expects(:before_create_method)
+
+      WithCallbacks.create name: 'Callbacks'
+    end
+
+    should "fire both before_create and before_save hooks if defined" do
+      WithCallbacks.any_instance.expects(:before_create_method)
+      WithCallbacks.any_instance.expects(:before_save_method)
+      WithCallbacks.any_instance.expects(:after_save_method)
+
+      WithCallbacks.create name: 'Callbacks'
+    end
+
+    should "fire before_save hooks" do
+      article = WithCallbacks.new name: 'Callbacks'
+      article.expects(:before_save_method)
+      article.expects(:after_save_method)
+      article.expects(:before_create_method)
+      article.save
+    end
+
+    should "fire before_destroy hooks" do
+      article = WithCallbacks.new name: 'Callbacks'
+      article.save
+      article.destroy
+
+      assert article.instance_variable_get(:@destroyed_flag), "should have destroyed flag"
+    end
+  end
+end

data/test/redis_model_parts/test_initialize.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+require 'helper'
+class VariableTypesTest < Test::Unit::TestCase
+  context "Definition & Types of variables" do
+    setup do
+      RedisModelExtension::Database.redis.flushdb
+
+      @test_model = TestRedisModel.new()
+    end 
+    
+    should "be have accessible fields" do
+      assert @test_model.respond_to?(:integer)
+      assert @test_model.respond_to?(:string)
+      assert @test_model.respond_to?(:boolean)
+      assert @test_model.respond_to?(:array)
+      assert @test_model.respond_to?(:hash)
+      assert @test_model.respond_to?(:time)
+      assert @test_model.respond_to?(:date)
+      assert @test_model.respond_to?(:float)
+    end
+
+    should "be have setable fields" do
+      assert @test_model.respond_to?(:"integer=")
+      assert @test_model.respond_to?(:"string=")
+      assert @test_model.respond_to?(:"boolean=")
+      assert @test_model.respond_to?(:"array=")
+      assert @test_model.respond_to?(:"hash=")
+      assert @test_model.respond_to?(:"time=")
+      assert @test_model.respond_to?(:"date=")
+      assert @test_model.respond_to?(:"float=")
+    end
+
+    should "be have field exist?" do
+      assert @test_model.respond_to?(:"integer?")
+      assert @test_model.respond_to?(:"string?")
+      assert @test_model.respond_to?(:"boolean?")
+      assert @test_model.respond_to?(:"array?")
+      assert @test_model.respond_to?(:"hash?")
+      assert @test_model.respond_to?(:"time?")
+      assert @test_model.respond_to?(:"date?")
+      assert @test_model.respond_to?(:"float?")
+    end    
+
+  end
+end
+