rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/unit/plugin/timestamp_spec.rb

@@ -1,117 +0,0 @@
-require 'rom/sql/plugin/timestamps'
-
-RSpec.describe 'Plugin / Timestamp' do
-  include_context 'users'
-  include_context 'notes'
-
-  with_adapters do
-    before do
-      conf.commands(:notes) do
-        define :create do
-          result :one
-          use :timestamps
-          timestamp :updated_at, :created_at
-          datestamp :written
-        end
-
-        define :create_many, type: :create do
-          result :many
-          use :timestamps
-          timestamp :updated_at, :created_at
-        end
-
-        define :update do
-          use :timestamps
-          timestamp :updated_at
-        end
-
-        define :create_with_user, type: :create do
-          result :one
-          use :timestamps
-          timestamp :updated_at, :created_at
-
-          before :assign_user
-          def assign_user(tuple, user)
-            tuple.merge(user_id: user[:id])
-          end
-        end
-      end
-
-      conf.commands(:users) do
-        define :create do
-          result :one
-        end
-      end
-    end
-
-    it "applies timestamps by default" do
-      time   = DateTime.now
-      result = container.commands[:notes].create.call(text: "This is a test")
-
-      created = DateTime.parse(result[:created_at].to_s)
-      updated = DateTime.parse(result[:updated_at].to_s)
-
-      expect(created).to be_within(1).of(time)
-      expect(updated).to eq created
-    end
-
-    it "applies datestamps by default" do
-      result = container.commands[:notes].create.call(text: "This is a test")
-      expect(Date.parse(result[:written].to_s)).to eq Date.today
-    end
-
-    it "sets timestamps on multi-tuple inputs" do
-      time = DateTime.now
-      input = [{text: "note one"}, {text: "note two"}]
-
-      results = container.commands[:notes].create_many.call(input)
-
-      results.each do |result|
-        created = DateTime.parse(result[:created_at].to_s)
-
-        expect(created).to be_within(1).of(time)
-      end
-    end
-
-    it "only updates specified timestamps" do
-      initial = container.commands[:notes].create.call(text: "testing")
-      sleep 1  # Unfortunate, but unless I start injecting clocks into the
-               # command, this is needed to make sure the time actually changes
-      updated = container.commands[:notes].update.call(text: "updated test").first
-
-      expect(updated[:created_at]).to eq initial[:created_at]
-      expect(updated[:updated_at]).not_to eq initial[:updated_at]
-    end
-
-    it "allows overriding timestamps" do |ex|
-      tomorrow = (Time.now + (60 * 60 * 24))
-
-      container.commands[:notes].create.call(text: "testing")
-      updated = container.commands[:notes].update.call(text: "updated test", updated_at: tomorrow).first
-
-      if jruby? && sqlite?(ex)
-        expect(updated[:updated_at]).to eql(tomorrow.strftime('%Y-%m-%d %H:%M:%S.%6N'))
-      else
-        expect(updated[:updated_at].iso8601).to eql(tomorrow.iso8601)
-      end
-    end
-
-    it "works with chained commands" do
-      create_user = container.commands[:users].create.curry(name: "John Doe")
-      create_note = container.commands[:notes].create_with_user.curry(text: "new note")
-
-      time   = DateTime.now
-      command = create_user >> create_note
-
-      result = command.call
-
-      created = DateTime.parse(result[:created_at].to_s)
-      updated = DateTime.parse(result[:updated_at].to_s)
-
-      expect(result[:user_id]).not_to be_nil
-      expect(created).to be_within(1).of(time)
-      expect(updated).to eq created
-   end
-
-  end
-end

data/spec/unit/projection_dsl_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::ProjectionDSL, :postgres, helpers: true do
-  include_context 'database setup'
-
-  subject(:dsl) do
-    ROM::SQL::ProjectionDSL.new(schema)
-  end
-
-  let(:schema) do
-    define_schema(:users, id: ROM::SQL::Types::Serial, name: ROM::SQL::Types::String, meta: ROM::SQL::Types::PG::JSONB)
-  end
-
-  let(:ds) do
-    conn[:users]
-  end
-
-  describe '#call' do
-    it 'evaluates the block and returns an array with attribute types' do
-      literals = dsl
-                   .call { int::count(id).as(:count) }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%(COUNT("id") AS "count")])
-    end
-
-    it 'supports chaining attribute db functions' do
-      literals = dsl
-                   .call { meta.pg_jsonb.get_text("name").as(:name) }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%{("meta" ->> 'name') AS "name"}])
-    end
-
-    it 'supports functions with args and chaining with other functions' do
-      literals = dsl
-                   .call { int::count(id.qualified).distinct }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%(COUNT(DISTINCT "users"."id"))])
-    end
-
-    it 'supports functions with args and chaining with other functions and an alias' do
-      literals = dsl
-                   .call { int::count(id.qualified).distinct.as(:count) }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%(COUNT(DISTINCT "users"."id") AS "count")])
-    end
-
-    it 'supports functions with arg being an attribute' do
-      literals = dsl
-                   .call { int::count(id).as(:count) }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%(COUNT("id") AS "count")])
-    end
-
-    it 'supports functions with arg being a qualified attribute' do
-      literals = dsl
-                   .call { int::count(id.qualified).as(:count) }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%(COUNT("users"."id") AS "count")])
-    end
-
-    it 'supports selecting literal strings' do
-      literals = dsl
-                   .call { `'event'`.as(:type) }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%('event' AS "type")])
-    end
-
-    it 'supports functions without return value' do
-      literals = dsl
-                   .call { void::pg_advisory_lock(1).as(:lock) }
-                   .map { |attr| attr.sql_literal(ds) }
-
-      expect(literals).to eql([%(PG_ADVISORY_LOCK(1) AS "lock")])
-    end
-  end
-
-  describe '#method_missing' do
-    it 'responds to methods matching attribute names' do
-      expect(dsl.id).to eql(schema[:id])
-      expect(dsl.name).to eql(schema[:name])
-    end
-
-    it 'responds to methods matching type identifiers' do
-      expect(dsl.int).to eql(ROM::SQL::Types::Int)
-      expect(dsl.string).to eql(ROM::SQL::Types::String)
-      expect(dsl.bool).to eql(ROM::SQL::Types::Bool)
-    end
-
-    it 'responds to methods matching type names' do
-      expect(dsl.DateTime).to eql(ROM::SQL::Types::DateTime)
-    end
-
-    it 'returns sql functions with return type specified' do
-      function = ROM::SQL::Function.new(ROM::SQL::Types::String).upper(schema[:name])
-
-      expect(dsl.string::upper(schema[:name])).to eql(function)
-    end
-
-    it 'raises NoMethodError when there is no matching attribute or type' do
-      expect { dsl.not_here }.to raise_error(NoMethodError, /not_here/)
-    end
-  end
-end

data/spec/unit/relation/assoc_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::Relation do
-  include_context 'users and tasks'
-
-  context 'with has_many' do
-    subject(:users) { relations[:users] }
-
-    let(:tasks) { relations[:tasks] }
-
-    before do
-      conf.relation(:users) do
-        schema(infer: true) do
-          associations do
-            has_many :tasks
-          end
-        end
-      end
-    end
-
-    with_adapters do
-      it 'returns child tuples for a relation' do
-        expect(users.assoc(:tasks).where(name: 'Jane').to_a).
-          to eql([{ id: 2, user_id: 1, title: "Jane's task" }])
-      end
-    end
-  end
-
-  context 'with has_many-through' do
-    subject(:tasks) { relations[:tasks] }
-
-    before do
-      conf.relation(:task_tags) do
-        schema(infer: true) do
-          associations do
-            belongs_to :tasks
-            belongs_to :tags
-          end
-        end
-      end
-
-      conf.relation(:tasks) do
-        schema(infer: true) do
-          associations do
-            has_many :tags, through: :task_tags
-          end
-        end
-      end
-
-      conn[:tags].insert id: 2, name: 'whatevah'
-      conn[:task_tags].insert(tag_id: 2, task_id: 2)
-    end
-
-    with_adapters do
-      it 'returns child tuples for a relation' do
-        expect(tasks.assoc(:tags).to_a).
-          to eql([{ id: 1, name: 'important', task_id: 1 }, { id: 2, name: 'whatevah', task_id: 2 }])
-      end
-
-      it 'returns child tuples for a restricted relation' do
-        expect(tasks.assoc(:tags).where(title: "Jane's task").to_a).
-          to eql([{ id: 2, name: 'whatevah', task_id: 2 }])
-      end
-    end
-  end
-
-  context 'with belongs_to' do
-    subject(:tasks) { relations[:tasks] }
-
-    before do
-      conf.relation(:tasks) do
-        schema(infer: true) do
-          associations do
-            belongs_to :users, as: :user
-          end
-        end
-      end
-    end
-
-    with_adapters do
-      it 'returns parent tuples for a relation' do
-        expect(tasks.assoc(:user).where(title: "Jane's task").to_a).
-          to eql([{ id: 1, task_id: 2, name: 'Jane' }])
-      end
-    end
-  end
-end

data/spec/unit/relation/associations_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe ROM::Relation, '#associations' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    context 'with schema' do
-      it 'returns configured primary key from the schema' do
-        conf.relation(:users) do
-          schema(infer: true) do
-            associations do
-              has_many :tasks
-            end
-          end
-        end
-
-        expect(relation.associations[:tasks]).to be(container.relations.users.schema.associations[:tasks])
-      end
-    end
-
-    context 'without schema' do
-      it 'returns an empty association set' do
-        expect(relation.associations.elements).to be_empty
-      end
-    end
-  end
-end

data/spec/unit/relation/avg_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ROM::Relation, '#avg' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'delegates to dataset and return value' do
-      expect(relation.avg(:id)).to eql(1.5)
-    end
-  end
-end

data/spec/unit/relation/by_pk_spec.rb

@@ -1,62 +0,0 @@
-RSpec.describe ROM::Relation, '#by_pk' do
-  include_context 'users and tasks'
-
-  with_adapters do
-    context 'with a single PK' do
-      subject(:relation) { relations[:users] }
-
-      it 'restricts a relation by its PK' do
-        expect(relation.by_pk(1).to_a).to eql([id: 1, name: 'Jane'])
-      end
-
-      it 'is available as a view' do
-        expect(relation.by_pk).to be_curried
-      end
-
-      it 'qualifies pk attr' do
-        expect(relation.qualified.by_pk(1).select(:id).join(:tasks, user_id: :id).one).to eql(id: 1)
-      end
-
-      it 'works even when PK is not projected' do
-        expect(relation.select(:name).by_pk(1).to_a).to eql([name: 'Jane'])
-      end
-    end
-
-    context 'with a composite PK' do
-      subject(:relation) { relations[:task_tags] }
-
-      it 'restricts a relation by is PK' do
-        expect(relation.by_pk(1, 1).to_a).to eql([{ tag_id: 1, task_id: 1 }])
-      end
-
-      it 'works even when PK is not projected' do
-        expect(relation.by_pk(1, 1).select { `1`.as(:num) }.to_a).to eql([num: 1])
-      end
-    end
-
-    context 'without PK' do
-      subject(:relation) { relations[:people] }
-
-      before do
-        conn.drop_table?(:people)
-
-        conn.create_table(:people) do
-          column :name, String
-        end
-
-        conf.relation(:people) do
-          schema do
-            attribute :name, ROM::SQL::Types::String
-          end
-        end
-      end
-
-      it 'raises a meaningful exception' do
-        expect { relation.by_pk(1) }.to \
-          raise_error(
-            ROM::SQL::MissingPrimaryKeyError,
-            'Missing primary key for :people')
-      end
-    end
-  end
-end

data/spec/unit/relation/dataset_spec.rb

@@ -1,50 +0,0 @@
-RSpec.describe ROM::Relation, '#dataset' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  let(:dataset) { container.gateways[:default].dataset(:users) }
-
-  with_adapters do
-    context 'with schema' do
-      before do
-        conf.relation(:users) do
-          schema do
-            attribute :id, ROM::SQL::Types::Serial
-            attribute :name, ROM::SQL::Types::String
-          end
-        end
-      end
-
-      it 'uses schema to infer default dataset' do
-        expect(relation.dataset.sql).
-          to eql(dataset.select(Sequel.qualify(:users, :id), Sequel.qualify(:users, :name)).order(Sequel.qualify(:users, :id)).sql)
-      end
-    end
-
-    context 'with cherry-picked attributes in schema' do
-      before do
-        conf.relation(:users) do
-          schema do
-            attribute :id, ROM::SQL::Types::Serial
-          end
-        end
-      end
-
-      it 'uses schema to infer default dataset' do
-        expect(relation.dataset.sql).
-          to eql(dataset.select(Sequel.qualify(:users, :id)).order(Sequel.qualify(:users, :id)).sql)
-      end
-    end
-
-    context 'with inferred schema' do
-      before do
-        conf.relation(:users) { schema(infer: true) }
-      end
-
-      it 'selects all qualified columns and sorts by pk' do
-        expect(relation.dataset.sql).to eql(dataset.select(*relation.schema.qualified).order(Sequel.qualify(:users, :id)).sql)
-      end
-    end
-  end
-end