rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/integration/plugins/auto_restrictions_spec.rb

@@ -1,74 +0,0 @@
-RSpec.describe 'Plugins / :auto_restrictions', seeds: true do
-  include_context 'users and tasks'
-
-  with_adapters do
-    before do
-      conn.add_index :tasks, :title, unique: true
-    end
-
-    shared_context 'auto-generated restriction view' do
-      it 'defines restriction views for all indexed attributes' do
-        expect(tasks.select(:id).by_title("Jane's task").one).to eql(id: 2)
-      end
-
-      it 'defines curried methods' do
-        expect(tasks.by_title.("Jane's task").first).to eql(id: 2, user_id: 1, title: "Jane's task")
-      end
-    end
-
-    context 'with an inferred schema' do
-      before do
-        conf.plugin(:sql, relations: :auto_restrictions)
-      end
-
-      include_context 'auto-generated restriction view'
-    end
-
-    context 'with explicit schema' do
-      before do
-        conf.relation(:tasks) do
-          schema do
-            attribute :id, ROM::SQL::Types::Serial
-            attribute :user_id, ROM::SQL::Types::Int
-            attribute :title, ROM::SQL::Types::String.meta(index: true)
-
-            indexes do
-              index :user_id, :title
-            end
-          end
-
-          use :auto_restrictions
-        end
-      end
-
-      include_context 'auto-generated restriction view'
-
-      it 'generates restrictrions by a composite index' do
-        expect(tasks.by_user_id_and_title(1, "Jane's task").first).to eql(id: 2, user_id: 1, title: "Jane's task")
-      end
-    end
-
-    if metadata[:postgres]
-      # An auto-generated restriction should include the prediate from the index definition
-      # but it seems to be too much from my POV, better leave it to the user
-      # Note that this can be enabled later
-      it 'skips partial indexes' do
-        conf.relation(:tasks) do
-          schema do
-            attribute :id, ROM::SQL::Types::Serial
-            attribute :user_id, ROM::SQL::Types::Int
-            attribute :title, ROM::SQL::Types::String
-
-            indexes do
-              index :title, predicate: 'title is not null'
-            end
-          end
-
-          use :auto_restrictions
-        end
-
-        expect(tasks).not_to respond_to(:by_title)
-      end
-    end
-  end
-end

data/spec/integration/relation_schema_spec.rb

@@ -1,271 +0,0 @@
-RSpec.describe 'Inferring schema from database' do
-  include_context 'users'
-  include_context 'posts'
-
-  with_adapters do
-    context "when database schema exists" do
-      it "infers the schema from the database relations" do
-        conf.relation(:users)
-
-        expect(container.relations.users.to_a)
-          .to eql(container.gateways[:default][:users].to_a)
-      end
-    end
-
-    context "for empty database schemas" do
-      it "returns an empty schema" do
-        expect { container.users }.to raise_error(NoMethodError)
-      end
-    end
-
-    context 'defining associations', seeds: false do
-      let(:config) { TestConfiguration.new(:sql, conn) }
-      let(:container) { ROM.container(config) }
-
-      let(:user_associations) do
-        config.relation(:accounts) { schema(infer: true) }
-        config.relation(:cards) { schema(infer: true) }
-        config.register_relation(Test::Users)
-        container.relations[:users].associations
-      end
-
-      let(:post_associations) do
-        config.relation(:tags) { schema(infer: true) }
-        config.relation(:posts_tags) { schema(infer: true) }
-        config.register_relation(Test::Posts)
-        container.relations[:posts].associations
-      end
-
-      let(:tag_associations) do
-        config.relation(:posts) { schema(infer: true) }
-        config.relation(:posts_tags) { schema(infer: true) }
-        config.register_relation(Test::Tags)
-        container.relations[:tags].associations
-      end
-
-      it "allows defining a one-to-many" do
-        class Test::Posts < ROM::Relation[:sql]
-          schema(:posts) do
-            associations do
-              one_to_many :tags
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::OneToMany.new(:posts, :tags)
-
-        expect(post_associations[:tags].definition).to eql(assoc)
-      end
-
-      it "allows defining a one-to-many using has_many shortcut" do
-        class Test::Posts < ROM::Relation[:sql]
-          schema(:posts) do
-            associations do
-              has_many :tags
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::OneToMany.new(:posts, :tags)
-
-        expect(post_associations[:tags].definition).to eql(assoc)
-      end
-
-      it "allows defining a one-to-one" do
-        class Test::Users < ROM::Relation[:sql]
-          schema(:users) do
-            associations do
-              one_to_one :accounts
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::OneToOne.new(:users, :accounts)
-
-        expect(user_associations[:accounts].definition).to eql(assoc)
-      end
-
-      it "allows defining a one-to-one using has_one shortcut" do
-        class Test::Users < ROM::Relation[:sql]
-          schema(:users) do
-            associations do
-              has_one :account
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::OneToOne.new(:users, :accounts, as: :account)
-
-        expect(user_associations[:account].definition).to eql(assoc)
-        expect(user_associations[:account].definition.target).to be_aliased
-      end
-
-      it "allows defining a one-to-one using has_one shortcut with an alias" do
-        class Test::Users < ROM::Relation[:sql]
-          schema(:users) do
-            associations do
-              has_one :account, as: :user_account
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::OneToOne.new(:users, :accounts, as: :user_account)
-
-        expect(user_associations[:user_account].definition).to eql(assoc)
-        expect(user_associations[:user_account].definition.target).to be_aliased
-      end
-
-      it "allows defining a one-to-one-through" do
-        class Test::Users < ROM::Relation[:sql]
-          schema(:users) do
-            associations do
-              one_to_one :cards, through: :accounts
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::OneToOneThrough.new(:users, :cards, through: :accounts)
-
-        expect(user_associations[:cards].definition).to eql(assoc)
-      end
-
-      it "allows defining a many-to-one" do
-        class Test::Tags < ROM::Relation[:sql]
-          schema(:tags) do
-            associations do
-              many_to_one :posts
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts)
-
-        expect(tag_associations[:posts].definition).to eql(assoc)
-      end
-
-      it "allows defining a many-to-one using belongs_to shortcut" do
-        class Test::Tags < ROM::Relation[:sql]
-          schema(:tags) do
-            associations do
-              belongs_to :post
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts, as: :post)
-
-        expect(tag_associations[:post].definition).to eql(assoc)
-      end
-
-      it "allows defining a many-to-one using belongs_to shortcut" do
-        class Test::Tags < ROM::Relation[:sql]
-          schema(:tags) do
-            associations do
-              belongs_to :post, as: :post_tag
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts, as: :post_tag)
-
-        expect(tag_associations[:post_tag].definition).to eql(assoc)
-      end
-
-      it "allows defining a many-to-many" do
-        class Test::Posts < ROM::Relation[:sql]
-          schema(:posts) do
-            associations do
-              one_to_many :tags, through: :posts_tags
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::ManyToMany.new(:posts, :tags, through: :posts_tags)
-
-        expect(post_associations[:tags].definition).to eql(assoc)
-      end
-
-      it "allows defining a many-to-one with a custom name" do
-        class Test::Tags < ROM::Relation[:sql]
-          schema(:tags) do
-            associations do
-              many_to_one :posts, as: :published_posts
-            end
-          end
-        end
-
-        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts, as: :published_posts)
-
-        expect(tag_associations[:published_posts].definition).to eql(assoc)
-      end
-    end
-
-    context 'defining indexes', :helpers do |ctx|
-      it 'allows defining indexes' do
-        class Test::Tags < ROM::Relation[:sql]
-          schema(:tags) do
-            attribute :id,         Types::Serial
-            attribute :name,       Types::String
-            attribute :created_at, Types::Time
-            attribute :updated_at, Types::Time
-
-            indexes do
-              index :name
-              index :created_at, :name
-              index :updated_at, name: :recently_idx
-              index :created_at, name: :unique_date, unique: true
-            end
-          end
-        end
-
-        conf.register_relation(Test::Tags)
-        schema = container.relations[:tags].schema
-
-        expect(schema.indexes.to_a).
-          to contain_exactly(
-               ROM::SQL::Index.new([define_attribute(:name, :String, source: schema.name)]),
-               ROM::SQL::Index.new(
-                 [define_attribute(:created_at, :Time, source: schema.name),
-                  define_attribute(:name, :String, source: schema.name)]
-               ),
-               ROM::SQL::Index.new(
-                 [define_attribute(:updated_at, :Time, source: schema.name)],
-                 name: :recently_idx
-               ),
-               ROM::SQL::Index.new(
-                 [define_attribute(:created_at, :Time, source: schema.name)],
-                 name: :unique_date,
-                 unique: true
-               )
-             )
-      end
-
-      if metadata[:postgres]
-        it 'can provide index type' do
-          class Test::Tags < ROM::Relation[:sql]
-            schema(:tags) do
-              attribute :id,         Types::Serial
-              attribute :name,       Types::String
-
-              indexes do
-                index :name, type: :gist
-              end
-            end
-          end
-
-          conf.register_relation(Test::Tags)
-          schema = container.relations[:tags].schema
-          index = schema.indexes.first
-
-          expect(index).to eql(
-                             ROM::SQL::Index.new(
-                               [define_attribute(:name, :String, source: schema.name)],
-                               type: :gist)
-                           )
-
-          expect(index.type).to eql(:gist)
-        end
-      end
-    end
-  end
-end

data/spec/integration/schema/call_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::Schema, '#call' do
-  include_context 'users'
-
-  with_adapters :postgres do
-    before do
-      conf.relation(:users) do
-        schema(infer: true)
-      end
-    end
-
-    let(:schema) { relations[:users].schema }
-
-    it 'auto-projects a relation' do
-      expect(schema.(relations[:users]).dataset.sql).to eql('SELECT "id", "name" FROM "users" ORDER BY "users"."id"')
-    end
-
-    it 'maintains schema' do
-      projected = relations[:users].schema.project(:name)
-      expect(projected.(relations[:users]).schema).to be(projected)
-    end
-  end
-end

data/spec/integration/schema/inferrer/mysql_spec.rb

@@ -1,45 +0,0 @@
-RSpec.describe 'ROM::SQL::Schema::MysqlInferrer', :mysql do
-  include_context 'database setup'
-
-  before do
-    inferrable_relations.concat %i(test_inferrence)
-  end
-
-  before do
-    conn.create_table :test_inferrence do
-      tinyint :tiny
-      mediumint :medium
-      bigint :big
-      datetime :created_at
-      column :date_and_time, 'datetime(0)'
-      column :time_with_ms, 'datetime(3)'
-      timestamp :unix_time_usec
-      column :unix_time_sec, 'timestamp(0) null'
-      boolean :flag, null: false
-    end
-  end
-
-  before do
-    conf.relation(:test_inferrence) do
-      schema(infer: true)
-    end
-  end
-
-  let(:schema) { container.relations[:test_inferrence].schema }
-  let(:source) { container.relations[:test_inferrence].name }
-
-  it 'can infer attributes for dataset' do
-    expect(schema.to_h).
-      to eql(
-           tiny: ROM::SQL::Types::Int.optional.meta(name: :tiny, source: source),
-           medium: ROM::SQL::Types::Int.optional.meta(name: :medium, source: source),
-           big: ROM::SQL::Types::Int.optional.meta(name: :big, source: source),
-           created_at: ROM::SQL::Types::Time.optional.meta(name: :created_at, source: source),
-           date_and_time: ROM::SQL::Types::Time.optional.meta(name: :date_and_time, source: source),
-           time_with_ms: ROM::SQL::Types::Time.optional.meta(name: :time_with_ms, source: source),
-           unix_time_usec: ROM::SQL::Types::Time.meta(name: :unix_time_usec, source: source),
-           unix_time_sec: ROM::SQL::Types::Time.optional.meta(name: :unix_time_sec, source: source),
-           flag: ROM::SQL::Types::Bool.meta(name: :flag, source: source)
-         )
-  end
-end

data/spec/integration/schema/inferrer/postgres_spec.rb

@@ -1,203 +0,0 @@
-RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
-  include_context 'database setup'
-
-  before do
-    inferrable_relations.concat %i(test_inferrence)
-  end
-
-  colors = %w(red orange yellow green blue purple)
-
-  before do
-    conn.extension :pg_enum
-
-    conn.execute('create extension if not exists hstore')
-    conn.drop_table?(:test_inferrence)
-    conn.drop_enum(:rainbow, if_exists: true)
-
-    conn.create_enum(:rainbow, colors)
-
-    conn.create_table :test_inferrence do
-      primary_key :id, :uuid
-      bigint :big
-      Json :json_data
-      Jsonb :jsonb_data
-      Decimal :money, null: false
-      column :tags, "text[]"
-      column :tag_ids, "bigint[]"
-      column :ip, "inet"
-      column :subnet, "cidr"
-      column :hw_address, "macaddr"
-      rainbow :color
-      point :center
-      xml :page
-      hstore :mapping
-      line :line
-      circle :circle
-      box :box
-      lseg :lseg
-      polygon :polygon
-      path :path
-      timestamp :created_at
-      column :datetime, "timestamp(0) without time zone"
-      column :datetime_tz, "timestamp(0) with time zone"
-      boolean :flag, null: false
-    end
-  end
-
-  let(:schema) { container.relations[:test_inferrence].schema }
-  let(:source) { container.relations[:test_inferrence].name }
-
-  context 'inferring db-specific attributes' do
-    before do
-      conf.relation(:test_inferrence) do
-        schema(infer: true)
-      end
-    end
-
-    it 'can infer attributes for dataset' do
-      expect(schema.to_h).
-        to eql(
-             id: ROM::SQL::Types::PG::UUID.meta(name: :id, source: source, primary_key: true),
-             big: ROM::SQL::Types::Int.optional.meta(name: :big, source: source),
-             json_data: ROM::SQL::Types::PG::JSON.optional.meta(name: :json_data, source: source),
-             jsonb_data: ROM::SQL::Types::PG::JSONB.optional.meta(name: :jsonb_data, source: source),
-             money: ROM::SQL::Types::Decimal.meta(name: :money, source: source),
-             tags: ROM::SQL::Types::PG::Array('text').optional.meta(name: :tags, source: source),
-             tag_ids: ROM::SQL::Types::PG::Array('biging').optional.meta(name: :tag_ids, source: source),
-             color: ROM::SQL::Types::String.enum(*colors).optional.meta(name: :color, source: source),
-             ip: ROM::SQL::Types::PG::IPAddress.optional.meta(
-               name: :ip,
-               source: source,
-               read: ROM::SQL::Types::PG::IPAddressR.optional
-             ),
-             subnet: ROM::SQL::Types::PG::IPAddress.optional.meta(
-               name: :subnet,
-               source: source,
-               read: ROM::SQL::Types::PG::IPAddressR.optional
-             ),
-             hw_address: ROM::SQL::Types::String.optional.meta(name: :hw_address, source: source),
-             center: ROM::SQL::Types::PG::PointT.optional.meta(
-               name: :center,
-               source: source,
-               read: ROM::SQL::Types::PG::PointTR.optional
-             ),
-             page: ROM::SQL::Types::String.optional.meta(name: :page, source: source),
-             mapping: ROM::SQL::Types::PG::HStore.optional.meta(
-               name: :mapping,
-               source: source,
-               read: ROM::SQL::Types::PG::HStoreR.optional
-             ),
-             line: ROM::SQL::Types::PG::LineT.optional.meta(
-               name: :line,
-               source: source,
-               read: ROM::SQL::Types::PG::LineTR.optional
-             ),
-             circle: ROM::SQL::Types::PG::CircleT.optional.meta(
-               name: :circle,
-               source: source,
-               read: ROM::SQL::Types::PG::CircleTR.optional
-             ),
-             box: ROM::SQL::Types::PG::BoxT.optional.meta(
-               name: :box,
-               source: source,
-               read: ROM::SQL::Types::PG::BoxTR.optional
-             ),
-             lseg: ROM::SQL::Types::PG::LineSegmentT.optional.meta(
-               name: :lseg,
-               source: source,
-               read: ROM::SQL::Types::PG::LineSegmentTR.optional
-             ),
-             polygon: ROM::SQL::Types::PG::PolygonT.optional.meta(
-               name: :polygon,
-               source: source,
-               read: ROM::SQL::Types::PG::PolygonTR.optional
-             ),
-             path: ROM::SQL::Types::PG::PathT.optional.meta(
-               name: :path,
-               source: source,
-               read: ROM::SQL::Types::PG::PathTR.optional
-             ),
-             created_at: ROM::SQL::Types::Time.optional.meta(name: :created_at, source: source),
-             datetime: ROM::SQL::Types::Time.optional.meta(name: :datetime, source: source),
-             datetime_tz: ROM::SQL::Types::Time.optional.meta(name: :datetime_tz, source: source),
-             flag: ROM::SQL::Types::Bool.meta(name: :flag, source: source)
-           )
-    end
-  end
-
-  context 'with a table without columns' do
-    before do
-      conn.create_table(:dummy) unless conn.table_exists?(:dummy)
-      conf.relation(:dummy) { schema(infer: true) }
-    end
-
-    it 'does not fail with a weird error when a relation does not have attributes' do
-      expect(container.relations[:dummy].schema).to be_empty
-    end
-  end
-
-  context 'with a column with bi-directional mapping' do
-    before do
-      conn.execute('create extension if not exists hstore')
-
-      conn.create_table(:test_bidirectional) do
-        primary_key :id
-        inet :ip
-        point :center
-        hstore :mapping
-        line :line
-        circle :circle
-        box :box
-        lseg :lseg
-        polygon :polygon
-        path :closed_path
-        path :open_path
-      end
-
-      conf.relation(:test_bidirectional) { schema(infer: true) }
-
-      conf.commands(:test_bidirectional) do
-        define(:create) do
-          result :one
-        end
-      end
-    end
-
-    let(:point) { ROM::SQL::Types::PG::Point.new(7.5, 30.5) }
-    let(:point_2) { ROM::SQL::Types::PG::Point.new(8.5, 35.5) }
-    let(:line) { ROM::SQL::Types::PG::Line.new(2.3, 4.9, 3.1415) }
-    let(:dns) { IPAddr.new('8.8.8.8') }
-    let(:mapping) { Hash['hot' => 'cold'] }
-    let(:circle) { ROM::SQL::Types::PG::Circle.new(point, 1.0) }
-    let(:lseg) { ROM::SQL::Types::PG::LineSegment.new(point, point_2) }
-    let(:box_corrected) { ROM::SQL::Types::PG::Box.new(point_2, point) }
-    let(:box) do
-      upper_left = ROM::SQL::Types::PG::Point.new(point.x, point_2.y)
-      lower_right = ROM::SQL::Types::PG::Point.new(point_2.x, point.y)
-
-      ROM::SQL::Types::PG::Box.new(upper_left, lower_right)
-    end
-    let(:polygon) { ROM::SQL::Types::PG::Polygon[[point, point_2]] }
-    let(:closed_path) { ROM::SQL::Types::PG::Path.new([point, point_2], :closed) }
-    let(:open_path) { ROM::SQL::Types::PG::Path.new([point, point_2], :open) }
-
-    let(:relation) { container.relations[:test_bidirectional] }
-    let(:create) { commands[:test_bidirectional].create }
-
-    it 'writes and reads data & corrects data' do
-      # Box coordinates are reordered if necessary
-      inserted = create.call(
-        id: 1, center: point, ip: dns, mapping: mapping,
-        line: line, circle: circle, lseg: lseg, box: box,
-        polygon: polygon, closed_path: closed_path, open_path: open_path
-      )
-      expect(inserted).
-        to eql(
-             id: 1, center: point, ip: dns, mapping: mapping,
-             line: line, circle: circle, lseg: lseg, box: box_corrected,
-             polygon: polygon, closed_path: closed_path, open_path: open_path
-           )
-      expect(relation.to_a).to eql([inserted])
-    end
-  end
-end