ooor 2.0.3 → 2.0.4

data/lib/ooor/reflection_ooor.rb

@@ -6,23 +6,29 @@ module Ooor
   module ReflectionOoor # :nodoc:
     extend ActiveSupport::Concern
 
+      def column_for_attribute(name)
+        self.class.columns_hash[name.to_s]
+      end
+
     module ClassMethods
-      def set_columns_hash(view_fields={})
-        reload_fields_definition()
-        @t.columns_hash ||= {}
-        @t.fields.each do |k, field|
-          unless @t.associations_keys.index(k)
-            @t.columns_hash[k] = field.merge({type: to_rails_type(view_fields[k] && view_fields[k]['type'] || field['type'])})
+      def columns_hash(view_fields=nil)
+        if view_fields || !@t.columns_hash
+          view_fields ||= {}
+          reload_fields_definition()
+          @t.columns_hash ||= {}
+          @t.fields.each do |k, field|
+            unless @t.associations_keys.index(k)
+              @t.columns_hash[k] = field.merge({type: to_rails_type(view_fields[k] && view_fields[k]['type'] || field['type'])})
+            end
           end
+          @t.columns_hash
+        else
+          @t.columns_hash
         end
-        @t.columns_hash
-      end
-
-      def column_for_attribute(name)
-        columns_hash[name.to_s]
       end
 
       def create_reflection(name)
+        reload_fields_definition()
         options = {}
         if many2one_associations.keys.include?(name)
           macro = :belongs_to
@@ -86,6 +92,25 @@ module Ooor
         @klass ||= connection.class_name_from_model_key(class_name).constantize
       end
 
+      def initialize(macro, name, options, active_record)
+        super
+        @collection = macro.in?([:has_many, :has_and_belongs_to_many])
+      end
+
+      # Returns a new, unsaved instance of the associated class. +options+ will
+      # be passed to the class's constructor.
+      def build_association(*options, &block)
+        klass.new(*options, &block)
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        @collection
+      end
+
+
     end
 
   end

data/lib/ooor/relation.rb

@@ -14,6 +14,7 @@ module Ooor
                   :select_values, :group_values, :order_values, :reorder_flag, :joins_values, :where_values, :having_values,
                   :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value, :from_value, :page_value, :per_value
     alias :loaded? :loaded
+    alias :model :klass
 
     def build_where(opts, other = [])#TODO OpenERP domain is more than just the intersection of restrictions
       case opts
@@ -54,14 +55,14 @@ module Ooor
     
     def order(*args)
       relation = clone
-      relation.order_values += args.flatten unless args.blank?
+      relation.order_values += args.flatten unless args.blank? || args[0] == false
       relation
     end
     
-    def count(column_name = nil, options = {})
-      column_name, options = nil, column_name if column_name.is_a?(Hash)
-      calculate(:count, column_name, options)
-    end
+#    def count(column_name = nil, options = {}) #TODO possible to implement?
+#      column_name, options = nil, column_name if column_name.is_a?(Hash)
+#      calculate(:count, column_name, options)
+#    end
     
     def initialize(klass, options={})
       @klass = klass
@@ -78,6 +79,8 @@ module Ooor
       @klass.new(*args, &block)
     end
     
+    alias build new
+
     def reload
       reset
       to_a # force reload
@@ -115,6 +118,14 @@ module Ooor
       args.any? ? apply_finder_options(args.first).to_a : to_a
     end
 
+    def first(*args)
+      limit(1).order('id').all(*args).first
+    end
+
+    def last(*args)
+      limit(1).order('id DESC').all(*args).first
+    end
+
     def to_a
       if loaded?
         @records
@@ -128,26 +139,10 @@ module Ooor
         if @options && @options[:name_search]
           name_search = @klass.name_search(@options[:name_search], where_values, 'ilike', @options[:context], @limit_value)
           @records = name_search.map do |tuple|
-            r = @klass.new({name: tuple[1]}, [])
-            r.id = tuple[0]
-            r #TODO load the fields optionally
+            @klass.new({name: tuple[1]}, []).tap { |r| r.id = tuple[0] } #TODO load the fields optionally
           end
         else
-          if @per_value && @page_value
-            offset = @per_value * @page_value
-            limit = @per_value
-          else
-            offset = @offset_value
-            limit = @limit_value || false
-          end
-          @loaded = true
-          opts = @options.merge({
-              domain: where_values,
-              offset: offset,
-              limit: limit,
-              order: search_order,
-            })
-          @records = @klass.find(:all, opts)
+          load_records_page(search_order)
         end
       end
     end
@@ -156,8 +151,38 @@ module Ooor
       false
     end
     
+    def inspect
+      entries = to_a.take([limit_value, 11].compact.min).map!(&:inspect)
+      entries[10] = '...' if entries.size == 11
+
+      "#<#{self.class.name} [#{entries.join(', ')}]>"
+    end
+
     protected
 
+    def load_records_page(search_order)
+      if @per_value && @page_value
+        offset = @per_value * @page_value
+        limit = @per_value
+      else
+        offset = @offset_value
+        limit = @limit_value || false
+      end
+      @loaded = true
+      opts = @options.merge({
+          domain: where_values,
+          offset: offset,
+          limit: limit,
+          order: search_order,
+        })
+      scope = @options.delete(:ids) || :all
+      if scope == []
+        @records = []
+      else
+        @records = @klass.find(scope, opts)
+      end
+    end
+
     def method_missing(method, *args, &block)
       if Array.method_defined?(method)
         to_a.send(method, *args, &block)

data/lib/ooor/type_casting.rb

@@ -1,5 +1,5 @@
 #    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-2014 Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #    Licensed under the MIT license, see MIT-LICENSE file
 
@@ -8,6 +8,7 @@ module Ooor
     extend ActiveSupport::Concern
     
     OPERATORS = ["=", "!=", "<=", "<", ">", ">=", "=?", "=like", "=ilike", "like", "not like", "ilike", "not ilike", "in", "not in", "child_of"]
+    BLACKLIST = %w[id write_date create_date write_ui create_ui]
   
     module ClassMethods
       
@@ -68,28 +69,8 @@ module Ooor
         elsif request.is_a?(Hash)
           request2 = {}
           request.each do |k, v|
-
-            if k.to_s.end_with?("_attributes")
-              attrs = []
-              if v.is_a?(Hash)
-                v.each do |key, val|
-                  if !val["_destroy"].empty?
-                    attrs << [2, val[:id] || val['id']]
-                  elsif val[:id] || val['id']
-                    attrs << [1, val[:id] || val['id'], cast_request_to_openerp(val)]
-                  else
-                    attrs << [0, 0, cast_request_to_openerp(val)]
-                  end
-                end
-              end
-
-              request2[k.to_s.gsub("_attributes", "")] = attrs
-            else
-              request2[k] = cast_request_to_openerp(v)
-            end
+            request2[k] = cast_request_to_openerp(v)
           end
-          request2
-
         else
           value_to_openerp(request)
         end
@@ -120,72 +101,124 @@ module Ooor
       
     end
     
-    def to_openerp_hash(attributes=@attributes, associations=@associations)
-      associations = cast_relations_to_openerp(associations)
-      blacklist = %w[id write_date create_date write_ui create_ui]
-      r = {}
-      attributes.reject {|k, v| blacklist.index(k)}.merge(associations).each do |k, v|
-        if k.end_with?("_id") && !self.class.associations_keys.index(k) && self.class.associations_keys.index(k.gsub(/_id$/, ""))
-          r[k.gsub(/_id$/, "")] = v && v.to_i || v
-        else
-          r[k] = v
-        end
+    def sanitize_attribute(skey, value)
+      type = self.class.fields[skey]['type']
+      if type == 'boolean' && value == 1 || value == "1"
+        true
+      elsif type == 'boolean'&& value == 0 || value == "0"
+        false
+      elsif value == false and type != 'boolean'
+        nil
+      else
+        value
+      end
+    end
+
+    def sanitize_association(skey, value)
+      if value.is_a?(Ooor::Base) || value.is_a?(Array) && value.all? {|i| i.is_a?(Ooor::Base)}
+        value
+      elsif value.is_a?(Array) && !self.class.many2one_associations.keys.index(skey)
+        value.reject {|i| i == ''}.map {|i| i.is_a?(String) ? i.to_i : i}
+      elsif value.is_a?(String)
+        sanitize_associatio_as_string(skey, value)
+      else
+        value
       end
-      r
+    end
+
+    def sanitize_associatio_as_string(skey, value)
+      if self.class.polymorphic_m2o_associations.has_key?(skey)
+        value
+      elsif self.class.many2one_associations.has_key?(skey)
+        sanitize_m2o_association(value)
+      else
+        value.split(",").map {|i| i.to_i}
+      end
+    end
+
+    def sanitize_m2o_association(value)
+      if value.blank? || value == "0"
+        false
+      else
+        value.to_i
+      end
+    end
+
+    def to_openerp_hash
+      attributes, associations = get_changed_values
+      associations = cast_associations_to_openerp(associations)
+      attributes.merge(associations)
     end
     
-    def cast_relations_to_openerp(associations=@associations)
-      associations2 = {}
-      associations.each do |k, v|
-        if k.match(/_ids$/) && !self.class.associations_keys.index(k) && self.class.associations_keys.index(rel = k.gsub(/_ids$/, ""))
-          if v.is_a? Array
-           v.reject! {|i| i == ''}.map! {|i| i.to_i}
-          end
-          associations2[rel] = v
-        elsif v.is_a?(Array) && (v.size == 0 or v[1].is_a?(String)) #reject non assigned many2one or empty list
-         next
-        else
-          if k.end_with?("_ids") && v.is_a?(String)
-            v = v.split(",").map{|i| i.to_i}
-          end
-          associations2[k] = v
+    def get_changed_values
+      attributes = {}
+      associations = {}
+
+      changed.each do |k|
+        if self.class.associations_keys.index(k)
+          associations[k] = @associations[k]#changes[k][1]
+        elsif self.class.fields.has_key?(k)
+          attributes[k]= @attributes[k]
+        elsif !BLACKLIST.index(k)
+          attributes[k] = changes[k][1]
         end
       end
+      return attributes, associations
+    end
 
-      associations2.each do |k, v| #see OpenERP awkward associations API
-        #already casted, possibly before server error!
-        next if (v.is_a?(Array) && v.size == 1 && v[0].is_a?(Array)) \
-                || self.class.many2one_associations[k] \
-                || !v.is_a?(Array)
-        new_rel = self.cast_relation(k, v, self.class.one2many_associations, self.class.many2many_associations)
-        if new_rel #matches a known o2m or m2m
-          associations2[k] = new_rel
-        else
-          self.class.many2one_associations.each do |k2, field| #try to cast the association to an inherited o2m or m2m:
-            linked_class = self.class.const_get(field['relation'])
-            new_rel = self.cast_relation(k, v, linked_class.one2many_associations, linked_class.many2many_associations)
-            associations2[k] = new_rel and break if new_rel
-          end
-        end
+    def cast_associations_to_openerp(associations=@associations)
+      associations.each do |k, v|
+        associations[k] = self.cast_association(k, v)
+      end
+    end
+
+    # talk OpenERP cryptic associations API
+    def cast_association(k, v)
+      if self.class.one2many_associations[k]
+        cast_o2m_assocation(v)
+      elsif self.class.many2many_associations[k]
+        [[6, false, (v || []).map {|i| i.is_a?(Base) ? i.id : i}]]
+      elsif self.class.many2one_associations[k]
+        cast_m2o_association(v)
       end
-      associations2
     end
 
-    def cast_relation(k, v, one2many_associations, many2many_associations)
-      if one2many_associations[k]
-        return v.collect do |value|
-          if value.is_a?(Base) #on the fly creation as in the GTK client
+    def cast_o2m_assocation(v)
+      if v.is_a?(Hash)
+        cast_o2m_nested_attributes(v)
+      else
+        v.collect do |value|
+          if value.is_a?(Base)
             [0, 0, value.to_openerp_hash]
+          elsif value.is_a?(Hash)
+            [0, 0, value]
           else
-            if value.is_a?(Hash)
-              [0, 0, value]
-            else
-              [1, value, {}]
-            end
+            [1, value, {}]
           end
         end
-      elsif many2many_associations[k]
-        return v = [[6, 0, v]]
+      end
+    end
+
+    def cast_o2m_nested_attributes(v)
+      v.keys.collect do |key|
+        val = v[key]
+        if !val["_destroy"].blank?
+          [2, val[:id].to_i || val['id']]
+        elsif val[:id] || val['id']
+          [1, val[:id].to_i || val['id'], val]
+        else
+          [0, 0, val]
+        end
+      end
+    end
+
+    def cast_m2o_association(v)
+      if v.is_a?(Array)
+        v[0]
+      elsif v.is_a?(Base)
+        v.id
+      else
+        v
       end
     end
  

data/lib/ooor/version.rb

@@ -1,7 +1,7 @@
 module Ooor
   MAJOR = 2
   MINOR = 0
-  TINY  = 3
+  TINY  = 4
   PRE   = nil
 
   VERSION = [MAJOR, MINOR, TINY].compact.join('.')

data/spec/ooor_spec.rb

@@ -42,15 +42,7 @@ describe Ooor do
     end
 
     it "should be able to load a profile" do
-      module_ids = IrModuleModule.search(['name','=', 'sale']) + IrModuleModule.search(['name','=', 'account_voucher']) + IrModuleModule.search(['name','=', 'sale_stock'])
-      module_ids.each do |accounting_module_id|
-        mod = IrModuleModule.find(accounting_module_id) 
-        unless mod.state == "installed"
-          mod.button_install
-        end
-      end
-      wizard = BaseModuleUpgrade.create
-      wizard.upgrade_module
+      IrModuleModule.install_modules(['sale', 'account_voucher'])
       @ooor.load_models
       @ooor.models.keys.should_not be_empty
     end
@@ -68,7 +60,7 @@ describe Ooor do
   describe "Do operations on configured database" do
     before(:all) do
       @ooor = Ooor.new(:url => @url, :username => @username, :password => @password, :database => @database,
-        :models => ['res.user', 'res.partner', 'product.product',  'sale.order', 'account.invoice', 'product.category', 'stock.move', 'ir.ui.menu', 'ir.module.module'])
+        :models => ['res.user', 'res.partner', 'product.product',  'sale.order', 'account.invoice', 'product.category', 'ir.cron', 'ir.ui.menu', 'ir.module.module'])
     end
 
     describe "Finders operations" do
@@ -173,8 +165,16 @@ describe Ooor do
       it "should cast dates properly from OpenERP to Ruby" do
         o = SaleOrder.find(1)
         o.date_order.should be_kind_of(Date)
-        m = StockMove.find(1)
-        m.date.should be_kind_of(DateTime)
+        c = IrCron.find(1)
+        c.nextcall.should be_kind_of(DateTime)
+      end
+
+      it "should not load false values in empty strings (for HTML forms)" do
+        ResPartner.first.phone.should be_nil
+      end
+
+      it "should map OpenERP types to Rails types" do
+        (%w[char binary many2one one2many many2many]).each { |t| Ooor::Base.to_rails_type(t).should be_kind_of(Symbol) }
       end
 
       it "should be able to call any Class method" do
@@ -218,6 +218,12 @@ describe Ooor do
         p.name.should == "testProduct1"
       end
 
+      it "should properly change value when m2o is set" do
+        p = ProductProduct.find(:first)
+        p.categ_id = 7
+        p.categ_id.id.should == 7
+      end
+
       it "should be able to create a product" do
         p = ProductProduct.create(:name => "testProduct1", :categ_id => 1)
         ProductProduct.find(p.id).categ_id.id.should == 1
@@ -235,12 +241,12 @@ describe Ooor do
         u.save
         u.id.should_not be_nil
         u.name.should == "joe"
-        u.destroy
+        u.destroy.should be_kind_of(ResUsers)
       end
 
       it "should be able to create an order" do
-        o = SaleOrder.create(:partner_id => ResPartner.search([['name', 'ilike', 'Agrolait']])[0], 
-          :partner_order_id => 1, :partner_invoice_id => 1, :partner_shipping_id => 1, :pricelist_id => 1)
+        p_id = ResPartner.search([['name', 'ilike', 'Agrolait']])[0]
+        o = SaleOrder.create(partner_id: p_id, partner_invoice_id: p_id, partner_shipping_id: p_id, pricelist_id: 1)
         o.id.should be_kind_of(Integer)
       end
 
@@ -268,7 +274,7 @@ describe Ooor do
 
       it "should use default fields on creation" do
         p = ProductProduct.new
-        p.sale_delay.should be_kind_of(Integer)
+        p.categ_id.should be_kind_of(ProductCategory)
       end
 
       it "should skipped inherited default fields properly, for instance at product variant creation" do
@@ -335,16 +341,44 @@ describe Ooor do
         p.taxes_id_ids.should be_kind_of(Array)
       end
 
-      it "should support Rails nested attributes" do
+      it "should support Rails nested attributes methods" do
         so = SaleOrder.find :first
         so.respond_to?(:order_line_attributes).should be_true
         so.respond_to?(:order_line_attributes=).should be_true
       end
 
+      it "should support CRUD on o2m via nested attributes" do
+        p = ProductProduct.create(name:'Ooor product with packages')
+        p.packaging_attributes = {'1' => {name: 'pack1'}, '2' => {name: 'pack2'}}
+        p.save
+        p = ProductProduct.find p.id
+        pack1 = p.packaging[0]
+        pack2 = p.packaging[1]
+        pack2.name.should == 'pack2'
+        p.packaging_attributes = {'1' => {name: 'pack1', '_destroy'=> true, id: pack1.id}, '2' => {name: 'pack2_modified', id: pack2.id}}
+        p.save
+        p.packaging.size.should == 1
+        p.packaging[0].name.should == 'pack2_modified'
+      end
+
       it "should be able to call build upon a o2m association" do
         so = SaleOrder.find :first
         so.order_line.build().should be_kind_of(SaleOrderLine)
       end
+
+      it "should recast string m2o string id to an integer (it happens in forms)" do
+        uom_id = @ooor.const_get('product.uom').search()[0]
+        p = ProductProduct.new(name: "z recast id", uom_id: uom_id.to_s)
+        p.save
+        p.uom_id.id.should == uom_id
+      end
+
+      it "should recast string m2m string ids to an array of integer (it happens in forms)" do
+        categ_ids = @ooor.const_get('res.partner.category').search()[0..1]
+        p = ResPartner.new(name: "z recast ids", category_id: categ_ids.join(','))
+        p.save
+        p.category_id.map{|c| c.id}.should == categ_ids
+      end
     end
 
     describe "Fields validations" do
@@ -354,6 +388,28 @@ describe Ooor do
         p.save.should == false
         p.errors.messages[:ean13].should_not be_nil 
       end
+
+      it "should list all available fields when you call an invalid field" do
+        expect { ProductProduct.find(1).unexisting_field_or_method }.to raise_error(Ooor::UnknownAttributeOrAssociationError, /AVAILABLE FIELDS/)
+      end
+    end
+
+    describe "Life cycle Callbacks" do
+      include Ooor
+
+      it "should call customized before_save callback" do
+        expect do
+          Ooor.xtend('ir.ui.menu') do
+            before_save do
+              raise 'before_save_called'
+            end
+          end
+
+          with_ooor_session username: 'demo', password: 'demo' do |session|
+            session['ir.ui.menu'].first.save
+          end
+        end.to raise_error(RuntimeError, /before_save_called/)
+      end
     end
 
     describe "ARel emulation" do
@@ -361,13 +417,37 @@ describe Ooor do
         ResUsers.all.should be_kind_of(Array)
       end
 
+      it "should have a 'first' method" do
+        ResUsers.first.id.should == 1
+      end
+
+      it "should have a 'last' method" do
+        ResUsers.last.id.should == ResUsers.find(:last).id
+      end
+
       it "should be ready for Kaminari pagination via ARel scoping" do
         num = 2
         default_per_page = 5
-        collection = ProductProduct.limit(default_per_page).offset(default_per_page * ([num.to_i, 1].max - 1))
+        collection = ProductProduct.where(active: true).limit(default_per_page).offset(default_per_page * ([num.to_i, 1].max - 1)).order("categ_id")
         collection.all(fields:['name']).should be_kind_of(Array)
         collection.all.size.should == 5
       end
+
+      it "should support name_search in ARel (used in association widgets with Ooorest)" do
+        Ooor.default_session.const_get('product.category').all(name_search: 'Com')[0].name.should == "All products / Saleable / Components"
+      end
+
+      it "should be possible to invoke batch methods on relations" do
+        Ooor.default_session.const_get('product.product').where(type: 'service').write(type: 'service').should == true
+      end
+
+      it "should forward Array methods to the Array" do
+        Ooor.default_session.const_get('product.product').where(type: 'service').size.should be_kind_of(Integer)
+      end
+
+      it "should support reloading relation" do
+        Ooor.default_session.const_get('product.product').where(type: 'service').reload.all.should be_kind_of(Array)
+      end
     end
 
     describe "report support" do
@@ -383,12 +463,12 @@ describe Ooor do
         inv.state.should == "draft"
         inv.wkf_action('invoice_open')
         inv.state.should == "open"
-        voucher = AccountVoucher.new({:amount=>inv.amount_total, :type=>"receipt", :partner_id => inv.partner_id.id}, {"default_amount"=>inv.amount_total, "invoice_id"=>inv.id})
-        voucher.on_change("onchange_partner_id", [], :partner_id, inv.partner_id.id, AccountJournal.find('account.bank_journal').id, 0.0, 1, 'receipt', false)
+        voucher = @ooor.const_get('account.voucher').new({:amount=>inv.amount_total, :type=>"receipt", :partner_id => inv.partner_id.id}, {"default_amount"=>inv.amount_total, "invoice_id"=>inv.id})
+        voucher.on_change("onchange_partner_id", [], :partner_id, inv.partner_id.id, @ooor.const_get('account.journal').find('account.bank_journal').id, 0.0, 1, 'receipt', false)
         voucher.save
-        voucher.wkf_action 'proforma_voucher'
+#        voucher.wkf_action 'proforma_voucher'
         
-        inv.reload
+#        inv.reload
       end
 
       it "should be possible to call resource actions and workflow actions" do
@@ -443,11 +523,19 @@ describe Ooor do
       Ooor.session_handler.reset!() # alias isn't part of the connection spec, we don't want connectio reuse here
       with_ooor_session(:url => @url, :database => @database, :username => @username, :password => @password, :aliases => {en_US: {products: 'product.product'}}, :param_keys => {'product.product' => 'name'}) do |session|
         session['products'].search().should be_kind_of(Array)
+        session['product.product'].alias.should == 'products'
       end
     end
 
-    it "should find by permalink" do
+    it "should have a to_param method" do
       Ooor.session_handler.reset!() # alias isn't part of the connection spec, we don't want connectio reuse here
+      with_ooor_session(:url => @url, :database => @database, :username => @username, :password => @password, :aliases => {en_US: {products: 'product.product'}}, :param_keys => {'product.product' => 'name'}) do |session|
+        session['product.product'].find(:first).to_param.should be_kind_of(String)
+      end
+    end
+
+    it "should find by permalink" do
+      Ooor.session_handler.reset!() # alias isn't part of the connection spec, we don't want connection reuse here
       with_ooor_session(:url => @url, :database => @database, :username => @username, :password => @password, :aliases => {en_US: {products: 'product.product'}}, :param_keys => {'product.product' => 'name'}) do |session|
         lang = Ooor::Locale.to_erp_locale('en')
         session['products'].find_by_permalink('Service', context: {'lang' => lang}, fields: ['name']).should be_kind_of(Ooor::Base)
@@ -455,24 +543,33 @@ describe Ooor do
     end
   end
 
-  describe "Ative-Record like Reflection" do
+  describe "Ative-Record like Reflections" do
     before(:all) do
-      @ooor = Ooor.new(:url => @url, :username => @username, :password => @password, :database => @database, :models => ['product.product'], :reload => true)
+      @ooor = Ooor.new(:url => @url, :username => @username, :password => @password, :database => @database, :models => ['product.product', 'product.category'], :reload => true)
     end
 
-    it "should test correct class attributes" do
+    it "should test correct class attributes of ActiveRecord Reflection" do
       object = Ooor::Reflection::AssociationReflection.new(:test, :people, {}, nil)
       object.name.should == :people
       object.macro.should == :test
       object.options.should == {}
     end
 
-    it "should test correct class name matching wit class name" do
+    it "should test correct class name matching with class name" do
       object = Ooor::Reflection::AssociationReflection.new(:test, 'product_product', {class_name: 'product.product'}, nil)
       object.connection = @ooor
       object.klass.should == ProductProduct
     end
 
+    it "should reflect on association (used in simple_form, cocoon...)" do
+      reflection = ProductProduct.reflect_on_association(:categ_id)
+      reflection.should be_kind_of(Ooor::Reflection::AssociationReflection)
+      reflection.klass.should == ProductCategory
+    end
+
+    it "should support column_for_attribute (used by simple_form)" do
+      @ooor.const_get('ir.cron').find(:first).column_for_attribute('name')[:type].should == :string
+    end
   end
 
   describe "Multi-instance and class name scoping" do
@@ -510,6 +607,15 @@ describe Ooor do
         session['res.users'].search().should be_kind_of(Array)
       end
     end
+
+    it "should recover from expired sessions" do
+      with_ooor_session(:url => @url, :username => @username, :password => @password, :database => @database) do |session|
+        user_obj = session['res.users']
+        user_obj.search().should be_kind_of(Array)
+        session.web_session[:session_id] = 'invalid'
+        user_obj.search().should be_kind_of(Array)
+      end
+    end
   end