qooxview 1.9.9

data/test/qv_entity.rb

@@ -0,0 +1,271 @@
+require 'test/unit'
+require 'benchmark'
+
+$bind = Kernel.binding
+
+class TC_Entity < Test::Unit::TestCase
+  def setup
+    dputs(2) { 'Deleting everything' }
+    Entities.delete_all_data
+
+    dputs(2) { 'Setting up data' }
+    @admin = Persons.create(:first_name => 'admin', :pass => 'super123',
+                            :address => 'cdlf 24', :credit => 10000)
+    Courses.create(:first_name => 'base_1010', :start => '1.10.2010')
+    @base_1011 = Courses.create(:first_name => 'base_1011', :start => '1.11.2010',
+                                :teacher => @admin)
+    @dummies_one = Dummies.create(:first_name => 'one', :phone => '111',
+                                  :no_cache => '123')
+    dputs(2) { 'Finished setting up data' }
+  end
+
+  def teardown
+  end
+
+  def test_create_with_new_id
+    student_id = 2
+    Persons.create(:person_id => student_id, :first_name => 'student')
+    guest_id = Persons.new_id[:person_id]
+    guest = Persons.create(:person_id => guest_id, :first_name => 'guest',
+                           :credit => 1000)
+    assert_equal guest_id, guest.person_id
+    assert_equal 'guest', guest.first_name
+    assert_equal 1000, guest.credit
+
+    guest = Persons.match_by_person_id(guest_id)
+    student = Persons.match_by_person_id(student_id)
+    assert_equal 'guest', guest.first_name
+    assert_equal 'student', student.first_name
+  end
+
+  def test_create_with_double_id
+    admin = Persons.match_by_first_name('admin')
+    student = Persons.create(:person_id => admin.person_id, :first_name => 'duplicate')
+    assert_equal nil, student
+  end
+
+  def test_find_admin
+    admin = Persons.match_by_first_name('admin')
+    assert_nothing_raised do
+      assert_equal 1, admin.person_id
+      assert_equal 'super123', admin.pass
+      assert_equal 'cdlf 24', admin.address
+      assert_equal 10000, admin.credit
+    end
+  end
+
+  def test_save_load
+    Entities.save_all
+    Entities.delete_all_data(true)
+    Entities.load_all
+    test_find_admin
+  end
+
+  def test_double_case
+    dc1 = DoubleCases.create(name: 'dc1')
+    d1 = Doubles.create(name: 'd1', dc: dc1)
+    assert_equal dc1, d1.dc
+    Entities.save_all
+    Entities.delete_all_data(true)
+    Entities.load_all
+
+    dc1 = DoubleCases.match_by_name('dc1')
+    d1 = Doubles.match_by_name('d1')
+    assert_equal dc1, d1.dc
+  end
+
+  def test_getfields
+    assert_equal %w( assistant course_id first_name start end street plz 
+      students teacher tel ).sort.to_s,
+                 Courses.get_field_names.sortk.to_s
+  end
+
+  def test_list
+    assert_equal %w( base_1010 base_1011 ),
+                 Courses.list_first_name
+  end
+
+  def test_value_add_new
+    assert_equal %w( address credit first_name l l_a l_c l_d l_s login_name pass password_plain permissions
+      person_id session_id value1 value2).sort.to_s,
+                 Persons.get_field_names.sortk.to_s
+
+    assert_equal ['list', :l_a, 'l_a', {:list_type => 'array', :list_values => []}],
+                 Persons.blocks[:lists][0].to_a
+    assert_equal ['list', :l_c, 'l_c', {:list_type => 'choice', :list_values => []}],
+                 Persons.blocks[:lists][1].to_a
+    assert_equal ['list', :l_d, 'l_d', {:list_type => 'drop', :list_values => []}],
+                 Persons.blocks[:lists][2].to_a
+    assert_equal ['list', :l_s, 'l_s', {:list_type => 'single', :list_values => []}],
+                 Persons.blocks[:lists][3].to_a
+    assert_equal ['list', :l, 'l', {:list_values => []}],
+                 Persons.blocks[:lists][4].to_a
+  end
+
+  def test_cache_data
+    dputs(2) { 'testing cache data' }
+    assert_equal 'one', @dummies_one.first_name
+    assert_equal '111', @dummies_one.phone
+    assert_equal 'no_cache', @dummies_one.no_cache
+  end
+
+  def test_data_get
+    assert_equal ['admin', 'super123'], @admin.data_get(%w( first_name pass ))
+  end
+
+  def test_value_entity
+    val = Courses.get_value(:teacher)
+    assert_equal 'entity', val.dtype
+    assert_equal 'Persons', val.entity_class
+    assert_equal Entities.Persons, val.eclass
+    val_hash = @base_1011.to_hash
+    assert_equal [1], val_hash[:teacher]
+    assert_equal 'super123', @base_1011.teacher.pass
+    @admin.pass = 'super321'
+    assert_equal 'super321', @base_1011.teacher.pass
+    @base_1011.teacher.pass = 'super111'
+    assert_equal 'super111', @base_1011.teacher.pass
+    assert_equal 'super111', @admin.pass
+  end
+
+  def test_speed_persons
+    require 'rubygems'
+    require 'perftools'
+    PerfTools::CpuProfiler.start('/tmp/profile') do
+      (1..400).each { |p|
+        dputs(1) { "Creating person #{p}" }
+        Courses.create(:first_name => "#{p}", :last_name => "#{p}")
+      }
+    end
+  end
+
+  def test_entity_empty
+    assert_equal 1, @admin.person_id
+    #@base_1011.data_set_hash({:assistant => [1]})
+    empty = Courses.get_value(:assistant).parse([0])
+    assert_equal 0, empty
+  end
+
+  def test_needs
+    assert Need1s.ok
+    assert Need2s.ok
+  end
+
+  def test_values_override
+    @admin.value1 = 10
+    assert_equal 5, @admin.value1
+    assert_equal 20, @admin.value2
+    assert_equal 10, @admin._value1
+  end
+
+  def test_missing_value
+    old = get_config(false, :DPuts, :silent)
+    set_config(true, :DPuts, :silent)
+    @admin.show_error_missing = false
+    assert_raise(NoMethodError) { @admin.value3 }
+    assert_raise(RuntimeError) { @admin._value3 }
+    assert_nothing_raised { @admin._value1 }
+    set_config(old, :DPuts, :silent)
+  end
+
+  def test_create_key
+    assert_equal({}, Persons.keys)
+    Persons.create_key_first_name
+
+    assert_equal({:first_name => {'admin' => 1}}, Persons.keys)
+  end
+
+  def test_match_key
+    Persons.create_key_first_name
+    assert_equal('super123', Persons.match_key_first_name('admin').pass)
+    assert_equal nil, Persons.match_key_first_name('foo')
+
+    foo = Persons.create(:first_name => 'foo', :pass => 'bar')
+    assert_equal('bar', Persons.match_key_first_name('foo').pass)
+    assert Persons.match_key_person_id(foo.id), 'Failed foo.id'
+    assert Persons.match_key_person_id(foo.id.to_s), 'Failed string of foo.id'
+  end
+
+  def test_speed_match
+    dputs(1) { 'Creating 1000 entries' }
+    Persons.save_after_create = false
+    (1..1000).each { |i|
+      Persons.create(:first_name => "name_#{i}", :pass => i)
+    }
+    (1..1).each { |i|
+      dputs(1) { "Benchmarking match - Turn #{i}" }
+      dputs(1) { Benchmark.measure("match_#{i}") {
+        (1..2000).each { |i|
+          Persons.match_by(:first_name, "name_#{i}")
+        }
+      }.to_s
+      }
+    }
+    (1..3).each { |i|
+      dputs(1) { "Benchmarking match_key - Turn #{i}" }
+      dputs(1) { Benchmark.measure("match_key_#{i}") {
+        (1..2000).each { |i|
+          Persons.match_key(:first_name, "name_#{i}")
+        }
+      }.to_s
+      }
+    }
+  end
+
+  def test_list_entity
+    @base_1011.teacher = @admin
+    assert_equal @admin, @base_1011.teacher
+    Entities.save_all
+    Entities.load_all
+    assert_equal @admin, @base_1011.teacher
+
+    course = Courses.create(:first_name => 'foo',
+                            :students => [@admin])
+    course.students = [@admin]
+    assert_equal @admin.to_hash, course.students.first.to_hash
+
+    Entities.save_all
+    Entities.load_all
+
+    course = Courses.find_by_first_name('foo')
+    assert_equal @admin.to_hash, course.students.first.to_hash
+  end
+
+  def test_create_equal
+    p = Persons.create(:value1 => 10)
+    assert_equal 20, p.value2
+  end
+
+  def test_new_id_inc
+    Entities.delete_all_data
+    assert_equal 1, Persons.last_id
+    persons = (1..2).collect { |i| Persons.create(login_name: "test_#{i}") }
+    assert_equal [1, 2], persons.collect { |p| p.person_id }
+    persons.first.delete
+    nperson = Persons.create(login_name: 'test_3')
+    assert_equal 3, nperson.person_id
+
+    Entities.save_all
+    Entities.delete_all_data(true)
+    Entities.load_all
+
+    nperson = Persons.create(login_name: 'test_4')
+    assert_equal 4, nperson.person_id
+  end
+
+  def test_top_class
+    Kernel.eval("class TestTop < Entity\nend", TOPLEVEL_BINDING)
+    klass = Kernel.eval('TestTop')
+    assert 'TestTop', klass.inspect
+  end
+
+  def test_static
+    Courses.static._test = 1
+    assert_equal(1, Courses.static._test)
+    Entities.save_all
+    Entities.delete_all_data(true)
+    assert_equal(nil, Courses.static._test)
+    Entities.load_all
+    assert_equal(1, Courses.static._test)
+  end
+end

data/test/qv_gettext.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'gettext'
+
+class TC_Gettext < Test::Unit::TestCase
+  def setup
+    dputs(0){"setting up"}
+    $name = "gettext"
+    GetText.bindtextdomain( 'gettext', :path => '/tmp' )
+    GetText.bindtextdomain( $name, :path => "po" )
+    GetText.locale = "en"
+    GetText::TextDomainManager.cached = false
+    dputs(0){"getting texts"}
+    @a = GetText._("one")
+    @b = GetText._("two")
+  end
+
+  def teardown
+  end
+
+  def tes_domain
+    GetText.locale = "fr"
+    assert_equal "un", GetText._("one")
+    assert_equal "one", @a
+    assert_equal "deux", GetText._("two")
+    assert_equal "two", @b
+    assert_equal "hello", GetText._("hello")
+  end
+end

data/test/qv_helpers.rb

@@ -0,0 +1,173 @@
+require 'test/unit'
+
+class TC_Helpers < Test::Unit::TestCase
+  def setup
+    Entities.delete_all_data()
+    #    Entities.Persons.create( :first_name => "admin", :pass => "super123", :session_id => '0.1', :permission => 'admin' )
+    #    Entities.Persons.create( :first_name => "surf", :pass => "surf", :session_id => '0.2', :permission => 'internet' )
+    #    Permission.session_add( '0.1', 'admin')
+    #    Permission.session_add( '0.2', 'internet')
+  end
+
+  def teardown
+  end
+
+  def request(service, method, args)
+    RPCQooxdooHandler.request(1, service, method, args)
+  end
+
+  def test_def_config
+    assert_equal 777, get_config(777, :TestConfigs)
+    assert_equal true, get_config(nil, :TestConfig, :One)
+    assert_equal 'hello', get_config(nil, :TestConfig, :Two)
+    assert_equal 30, get_config(nil, :TestConfig, :Three, :Thirty)
+  end
+
+  def test_set_config
+    set_config(1, :SetConfig)
+    assert_equal 1, get_config(2, :SetConfig)
+    set_config(2, :SetConfig)
+    assert_equal 2, get_config(3, :SetConfig)
+    set_config(2, :SetConfig2, :Level)
+    assert_equal 2, get_config(3, :SetConfig2, :Level)
+    set_config(3, :SetConfig2, :Level)
+    assert_equal 3, get_config(4, :SetConfig2, :Level)
+    set_config(4, :SetConfig3, :Level, :Two)
+    assert_equal 4, get_config(5, :SetConfig3, :Level, :Two)
+  end
+
+  def test_dputs_time
+    dputs(1) { 'Testing time'
+    }
+    set_config('sec', :DPuts, :showTime)
+    dputs(1) { 'First'
+    }
+    dputs(1) { 'Second'
+    }
+    sleep(1)
+    dputs(1) { 'Third'
+    }
+  end
+
+  def show_me
+    @inside += 1
+    return 'hello'
+  end
+
+  def test_dputs
+    old = get_config(false, :DPuts, :silent)
+    set_config(true, :DPuts, :silent)
+
+    @inside = 1
+    dbg = DEBUG_LVL
+    Object.send(:remove_const, :DEBUG_LVL)
+    Object.const_set(:DEBUG_LVL, 1)
+
+    dputs(1) { "Calling for show_me #{show_me}" }
+    assert_equal 2, @inside
+
+    dputs(2) { "This shouldn't be called #{show_me}" }
+    assert_equal 2, @inside
+
+    Object.send(:remove_const, :DEBUG_LVL)
+    Object.const_set(:DEBUG_LVL, dbg)
+
+    set_config(old, :DPuts, :silent)
+  end
+
+  def test_speed_create
+    dputs(1) { 'Benchmarking'
+    }
+    (0..4).each { |b|
+      dputs(1) { Benchmark.measure("Users #{(b*50).to_s.rjust(3)}") {
+        (1..50).each { |i|
+          Entities.Persons.create(:first_name => "admin#{b*50+i}", :pass => 'super123', :session_id => '0.1', :permission => 'admin')
+        }
+      }.to_s
+      }
+    }
+  end
+
+  def test_config_list
+    assert_equal ['one', 'two three'], get_config(nil, :TestList)
+
+    assert_equal ["Link: <a href='hello there'>link</a>"],
+                 get_config(nil, :TestLink1)
+
+    assert_equal "Something over\nmultiple lines:\none two three\n",
+                 get_config(nil, :TestLink2)
+  end
+
+  def test_create_sqlite
+    Accounts.create(:name => 'test')
+  end
+
+  def test_speed_sqlite
+    dputs(1) { 'Benchmark' }
+    (0..4).each { |b|
+      dputs(1) { Benchmark.measure("Accounts #{(b*50).to_s.rjust(3)}") {
+        (1..500).each { |i|
+          Accounts.create(:name => 'test')
+        }
+      }.to_s
+      }
+    }
+  end
+
+  def test_make_steps
+    session = {s_data: {value: 10}}
+    ms = MakeSteps.new(session) { |session, _data, step|
+      case step
+        when 0
+          assert_equal 10, session._s_data._value
+          session._s_data._value += 1
+        when 1
+          assert_equal 11, session._s_data._value
+          session._s_data._value += 1
+          ms.step = 3
+        when 2
+          assert_equal 13, session._s_data._value
+          session._s_data._value += 1
+          ms.step = -1
+        when 3
+          assert_equal 12, session._s_data._value
+          session._s_data._value += 1
+          ms.step = 2
+      end
+      nil
+    }
+
+    ms.make_step(session)
+    ms.make_step(session)
+    ms.make_step(session)
+    ms.make_step(session)
+    assert_equal 14, session._s_data._value
+  end
+
+  def test_make_steps_wait
+    session = {s_data: {value: 10}}
+    ms = MakeSteps.new(session, -1) { |session, _data, step|
+      case step
+        when 0
+          assert_equal 10, session._s_data._value
+          sleep 1.5
+          [session._s_data._value += 1]
+        when 1
+          assert_equal 11, session._s_data._value
+          [session._s_data._value += 1]
+      end
+    }
+
+    assert_equal [{:cmd=>:auto_update, :data=>-1}], ms.make_step(session)
+    assert_equal [11,{:cmd=>:auto_update, :data=>0}], ms.make_step(session)
+    ms.make_step(session)
+    assert_equal 12, session._s_data._value
+  end
+
+  def test_hash_accessor
+    a = {}
+    assert_equal nil, a._b
+    a._b = 3
+    assert_equal 3, a._b
+  end
+end

data/test/qv_icc.rb

@@ -0,0 +1,60 @@
+require 'benchmark'
+require 'securerandom'
+
+class TC_ICC < Test::Unit::TestCase
+  def setup
+    dputs(2) { "Deleting everything" }
+    Entities.delete_all_data
+
+    @admin = Persons.create(login_name: 'admin', password_plain: '1234')
+  end
+
+  def teardown
+  end
+
+  def with_server
+    ConfigBase.block_size = 4096
+
+    @port = 3302
+    @url = "http://localhost:#{@port}/icc"
+    @main = Thread.new {
+      QooxView::startWeb(@port)
+    }
+    dputs(1) { "Starting at port #{@port}" }
+    sleep 1
+
+    yield @port, @url, @main
+
+    @main.kill.join
+  end
+
+  def test_transfer
+    with_server do
+      ICC.transfer(@admin, 'Persons.adduser', {:first_name => 'foo', :pass => 'bar'},
+                   url: @url)
+
+      fb = Persons.find_by_first_name('foo')
+      assert_equal 'bar', fb.pass
+
+      ICC.transfer(@admin, 'Persons.longtransfer', SecureRandom.random_bytes(16384),
+                   url: @url)
+      assert_equal 16384, Persons.get_longtransfer_bytes
+
+      @str = ''
+      ICC.transfer(@admin, 'Persons.longtransfer', SecureRandom.random_bytes(1500),
+                   url: @url) { |s| @str += s }
+      assert_equal '0%50%100%', @str
+    end
+  end
+
+  def test_fetch_binary
+    with_server do
+      ret = ICC.get(:Persons, :_getbinary, url: @url)
+      file1 = ret._msg
+      file2 = IO.read('file_binary.bin').force_encoding(Encoding::ASCII_8BIT)
+      assert Digest::MD5.hexdigest(file1) == Digest::MD5.hexdigest(file2)
+      assert file1 == file2
+    end
+  end
+
+end

data/test/qv_migration.rb

@@ -0,0 +1,130 @@
+require 'test/unit'
+require 'benchmark'
+
+class TC_Migration < Test::Unit::TestCase
+  def setup
+    Entities.delete_all_data
+    CVSInventories.class_eval( '
+      def setup_data
+        value_date :date
+        value_str :iname
+      end
+
+      (1..3).each{|v|
+        begin
+          remove_method "migration_#{v}".to_sym
+        rescue NameError
+        end
+        begin
+          remove_method "migration_#{v}_raw".to_sym
+        rescue NameError
+        end
+      }
+
+      RPCQooxdooService.add_prime_service( CVSInventories,
+        "Entities.CVSInventories" )
+      ')
+    @pers = Persons.create( :login_name => 'test')
+    @inv1 = CVSInventories.create( :date => '121201', :iname => 'comp 01')
+    @inv2 = CVSInventories.create( :date => '121202', :iname => 'comp 02')
+    @inv3 = CVSInventories.create( :date => '121203', :iname => 'comp 03')
+    Entities.save_all
+  end
+
+  def teardown
+    dputs(1){ 'Tearing down' }
+  end
+  
+  def test_cvs_normal
+    assert_equal '121201', @inv1.date
+  end
+  
+  def test_cvs_init
+    assert_equal 'comp 01', CVSInventories.match_by_date('121201').iname
+
+    dputs(5){ 'Before class_eval' }
+    CVSInventories.class_eval( '
+      def setup_data
+        dputs(1){"new inventories"}
+        value_date :date
+        value_str :iname
+        value_str :typ
+      end
+  
+      def migration_1( inv )
+        dputs(1){"Adjusting inv #{inv.inspect}"}
+        inv.typ = inv.iname.split[0]
+      end
+
+      dputs(1){"Adding to RPC"}
+      RPCQooxdooService.add_prime_service( CVSInventories,
+        "Entities.CVSInventories" )
+      ')
+
+    Entities.load_all
+    assert_equal 'comp', CVSInventories.match_by_date('121201').typ
+    
+    CVSInventories.class_eval( '
+      def migration_2( inv )
+        dputs(1){"Adjusting inv #{inv.inspect}"}
+        inv.typ = inv.date
+      end
+
+      def migration_3( inv )
+        dputs(1){"Adjusting inv #{inv.inspect}"}
+        inv.iname = inv.typ + "-"
+      end
+
+      RPCQooxdooService.add_prime_service( CVSInventories,
+        "Entities.CVSInventories" )
+      ')
+    Entities.load_all
+    assert_equal '121201-', CVSInventories.match_by_date('121201').iname
+  end
+  
+  # Also tests deletion - this is kind of a bug that it works, because
+  # the Entities.load function should not load fields that are not
+  # defined - probably only works for CVS...
+  # As this is a raw-migration, it is probably OK
+  def test_cvs_rename
+    CVSInventories.class_eval( '
+      def setup_data
+        value_date :date
+        value_str :i_name
+      end
+
+      def migration_1_raw( inv )
+        dputs(1){"rename: Adjusting inv #{inv.inspect}"}
+        inv._i_name = inv._iname
+      end
+
+      RPCQooxdooService.add_prime_service( CVSInventories,
+        "Entities.CVSInventories" )
+      ')
+
+    Entities.load_all
+    assert_equal 'comp 01', CVSInventories.match_by_date('121201').i_name
+  end
+  
+  def test_raw
+    CVSInventories.class_eval( '
+      def setup_data
+        value_date :date
+        value_str :i_name
+      end
+  
+      def migration_1_raw( inv )
+        dputs(1){"renaming raw: Adjusting inv #{inv.inspect}"}
+        inv[:i_name] = inv[:iname]
+        dputs(1){"Is now #{inv.inspect}"}
+      end
+
+      RPCQooxdooService.add_prime_service( CVSInventories,
+        "Entities.CVSInventories" )
+      ')
+
+    Entities.load_all
+    cvs = CVSInventories.match_by_date('121201')
+    assert_equal 'comp 01', cvs.i_name
+  end
+end

data/test/qv_permission.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+
+class Tc_permission < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_can_view
+    assert Permission.can_view( 'internet', 'Internet'), 'Internet is not allowed'
+    assert ( not Permission.can_view( 'internet', 'PersonModify') )
+    assert Permission.can_view( 'secretary', 'Internet')
+  end
+  
+  def test_views
+    assert_equal %w( View View.Login ), Permission.views( :default )
+    assert_equal %w( Internet PersonShow View View.Login ), 
+      Permission.views( :internet )
+    assert_equal %w( Internet PersonShow View View.Login ), 
+      Permission.views( %w( internet default ) )
+  end
+
+  def test_has_role
+    assert Permission.has_role( 'professor', 'professor' )
+    assert ! Permission.has_role( 'professo', 'professor' )
+    assert ! Permission.has_role( 'rofessor', 'professor' )
+    assert Permission.has_role( 'admin', 'professor' )
+    assert ! Permission.has_role( 'student', 'professor' )
+    assert Permission.has_role( %w( professor secretary ), 'cybermanager' )
+    assert Permission.has_role( %w( secretary professor ), 'cybermanager' )
+  end
+  
+end