lore 0.4.8 → 0.9.2

data/test/tc_filter.rb

@@ -1,37 +0,0 @@
-
-require 'test/unit'
-require './test/model'
-
-module Lore
-module Unit
-
-  class TC_Filter < Test::Unit::TestCase
-    
-    public
-
-    def setup
-    end
-    
-    def teardown
-    end
-
-    def test_simple
-   
-      m1 = Manufacturer.create( :name => 'Dodge' )
-      ct1 = Car_Type.create( :name => 'VPenis' )
-      
-      c1 = Car.create(
-                      :manuf_id => m1.manuf_id,
-                      :name => 'Viper', 
-                      :num_seats => 2, 
-                      :maxspeed => 230, 
-                      :num_doors => 3, 
-                      :car_type_id => ct1.car_type_id
-                     )
-                      
-    end
-
-  end
-  
-end # module
-end # module

data/test/tc_form.rb

@@ -1,32 +0,0 @@
-
-require 'test/unit'
-require 'lore/gui/form_generator'
-require './test/model'
-
-module Lore
-module Unit
-
-  class TC_Form < Test::Unit::TestCase
-    
-  public
-
-    def setup
-      for count in (1..5) do
-        Manufacturer.create( :name => 'manufacturer_' << count.to_s)
-        Car_Type.create( :name => 'car_type_' << count.to_s)
-      end
-    end
-    
-    def teardown
-      Manufacturer.delete_all
-      Car_Type.delete_all
-    end
-
-    def test_simple
-      form = GUI::Form_Generator.new(Car).generate
-    end
-
-  end
-  
-end # module
-end # module

data/test/tc_model.rb

@@ -1,140 +0,0 @@
-
-require 'test/unit'
-require './test/model'
-require 'lore/symbol'
-
-module Lore
-module Unit
-
-
-  class TC_Model < Test::Unit::TestCase
-
-    def setup
-    end
-
-    def teardown
-    end
-
-    def test_basic_attribs
-
-      assert(Car.table_name == 'public.car', 'Table name incorrect')
-      assert(Vehicle.table_name == 'public.vehicle', 'Table name incorrect')
-
-      assert(Car.get_is_a.has_key?(Vehicle.table_name))
-      assert(!(Car.get_is_a.has_key?(Car_Type.table_name)))
-      assert(Car.get_joins.has_key?(Car_Type.table_name))
-
-      assert(Car.get_has_a_klasses['public.vehicle.manuf_id'] == Manufacturer)
-
-      attribs = Car.get_attributes
-      types = Car.get_attribute_types
-      assert(attribs.has_key?('public.vehicle'))
-      assert(attribs.has_key?('public.car'))
-      assert(types.has_key?('public.vehicle'))
-      assert(types.has_key?('public.car'))
-    end
-
-    def test_aggregates
-      is_a_hierarchy = Car.get_is_a
-      # Car_Type is an aggregate, it must not be listed 
-      # as base table: 
-      assert(!is_a_hierarchy.keys_flat.include?('public.car_type'))
-    end
-    
-    def test_create
-      v = Vehicle.create(:name => 'Async', :maxspeed => 100, 
-                         :num_seats => 2, 
-                         :manuf_id => 0)
-
-      car_type = Car_Type.create(:name => 'Basic_Type')
-      assert_equal(car_type.name, 'Basic_Type')
-      v.delete
-      car_type.commit
-      ct = Car_Type.load(:car_type_id => car_type.car_type_id)
-      assert_equal(ct.name, 'Basic_Type')
-      ct.delete
-    end
-
-    def test_joined_attributes_order
-
-      num_loops = 25
-
-      Vehicle_Owner.delete_all
-      owners = []
-      vehicles = []
-      for i in 0...num_loops do
-        o = Owner.create(:name => "owner_#{i}")
-        v = Vehicle.create(:name => 'Async', :maxspeed => 10*i, 
-                           :num_seats => i, 
-                           :manuf_id => i)
-        j = Vehicle_Owner.create(:vehicle_id => v.id, :owner_id => o.id)
-        owners << o
-        vehicles << v
-      end
-      vo = Vehicle_Owner.find(num_loops).sort_by(:vehicle_id, :asc).entities
-      for i in 0...vo.length do
-        assert_equal(owners[i].id, vo[i].owner_id)
-        assert_equal(vehicles[i].id, vo[i].vehicle_id)
-      end
-
-      join = Vehicle_Owner.select { |vo| 
-        vo.join(Vehicle).on(Vehicle_Owner.vehicle_id == Vehicle.id) { |v|
-          v.join(Owner).on(Owner.owner_id == Vehicle_Owner.owner_id) { |o|
-            o.where(true)
-            o.limit(num_loops)
-            o.order_by(:vehicle_id, :asc)
-          }
-        }
-      }
-      assert_equal(num_loops, join.length)
-
-      for i in 0...join.length do
-        fulljoin = join[i]
-        assert_equal(owners[i].id, fulljoin.owner_id)
-        assert_equal(vehicles[i].id, fulljoin.vehicle_id)
-      end
-
-      join_ids = Vehicle_Owner.select_values(:vehicle_id) { |vo| 
-        vo.join(Vehicle).on(Vehicle_Owner.vehicle_id == Vehicle.id) { |v|
-          v.join(Owner).on(Owner.owner_id == Vehicle_Owner.owner_id) { |o|
-            o.where(true)
-            o.limit(num_loops)
-            o.order_by(:vehicle_id, :asc)
-          }
-        }
-      }
-      for i in 0...join_ids.length do
-        assert_equal(vehicles[i].id, join_ids[i])
-      end
-
-    end
-
-    def test_create_with_inheritance
-      car_type = Car_Type.create(:name => 'Temp')
-      inst_attribs =  { 
-        :num_seats => 5, :num_doors => 5, 
-        :maxspeed => 180, :name => 'Basic', 
-        :owner_id => 0, :manuf_id => 0, 
-        :car_type_id => car_type.car_type_id
-      }
-      car = Car.create(inst_attribs)
-
-      car.name = 'Changed Name'
-      assert_equal(car.name, 'Changed Name')
-      # As Car is not derived from Car_Type but aggregating 
-      # it only, Car.name and Car_Type.name are not conflicting! 
-      # Updating a Car instance must not affect its aggregated 
-      # instances. 
-      assert_equal(car_type.name, 'Temp')
-      assert(car.touched?)
-      car.commit
-      assert(!car.touched?)
-
-      car.delete
-      car_type.delete
-    end
-
-  end
-
-end
-end

data/test/tc_prepare.rb

@@ -1,44 +0,0 @@
-
-require 'test/unit'
-
-require('./test/model')
-
-module Lore
-module Unit
-
-  Car.prepare(:by_id, Lore::Type.integer) { |a|
-    a.where(Car.id == Lore::Clause.new('$1'))
-  }
-
-  class TC_Prepare < Test::Unit::TestCase
-
-    def setup
-      @org_units = Hash.new
-      @org_units[:m] = Manufacturer.create( :name => 'PrepManufacturer' )
-      @org_units[:t] = Car_Type.create( :name => 'PrepType' )
-      @org_units[:c] = Car.create(
-        :manuf_id => @org_units[:m].manuf_id, 
-        :name => 'SLK', 
-        :num_seats => 2, 
-        :maxspeed => 180, 
-        :num_doors => 3, 
-        :car_type_id => @org_units[:t].car_type_id
-      )
-      assert(@org_units[:c].instance_of?(Car))
-    end
-
-    def teardown
-      @org_units.each_pair { |id,instance|
-        instance.delete
-      }
-    end
-
-    def test_basic
-      co = Car.load(:id => @org_units[:c].id)
-      cp = Car.by_id(@org_units[:c].id).first
-      assert_equal(co, cp)
-    end
-
-  end
-end
-end

data/test/tc_refined_query.rb

@@ -1,88 +0,0 @@
-
-require 'test/unit'
-require('./test/model')
-require('lore/clause')
-
-module Lore
-module Unit
-
-
-  class TC_Refined_Query < Test::Unit::TestCase
-
-    def setup
-      Car.delete_all
-
-      Car.create(
-                 :manuf_id => 1,
-                 :name => 'SLK', 
-                 :num_seats => 2, 
-                 :maxspeed => 180, 
-                 :num_doors => 3, 
-                 :car_type_id => 1
-                 )
-      Car.create(
-                 :manuf_id => 1,
-                 :name => 'SLK2', 
-                 :num_seats => 2, 
-                 :maxspeed => 180, 
-                 :num_doors => 3, 
-                 :car_type_id => 1
-                 ) 
-    end
-
-    def teardown
-      Car.delete_all
-    end
-
-    def test_select_value
-      manuf = Manufacturer.create( :name => 'Fiat' )
-      ct = Car_Type.create( :name => 'Transporter' )
-      c1 = Car.create(
-        :manuf_id => manuf.manuf_id,
-        :name => 'test_refined_1', 
-        :num_seats => 2, 
-        :maxspeed => 180, 
-        :num_doors => 3, 
-        :car_type_id => ct.car_type_id
-      )
-      c2 = Car.create(
-        :manuf_id => manuf.manuf_id,
-        :name => 'test_refined_2', 
-        :num_seats => 2, 
-        :maxspeed => 180, 
-        :num_doors => 3, 
-        :car_type_id => ct.car_type_id
-      )
-      u1 = Car.all(Car.name).with(Car.manuf_id == manuf.manuf_id).entities
-      assert(u1.include?('test_refined_1'))
-      assert(u1.include?('test_refined_2'))
-    end
-
-    def test_select_max
-      max = Car.value_of.max(Car.id).to_i
-    end
-
-    def test_select_sum
-      type = Car_Type.create(:name => 'temp')
-      7.times { 
-       Car.create(:manuf_id => 123, 
-                  :num_seats => 5, 
-                  :owner_id => 0, 
-                  :name => 'SumMe', 
-                  :car_type_id => type.car_type_id, 
-                  :maxspeed => 120, 
-                  :num_doors => 3)
-
-      }
-      sum = Car.value_of.sum(Car.num_seats).with(Car.manuf_id == 123).to_i
-    end
-
-    def test_inner_select
-      inner = Manufacturer.all(Manufacturer.manuf_id).with(Manufacturer.name == 'Mercedes')
-      u1 = Car.find(1).with(Car.manuf_id.in(inner)).entity
-    end
-
-  end
-
-end
-end

data/test/tc_table_accessor.rb

@@ -1,267 +0,0 @@
-
-require 'test/unit'
-require 'lore/table_accessor'
-
-module Lore
-module Unit
-
-  class TC_Table_Accessor < Test::Unit::TestCase
-
-    def setup
-
-      Manufacturer.delete_all
-      Vehicle.delete_all
-      Car_Type.delete_all
-      Car.delete_all
-      Bike.delete_all
-      Owner.delete_all
-      Garage.delete_all
-      Trailer.delete_all
-      # Fill Lore: 
-      $units = Hash.new
-      $units[:manufacturer] = Array.new
-      $units[:car] = Array.new
-      $units[:car_type] = Array.new
-      $units[:bike] = Array.new
-      $units[:garage] = Array.new
-      $units[:owner] = Array.new
-
-      m1 = Manufacturer.create( :name => 'BMW' )
-      assert(m1.name == 'BMW')
-      $units[:manufacturer] << m1
-      m2 = Manufacturer.create( :name => 'Mercedes' )
-      assert(m2.name == 'Mercedes')
-      $units[:manufacturer] << m2
-      m3 = Manufacturer.create( :name => 'Audi' )
-      assert(m3.name == 'Audi')
-      $units[:manufacturer] << m3
-    
-      ct1 = Car_Type.create( :name => 'Limousine' )
-      $units[:car_type] << ct1
-      ct2 = Car_Type.create( :name => 'SUV' )
-      $units[:car_type] << ct2
-      ct3 = Car_Type.create( :name => 'Cabrio' )
-      $units[:car_type] << ct3
-      ct4 = Car_Type.create( :name => 'Boxter' )
-      $units[:car_type] << ct4
-      
-      c1 = Car.create(
-        :manuf_id => m2.manuf_id,
-        :name => 'SLK', 
-        :num_seats => 2, 
-        :maxspeed => 180, 
-        :num_doors => 3, 
-        :car_type_id => ct3.car_type_id
-      )
-      $units[:car] << c1
-
-      o1 = Owner.create(:name => 'owner_1')
-      $units[:owner] << o1
-
-    end
-
-    def teardown
-    end
-
-    def test_custom_join
-      
-      # Do not expand anything
-      o1 = Owner.select { |o|
-        o.join(Vehicle_Owner).using(:owner_id) { |vo|
-          vo.join(Vehicle).on(Vehicle_Owner.vehicle_id == Vehicle.id) { |v|
-            v.where true
-          }
-        }
-      }
-      # Expand Car by Vehicle automatically (Car.vehicle_id)
-      Car.select { |c|
-        c.join(Vehicle_Owner).on(Car.vehicle_id == Vehicle_Owner.vehicle_id) { |vo|
-          vo.join(Owner).on(Vehicle_Owner.owner_id == Owner.owner_id) { |o|
-            o.where true
-          }
-        }
-      }
-      # Expand Car by Vehicle automatically in a nested join
-      Owner.select { |o|
-        o.join(Vehicle_Owner).on(Vehicle_Owner.owner_id == Owner.owner_id) { |vo|
-          vo.join(Car).on(Car.vehicle_id == Vehicle_Owner.vehicle_id) { |c|
-            c.where true
-          }
-        }
-      }
-
-    end 
-
-    def test_ignore_params
-      Car_Type.create( :name => 'Foo', :ignore => 'these', :params => 'please' )
-    end
-
-    def test_validation
-
-      validation_failed = false
-      begin
-        failing_unit = Car_Type.create( :name => 'Van#2' ) # special chars
-      rescue Lore::Exception::Invalid_Klass_Parameters => ikp
-        validation_failed = true
-      end
-      assert(validation_failed, 'Invalid parameter passed validation')
-
-      validation_failed = false
-      begin
-        failing_unit = Car_Type.create( :name => 'Li' ) # too short
-      rescue Lore::Exception::Invalid_Klass_Parameters => ikp
-        validation_failed = true        
-      end
-      assert(validation_failed, 'Invalid parameter passed validation')
-
-      # Test if validation works for inherited constraints: 
-      validation_failed = false
-      begin
-        Car.create(
-                   :manuf_id => $units[:manufacturer].first.manuf_id, 
-                   :name => 'SLK! this will fail pass thanks to filtering', 
-                   :num_seats => 2, 
-                   :maxspeed => 180, 
-                   :num_doors => 3, 
-                   :car_type_id => $units[:car_type].first.car_type_id
-                  )
-      rescue Lore::Exception::Invalid_Klass_Parameters => ikp
-        validation_failed = true
-      end
-      assert(!validation_failed, 'Invalid parameter passed validation')
-
-    end
-
-    def test_select_variants
-
-      car = $units[:car][0]
-      car_id = car.id
-
-      s1 = Car.select { |c|
-        c.where(Car.id == car_id)
-        c.limit(1)
-      }.first
-
-      s2 = Car.load(:id => car_id)
-      s3 = Car.find(1).with(Car.id == car_id).entity
-      s4 = Car.all_with(Car.id == car_id).entity
-
-      assert(s1 == s2)
-      assert(s1 == s3)
-      assert(s1 == s4)
-
-    end
-
-    def test_aggregation_on_joined_models
-      t = Trailer.create(:car_id => Car.create(:name => 'TrailerCar',
-                                               :manuf_id => $units[:manufacturer].first.manuf_id, 
-                                               :num_seats => 2, 
-                                               :maxspeed => 120, 
-                                               :num_doors => 4, 
-                                               :car_type_id => $units[:car_type].first.car_type_id).id, 
-                         :maxweight => 4000)
-      tl = Trailer.select { |trailer|
-        trailer.where(trailer.trailer_id == t.trailer_id)
-        trailer.limit 1
-      }.first
-      assert_equal(t, tl)
-    end
-
-    def test_simple_create
-    end
-
-    def test_instance_compairison
-      m1_a = Manufacturer.load({ :manuf_id => $units[:manufacturer][0].manuf_id })
-      m1_b = Manufacturer.load({ :manuf_id => $units[:manufacturer][0].manuf_id })
-      m2   = Manufacturer.load({ :manuf_id => $units[:manufacturer][1].manuf_id })
-      assert(m1_a == m1_a)
-      assert(m1_a == m1_b)
-      assert(m1_a <=> m2)
-
-    end
-
-    def test_simple_load
-      m1  = Manufacturer.load({ :manuf_id => $units[:manufacturer][0].manuf_id })
-      assert(m1 == $units[:manufacturer][0])
-      m2  = Manufacturer.load({ :manuf_id => $units[:manufacturer][1].manuf_id })
-      assert(m2 == $units[:manufacturer][1])
-      ct1 = Car_Type.load({ :car_type_id => $units[:car_type][0].car_type_id })
-      assert(ct1 == $units[:car_type][0])
-      ct2 = Car_Type.load({ :car_type_id => $units[:car_type][1].car_type_id })
-      assert(ct2 == $units[:car_type][1])
-    end
-
-    def test_create_single_inherit
-      m1  = Manufacturer.load({ :manuf_id => $units[:manufacturer][0].manuf_id })
-      m2  = Manufacturer.load({ :manuf_id => $units[:manufacturer][1].manuf_id })
-      ct1 = Car_Type.load({ :car_type_id => $units[:car_type][0].car_type_id })
-      ct2 = Car_Type.load({ :car_type_id => $units[:car_type][1].car_type_id })
-
-      c1 = Car.create(
-        :manuf_id => m1.manuf_id,
-        :name => '325M', 
-        :name => '325M', 
-        :num_seats => 5, 
-        :maxspeed => 180, 
-        :num_doors => 5, 
-        :car_type_id => ct1.car_type_id
-      )
-
-      assert(c1.manuf_id == m1.manuf_id)
-
-      assert_equal(c1[Vehicle.name], '325m')
-      assert_equal(c1[Car_Type.name], 'Limousine')
-      assert_equal(c1.num_seats, '5')
-      assert_equal('180km/h', c1.maxspeed, 'c1.maxspeed is ' << c1.maxspeed)
-      assert_equal(c1.num_doors, '5')
-      assert_equal(c1.car_type_id, ct1.car_type_id)
-
-    end
-
-    def test_inherited_has_a
-      m1  = Manufacturer.load( :manuf_id => $units[:manufacturer][0].manuf_id )
-      assert(m1.name == $units[:manufacturer][0].name)
-      m2  = Manufacturer.load( :manuf_id => $units[:manufacturer][1].manuf_id )
-      assert(m2.name == $units[:manufacturer][1].name)
-      ct1 = Car_Type.load( :car_type_id => $units[:car_type][0].car_type_id )
-      ct2 = Car_Type.load( :car_type_id => $units[:car_type][1].car_type_id )
-
-      c1 = Car.create(
-        :manuf_id => m1.manuf_id,
-        Car.name.to_s => '318i', 
-        :num_seats => 5, 
-        :maxspeed => 180, 
-        :num_doors => 5, 
-        :owner_id => 1,
-        :car_type_id => ct1.car_type_id
-      )
-      c1_s = Car.find(1).with(Car.name == '318i').entity
-      assert_equal(c1.manufacturer_entity, m1)
-      assert_equal(c1.car_type_id, ct1.car_type_id)
-
-      c1.set_manufacturer_entity(m2)
-      c1.commit
-      c1.set_car_type_entity!(ct2)
-
-      assert(c1.manufacturer_entity == m2)
-      assert(c1.car_type_entity == ct2)
-
-      c1_s = Car.find(1).with(Car.name == '318i').entity
-
-      assert(c1_s.manufacturer_entity == m2)
-      assert(c1_s.car_type_entity == ct2)
-
-      assert(!c1_s.nil? && c1_s[Vehicle.name] == '318i')
-
-      c1.delete
-
-    end
-
-    def test_create_multi_inherit
-    end
-
-  end
-
-end
-end
-