knjrbfw 0.0.110 → 0.0.111

data/spec/db_spec.rb

@@ -1,282 +0,0 @@
-#encoding: utf-8
-
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Db" do
-  it "should be able to handle various encodings" do
-    #I never got this test to actually fail... :-(
-    
-    require "knj/db"
-    require "knj/os"
-    require "rubygems"
-    require "sqlite3" if !Kernel.const_defined?("SQLite3") and RUBY_ENGINE != "jruby"
-    
-    db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
-    
-    db = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    db.tables.create("test", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "text", "type" => "varchar"}
-      ]
-    })
-    
-    
-    
-    #Get a list of tables and check the list for errors.
-    list = db.tables.list
-    raise "Table not found: 'test'." if !list.key?("test")
-    raise "Table-name expected to be 'test' but wasnt: '#{list["test"].name}'." if list["test"].name != "test"
-    
-    
-    #Test revision to create tables, indexes and insert rows.
-    schema = {
-      "tables" => {
-        "test_table" => {
-          "columns" => [
-            {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-            {"name" => "name", "type" => "varchar"},
-            {"name" => "age", "type" => "int"},
-            {"name" => "nickname", "type" => "varchar"}
-          ],
-          "indexes" => [
-            "name"
-          ],
-          "rows" => [
-            {
-              "find_by" => {"id" => 1},
-              "data" => {"id" => 1, "name" => "trala"}
-            }
-          ]
-        }
-      }
-    }
-    
-    rev = Knj::Db::Revision.new
-    rev.init_db("schema" => schema, "db" => db)
-    
-    
-    #Test wrong encoding.
-    cont = File.read("#{File.dirname(__FILE__)}/db_spec_encoding_test_file.txt")
-    cont.force_encoding("ASCII-8BIT")
-    
-    db.insert("test", {
-      "text" => cont
-    })
-    
-    
-    #Throw out invalid encoding because it will make dumping fail.
-    db.tables[:test].truncate
-    
-    
-    
-    #Test IDQueries.
-    rows_count = 1250
-    db.transaction do
-      0.upto(rows_count) do |count|
-        db.insert(:test_table, {:name => "User #{count}"})
-      end
-    end
-    
-    block_ran = 0
-    idq = Knj::Db::Idquery.new(:db => db, :debug => false, :table => :test_table, :query => "SELECT id FROM test_table") do |data|
-      block_ran += 1
-    end
-    
-    raise "Block with should have ran too little: #{block_ran}." if block_ran < rows_count
-    
-    block_ran = 0
-    db.select(:test_table, {}, {:idquery => true}) do |data|
-      block_ran += 1
-    end
-    
-    raise "Block with should have ran too little: #{block_ran}." if block_ran < rows_count
-    
-    
-    #Test upserting.
-    data = {:name => "Kasper Johansen"}
-    sel = {:nickname => "kaspernj"}
-    
-    table = db.tables[:test_table]
-    table.reload
-    rows_count = table.rows_count
-    
-    db.upsert(:test_table, sel, data)
-    
-    table.reload
-    table.rows_count.should eql(rows_count + 1)
-    
-    db.upsert(:test_table, sel, data)
-    
-    table.reload
-    table.rows_count.should eql(rows_count + 1)
-    
-    
-    #Test dumping.
-    dump = Knj::Db::Dump.new(:db => db, :debug => false)
-    str_io = StringIO.new
-    dump.dump(str_io)
-    str_io.rewind
-    
-    
-    #Remember some numbers for validation.
-    tables_count = db.tables.list.length
-    
-    
-    #Remove everything in the db.
-    db.tables.list do |table|
-      table.drop unless table.native?
-    end
-    
-    
-    #Run the exported SQL.
-    db.transaction do
-      str_io.each_line do |sql|
-        db.q(sql)
-      end
-    end
-    
-    
-    #Vaildate import.
-    raise "Not same amount of tables: #{tables_count}, #{db.tables.list.length}" if tables_count != db.tables.list.length
-    
-    
-    
-    #Test revision table renaming.
-    Knj::Db::Revision.new.init_db("db" => db, "schema" => {
-      "tables" => {
-        "new_test_table" => {
-          "renames" => ["test_table"]
-        }
-      }
-    })
-    tables = db.tables.list
-    raise "Didnt expect table 'test_table' to exist but it did." if tables.key?("test_table")
-    raise "Expected 'new_test_table' to exist but it didnt." if !tables.key?("new_test_table")
-    
-    
-    #Test revision for column renaming.
-    Knj::Db::Revision.new.init_db("db" => db, "schema" => {
-      "tables" => {
-        "new_test_table" => {
-          "columns" => [
-            {"name" => "new_name", "type" => "varchar", "renames" => ["name"]}
-          ]
-        }
-      }
-    })
-    columns = db.tables["new_test_table"].columns
-    raise "Didnt expect 'name' to exist but it did." if columns.key?("name")
-    raise "Expected 'new_name'-column to exist but it didnt." if !columns.key?("new_name")
-    
-    
-    #Delete test-database if everything went well.
-    File.unlink(db_path) if File.exists?(db_path)
-  end
-  
-  it "should generate proper sql" do
-    require "knj/db"
-    require "knj/os"
-    require "rubygems"
-    require "sqlite3" if !Kernel.const_defined?("SQLite3") and RUBY_ENGINE != "jruby"
-    
-    db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
-    
-    db = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    time = Time.new(1985, 6, 17, 10, 30)
-    db.insert(:test, {:date => time}, :return_sql => true).should eql("INSERT INTO `test` (`date`) VALUES ('1985-06-17 10:30:00')")
-    
-    date = Date.new(1985, 6, 17)
-    db.insert(:test, {:date => date}, :return_sql => true).should eql("INSERT INTO `test` (`date`) VALUES ('1985-06-17')")
-  end
-  
-  it "should copy database structure and data" do
-    require "knj/db"
-    require "knj/os"
-    require "rubygems"
-    require "sqlite3" if !Kernel.const_defined?("SQLite3") and RUBY_ENGINE != "jruby"
-    
-    db_path1 = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3_db1.sqlite3"
-    File.unlink(db_path1) if File.exists?(db_path1)
-    
-    db_path2 = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3_db2.sqlite3"
-    File.unlink(db_path2) if File.exists?(db_path2)
-    
-    db1 = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path1,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    db1.tables.create(:test_table, {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "testname", "type" => "varchar"}
-      ],
-      "indexes" => [
-        "testname"
-      ]
-    })
-    
-    table1 = db1.tables["test_table"]
-    cols1 = table1.columns
-    
-    100.times do |count|
-      table1.insert(:testname => "TestRow#{count}")
-    end
-    
-    db2 = Knj::Db.new(
-      :type => "sqlite3",
-      :path => db_path2,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    begin
-      table2 = db2.tables["test_table"]
-      raise "Expected not-found exception."
-    rescue Errno::ENOENT
-      #expected
-    end
-    
-    db1.copy_to(db2)
-    
-    table2 = db2.tables["test_table"]
-    
-    cols2 = table2.columns
-    cols2.length.should eql(cols1.length)
-    
-    table2.rows_count.should eql(table1.rows_count)
-    
-    db1.select(:test_table) do |row1|
-      found = 0
-      db2.select(:test_table, row1) do |row2|
-        found += 1
-        
-        row1.each do |key, val|
-          row2[key].should eql(val)
-        end
-      end
-      
-      found.should eql(1)
-    end
-    
-    table1.indexes.length.should eql(1)
-    table2.indexes.length.should eql(table1.indexes.length)
-  end
-end

data/spec/db_spec_encoding_test_file.txt

@@ -1 +0,0 @@
-��pl��p���

data/spec/objects_spec.rb

@@ -1,394 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Objects" do
-  it "should be able to cache rows" do
-    begin
-      require "#{File.dirname(__FILE__)}/../../array_enumerator/lib/array_enumerator"
-    rescue LoadError
-      require "array_enumerator"
-    end
-    
-    require "sqlite3" if RUBY_ENGINE != "jruby"
-    
-    $db_path = "#{Knj::Os.tmpdir}/knjrbfw_objects_cache_test.sqlite3"
-    File.unlink($db_path) if File.exists?($db_path)
-    $db = Knj::Db.new(:type => :sqlite3, :path => $db_path, :return_keys => "symbols", :debug => false)
-    
-    schema = {
-      "tables" => {
-        "Group" => {
-          "columns" => [
-            {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-            {"name" => "groupname", "type" => "varchar"}
-          ]
-        },
-        "User" => {
-          "columns" => [
-            {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-            {"name" => "username", "type" => "varchar"}
-          ]
-        }
-      }
-    }
-    Knj::Db::Revision.new.init_db("schema" => schema, "db" => $db)
-    
-    class User < Knj::Datarow; end
-    
-    $ob = Knj::Objects.new(
-      :db => $db,
-      :datarow => true,
-      :require => false,
-      :array_enum => true,
-      :models => {
-        :User => {
-          :cache_ids => true
-        }
-      }
-    )
-    
-    $ob.adds(:User, [
-      {:username => "User 1"},
-      {:username => "User 2"},
-      {:username => "User 3"},
-      {:username => "User 4"},
-      {:username => "User 5"}
-    ])
-    
-    raise "Expected user-ID-cache to be 5 but it wasnt: #{$ob.ids_cache[:User].length}" if $ob.ids_cache[:User].length != 5
-    
-    user = $ob.get(:User, 4)
-    raise "No user returned." if !user
-    $ob.delete(user)
-    raise "Expected user-ID-cache to be 4 but it wasnt: #{$ob.ids_cache[:User].length} #{$ob.ids_cache}" if $ob.ids_cache[:User].length != 4
-    
-    $ob.deletes([$ob.get(:User, 1), $ob.get(:User, 2)])
-    raise "Expected user-ID-cache to be 2 but it wasnt: #{$ob.ids_cache[:User].length} #{$ob.ids_cache}" if $ob.ids_cache[:User].length != 2
-  end
-  
-  it "should be able to do 'select_col_as_array'" do
-    res = $ob.list(:User, {"select_col_as_array" => "id"}).to_a
-    raise "Expected length of 2 but got: #{res.length}" if res.length != 2
-  end
-  
-  it "should work even though stressed by threads (thread-safe)." do
-    userd = []
-    10.upto(25) do |i|
-      userd << {:username => "User #{i}"}
-    end
-    
-    $ob.adds(:User, userd)
-    users = $ob.list(:User).to_a
-    
-    #Stress it to test threadsafety...
-    threads = []
-    0.upto(5) do |tc|
-      threads << Knj::Thread.new do
-        0.upto(5) do |ic|
-          user = $ob.add(:User, {:username => "User #{tc}-#{ic}"})
-          raise "No user returned." if !user
-          $ob.delete(user)
-          
-          user1 = $ob.add(:User, {:username => "User #{tc}-#{ic}-1"})
-          user2 = $ob.add(:User, {:username => "User #{tc}-#{ic}-2"})
-          user3 = $ob.add(:User, {:username => "User #{tc}-#{ic}-3"})
-          
-          raise "Missing user?" if !user1 or !user2 or !user3 or user1.deleted? or user2.deleted? or user3.deleted?
-          $ob.deletes([user1, user2, user3])
-          
-          count = 0
-          users.each do |user|
-            count += 1
-            user[:username] = "#{user[:username]}." if !user.deleted?
-          end
-          
-          raise "Expected at least 15 users but got #{count}." if count != 18
-        end
-      end
-    end
-    
-    threads.each do |thread|
-      thread.join
-    end
-  end
-  
-  it "should be able to skip queries when adding" do
-    class Group < Knj::Datarow; end
-    
-    $ob2 = Knj::Objects.new(
-      :db => $db,
-      :datarow => true,
-      :require => false
-    )
-    
-    threads = []
-    0.upto(5) do
-      threads << Knj::Thread.new do
-        0.upto(5) do
-          ret = $ob2.add(:Group, {:groupname => "User 1"}, {:skip_ret => true})
-          raise "Expected empty return but got something: #{ret}" if ret
-        end
-      end
-    end
-    
-    threads.each do |thread|
-      thread.join
-    end
-  end
-  
-  it "should delete the temporary database." do
-    File.unlink($db_path) if File.exists?($db_path)
-  end
-  
-  #Moved from "knjrbfw_spec.rb"
-  it "should be able to generate a sample SQLite database and add a sample table, with sample columns and with a sample index to it" do
-    $db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    $db = Knj::Db.new(
-      :type => "sqlite3",
-      :path => $db_path,
-      :return_keys => "symbols",
-      :index_append_table_name => true
-    )
-    
-    $db.tables.create("Project", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "category_id", "type" => "int"},
-        {"name" => "name", "type" => "varchar"}
-      ],
-      "indexes" => [
-        {"name" => "category_id", "columns" => ["category_id"]}
-      ]
-    })
-    
-    $db.tables.create("Task", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "project_id", "type" => "int"},
-        {"name" => "person_id", "type" => "int"},
-        {"name" => "name", "type" => "varchar"}
-      ],
-      "indexes" => [
-        {"name" => "project_id", "columns" => ["project_id"]}
-      ]
-    })
-    
-    $db.tables.create("Person", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "name", "type" => "varchar"}
-      ]
-    })
-    
-    $db.tables.create("Timelog", {
-      "columns" => [
-        {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-        {"name" => "person_id", "type" => "int"}
-      ],
-      "indexes" => [
-        "person_id"
-      ]
-    })
-    
-    table = $db.tables["Project"]
-    
-    indexes = table.indexes
-    raise "Could not find the sample-index 'category_id' that should have been created." if !indexes["Project__category_id"]
-    
-    
-    #If we insert a row the ID should increase and the name should be the same as inserted (or something is very very wrong)...
-    $db.insert("Project", {
-      "name" => "Test project"
-    })
-    
-    count = 0
-    $db.q("SELECT * FROM Project") do |d|
-      raise "Somehow name was not 'Test project'" if d[:name] != "Test project"
-      raise "ID was not set?" if d[:id].to_i <= 0
-      count += 1
-    end
-    
-    raise "Expected count of 1 but it wasnt: #{count}" if count != 1
-  end
-  
-  it "should be able to automatic generate methods on datarow-classes (has_many, has_one)." do
-    class Project < Knj::Datarow
-      has_many [
-        {:class => :Task, :col => :project_id, :depends => true}
-      ]
-    end
-    
-    class Task < Knj::Datarow
-      has_one [
-        {:class => :Person, :required => true},
-        :Project
-      ]
-    end
-    
-    class Person < Knj::Datarow
-      has_one [:Project]
-      
-      has_many [
-        {:class => :Timelog, :autozero => true}
-      ]
-      
-      def html
-        return self[:name]
-      end
-    end
-    
-    class Timelog < Knj::Datarow
-      
-    end
-    
-    $ob = Knj::Objects.new(:db => $db, :datarow => true, :require => false)
-    
-    $ob.add(:Person, {
-      :name => "Kasper"
-    })
-    $ob.add(:Task, {
-      :name => "Test task",
-      :person_id => 1,
-      :project_id => 1
-    })
-    
-    begin
-      $obb.add(:Task, {:name => "Test task"})
-      raise "Method should fail but didnt."
-    rescue
-      #ignore.
-    end
-    
-    
-    #Test 'list_invalid_required'.
-    $db.insert(:Task, :name => "Invalid require")
-    id = $db.last_id
-    found = false
-    
-    $ob.list_invalid_required(:class => :Task) do |d|
-      raise "Expected object ID to be #{id} but it wasnt: #{d[:obj].id}" if d[:obj].id.to_i != id.to_i
-      $ob.delete(d[:obj])
-      found = true
-    end
-    
-    raise "Expected to find a task but didnt." if !found
-    
-    
-    ret_proc = []
-    $ob.list(:Task) do |task|
-      ret_proc << task
-    end
-    
-    raise "list with proc should return one task but didnt." if ret_proc.length != 1
-    
-    
-    project = $ob.get(:Project, 1)
-    
-    tasks = project.tasks
-    raise "No tasks were found on project?" if tasks.empty?
-    
-    
-    ret_proc = []
-    ret_test = project.tasks do |task|
-      ret_proc << task
-    end
-    
-    raise "When given a block the return should be nil so it doesnt hold weak-ref-objects in memory but it didnt return nil." if ret_test != nil
-    raise "list for project with proc should return one task but didnt (#{ret_proc.length})." if ret_proc.length != 1
-    
-    person = tasks.first.person
-    project_second = tasks.first.project
-    
-    raise "Returned object was not a person on task." if !person.is_a?(Person)
-    raise "Returned object was not a project on task." if !project_second.is_a?(Project)
-    
-    
-    #Check that has_many-depending is actually working.
-    begin
-      $ob.delete(project)
-      raise "It was possible to delete project 1 even though task 1 depended on it!"
-    rescue
-      #this should happen - it should not possible to delete project 1 because task 1 depends on it."
-    end
-  end
-  
-  it "should be able to generate lists for inputs" do
-    Knj::Web.inputs([{
-      :title => "Test 3",
-      :name => :seltest3,
-      :type => :select,
-      :default => 1,
-      :opts => $ob.list_optshash(:Task)
-    }])
-  end
-  
-  it "should be able to connect to objects 'no-html' callback and test it." do
-    task = $ob.get(:Task, 1)
-    $ob.events.connect(:no_html) do |event, classname|
-      "[no #{classname.to_s.downcase}]"
-    end
-    
-    raise "Unexpected person_html from task (should have been 'Kasper'): '#{task.person_html}'." if task.person_html != "Kasper"
-    task.update(:person_id => 0)
-    raise "Unexpected person_html from task (should have been '[no person]')." if task.person_html != "[no person]"
-  end
-  
-  it "should be able to to multiple additions and delete objects through a buffer" do
-    objs = []
-    0.upto(500) do
-      objs << {:name => :Kasper}
-    end
-    
-    $ob.adds(:Person, objs)
-    pers_length = $ob.list(:Person, "count" => true)
-    
-    count = 0
-    $db.q_buffer do |buffer|
-      $ob.list(:Person) do |person|
-        count += 1
-        $ob.delete(person, :db_buffer => buffer)
-      end
-      
-      buffer.flush
-    end
-    
-    raise "Expected count to be #{pers_length} but it wasnt: #{count}" if count != pers_length
-    
-    persons = $ob.list(:Person).to_a
-    raise "Expected persons count to be 0 but it wasnt: #{persons.map{|e| e.data} }" if persons.length > 0
-  end
-  
-  it "should do autozero when deleting objects" do
-    person1 = $ob.add(:Person, {
-      :name => "Kasper"
-    })
-    person2 = $ob.add(:Person, {
-      :name => "Charlotte"
-    })
-    
-    timelog1 = $ob.add(:Timelog, {
-      :person_id => person1.id
-    })
-    timelog2 = $ob.add(:Timelog, {
-      :person_id => person2.id
-    })
-    
-    $ob.delete(person1)
-    
-    raise "Expected timelog1's person-ID to be zero but it wasnt: '#{timelog1[:person_id]}'." if timelog1[:person_id].to_i != 0
-    raise "Expected timelog2's person-ID to be #{person2.id} but it wasnt: '#{timelog2[:person_id]}'." if timelog2[:person_id].to_i != person2.id.to_i
-  end
-  
-  it "should be able to do multiple deletes from ids" do
-    ids = []
-    1.upto(10) do |count|
-      ids << $ob.add(:Person).id
-    end
-    
-    $ob.delete_ids(:class => :Person, :ids => ids)
-  end
-  
-  it "should delete the temp database again." do
-    db_path = "#{Knj::Os.tmpdir}/knjrbfw_test_sqlite3.sqlite3"
-    File.unlink(db_path) if File.exists?(db_path)
-  end
-end