rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/shared/puppies.rb

@@ -1,15 +0,0 @@
-RSpec.shared_context 'puppies' do
-  before do
-    inferrable_relations.concat %i(puppies)
-  end
-
-  before do
-    conn.create_table :puppies do
-      primary_key :id
-      String :name, null: false
-      boolean :cute, null: false, default: true
-    end
-
-    conf.relation(:puppies) { schema(infer: true) }
-  end
-end

data/spec/shared/relations.rb

@@ -1,8 +0,0 @@
-RSpec.shared_context 'relations' do
-  include_context 'users and tasks'
-
-  before do
-    conf.relation(:users) { schema(infer: true) }
-    conf.relation(:tasks) { schema(infer: true) }
-  end
-end

data/spec/shared/users.rb

@@ -1,32 +0,0 @@
-RSpec.shared_context 'users' do
-  include_context 'database setup'
-
-  before do
-    inferrable_relations.concat %i(users)
-  end
-
-  let(:users) { container.relations[:users] }
-  let(:user_commands) { container.commands[:users] }
-
-  let(:jane_id) { 1 }
-  let(:joe_id) { 2 }
-
-  before do |example|
-    ctx = self
-
-    conn.create_table :users do
-      primary_key :id
-      String :name, text: false, null: false
-      check { char_length(name) > 2 } if ctx.postgres?(example)
-    end
-
-    conf.relation(:users) { schema(infer: true) }
-  end
-
-  before do |example|
-    next if example.metadata[:seeds] == false
-
-    conn[:users].insert name: 'Jane'
-    conn[:users].insert name: 'Joe'
-  end
-end

data/spec/shared/users_and_tasks.rb

@@ -1,50 +0,0 @@
-RSpec.shared_context 'users and tasks' do
-  include_context 'users'
-
-  let(:tasks) { container.relations[:tasks] }
-  let(:tags) { container.relations[:tags] }
-
-  let(:task_commands) { container.commands[:tasks] }
-  let(:tag_commands) { container.commands[:tags] }
-
-  before do
-    inferrable_relations.concat %i(tasks tags task_tags)
-  end
-
-  before do |example|
-    ctx = self
-
-    conn.create_table :tasks do
-      primary_key :id
-      foreign_key :user_id, :users
-      String :title, text: false
-      constraint(:title_length) { char_length(title) > 1 } if ctx.postgres?(example)
-      constraint(:title_length) { length(title) > 1 }      if ctx.sqlite?(example)
-    end
-
-    conn.create_table :tags do
-      primary_key :id
-      String :name
-    end
-
-    conn.create_table :task_tags do
-      primary_key [:tag_id, :task_id]
-      Integer :tag_id
-      Integer :task_id
-    end
-
-    conf.relation(:tasks) { schema(infer: true) }
-    conf.relation(:task_tags) { schema(infer: true) }
-    conf.relation(:tags) { schema(infer: true) }
-  end
-
-  before do |example|
-    next if example.metadata[:seeds] == false
-
-    conn[:tasks].insert id: 1, user_id: 2, title: "Joe's task"
-    conn[:tasks].insert id: 2, user_id: 1, title: "Jane's task"
-
-    conn[:tags].insert id: 1, name: 'important'
-    conn[:task_tags].insert(tag_id: 1, task_id: 1)
-  end
-end

data/spec/spec_helper.rb

@@ -1,122 +0,0 @@
-require 'bundler'
-Bundler.setup
-
-if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
-  require 'yaml'
-  rubies = YAML.load(File.read(File.join(__dir__, '..', '.travis.yml')))['rvm']
-  latest_mri = rubies.select { |v| v =~ /\A\d+\.\d+.\d+\z/ }.max
-
-  if RUBY_VERSION == latest_mri
-    require 'simplecov'
-    SimpleCov.start do
-      add_filter '/spec/'
-    end
-  end
-end
-
-require 'rom-sql'
-require 'rom/sql/rake_task'
-
-require 'logger'
-require 'tempfile'
-
-begin
-  require ENV['DEBUGGER'] || 'byebug'
-rescue LoadError
-  require 'pry'
-end
-
-LOGGER = Logger.new(File.open('./log/test.log', 'a'))
-ENV['TZ'] ||= 'UTC'
-
-oracle_settings = {
-  db_name: ENV.fetch('ROM_ORACLE_DATABASE', 'xe'),
-  host: ENV.fetch('ROM_ORACLE_HOST', 'localhost'),
-  port: Integer(ENV.fetch('ROM_ORACLE_PORT', '1521'))
-}
-
-if defined? JRUBY_VERSION
-  DB_URIS = {
-    sqlite: 'jdbc:sqlite:::memory',
-    postgres: 'jdbc:postgresql://localhost/rom_sql',
-    mysql: 'jdbc:mysql://localhost/rom_sql?user=root&sql_mode=STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION',
-    oracle: ENV['ROM_USE_ORACLE'] ? fail('Setup Oracle for JRuby!') : nil
-  }
-else
-  DB_URIS = {
-    sqlite: 'sqlite::memory',
-    postgres: 'postgres://localhost/rom_sql',
-    mysql: 'mysql2://root@localhost/rom_sql?sql_mode=STRICT_TRANS_TABLES,NO_ENGINE_SUBSTITUTION',
-    oracle: "oracle://#{ oracle_settings[:host] }:#{ oracle_settings[:port] }/" \
-            "#{ oracle_settings[:db_name] }?username=rom_sql&password=rom_sql&autosequence=true"
-  }
-end
-
-ADAPTERS = ENV['ROM_USE_ORACLE'] ? DB_URIS.keys : DB_URIS.keys - %i(oracle)
-PG_LTE_95 = ENV.fetch('PG_LTE_95', 'true') == 'true'
-
-SPEC_ROOT = root = Pathname(__FILE__).dirname
-
-TMP_PATH = root.join('../tmp')
-
-# quiet in specs
-ROM::SQL::Relation.tap { |r| r.schema_inferrer(r.schema_inferrer.suppress_errors) }
-
-require 'dry/core/deprecations'
-Dry::Core::Deprecations.set_logger!(root.join('../log/deprecations.log'))
-
-ROM::SQL.load_extensions(:postgres, :sqlite)
-
-require 'dry-types'
-module Types
-  include Dry::Types.module
-end
-
-def with_adapters(*args, &block)
-  reset_adapter = Hash[*ADAPTERS.flat_map { |a| [a, false] }]
-  adapters = args.empty? || args[0] == :all ? ADAPTERS : (args & ADAPTERS)
-
-  adapters.each do |adapter|
-    context("with #{adapter}", **reset_adapter, adapter => true, &block)
-  end
-end
-
-warning_api_available = RUBY_VERSION >= '2.4.0'
-
-module SileneceWarnings
-  def warn(str)
-    if str['/sequel/'] || str['/rspec-core']
-      nil
-    else
-      super
-    end
-  end
-end
-
-Warning.extend(SileneceWarnings) if warning_api_available
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.warnings = warning_api_available
-
-  config.before(:suite) do
-    tmp_test_dir = TMP_PATH.join('test')
-    FileUtils.rm_r(tmp_test_dir) if File.exist?(tmp_test_dir)
-    FileUtils.mkdir_p(tmp_test_dir)
-  end
-
-  config.before do
-    module Test
-    end
-  end
-
-  config.after do
-    Object.send(:remove_const, :Test)
-  end
-
-  Dir[root.join('shared/**/*.rb')].each { |f| require f }
-  Dir[root.join('support/**/*.rb')].each { |f| require f }
-
-  config.include(Helpers, helpers: true)
-  config.include ENVHelper
-end

data/spec/support/env_helper.rb

@@ -1,25 +0,0 @@
-module ENVHelper
-  def db?(type, example)
-    example.metadata[type]
-  end
-
-  def postgres?(example)
-    db?(:postgres, example)
-  end
-
-  def mysql?(example)
-    db?(:mysql, example)
-  end
-
-  def sqlite?(example)
-    db?(:sqlite, example)
-  end
-
-  def oracle?(example)
-    db?(:oracle, example)
-  end
-
-  def jruby?
-    defined? JRUBY_VERSION
-  end
-end

data/spec/support/helpers.rb

@@ -1,24 +0,0 @@
-module Helpers
-  def assoc_name(*args)
-    ROM::Relation::Name[*args]
-  end
-
-  def define_schema(name, attrs = [])
-    relation_name = ROM::Relation::Name.new(name)
-    ROM::SQL::Schema.define(
-      relation_name,
-      attributes: attrs.map { |key, value| value.meta(name: key, source: relation_name) },
-      attr_class: ROM::SQL::Attribute
-    )
-  end
-
-  def define_attribute(name, id, **opts)
-    ROM::SQL::Attribute.new(ROM::Types.const_get(id).meta(name: name, **opts))
-  end
-
-  def build_assoc(type, *args)
-    klass = Dry::Core::Inflector.classify(type)
-    definition = ROM::Associations::Definitions.const_get(klass).new(*args)
-    ROM::SQL::Associations.const_get(definition.type).new(definition, relations)
-  end
-end

data/spec/support/oracle/create_users.sql

@@ -1,7 +0,0 @@
-alter database default tablespace USERS;
-
-CREATE USER rom_sql IDENTIFIED BY rom_sql;
-
-GRANT unlimited tablespace, create session, create table, create sequence,
-create procedure, create trigger, create view, create materialized view,
-create database link, create synonym, create type, ctxapp TO rom_sql;

data/spec/support/oracle/set_sys_passwords.sql

@@ -1,2 +0,0 @@
--- alter user sys identified by admin;
--- alter user system identified by admin;

data/spec/support/test_configuration.rb

@@ -1,16 +0,0 @@
-require 'rom/configuration'
-
-class TestConfiguration < ROM::Configuration
-  def relation(name, &block)
-    if registered_relation_names.include?(name)
-      setup.relation_classes.delete_if do |klass|
-        klass.relation_name.relation == name
-      end
-    end
-    super
-  end
-
-  def registered_relation_names
-    setup.relation_classes.map(&:relation_name).map(&:relation)
-  end
-end

data/spec/unit/attribute_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::Attribute, :postgres do
-  include_context 'users and tasks'
-
-  let(:ds) { users.dataset }
-
-  describe '#is' do
-    context 'with a standard value' do
-      it 'returns a boolean expression' do
-        expect(users[:id].is(1).sql_literal(ds)).to eql('("id" = 1)')
-      end
-
-      it 'returns a boolean equality expression for qualified attribute' do
-        expect((users[:id].qualified.is(1)).sql_literal(ds)).to eql('("users"."id" = 1)')
-      end
-    end
-
-    context 'with a nil value' do
-      it 'returns an IS NULL expression' do
-        expect(users[:id].is(nil).sql_literal(ds)).to eql('("id" IS NULL)')
-      end
-
-      it 'returns an IS NULL expression for qualified attribute' do
-        expect((users[:id].qualified.is(nil)).sql_literal(ds)).to eql('("users"."id" IS NULL)')
-      end
-    end
-
-    context 'with a boolean true' do
-      it 'returns an IS TRUE expression' do
-        expect(users[:id].is(true).sql_literal(ds)).to eql('("id" IS TRUE)')
-      end
-
-      it 'returns an IS TRUE expression for qualified attribute' do
-        expect((users[:id].qualified.is(true)).sql_literal(ds)).to eql('("users"."id" IS TRUE)')
-      end
-    end
-
-    context 'with a boolean false' do
-      it 'returns an IS FALSE expression' do
-        expect(users[:id].is(false).sql_literal(ds)).to eql('("id" IS FALSE)')
-      end
-
-      it 'returns an IS FALSE expression for qualified attribute' do
-        expect((users[:id].qualified.is(false)).sql_literal(ds)).to eql('("users"."id" IS FALSE)')
-      end
-    end
-  end
-
-  describe '#not' do
-    context 'with a standard value' do
-      it 'returns a negated boolean equality expression' do
-        expect(users[:id].not(1).sql_literal(ds)).to eql('("id" != 1)')
-      end
-
-      it 'returns a negated boolean equality expression for qualified attribute' do
-        expect((users[:id].qualified.not(1)).sql_literal(ds)).to eql('("users"."id" != 1)')
-      end
-    end
-
-    context 'with a nil value' do
-      it 'returns an IS NOT NULL expression' do
-        expect(users[:id].not(nil).sql_literal(ds)).to eql('("id" IS NOT NULL)')
-      end
-
-      it 'returns an IS NOT NULL expression for qualified attribute' do
-        expect((users[:id].qualified.not(nil)).sql_literal(ds)).to eql('("users"."id" IS NOT NULL)')
-      end
-    end
-
-    context 'with a boolean true' do
-      it 'returns an IS NOT TRUE expression' do
-        expect(users[:id].not(true).sql_literal(ds)).to eql('("id" IS NOT TRUE)')
-      end
-
-      it 'returns an IS NOT TRUE expression for qualified attribute' do
-        expect((users[:id].qualified.not(true)).sql_literal(ds)).to eql('("users"."id" IS NOT TRUE)')
-      end
-    end
-
-    context 'with a boolean false' do
-      it 'returns an IS NOT FALSE expression' do
-        expect(users[:id].not(false).sql_literal(ds)).to eql('("id" IS NOT FALSE)')
-      end
-
-      it 'returns an IS NOT FALSE expression for qualified attribute' do
-        expect((users[:id].qualified.not(false)).sql_literal(ds)).to eql('("users"."id" IS NOT FALSE)')
-      end
-    end
-  end
-
-  describe '#!' do
-    it 'returns a new attribute with negated sql expr' do
-      expect((!users[:id].is(1)).sql_literal(ds)).to eql('("id" != 1)')
-    end
-  end
-
-  describe '#concat' do
-    it 'returns a concat function attribute' do
-      expect(users[:id].concat(users[:name]).as(:uid).sql_literal(ds)).
-        to eql(%(CONCAT("id", ' ', "name") AS "uid"))
-    end
-  end
-end

data/spec/unit/function_spec.rb

@@ -1,48 +0,0 @@
-require 'rom/sql/function'
-
-RSpec.describe ROM::SQL::Function, :postgres do
-  subject(:func) { ROM::SQL::Function.new(type) }
-
-  include_context 'database setup'
-
-  let(:ds) { container.gateways[:default][:users] }
-  let(:type) { ROM::SQL::Types::Int }
-
-  describe '#sql_literal' do
-    context 'without alias' do
-      specify do
-        expect(func.count(:id).sql_literal(ds)).to eql(%(COUNT("id")))
-      end
-    end
-
-    context 'with alias' do
-      specify do
-        expect(func.count(:id).as(:count).sql_literal(ds)).to eql(%(COUNT("id") AS "count"))
-      end
-    end
-  end
-
-  describe '#is' do
-    it 'returns an sql boolean expression' do
-      expect(ds.literal(func.count(:id).is(1))).to eql(%((COUNT("id") = 1)))
-    end
-  end
-
-  describe '#method_missing' do
-    it 'responds to anything when not set' do
-      expect(func.count(:id)).to be_instance_of(func.class)
-    end
-
-    it 'raises error when is set already' do
-      expect { func.count(:id).upper.sql_literal(ds) }.
-        to raise_error(NoMethodError, /upper/)
-    end
-  end
-
-  describe '#cast' do
-    it 'transforms data' do
-      expect(func.cast(:id, 'varchar').sql_literal(ds)).
-        to eql(%(CAST("id" AS varchar(255))))
-    end
-  end
-end