sencha-model 0.5.0

data/shoulda_macros/macros.rb

@@ -0,0 +1,20 @@
+class Test::Unit::TestCase
+  ##
+  # Asserts that the passed list of fields are specified in the whorm_fields call
+  # in the model class.
+  # @fieldset {Symbol} fieldset (optional, set to :default if missing)
+  # @options {Hash} Should contain a :fields key with an array of fields to check for
+  #
+  def self.should_have_whorm_fields_for_fieldset fieldset = :default, fields = []
+    klass = described_type
+    should "have the correct extjs_fields" do
+      assert !fields.empty?, "an array of fields must be passed.  Example: (:fieldset_name, [:name, :id])"
+      fields.each do |field|
+        found_record = klass.whorm_get_fields_for_fieldset(fieldset).find do|record_field|
+          record_field[:name].to_sym == field.to_sym
+        end
+        assert_not_nil found_record, "whorm field #{field} isn't listed in the #{klass.name} model"
+      end
+    end
+  end
+end

data/test/app/config/application.rb

@@ -0,0 +1,70 @@
+# TODO: Figure out how to iterate each ORM framework AR, DM, MM and test each.
+require 'active_record'
+require 'active_support'
+require 'sencha-model'
+require 'extlib/inflection'
+
+gem 'sqlite3-ruby'
+
+class Test::App
+  
+  attr_reader :models
+  
+  def initialize(orm = :active_record)
+    @orm = orm
+    @config = YAML::load(IO.read("#{ROOT}/config/database.yml"))
+    
+    # Load ORM
+    send("boot_#{orm.to_s}")
+    
+    load_models
+
+    require 'db/schema'
+    
+  end
+  
+  ##
+  # Reset a model's @sencha_fieldsets
+  #
+  def clean_all
+    @models.map { |klass| clean klass }
+  end
+  
+  
+private
+  
+  def boot_active_record
+    ActiveRecord::Base.establish_connection(@config['test'])
+  end
+  
+  def boot_mongo_mapper
+    
+  end
+  
+  def boot_data_mapper
+    
+  end
+  
+  ##
+  # Do a dir on /models and constantize each filename
+  #
+  def load_models
+    @models = []
+    # Load Models and Schema for corresponding orm
+    re = /^.*\/(.*).rb$/
+    Dir["#{ROOT}/models/#{@orm.to_s}/*"].each { |c| 
+        require c 
+        match = c.match(re)
+        @models << Extlib::Inflection.constantize(Extlib::Inflection.camelize(match[1])) if match
+    }
+  end
+  
+  def clean klass
+    klass.instance_variables.each do |var_name|
+      if /\A@sencha_fieldsets__/ =~ var_name.to_s
+        klass.instance_variable_set( var_name.to_sym, nil )
+      end
+    end
+  end
+  
+end

data/test/app/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"

data/test/app/db/schema.rb

@@ -0,0 +1,75 @@
+
+##
+# build simple database
+#
+# people
+#
+ActiveRecord::Base.connection.create_table :users, :force => true do |table|
+  table.column :id, :serial
+  table.column :person_id, :integer
+  table.column :password, :string
+  table.column :created_at, :date
+  table.column :disabled, :boolean, :default => true
+end
+##
+# people
+#
+ActiveRecord::Base.connection.create_table :people, :force => true do |table|
+  table.column :id, :serial
+  table.column :first, :string, :null => false
+  table.column :last, :string, :null => false
+  table.column :email, :string, :null => false
+end
+##
+# user_groups, join table
+#
+ActiveRecord::Base.connection.create_table :user_groups, :force => true do |table|
+  table.column :user_id, :integer
+  table.column :group_id, :integer
+end
+
+##
+# groups
+#
+ActiveRecord::Base.connection.create_table :groups, :force => true do |table|
+  table.column :id, :serial
+  table.column :title, :string
+end
+
+##
+# locations
+#
+ActiveRecord::Base.connection.create_table :locations, :force => true do |table|
+  table.column :id, :serial
+  table.column :name, :string
+  table.column :street, :string
+  table.column :type, :string
+end
+
+##
+# addresses
+#
+ActiveRecord::Base.connection.create_table :addresses, :force => true do |table|
+  table.column :id, :serial
+  table.column :addressable_type, :string
+  table.column :addressable_id, :integer
+  table.column :street, :string
+end
+
+##
+# Mock a Model for testing data-types
+#
+ActiveRecord::Base.connection.create_table :data_types, :force => true do |table|
+  table.column :id, :serial
+  table.column :string_column, :string
+  table.column :decimal_column, :decimal
+  table.column :float_column, :float
+  table.column :date_column, :date
+  table.column :datetime_column, :datetime
+  table.column :time_column, :time
+  table.column :email, :string
+  table.column :integer_column, :integer
+  table.column :notnull_column, :string, :null => false
+  table.column :default_column, :boolean, :default => true
+  table.column :boolean_column, :boolean
+end

data/test/app/models/active_record/address.rb

@@ -0,0 +1,4 @@
+class Address < ActiveRecord::Base
+  belongs_to :addressable, :polymorphic => true
+  include Sencha::Model
+end

data/test/app/models/active_record/data_type.rb

@@ -0,0 +1,3 @@
+class DataType < ActiveRecord::Base
+  include Sencha::Model
+end

data/test/app/models/active_record/group.rb

@@ -0,0 +1,4 @@
+class Group < ActiveRecord::Base
+  has_many :users
+  include Sencha::Model
+end

data/test/app/models/active_record/house.rb

@@ -0,0 +1,4 @@
+require "#{File.dirname(__FILE__)}/location"
+
+class House < Location
+end

data/test/app/models/active_record/location.rb

@@ -0,0 +1,5 @@
+class Location < ActiveRecord::Base
+  has_one :address, :as => :addressable
+  include Sencha::Model
+end
+

data/test/app/models/active_record/person.rb

@@ -0,0 +1,4 @@
+class Person < ActiveRecord::Base
+  has_one :user
+  include Sencha::Model
+end

data/test/app/models/active_record/user.rb

@@ -0,0 +1,6 @@
+class User < ActiveRecord::Base
+  include Sencha::Model
+  belongs_to :person
+  
+  has_and_belongs_to_many :groups, :join_table => :user_groups
+end

data/test/app/models/active_record/user_group.rb

@@ -0,0 +1,4 @@
+class UserGroup < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :group
+end

data/test/model_test.rb

@@ -0,0 +1,526 @@
+require 'test_helper'
+
+##
+# create a couple of related instances.
+#
+p = Person.create(:first => "Chris", :last => "Scott", :email => "chris@scott.com")
+u = User.create(:password => "1234", :person => p)
+
+class BogusModel
+  include Sencha::Model
+  def additional_attribute
+    'computed value'
+  end
+  class << self
+    def sencha_allow_blank(col)
+      true
+    end
+    
+    def sencha_default(col)
+      nil
+    end
+    
+    def sencha_type(col)
+      nil
+    end
+    
+    def sencha_column_names
+      [:one, :two, :three_id]
+    end
+    
+    def sencha_columns_hash
+      {
+        :one   => {},
+        :two   => {},
+        :three_id => {}
+      }
+    end
+    
+    def sencha_polymorphic_type(id_column_name)
+      id_column_name.to_s.gsub(/_id\Z/, '_type').to_sym
+    end
+    
+    def sencha_primary_key
+      :id
+    end
+ 
+    def sencha_associations
+      {
+        :three => {
+          :name => :tree,
+          :type => :belongs_to,
+          :class => nil,
+          :foreign_key => :three_id,
+          :is_polymorphic => false
+        }
+      }
+    end
+  end
+end
+
+
+class BogusModelChild < BogusModel
+end
+
+class ModelTest < Test::Unit::TestCase
+  context "Rendering DataReader configuration for Person and User" do
+
+	  setup do
+	    App.clean_all
+	  end
+
+	  should "Person and User should render a valid Reader config" do
+	    reader = Person.sencha_schema
+	    assert reader.kind_of?(Hash) && reader.has_key?(:fields) && reader.has_key?(:idProperty)
+	  end
+	  should "Person instance should render with to_record, a Hash containing at least a primary_key" do
+	    rec = Person.first.to_record
+	    assert_kind_of(Hash, rec)
+	    assert_array_has_item(rec.keys, 'has primary key') { |i| i.to_s == Person.sencha_primary_key.to_s }
+	  end
+	  should "User should render a Reader config" do
+	    reader = User.sencha_schema
+	    assert reader.kind_of?(Hash) && reader.has_key?(:fields) && reader.has_key?(:idProperty)
+	  end
+	  should "User instance should render with to_record, a Hash containing at least a primary_key" do
+	    rec = User.first.to_record
+	    assert rec.kind_of?(Hash) && rec.keys.include?(User.sencha_primary_key)
+	  end
+	  should "User instance should render to_record containing foreign_key of Person" do
+	    rec = User.first.to_record
+	    assn = User.sencha_associations[:person]
+	    assert rec.keys.include?(assn[:foreign_key])
+	  end
+	  
+  end
+  
+  context "A User with HABTM relationship with Group" do
+    setup do
+      App.clean_all
+      UserGroup.destroy_all
+      
+      @user = User.first
+      UserGroup.create(:user => @user, :group => Group.create(:title => "Merb"))
+      UserGroup.create(:user => @user, :group => Group.create(:title => "Rails"))
+    end
+    
+    should "Render to_record should return 2 groups" do
+      User.sencha_fields(:groups)
+      assert @user.to_record[:groups].length == 2
+    end
+  end
+
+  context "A User with Person relationship: User.sencha_fields(:password, :person => [:first, {:last => {'sortDir' => 'ASC'}}])" do
+    setup do
+      App.clean_all
+      User.sencha_fields(:password, {:person => [:first, {:last => {:sortDir => "ASC"}}]})
+	    @fields = User.sencha_schema[:fields]
+    end
+    
+    should "User should render a Reader with 4 total fields" do
+	    assert @fields.count === 4
+    end
+    should "Reader fields should contain 'password' field" do
+      assert_array_has_item(@fields, 'has password field') {|f| f[:name] === "password"}
+    end
+    should "Reader fields should contain person_id" do
+      assns = User.sencha_associations  
+      assn = assns[:person]
+      assert_array_has_item(@fields, 'has foreign key person_id') {|f| f[:name] === assns[:person][:foreign_key].to_s }
+    end
+    should "Reader fields should contain mapped field 'person.first'" do
+      assert_array_has_item(@fields, 'has person_first') {|f| f[:name] === "person_first" and f[:mapping] === "person.first"}
+    end
+    should "Reader fields should contain mapped field 'person.last'" do
+      assert_array_has_item(@fields, 'has person_last') {|f| f[:name] === "person_last" and f[:mapping] === "person.last"}
+    end
+    should "person.last should have additional configuration 'sortDir' => 'ASC'" do
+      assert_array_has_item(@fields, 'has person.last with sortDir') {|f| f[:name] === "person_last" and f[:sortDir] === 'ASC' }
+    end
+    
+    should "produce a valid to_record record" do
+      person = Person.create!(:first => 'first', :last => 'last', :email => 'email')
+      user = User.create!(:person_id => person.id, :password => 'password')
+      record = user.to_record
+      assert_equal(user.id, record[:id])
+      assert_equal(person.id, record[:person_id])
+      assert_equal('password', record[:password])
+      assert_equal('last', record[:person][:last])
+      assert_equal('first', record[:person][:first])
+    end
+  end
+  
+  context "User with standard Person association" do
+    setup do
+      App.clean_all
+      User.sencha_fields(:id, :password, :person)
+    end
+    should "produce a valid store config" do
+      fields = User.sencha_schema[:fields]
+      assert_array_has_item(fields, 'has id') {|f| f[:name] === "id" }
+      assert_array_has_item(fields, 'has person_id') {|f| f[:name] === "person_id" }
+      assert_array_has_item(fields, 'has password') {|f| f[:name] === "password" }
+      assert_array_has_item(fields, 'has person_last') {|f| f[:name] === "person_last" and f[:mapping] == "person.last" }
+      assert_array_has_item(fields, 'has person_first') {|f| f[:name] === "person_first" and f[:mapping] == "person.first" }
+    end
+    should "produce a valid to_record record" do
+      person = Person.create!(:first => 'first', :last => 'last', :email => 'email')
+      user = User.create!(:person_id => person.id, :password => 'password')
+      record = user.to_record
+      assert_equal(user.id, record[:id])
+      assert_equal(person.id, record[:person_id])
+      assert_equal('password', record[:password])
+      assert_equal('last', record[:person][:last])
+      assert_equal('first', record[:person][:first])
+    end
+  end
+  
+  context "Person with User association (has_one relationship)" do
+    setup do
+      App.clean_all
+      User.sencha_fields(:id, :password)
+      Person.sencha_fields(:id, :user)
+    end
+    should "produce a valid store config" do
+      fields = Person.sencha_schema[:fields]
+      assert_array_has_item(fields, 'has id') {|f| f[:name] === "id" }
+      assert_array_has_item(fields, 'has user_id') {|f| f[:name] === "user_id" and f[:mapping] == 'user.id' }
+      assert_array_has_item(fields, 'has user_password') {|f| f[:name] === "user_password"and f[:mapping] == 'user.password' }
+    end
+    should "produce a valid to_record record" do
+      person = Person.create!(:first => 'first', :last => 'last', :email => 'email')
+      user = User.create!(:person_id => person.id, :password => 'password')
+      record = person.reload.to_record
+      assert_equal(person.id, record[:id])
+      assert_equal(user.id, record[:user][:id])
+      assert_equal('password', record[:user][:password])
+    end
+  end
+  
+  context "Person with User association (has_one/belongs_to relationship) cyclic reference" do
+    setup do
+      App.clean_all
+      User.sencha_fields(:id, :person)
+      Person.sencha_fields(:id, :user)
+    end
+    should "produce a valid store config for Person" do
+      fields = Person.sencha_schema[:fields]
+      assert_array_has_item(fields, 'has id') {|f| f[:name] === "id" }
+      assert_array_has_item(fields, 'has user_id') {|f| f[:name] === "user_id" and f[:mapping] == 'user.id' }
+    end
+    should "produce a valid to_record record for Person" do
+      person = Person.create!(:first => 'first', :last => 'last', :email => 'email')
+      user = User.create!(:person_id => person.id, :password => 'password')
+      record = person.reload.to_record
+      assert_equal(person.id, record[:id])
+      assert_equal(user.id, record[:user][:id])
+    end
+  end
+  
+  context "Fields should render with correct, ExtJS-compatible data-types" do
+    setup do
+      App.clean_all
+      @fields = DataType.sencha_schema[:fields]
+    end
+    
+    should "Understand 'string'" do
+      assert_array_has_item(@fields, 'has string_column with string') {|f| f[:name] == 'string_column' and f[:type] == 'string'}
+    end
+    should "Understand 'integer' as 'int'" do
+      assert_array_has_item(@fields, 'has integer_column with int') {|f| f[:name] == 'integer_column' and f[:type] == 'int'}
+    end
+    should "Understand 'float'" do
+      assert_array_has_item(@fields, 'has float_column with float') {|f| f[:name] == 'float_column' and f[:type] == 'float'}
+    end
+    should "Understand 'decimal' as 'float'" do # Is this correct??
+      assert_array_has_item(@fields, 'has decimal_column with float') {|f| f[:name] == 'decimal_column' and f[:type] == 'float'}
+    end
+    should "Understand 'date'" do
+      assert_array_has_item(@fields, 'has date_column with date') {|f| f[:name] == 'date_column' and f[:type] == 'date'}
+    end
+    should "Understand 'datetime' as 'date'" do
+      assert_array_has_item(@fields, 'has datetime_column with date') {|f| f[:name] == 'datetime_column' and f[:type] == 'date'}
+    end
+    should "Understand 'time' as 'date'" do
+      assert_array_has_item(@fields, 'has time_column with date') {|f| f[:name] == 'time_column' and f[:type] == 'date'}
+    end
+    should "Understand 'boolean'" do
+      assert_array_has_item(@fields, 'has boolean_column with boolean') {|f| f[:name] == 'boolean_column' and f[:type] == 'boolean'}
+    end
+    should "Understand NOT NULL" do
+      assert_array_has_item(@fields, 'has notnull_column with allowBlank == false') {|f| f[:name] == 'notnull_column' and f[:allowBlank] === false}
+    end
+    should "Understand DEFAULT" do
+      assert_array_has_item(@fields, 'has default_column with defaultValue == true') {|f| f[:name] == 'default_column' and f[:defaultValue] === true}
+    end
+  end
+  
+  context "polymorphic associations" do
+    setup do
+      App.clean_all
+    end
+    
+    should "return nil as class for a polymorphic relation" do
+      assert_equal(nil, Address.sencha_associations[:addressable][:class])
+    end
+    
+    should "create a proper default store config" do
+      Address.sencha_fields
+      fields = Address.sencha_schema[:fields]
+      assert_array_has_item(fields, 'has addressable_id') {|f| f[:name] === 'addressable_id' && !f[:mapping] }
+      assert_array_has_item(fields, 'addressable_type') {|f| f[:name] === 'addressable_type' && !f[:mapping] }
+    end
+    
+    should "create the right store config when including members of the polymorphic association" do
+      Address.sencha_fields :street, :addressable => [:name]
+      fields = Address.sencha_schema[:fields]
+      assert_array_has_item(fields, "has addressable_name") {|f| f[:name] === 'addressable_name' && f[:mapping] === 'addressable.name'}
+      assert_array_has_item(fields, "has addressable_id") {|f| f[:name] === 'addressable_id' && !f[:mapping] }
+      assert_array_has_item(fields, "has addressable_type") {|f| f[:name] === 'addressable_type' && !f[:mapping] }
+    end
+    
+    should "fill in the right values for to_record" do
+      Address.sencha_fields :street, :addressable => [:name]
+      location = Location.create!(:name => 'Home')
+      address = location.create_address(:street => 'Main Street 1')
+      record = address.to_record
+      assert_equal({:name => "Home", :id => location.id}, record[:addressable])
+      assert_equal("Location", record[:addressable_type])
+      assert_equal(location.id, record[:addressable_id])
+      assert_equal(address.id, record[:id])
+      assert_equal("Main Street 1", record[:street])
+    end
+  end
+  
+  context "single table inheritance" do
+    setup do
+      App.clean_all
+    end
+    
+    should "fieldsets should be accessible from descendants" do
+      Location.sencha_fieldset :on_location, [:street]
+      fields = House.sencha_schema(:on_location)[:fields]
+      assert_array_has_item(fields, 'has street') {|f| f[:name] === 'street' }
+      assert_array_has_not_item(fields, 'has name') {|f| f[:name] === 'name' }
+    end
+    should "fieldsets should be overrideable from descendants" do
+      Location.sencha_fieldset :override, [:street]
+      House.sencha_fieldset :override, [:name]
+      fields = House.sencha_schema(:override)[:fields]
+      assert_array_has_not_item(fields, 'has street') {|f| f[:name] === 'street' }
+      assert_array_has_item(fields, 'has name') {|f| f[:name] === 'name' }
+    end
+  end
+  
+  context "Sencha::Model::Util" do
+    context "#extract_fieldset_and_options default" do
+      setup do
+        @fieldset, @options = Sencha::Model::Util.extract_fieldset_and_options [:fields => [:one, :two, :three]]
+        @fields = @options[:fields]
+      end
+      should "return :default when no fieldset provided" do
+        assert_equal(:'default', @fieldset)
+      end
+      should "not alter the fields array" do
+        assert_equal([:one, :two, :three], @fields)
+      end
+    end
+
+    context "#extract_fieldset_and_options with explicit fieldset definition and array with fields" do
+      setup do
+        @fieldset, @options = Sencha::Model::Util.extract_fieldset_and_options [:explicit, [:one, :two, :three]]
+        @fields = @options[:fields]
+      end
+      should "return :default when no fieldset provided" do
+        assert_equal(:'explicit', @fieldset)
+      end
+      should "not alter the fields array" do
+        assert_equal([:one, :two, :three], @fields)
+      end
+    end
+    
+    context "#extract_fieldset_and_options with explicit fieldset definition and hash with fields" do
+      setup do
+        @fieldset, @options = Sencha::Model::Util.extract_fieldset_and_options [:explicit, {:fields => [:one, :two, :three]}]
+        @fields = @options[:fields]
+      end
+      should "return :default when no fieldset provided" do
+        assert_equal(:'explicit', @fieldset)
+      end
+      should "not alter the fields array" do
+        assert_equal([:one, :two, :three], @fields)
+      end
+    end
+    
+    context "#extract_fieldset_and_options with only a hash" do
+      setup do
+        @fieldset, @options = Sencha::Model::Util.extract_fieldset_and_options [{:fieldset => :explicit, :fields => [:one, :two, :three]}]
+        @fields = @options[:fields]
+      end
+      should "return :default when no fieldset provided" do
+        assert_equal(:'explicit', @fieldset)
+      end
+      should "not alter the fields array" do
+        assert_equal([:one, :two, :three], @fields)
+      end
+    end
+    
+    context "#extract_fieldset_and_options edge cases" do
+      should "called without arguments" do
+        @fieldset, @options = Sencha::Model::Util.extract_fieldset_and_options []
+        @fields = @options[:fields]
+        assert_equal(:'default', @fieldset)
+        assert_equal([], @fields)
+      end
+      should "called with only the fieldset and no field arguments" do
+        @fieldset, @options = Sencha::Model::Util.extract_fieldset_and_options [:explicit]
+        @fields = @options[:fields]
+        assert_equal(:'explicit', @fieldset)
+        assert_equal([], @fields)
+      end
+      should "raise error when called with more than 2 arguments" do
+        assert_raise(ArgumentError) { Sencha::Model::Util.extract_fieldset_and_options [:explicit, :some, {}] }
+      end
+      should "raise error when called with 2 arguments and the first one is no symbol" do
+        assert_raise(ArgumentError) { Sencha::Model::Util.extract_fieldset_and_options [{ :fields => [] }, :explicit] }
+      end
+    end
+  end
+  
+  context "Sencha::Model::ClassMethods" do
+    
+    context "#process_fields" do
+      should "handle a simple Array of Symbols" do
+        @fields = BogusModel.process_fields :one, :two, :three
+        assert_equal([{:name => :one}, {:name => :two}, {:name => :three}], @fields)
+      end
+      should "handle a mixed Array where the last item is a Hash" do
+        @fields = BogusModel.process_fields :one, :two, :three => [:three_one, :three_two]
+        assert_equal([{:name => :one}, {:name => :two}, {:name => :three, :fields => [{:name => :three_one}, {:name => :three_two}]}], @fields)
+      end
+      should "handle a mixed Array where a middle item is a Hash" do
+        @fields = BogusModel.process_fields :one, {:two => [:two_one, :two_two]}, :three
+        assert_equal([
+          {:name => :one}, 
+          {:name => :two, :fields => [{:name => :two_one}, {:name => :two_two}]}, 
+          {:name => :three}], @fields)
+      end
+      should "handle option :only" do
+        @fields = BogusModel.process_fields :only => [:one, :two, :three]
+        assert_equal([{:name => :one}, {:name => :two}, {:name => :three}], @fields)
+      end
+      should "handle option :exclude" do
+        @fields = BogusModel.process_fields :exclude => [:two]
+        assert_equal([{:name => :one}, {:name => :three_id}], @fields)
+      end
+      should "handle option :additional" do
+        @fields = BogusModel.process_fields :additional => [:additional_attribute]
+        assert_equal([{:name => :one}, {:name => :two}, {:name => :three_id}, {:name => :additional_attribute}], @fields)
+        
+      end
+      should "handle {:field => {:sortDir => 'ASC'}}" do
+        @fields = BogusModel.process_fields({:field => {:sortDir => 'ASC'}})
+        assert_equal([{:name => :field, :sortDir => 'ASC'}], @fields)
+      end
+      should "handle recursive definition" do
+        @fields = BogusModel.process_fields(:one, {:three => [{:one => [:one, :two]}, {:two => {:sortDir => "ASC"}}]})
+        assert_equal([{:name => :one}, {:name => :three, :fields => [{:name => :one, :fields => [{:name => :one}, {:name => :two}]}, {:name => :two, :sortDir => 'ASC'}]}], @fields)
+      end
+      should "not touch already correct fields" do
+        @fields = BogusModel.process_fields(:one, {:name => :field,:sortDir => 'ASC'})
+        assert_equal([{:name => :one},{:name => :field, :sortDir => 'ASC'}], @fields)
+      end
+      should "raise ArgumentError when pass in bogus hash" do
+        assert_raise(ArgumentError) { @fields = BogusModel.process_fields(:one, {:nme => :field,:sortDir => 'ASC'}) }
+      end
+    end
+    
+    context "#sencha_field" do
+      should "type gets set to 'auto' when not present" do
+        @field = BogusModel.sencha_field({:name => :test})
+        assert_equal('auto', @field[:type])
+      end
+      should "not touch type when alredy present" do
+        @field = BogusModel.sencha_field({:name => :test, :type => 'untouched'})
+        assert_equal('untouched', @field[:type])
+      end
+      should "raise exception when bogus field config passed" do
+        assert_raise(ArgumentError) { BogusModel.sencha_field({:name => :test, "type" => 'untouched'}) }
+      end
+
+    end
+    
+    context "#sencha_field with ORM config" do
+      should "set allowBlank" do
+        BogusModel.expects(:sencha_allow_blank).returns(false)
+        @field = BogusModel.sencha_field({:name => :test}, stub())
+        assert_equal(false, @field[:allowBlank])
+      end
+      should "set type" do
+        BogusModel.expects(:sencha_type).returns('int')
+        @field = BogusModel.sencha_field({:name => :test}, stub())
+        assert_equal('int', @field[:type])
+      end
+      should "set defaultValue" do
+        BogusModel.expects(:sencha_default).returns(true)
+        @field = BogusModel.sencha_field({:name => :test}, stub())
+        assert_equal(true, @field[:defaultValue])
+      end
+      should "set dateFormat to c it's a date" do
+        BogusModel.expects(:sencha_type).returns('date')
+        @field = BogusModel.sencha_field({:name => :test}, stub())
+        assert_equal('c', @field[:dateFormat])
+      end
+      should "not touch dateFormat if it's already set" do
+        BogusModel.expects(:sencha_type).returns('date')
+        @field = BogusModel.sencha_field({:name => :test, :dateFormat => 'not-c'}, stub())
+        assert_equal('not-c', @field[:dateFormat])
+      end
+    end
+    
+    context "#sencha_field with Hash config" do
+      should "set correct name and mapping" do
+        @field = BogusModel.sencha_field({:name => :son}, {:mapping => 'grandfather.father', :parent_trail => 'grandfather_father'})
+        assert_equal('grandfather_father_son', @field[:name])
+        assert_equal('grandfather.father.son', @field[:mapping])
+      end
+      should "apply config to field" do
+        @field = BogusModel.sencha_field({:name => :son}, {:sortDir => 'ASC'})
+        assert_equal('ASC', @field[:sortDir])
+      end
+    end
+    
+    context "#sencha_get_fields_for_fieldset" do
+      should "return full list of columns for fieldset that was not defined, yet" do
+        @fields = BogusModel.sencha_get_fields_for_fieldset :not_there
+        assert_equal(BogusModel.process_fields(*BogusModel.sencha_column_names), @fields)
+      end
+      should "return the right fields for a fieldset that was defined before in the same class" do
+        BogusModel.sencha_fieldset :fieldset_was_defined, [:one]
+        @fields = BogusModel.sencha_get_fields_for_fieldset :fieldset_was_defined
+        assert_equal(BogusModel.process_fields(:one), @fields)
+      end
+      should "return the fieldset of the ancestor when it was only defined in the ancestor" do
+        BogusModel.sencha_fieldset :fieldset_was_defined_in_ancestor, [:one]
+        @fields = BogusModelChild.sencha_get_fields_for_fieldset :fieldset_was_defined_in_ancestor
+        assert_equal(BogusModel.process_fields(:one), @fields)
+      end
+      should "return the fieldset of the child when it was defined in the child and the ancestor" do
+        BogusModel.sencha_fieldset :fieldset_was_defined_in_both, [:one]
+        BogusModelChild.sencha_fieldset :fieldset_was_defined_in_both, [:two]
+        @fields = BogusModelChild.sencha_get_fields_for_fieldset :fieldset_was_defined_in_both
+        assert_equal(BogusModel.process_fields(:two), @fields)
+      end
+    end
+  end
+
+  protected
+  def assert_array_has_item array, item_description, &blk
+    assert array.find {|i| blk.call(i) }, "The array #{array.inspect} should #{item_description} but it does not"
+  end
+  def assert_array_has_not_item array, item_description, &blk
+    assert !array.find {|i| blk.call(i) }, "The array #{array.inspect} should not #{item_description} but it does"
+  end
+  
+end
+