baza 0.0.19 → 0.0.20

data/spec/support/driver_collection.rb

@@ -5,18 +5,16 @@ shared_examples_for "a baza driver" do
   let(:db2) { driver2.db }
   let(:db_with_type_translation) { constant.new(type_translation: true, debug: false).db }
   let(:row) do
-    test_table.insert(text: 'Kasper', number: 30, float: 4.5)
-    db.select(:test, text: 'Kasper').fetch
+    test_table.insert(text: "Kasper", number: 30, float: 4.5)
+    db.select(:test, text: "Kasper").fetch
   end
   let(:test_table) do
-    db.tables.create("test", {
-      columns: [
-        {name: 'id', type: :int, autoincr: true, primarykey: true},
-        {name: 'text', type: :varchar},
-        {name: 'number', type: :int, default: 0},
-        {name: 'float', type: :float, default: 0.0}
-      ]
-    })
+    db.tables.create("test", columns: [
+      {name: "id", type: :int, autoincr: true, primarykey: true},
+      {name: "text", type: :varchar},
+      {name: "number", type: :int, default: 0},
+      {name: "float", type: :float, default: 0.0}
+    ])
     db.tables[:test]
   end
 
@@ -59,11 +57,11 @@ shared_examples_for "a baza driver" do
     rev.init_db(schema: schema, debug: false, db: db)
 
     test_table = db.tables[:test_table]
-    test_table.columns.keys.should include :age
-    test_table.columns.keys.should include :nickname
+    expect(test_table.columns.map(&:name)).to include "age"
+    expect(test_table.columns.map(&:name)).to include "nickname"
   end
 
-  it "should do id-queries" do
+  it "does id-queries" do
     test_table
 
     rows_count = 1250
@@ -74,21 +72,21 @@ shared_examples_for "a baza driver" do
     end
 
     block_ran = 0
-    idq = Baza::Idquery.new(db: db, debug: false, table: :test, query: "SELECT id FROM test") do |data|
+    idq = Baza::Idquery.new(db: db, debug: false, table: :test, query: "SELECT id FROM test") 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, {}, idquery: true) do |data|
+    db.select(:test, {}, idquery: true) do |_data|
       block_ran += 1
     end
 
     raise "Block with should have ran too little: #{block_ran}." if block_ran < rows_count
   end
 
-  it 'does unbuffered queries' do
+  it "does unbuffered queries" do
     test_table
 
     10.times do |count|
@@ -104,10 +102,10 @@ shared_examples_for "a baza driver" do
     expect(count_results).to eq 10
   end
 
-  it "should do upserting" do
+  it "does upserting" do
     test_table.create_columns([{name: "nickname", type: :varchar}])
 
-    #Test upserting.
+    # Test upserting.
     data = {text: "upsert - Kasper Johansen"}
     data2 = {text: "upsert - Kasper Nielsen Johansen"}
     sel = {nickname: "upsert - kaspernj"}
@@ -131,85 +129,94 @@ shared_examples_for "a baza driver" do
     table.rows_count.should eq rows_count + 1
   end
 
-  it "should dump as SQL" do
+  it "dumps as SQL" do
     dump = Baza::Dump.new(db: db, debug: false)
     str_io = StringIO.new
     dump.dump(str_io)
     str_io.rewind
 
-    #Remember some numbers for validation.
+    # Remember some numbers for validation.
     tables_count = db.tables.list.length
 
-    #Remove everything in the db.
+    # Remove everything in the db.
     db.tables.list do |table|
       table.drop unless table.native?
     end
 
-    #Run the exported SQL.
+    # Run the exported SQL.
     db.transaction do
       str_io.each_line do |sql|
         db.q(sql)
       end
     end
 
-    #Vaildate import.
+    # Vaildate import.
     raise "Not same amount of tables: #{tables_count}, #{db.tables.list.length}" if tables_count != db.tables.list.length
   end
 
-  it "should rename tables in revisions" do
+  it "renames tables in revisions" do
     test_table
 
-    Baza::Revision.new.init_db(db: db, debug: false, schema: {
-      tables: {
-        new_test_table: {
-          renames: [:test]
+    Baza::Revision.new.init_db(
+      db: db,
+      debug: false,
+      schema: {
+        tables: {
+          new_test_table: {
+            renames: [:test]
+          }
         }
       }
-    })
-    tables = db.tables.list
-    raise "Didnt expect table 'test' to exist but it did." if tables.key?(:test)
-    raise "Expected 'new_test_table' to exist but it didnt." if !tables.key?(:new_test_table)
+    )
+
+    tables = db.tables.list.map(&:name)
+
+    expect(tables).to_not include "test"
+    expect(tables).to include "new_test_table"
   end
 
-  it "should rename columns in revisions" do
+  it "renames columns in revisions" do
     test_table
 
-    Baza::Revision.new.init_db(db: db, debug: false, schema: {
-      tables: {
-        new_test_table: {
-          columns: [
-            {name: :new_name, type: :varchar, renames: [:text]}
-          ]
+    Baza::Revision.new.init_db(
+      db: db,
+      debug: false,
+      schema: {
+        tables: {
+          new_test_table: {
+            columns: [
+              {name: :new_name, type: :varchar, renames: [:text]}
+            ]
+          }
         }
       }
-    })
-    columns = db.tables[:new_test_table].columns
-    raise "Didnt expect 'text' to exist but it did." if columns.key?(:text)
-    raise "Expected 'new_name'-column to exist but it didnt." unless columns.key?(:new_name)
+    )
+
+    columns = db.tables[:new_test_table].columns.map(&:name)
+    expect(columns).to_not include "text"
+    expect(columns).to include "new_name"
   end
 
-  it "should generate proper sql" do
+  it "generates proper sql" do
     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')")
+    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')")
+    db.insert(:test, {date: date}, return_sql: true).should eql("INSERT INTO `test` (`date`) VALUES ('1985-06-17')")
   end
 
-  it "should be able to make new connections based on given objects" do
+  it "is able to make new connections based on given objects" do
     # Mysql doesn't support it...
     unless db.opts.fetch(:type) == :mysql
-      new_db = Baza::Db.from_object(object: db.conn.conn)
+      new_db = Baza::Db.from_object(object: db.driver.conn)
     end
   end
 
-  it "should be able to do ID-queries through the select-method" do
-    db.tables.create(:test_table, {
-      :columns => [
-        {:name => :idrow, :type => :int, :autoincr => true, :primarykey => true},
-        {:name => :name, :type => :varchar}
-      ]
-    })
+  it "is able to do ID-queries through the select-method" do
+    db.tables.create(:test_table, columns: [
+      {name: :idrow, type: :int, autoincr: true, primarykey: true},
+      {name: :name, type: :varchar}
+    ])
 
     count = 0
     100.times do
@@ -229,26 +236,24 @@ shared_examples_for "a baza driver" do
       row[:name].should eq "Kasper #{count_found}"
     end
 
-    expect(count_found).to eq 10000
+    expect(count_found).to eq 10_000
   end
 
   it "should be able to use query buffers" do
-    db.tables.create(:test_table, {
-      columns: [
-        {name: :id, type: :int, autoincr: true, primarykey: true},
-        {name: :name, type: :varchar}
-      ]
-    })
+    db.tables.create(:test_table, columns: [
+      {name: :id, type: :int, autoincr: true, primarykey: true},
+      {name: :name, type: :varchar}
+    ])
 
     upsert = false
     count_inserts = 0
     db.q_buffer do |buffer|
       2500.times do |count|
         if upsert
-          buffer.upsert(:test_table, {name: "Kasper #{count}"}, {name: "Kasper #{count}"})
+          buffer.upsert(:test_table, {name: "Kasper #{count}"}, name: "Kasper #{count}")
           upsert = false
         else
-          buffer.insert(:test_table, {name: "Kasper #{count}"})
+          buffer.insert(:test_table, name: "Kasper #{count}")
           upsert = true
         end
 
@@ -290,34 +295,31 @@ shared_examples_for "a baza driver" do
 
     expect(count).to eq 2500
 
-    #Test the flush-async which flushes transactions in a thread asyncronous.
+    # Test the flush-async which flushes transactions in a thread asyncronous.
     db.q_buffer(flush_async: true) do |buffer|
       count = 0
       db.select(:test_table) do |row|
         count += 1
 
-        if count == 1000
-          time_start = Time.now.to_f
-        end
+        time_start = Time.now.to_f if count == 1000
 
         buffer.delete(:test_table, id: row[:id])
 
-        if count == 1000
-          time_end = Time.now.to_f
+        next unless count == 1000
+        time_end = Time.now.to_f
 
-          time_spent = time_end - time_start
-          raise "Too much time spent: '#{time_spent}'." if time_spent > 0.01
-        end
+        time_spent = time_end - time_start
+        raise "Too much time spent: '#{time_spent}'." if time_spent > 0.01
       end
     end
 
     expect(test_table.rows_count).to eq 0
   end
 
-  describe 'results' do
+  describe "results" do
     before do
-      test_table.insert(text: 'test 1')
-      test_table.insert(text: 'test 2')
+      test_table.insert(text: "test 1")
+      test_table.insert(text: "test 2")
     end
 
     it '#to_a' do
@@ -342,37 +344,38 @@ shared_examples_for "a baza driver" do
     end
   end
 
-  it 'counts' do
-    test_table.insert(text: 'test 1')
-    expect(db.count(:test, text: 'test 1')).to eq 1
+  it "counts" do
+    test_table.insert(text: "test 1")
+    expect(db.count(:test, text: "test 1")).to eq 1
   end
 
-  it 'doesnt do type translation by default' do
+  it "doesnt do type translation by default" do
     expect(row.fetch(:text).class).to eq String
     expect(row.fetch(:number).class).to eq String
     expect(row.fetch(:float).class).to eq String
   end
 
-  it 'does type translation' do
-    db_with_type_translation.tables.create(:test, {
-      columns: [
-        {name: "id", type: :int, autoincr: true, primarykey: true},
-        {name: "text", type: :varchar},
-        {name: 'number', type: :int},
-        {name: 'float', type: :float},
-        {name: 'created_at', type: :datetime},
-        {name: 'date', type: :date}
-      ]
-    })
+  it "does type translation" do
+    db_with_type_translation.tables.create(:test, columns: [
+      {name: "id", type: :int, autoincr: true, primarykey: true},
+      {name: "text", type: :varchar},
+      {name: "number", type: :int},
+      {name: "float", type: :float},
+      {name: "created_at", type: :datetime},
+      {name: "date", type: :date}
+    ])
 
-    db_with_type_translation.insert(:test, text: 'Kasper', number: 30, float: 4.5, created_at: Time.now, date: Date.new(2015, 06, 17))
+    db_with_type_translation.insert(:test, text: "Kasper", number: 30, float: 4.5, created_at: Time.now, date: Date.new(2015, 06, 17))
 
-    row = db_with_type_translation.select(:test, text: 'Kasper').fetch
+    row = db_with_type_translation.select(:test, text: "Kasper").fetch
 
     expect(row.fetch(:text).class).to eq String
     expect(row.fetch(:number).class).to eq Fixnum
     expect(row.fetch(:float).class).to eq Float
-    expect(row.fetch(:created_at).class).to eq Time
-    expect(row.fetch(:date).class).to eq Date
+
+    unless db.driver.conn.class.name == "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
+      expect(row.fetch(:created_at).class).to eq Time
+      expect(row.fetch(:date).class).to eq Date
+    end
   end
 end

data/spec/support/driver_columns_collection.rb

@@ -1,15 +1,13 @@
 shared_examples_for "a baza columns driver" do
-  let(:driver){ constant.new }
-  let(:db){ driver.db }
-  let(:test_table){
-    db.tables.create("test", {
-      columns: [
-        {name: "id", type: :int, autoincr: true, primarykey: true},
-        {name: "text", type: :varchar}
-      ]
-    })
+  let(:driver) { constant.new }
+  let(:db) { driver.db }
+  let(:test_table) do
+    db.tables.create("test", columns: [
+      {name: "id", type: :int, autoincr: true, primarykey: true},
+      {name: "text", type: :varchar}
+    ])
     db.tables[:test]
-  }
+  end
 
   before do
     driver.before
@@ -20,19 +18,17 @@ shared_examples_for "a baza columns driver" do
   end
 
   it "renames columns for renamed tables" do
-    # Load up columns to make them set table-name.
-    test_table.columns.each do |name, column|
-    end
+    test_table.columns # Load up columns to make them set table-name.
 
     test_table.rename("test2")
-    test_table.columns[:text].change(name: "text2")
+    test_table.column(:text).change(name: "text2")
 
     table = db.tables[:test2]
-    column = table.columns[:text2]
-    column.table.name.should eq :test2
+    column = table.column(:text2)
+    column.table.name.should eq "test2"
   end
 
-  it "should create columns right" do
+  it "creates columns right" do
     col_id = test_table.column(:id)
     col_id.type.should eq :int
 
@@ -40,20 +36,20 @@ shared_examples_for "a baza columns driver" do
     col_text.type.should eq :varchar
   end
 
-  it "should be able to change columns" do
+  it "is able to change columns" do
     col_text = test_table.column(:text)
     col_text.change(name: "text2", type: :int, default: 5)
 
     col_text.type.should eq :int
     col_text.default.should eq "5"
-    col_text.name.should eq :text2
+    col_text.name.should eq "text2"
   end
 
-  it "should be able to drop a column" do
+  it "is able to drop a column" do
     test_table.column(:text).drop
 
-    expect {
+    expect do
       test_table.column(:text)
-    }.to raise_error(Errno::ENOENT)
+    end.to raise_error(Baza::Errors::ColumnNotFound)
   end
 end

data/spec/support/driver_databases_collection.rb

@@ -0,0 +1,29 @@
+shared_examples_for "a baza databases driver" do
+  let(:driver) { constant.new }
+  let(:driver2) { constant.new }
+  let(:db) { driver.db }
+  let(:db2) { driver2.db }
+  let(:test_database) do
+    db.databases.create(name: "baza-test-create", if_not_exists: true)
+    db.databases["baza-test-create"]
+  end
+
+  it "renames database" do
+    begin
+      db.databases["renamed-db"].drop
+    rescue Baza::Errors::DatabaseNotFound
+      # Ignore - it shouldn't exist
+    end
+
+    test_database.name = "renamed-db"
+    test_database.save!
+
+    expect(test_database.name).to eq "renamed-db"
+  end
+
+  it "drops databases" do
+    test_database.drop
+
+    expect { db.databases["baza-test-create"] }.to raise_error(Baza::Errors::DatabaseNotFound)
+  end
+end

data/spec/support/driver_indexes_collection.rb

@@ -2,7 +2,8 @@ shared_examples_for "a baza indexes driver" do
   let(:driver) { constant.new }
   let(:db) { driver.db }
   let(:test_table) do
-    db.tables.create("test", {
+    db.tables.create(
+      "test",
       columns: [
         {name: "id", type: :int, autoincr: true, primarykey: true},
         {name: "text", type: :varchar},
@@ -12,7 +13,7 @@ shared_examples_for "a baza indexes driver" do
         :text,
         {name: :email, unique: true, columns: [:email]}
       ]
-    })
+    )
     db.tables[:test]
   end
 
@@ -35,13 +36,13 @@ shared_examples_for "a baza indexes driver" do
 
     table = db.tables[:test2]
     index = table.index(:index_on_text2)
-    index.table.name.should eq :test2
+    expect(index.table.name).to eq "test2"
   end
 
-  it "should raise an error when index is not found" do
-    expect {
+  it "raises an error when an index isn't found" do
+    expect do
       test_table.index("index_that_doesnt_exist")
-    }.to raise_error(Errno::ENOENT)
+    end.to raise_error(Baza::Errors::IndexNotFound)
   end
 
   describe "#unique?" do

data/spec/support/driver_tables_collection.rb

@@ -1,17 +1,15 @@
 shared_examples_for "a baza tables driver" do
-  let(:driver){ constant.new }
-  let(:driver2){ constant.new }
-  let(:db){ driver.db }
-  let(:db2){ driver2.db }
-  let(:test_table){
-    db.tables.create("test", {
-      columns: [
-        {name: "id", type: :int, autoincr: true, primarykey: true},
-        {name: "text", type: :varchar}
-      ]
-    })
+  let(:driver) { constant.new }
+  let(:driver2) { constant.new }
+  let(:db) { driver.db }
+  let(:db2) { driver2.db }
+  let(:test_table) do
+    db.tables.create("test", columns: [
+      {name: "id", type: :int, autoincr: true, primarykey: true},
+      {name: "text", type: :varchar}
+    ])
     db.tables[:test]
-  }
+  end
 
   before do
     driver.before
@@ -21,36 +19,40 @@ shared_examples_for "a baza tables driver" do
     driver.after
   end
 
-  it "should create tables" do
-    test_table.name.should eq :test
-    db.tables[:test].should_not eq nil
+  it "creates tables" do
+    expect(test_table.name).to eq "test"
+    expect(db.tables[:test]).to_not eq nil
   end
 
-  it "should list tables" do
+  it "#list" do
     test_table
-    db.tables.list.values.should include test_table
+    expect(db.tables.list).to include test_table
   end
 
-  it "should optimize tables" do
+  it "#optimize" do
     test_table.optimize
     # FIXME: How to validate?
   end
 
-  it "should truncate tables" do
+  it "#truncate" do
     test_table
 
     db.insert(:test, text: "test")
-    test_table.rows_count.should eq 1
+    expect(db.select(:test).fetch.fetch(:id).to_i).to eq 1
+    expect(test_table.rows_count).to eq 1
 
     # Throw out invalid encoding because it will make dumping fail.
     db.tables[:test].truncate
-    test_table.rows_count.should eq 0
+    expect(test_table.rows_count).to eq 0
+
+    db.insert(:test, text: "test")
+    expect(db.select(:test).fetch.fetch(:id).to_i).to eq 1
   end
 
   it "#clone" do
     test_table
     test_table.create_indexes([{name: "index_on_text", columns: ["text"]}])
-    test_table.indexes.length.should eq 1
+    expect(test_table.indexes.length).to eq 1
 
     test_table.insert(text: "test1")
     test_table.insert(text: "test2")
@@ -58,9 +60,19 @@ shared_examples_for "a baza tables driver" do
     test_table.clone("test2")
     test_table2 = db.tables[:test2]
 
-    test_table2.columns.length.should eq test_table.columns.length
-    test_table2.indexes.length.should eq test_table.indexes.length
-    test_table2.rows_count.should eq test_table.rows_count
-    test_table2.rows_count.should eq 2
+    expect(test_table2.columns.length).to eq test_table.columns.length
+    expect(test_table2.indexes.length).to eq test_table.indexes.length
+    expect(test_table2.rows_count).to eq test_table.rows_count
+    expect(test_table2.rows_count).to eq 2
+  end
+
+  describe "#reload" do
+    it "reloads the data on the table" do
+      test_table.reload
+      expect(test_table.name).to eq "test"
+
+      test_table.drop
+      expect { test_table.reload }.to raise_error(Baza::Errors::TableNotFound)
+    end
   end
 end