baza 0.0.20 → 0.0.21

data/spec/support/driver_collection.rb

@@ -9,12 +9,16 @@ shared_examples_for "a baza driver" do
     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},
+        {name: "created_at", type: :datetime}
+      ]
+    )
     db.tables[:test]
   end
 
@@ -28,62 +32,29 @@ shared_examples_for "a baza driver" do
     driver2.after
   end
 
-  it "should do revisions" do
-    test_table
-
-    schema = {
-      tables: {
-        test_table: {
-          columns: [
-            {name: "id", type: :int, autoincr: true, primarykey: true},
-            {name: "name", type: :varchar},
-            {name: "age", type: :int, default: 0},
-            {name: "nickname", type: :varchar, default: ""}
-          ],
-          indexes: [
-            "name"
-          ],
-          rows: [
-            {
-              find_by: {"id" => 1},
-              data: {"id" => 1, "name" => "trala"}
-            }
-          ]
-        }
-      }
-    }
-
-    rev = Baza::Revision.new
-    rev.init_db(schema: schema, debug: false, db: db)
-
-    test_table = db.tables[:test_table]
-    expect(test_table.columns.map(&:name)).to include "age"
-    expect(test_table.columns.map(&:name)).to include "nickname"
-  end
-
   it "does id-queries" do
     test_table
 
     rows_count = 1250
     db.transaction do
-      0.upto(rows_count) do |count|
+      rows_count.times do |count|
         db.insert(:test, text: "User #{count}")
       end
     end
 
     block_ran = 0
-    idq = Baza::Idquery.new(db: db, debug: false, table: :test, query: "SELECT id FROM test") do |_data|
+    Baza::Idquery.new(db: db, debug: false, table: :test, query: "SELECT id FROM test") do
       block_ran += 1
     end
 
-    raise "Block with should have ran too little: #{block_ran}." if block_ran < rows_count
+    expect(block_ran).to eq rows_count
 
     block_ran = 0
-    db.select(:test, {}, idquery: true) do |_data|
+    db.select(:test, {}, idquery: true) do
       block_ran += 1
     end
 
-    raise "Block with should have ran too little: #{block_ran}." if block_ran < rows_count
+    expect(block_ran).to eq rows_count
   end
 
   it "does unbuffered queries" do
@@ -94,7 +65,7 @@ shared_examples_for "a baza driver" do
     end
 
     count_results = 0
-    db.q("SELECT * FROM test", type: :unbuffered) do |row|
+    db.query_ubuf("SELECT * FROM test") do |row|
       expect(row[:text]).to eq "Test #{count_results}"
       count_results += 1
     end
@@ -102,7 +73,7 @@ shared_examples_for "a baza driver" do
     expect(count_results).to eq 10
   end
 
-  it "does upserting" do
+  it "#upsert" do
     test_table.create_columns([{name: "nickname", type: :varchar}])
 
     # Test upserting.
@@ -116,17 +87,53 @@ shared_examples_for "a baza driver" do
 
     db.upsert(:test, data, sel)
     row = db.select(:test, sel).fetch
-    row[:text].should eq "upsert - Kasper Johansen"
+    expect(row[:text]).to eq "upsert - Kasper Johansen"
 
     table.reload
-    table.rows_count.should eql(rows_count + 1)
+    expect(table.rows_count).to eq rows_count + 1
 
     db.upsert(:test, data2, sel)
     row = db.select(:test, sel).fetch
-    row[:text].should eq "upsert - Kasper Nielsen Johansen"
+    expect(row[:text]).to eq "upsert - Kasper Nielsen Johansen"
 
     table.reload
-    table.rows_count.should eq rows_count + 1
+    expect(table.rows_count).to eq rows_count + 1
+  end
+
+  describe "#upsert_duplicate_key" do
+    before do
+      test_table.create_indexes([name: "unique_text", columns: ["text"], unique: true])
+    end
+
+    it "inserts records with terms" do
+      expect(test_table.rows_count).to eq 0
+      test_table.upsert_duplicate_key({number: 2}, text: "test1")
+      expect(test_table.rows_count).to eq 1
+    end
+
+    it "updates existing records with terms" do
+      test_table.insert(text: "test1", number: 1)
+      test_table.upsert_duplicate_key({number: 2}, text: "test1")
+      expect(test_table.rows_count).to eq 1
+
+      rows = test_table.rows.to_a.map(&:to_hash)
+      rows[0][:float] = "0.0" if rows[0][:float] == "0"
+      expect(rows).to eq [{id: "1", text: "test1", number: "2", float: "0.0", created_at: ""}]
+    end
+
+    it "inserts with empty terms" do
+      expect(test_table.rows_count).to eq 0
+      id = test_table.upsert_duplicate_key({text: "test2"}, {}, return_id: true)
+      expect(test_table.rows_count).to eq 1
+      expect(id).to eq 1
+    end
+
+    it "updates existing records with empty terms" do
+      test_table.insert(text: "test1", number: 1)
+      id = test_table.upsert_duplicate_key({number: 2, text: "test1"}, {}, return_id: true)
+      expect(test_table.rows_count).to eq 1
+      expect(id).to eq 1
+    end
   end
 
   it "dumps as SQL" do
@@ -139,9 +146,7 @@ shared_examples_for "a baza driver" do
     tables_count = db.tables.list.length
 
     # Remove everything in the db.
-    db.tables.list do |table|
-      table.drop unless table.native?
-    end
+    db.tables.list.select(&:native?).each(&:drop)
 
     # Run the exported SQL.
     db.transaction do
@@ -154,69 +159,29 @@ shared_examples_for "a baza driver" do
     raise "Not same amount of tables: #{tables_count}, #{db.tables.list.length}" if tables_count != db.tables.list.length
   end
 
-  it "renames tables in revisions" do
-    test_table
-
-    Baza::Revision.new.init_db(
-      db: db,
-      debug: false,
-      schema: {
-        tables: {
-          new_test_table: {
-            renames: [:test]
-          }
-        }
-      }
-    )
-
-    tables = db.tables.list.map(&:name)
-
-    expect(tables).to_not include "test"
-    expect(tables).to include "new_test_table"
-  end
-
-  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]}
-            ]
-          }
-        }
-      }
-    )
-
-    columns = db.tables[:new_test_table].columns.map(&:name)
-    expect(columns).to_not include "text"
-    expect(columns).to include "new_name"
-  end
-
   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')")
+    expect(db.insert(:test, {date: time}, return_sql: true)).to eq "INSERT INTO #{db.sep_table}test#{db.sep_table} (#{db.sep_col}date#{db.sep_col}) VALUES (#{db.sep_val}1985-06-17 10:30:00#{db.sep_val})"
 
     date = Date.new(1985, 6, 17)
-    db.insert(:test, {date: date}, return_sql: true).should eql("INSERT INTO `test` (`date`) VALUES ('1985-06-17')")
+    expect(db.insert(:test, {date: date}, return_sql: true)).to eq "INSERT INTO #{db.sep_table}test#{db.sep_table} (#{db.sep_col}date#{db.sep_col}) VALUES (#{db.sep_val}1985-06-17#{db.sep_val})"
   end
 
   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.driver.conn)
+      Baza::Db.from_object(object: db.driver.conn)
     end
   end
 
   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}
-    ])
+    db.tables.create(
+      :test_table,
+      columns: [
+        {name: :idrow, type: :int, autoincr: true, primarykey: true},
+        {name: :name, type: :varchar}
+      ]
+    )
 
     count = 0
     100.times do
@@ -233,17 +198,20 @@ shared_examples_for "a baza driver" do
     db.select(:test_table, nil, idquery: :idrow) do |row|
       count_found += 1
 
-      row[:name].should eq "Kasper #{count_found}"
+      expect(row[:name]).to eq "Kasper #{count_found}"
     end
 
     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}
-    ])
+  it "uses query buffers" do
+    db.tables.create(
+      :test_table,
+      columns: [
+        {name: :id, type: :int, autoincr: true, primarykey: true},
+        {name: :name, type: :varchar}
+      ]
+    )
 
     upsert = false
     count_inserts = 0
@@ -300,16 +268,15 @@ shared_examples_for "a baza driver" do
       count = 0
       db.select(:test_table) do |row|
         count += 1
-
         time_start = Time.now.to_f if count == 1000
 
-        buffer.delete(:test_table, id: row[:id])
+        buffer.delete(:test_table, id: row.fetch(:id))
 
         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
+        raise "Too much time spent: '#{time_spent}'." if time_spent > 0.015
       end
     end
 
@@ -356,14 +323,17 @@ shared_examples_for "a baza driver" do
   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}
-    ])
+    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))
 
@@ -373,9 +343,54 @@ shared_examples_for "a baza driver" do
     expect(row.fetch(:number).class).to eq Fixnum
     expect(row.fetch(:float).class).to eq Float
 
-    unless db.driver.conn.class.name == "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
+    if db.driver.conn.class.name == "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
+      check_time_and_date = false
+    elsif db.driver.class.name == "Baza::Driver::ActiveRecord" && RUBY_PLATFORM == "java"
+      check_time_and_date = false
+    else
+      check_time_and_date = true
+    end
+
+    if check_time_and_date
       expect(row.fetch(:created_at).class).to eq Time
       expect(row.fetch(:date).class).to eq Date
     end
   end
+
+  it "returns arguments used to connect" do
+    require_relative "../../lib/baza/driver/active_record"
+
+    unless db.driver.is_a?(Baza::Driver::ActiveRecord)
+      args = db.driver.class.args
+      expect(args).to be_a Array
+    end
+  end
+
+  it "#new_query" do
+    test_table
+    test_table.insert(text: "Kasper")
+
+    query = db.new_query.from(:test).where(text: "Kasper").to_a
+    query[0][:float] = query[0][:float].to_f.to_s if query[0][:float] == "0"
+    expect(query.to_a).to eq [{id: "1", text: "Kasper", number: "0", float: "0.0", created_at: ""}]
+  end
+
+  it "#last_id" do
+    test_table.insert(text: "Kasper")
+    expect(db.last_id).to eq 1
+  end
+
+  it "handels null values for datetimes" do
+    id = test_table.insert({text: "Kasper"}, return_id: true)
+    row = test_table.row(id)
+    expect(row[:created_at]).to eq ""
+  end
+
+  describe "#insert" do
+    it "returns id" do
+      test_table
+      id = db.insert("test", {text: "Kasper"}, return_id: true)
+      expect(id).to eq 1
+    end
+  end
 end

data/spec/support/driver_columns_collection.rb

@@ -2,10 +2,13 @@ shared_examples_for "a baza columns driver" do
   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.create(
+      "test",
+      columns: [
+        {name: "id", type: :int, autoincr: true, primarykey: true},
+        {name: "text", type: :varchar}
+      ]
+    )
     db.tables[:test]
   end
 
@@ -25,24 +28,30 @@ shared_examples_for "a baza columns driver" do
 
     table = db.tables[:test2]
     column = table.column(:text2)
-    column.table.name.should eq "test2"
+    expect(column.table.name).to eq "test2"
   end
 
   it "creates columns right" do
     col_id = test_table.column(:id)
-    col_id.type.should eq :int
+    expect(col_id.type).to eq :int
+    expect(col_id.primarykey?).to eq true
+    expect(col_id.autoincr?).to eq true
+    expect(col_id.default).to eq nil
 
     col_text = test_table.column(:text)
-    col_text.type.should eq :varchar
+    expect(col_text.type).to eq :varchar
+    expect(col_text.primarykey?).to eq false
+    expect(col_text.autoincr?).to eq false
+    expect(col_text.default).to eq nil
   end
 
   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"
+    expect(col_text.type).to eq :int
+    expect(col_text.default).to eq "5"
+    expect(col_text.name).to eq "text2"
   end
 
   it "is able to drop a column" do

data/spec/support/driver_databases_collection.rb

@@ -11,7 +11,9 @@ shared_examples_for "a baza databases driver" do
   it "renames database" do
     begin
       db.databases["renamed-db"].drop
+    # rubocop:disable Lint/HandleExceptions
     rescue Baza::Errors::DatabaseNotFound
+      # rubocop:enable Lint/HandleExceptions
       # Ignore - it shouldn't exist
     end
 
@@ -23,7 +25,27 @@ shared_examples_for "a baza databases driver" do
 
   it "drops databases" do
     test_database.drop
-
     expect { db.databases["baza-test-create"] }.to raise_error(Baza::Errors::DatabaseNotFound)
   end
+
+  it "creates tables" do
+    if test_database.table_exists?("test")
+      puts "DROPPING TEST TABLE"
+      test_database.table("test").drop
+    end
+
+    test_database.create_table(
+      "test",
+      columns: [
+        {name: :id, type: :int, autoincr: true, primarykey: true},
+        {name: :name, type: :varchar}
+      ]
+    )
+
+    tables = test_database.tables.map(&:name).to_a
+    expect(tables).to eq ["test"]
+
+    table = test_database.table("test")
+    expect(table.name).to eq "test"
+  end
 end