baza 0.0.38 → 0.0.39

data/spec/support/driver_databases_collection.rb

@@ -1,48 +0,0 @@
-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
-    # rubocop:disable Lint/HandleExceptions
-    rescue Baza::Errors::DatabaseNotFound
-      # rubocop:enable Lint/HandleExceptions
-      # 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
-
-  it "creates tables" do
-    test_database.table("test").drop if test_database.table_exists?("test")
-
-    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

data/spec/support/driver_foreign_keys_collection.rb

@@ -1,54 +0,0 @@
-shared_examples_for "a baza foreign keys driver" do
-  let(:driver) { constant.new }
-  let(:db) { driver.db }
-  let(:posts_table) do
-    db.tables.create(
-      "posts",
-      columns: [
-        {name: "id", type: :int, autoincr: true, primarykey: true},
-        {name: "user_id", type: :int},
-        {name: "text", type: :varchar}
-      ]
-    )
-    db.tables[:posts]
-  end
-  let(:users_table) do
-    db.tables.create(
-      "users",
-      columns: [
-        {name: "id", type: :int, autoincr: true, primarykey: true},
-        {name: "email", type: :varchar}
-      ]
-    )
-    db.tables[:users]
-  end
-  let(:users_id_column) { users_table.column("id") }
-  let(:user_id_foreign_key) do
-    posts_table.column("user_id").create_foreign_key(
-      column: users_id_column,
-      name: "test_column_key"
-    )
-    posts_table.foreign_key("test_column_key")
-  end
-
-  before do
-    driver.before
-  end
-
-  after do
-    driver.after
-  end
-
-  it "creates foreign keys" do
-    user_id_foreign_key
-
-    expect(posts_table.foreign_keys.length).to eq 1
-    expect(posts_table.foreign_key("test_column_key").name).to eq "test_column_key"
-  end
-
-  it "destroys foreign keys" do
-    user_id_foreign_key.drop
-
-    expect { posts_table.foreign_key("test_column_key") }.to raise_error(Baza::Errors::ForeignKeyNotFound)
-  end
-end

data/spec/support/driver_importer_collection.rb

@@ -1,38 +0,0 @@
-shared_examples_for "a baza importer driver" do
-  let(:driver) { constant.new(debug: false) }
-  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
-  end
-
-  after do
-    driver.after
-  end
-
-  it "imports sql" do
-    test_table
-
-    io = StringIO.new
-    dumper = Baza::Dump.new(db: db)
-    dumper.dump(io)
-    io.rewind
-
-    test_table.drop
-
-    importer = Baza::Commands::Importer.new(db: db, io: io)
-    importer.execute
-
-    expect(db.tables[:test].name).to eq "test"
-  end
-end

data/spec/support/driver_indexes_collection.rb

@@ -1,66 +0,0 @@
-shared_examples_for "a baza indexes 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},
-        {name: "email", type: :varchar}
-      ],
-      indexes: [
-        :text,
-        {name: :email, unique: true, columns: [:email]},
-        {name: :two_columns, columns: [:text, :email]}
-      ]
-    )
-    db.tables[:test]
-  end
-
-  before do
-    driver.before
-  end
-
-  after do
-    driver.after
-  end
-
-  it "renames indexes for renamed tables" do
-    # Load up columns to make them set table-name.
-    test_table.indexes.each do |name, index|
-    end
-
-    test_table.create_indexes([{name: "index_on_text", columns: [:text]}])
-    test_table.rename("test2")
-    test_table.index("index_on_text").rename("index_on_text2")
-
-    table = db.tables[:test2]
-    index = table.index(:index_on_text2)
-    expect(index.table.name).to eq "test2"
-  end
-
-  it "raises an error when an index isn't found" do
-    expect do
-      test_table.index("index_that_doesnt_exist")
-    end.to raise_error(Baza::Errors::IndexNotFound)
-  end
-
-  describe Baza::Index do
-    describe "#unique?" do
-      it "returns true when it is unique" do
-        expect(test_table.index("email").unique?).to eq true
-      end
-
-      it "returns false when it isn't unique" do
-        expect(test_table.index("text").unique?).to eq false
-      end
-    end
-
-    describe "#columns" do
-      it "returns the correct columns" do
-        expect(test_table.index("two_columns").columns).to eq %w(text email)
-      end
-    end
-  end
-end

data/spec/support/driver_tables_collection.rb

@@ -1,116 +0,0 @@
-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) 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
-  end
-
-  after do
-    driver.after
-  end
-
-  it "creates tables" do
-    expect(test_table.name).to eq "test"
-    expect(db.tables[:test].name).to eq "test"
-  end
-
-  describe "#exists?" do
-    it "returns true for tables that exists" do
-      test_table
-      expect(db.tables.exists?("test")).to eq true
-    end
-
-    it "returns false for tables that doesnt exist" do
-      expect(db.tables.exists?("testtest")).to eq false
-    end
-  end
-
-  it "#list" do
-    test_table
-    expect(db.tables.list).to include test_table
-  end
-
-  it "#optimize" do
-    test_table.optimize
-    # FIXME: How to validate?
-  end
-
-  it "#rows_count" do
-    expect(test_table.rows_count).to eq 0
-    test_table.insert(text: "Test")
-    expect(test_table.rows_count).to eq 1
-  end
-
-  it "#native?" do
-    expect(test_table.native?).to eq false
-  end
-
-  it "#row" do
-    expect { test_table.row(500) }.to raise_error(Baza::Errors::RowNotFound)
-    test_table.insert(id: 1, text: "Test")
-    expect(test_table.row(1)[:text]).to eq "Test"
-  end
-
-  it "#truncate" do
-    test_table
-
-    db.insert(:test, text: "test")
-    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
-    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"]}])
-
-    expect(test_table.indexes.length).to eq 1
-
-    test_table.insert(text: "test1")
-    test_table.insert(text: "test2")
-
-    test_table.clone("test2")
-    test_table2 = db.tables[:test2]
-
-    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
-
-  describe "Baza::Table#rows_count" do
-    it "returns the number of rows in the table" do
-      3.times { |n| test_table.insert(text: "Test #{n}") }
-      expect(test_table.rows_count).to eq 3
-    end
-  end
-end

data/spec/support/driver_users_collection.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-shared_examples_for "a baza users driver" do
-  let(:driver) { constant.new }
-  let(:db) { driver.db }
-  let(:test_user_name) { "baza-test-create" }
-  let(:user) { db.users.create(name: test_user_name, host: "localhost", password: "mypassword") }
-
-  before do
-    # Drop any existing user with the test user name
-    begin
-      db.users.find_by_name(test_user_name).drop
-    rescue Baza::Errors::UserNotFound # rubocop:disable Lint/HandleExceptions
-    end
-  end
-
-  it "Users#list" do
-    root_found = false
-    db.users.list do |user|
-      if user.name == "root"
-        root_found = true
-        break
-      end
-    end
-
-    expect(root_found).to eq true
-  end
-
-  it "Users#find_by_name" do
-    root_user = db.users.find_by_name("root")
-    expect(root_user.name).to eq "root"
-  end
-
-  it "Users#create" do
-    my_user = db.users.create(name: test_user_name, host: "localhost", password: "mypassword")
-
-    expect(my_user.name).to eq test_user_name
-    expect(my_user.host).to eq "localhost"
-  end
-
-  it "User#drop" do
-    user.drop
-    expect { db.users.find_by_name(test_user_name) }.to raise_error(Baza::Errors::UserNotFound)
-  end
-
-  it "User#name" do
-    expect(user.name).to eq test_user_name
-  end
-
-  it "User#host" do
-    expect(user.host).to eq "localhost"
-  end
-end