rom-sql 0.8.0 → 0.9.0

data/spec/unit/association/one_to_many_spec.rb

@@ -8,6 +8,26 @@ RSpec.describe ROM::SQL::Association::OneToMany, helpers: true do
   let(:users) { double(:users, primary_key: :id) }
   let(:tasks) { double(:tasks) }
 
+  describe '#associate' do
+    let(:source) { :users }
+    let(:target) { :tasks }
+
+    let(:relations) do
+      { users: users, tasks: tasks }
+    end
+
+    it 'returns child tuple with FK set' do
+      expect(tasks).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+      task_tuple = { title: 'Task' }
+      user_tuple = { id: 3 }
+
+      expect(assoc.associate(relations, task_tuple, user_tuple)).to eql(
+        user_id: 3, title: 'Task'
+      )
+    end
+  end
+
   shared_examples_for 'one-to-many association' do
     describe '#combine_keys' do
       it 'returns a hash with combine keys' do

data/spec/unit/association/one_to_one_spec.rb

@@ -5,8 +5,29 @@ RSpec.describe ROM::SQL::Association::OneToOne, helpers: true do
 
   let(:options) { {} }
 
-  let(:users) { double(:users, primary_key: :id) }
-  let(:tasks) { double(:tasks) }
+  let(:users)   { double(:users, primary_key: :id) }
+  let(:tasks)   { double(:tasks) }
+  let(:avatars) { double(:avatars) }
+
+  describe '#associate' do
+    let(:source) { :users }
+    let(:target) { :avatar }
+
+    let(:relations) do
+      { users: users, avatar: avatars }
+    end
+
+    it 'returns child tuple with FK set' do
+      expect(avatars).to receive(:foreign_key).with(:users).and_return(:user_id)
+
+      avatar_tuple = { url: 'http://rom-rb.org/images/logo.svg' }
+      user_tuple   = { id: 3 }
+
+      expect(assoc.associate(relations, avatar_tuple, user_tuple)).to eql(
+        user_id: 3, url: 'http://rom-rb.org/images/logo.svg'
+      )
+    end
+  end
 
   shared_examples_for 'one-to-one association' do
     describe '#combine_keys' do

data/spec/unit/association_errors_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'Association errors' do
+RSpec.describe 'Association errors', :postgres do
   include_context 'users and tasks'
 
   describe 'accessing an undefined association' do

data/spec/unit/gateway_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 require 'rom/lint/spec'
 
-describe ROM::SQL::Gateway do
+RSpec.describe ROM::SQL::Gateway, :postgres do
   include_context 'users and tasks'
 
   let(:gateway) { container.gateways[:default] }
@@ -10,13 +10,14 @@ describe ROM::SQL::Gateway do
   it_behaves_like 'a rom gateway' do
     let(:identifier) { :sql }
     let(:gateway) { ROM::SQL::Gateway }
-    let(:uri) { POSTGRES_DB_URI }
   end
 
-  describe 'sqlite with a file db' do
+  describe 'sqlite with a file db', :sqlite, postgres: false do
+    before do
+      Tempfile.new('test.sqlite')
+    end
+
     it 'establishes an sqlite connection' do
-      db_file = Tempfile.new('test.sqlite')
-      uri = "#{defined?(JRUBY_VERSION) ? 'jdbc:sqlite' : 'sqlite'}://#{db_file.path}"
       gateway = ROM::SQL::Gateway.new(uri)
       expect(gateway).to be_instance_of(ROM::SQL::Gateway)
     end
@@ -37,10 +38,10 @@ describe ROM::SQL::Gateway do
       migrator = double('migrator')
 
       expect(Sequel).to receive(:connect)
-        .with(POSTGRES_DB_URI, host: '127.0.0.1')
+        .with(uri, host: '127.0.0.1')
         .and_return(conn)
 
-      gateway = ROM::SQL::Gateway.new(POSTGRES_DB_URI, migrator: migrator, host: '127.0.0.1')
+      gateway = ROM::SQL::Gateway.new(uri, migrator: migrator, host: '127.0.0.1')
 
       expect(gateway.options).to eql(migrator: migrator)
     end
@@ -49,7 +50,7 @@ describe ROM::SQL::Gateway do
       extensions = [:pg_array, :pg_enum]
       connection = Sequel.connect uri
 
-      expect(connection).to receive(:extension).with(:pg_array, :pg_enum)
+      expect(connection).to receive(:extension).with(:pg_array, :pg_json, :pg_enum)
 
       ROM::SQL::Gateway.new(connection, extensions: extensions)
     end

data/spec/unit/logger_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Logger' do
+RSpec.describe 'Logger', :postgres do
   include_context 'database setup'
 
   it 'sets up a logger for sequel' do

data/spec/unit/migration_tasks_spec.rb

@@ -6,9 +6,9 @@ namespace :db do
   end
 end
 
-describe 'MigrationTasks' do
-  let(:conf) { ROM::Configuration.new(:sql, POSTGRES_DB_URI) }
-  let!(:container) { ROM.container(conf) }
+RSpec.describe 'MigrationTasks', :postgres, skip_tables: true do
+  include_context 'database setup'
+
   let(:migrator) { container.gateways[:default].migrator }
 
   before do

data/spec/unit/migrator_spec.rb

@@ -1,7 +1,8 @@
-RSpec.describe ROM::SQL::Migration::Migrator do
+RSpec.describe ROM::SQL::Migration::Migrator, :postgres, skip_tables: true do
+  include_context 'database setup'
+
   subject(:migrator) { ROM::SQL::Migration::Migrator.new(conn, options) }
 
-  let(:conn) { Sequel.connect(POSTGRES_DB_URI) }
   let(:options) { { path: TMP_PATH.join('test/migrations') } }
 
   describe '#create_file' do

data/spec/unit/plugin/assoc_macros/combined_associations_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'Defining multiple associations' do
+RSpec.describe 'Defining multiple associations', :postgres do
   include_context 'users and tasks'
 
   it 'extends relation with association methods' do

data/spec/unit/plugin/assoc_macros/many_to_many_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'Defining many-to-one association' do
+RSpec.describe 'Defining many-to-one association', :postgres do
   include_context 'users and tasks'
 
   it 'extends relation with association methods' do

data/spec/unit/plugin/assoc_macros/many_to_one_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'Defining many-to-one association' do
+RSpec.describe 'Defining many-to-one association', :postgres do
   include_context 'users and tasks'
 
   before do

data/spec/unit/plugin/assoc_macros/one_to_many_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'Defining one-to-many association' do
+RSpec.describe 'Defining one-to-many association', :postgres do
   include_context 'users and tasks'
 
   before do

data/spec/unit/relation/associations_spec.rb

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,15 @@
+RSpec.describe ROM::Relation, '#by_pk' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    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
+  end
+end

data/spec/unit/relation/dataset_spec.rb

@@ -0,0 +1,48 @@
+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).to eql(dataset.select(:id, :name).order(:users__id))
+      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).to eql(dataset.select(:id).order(:users__id))
+      end
+    end
+
+    context 'without schema' do
+      before do
+        conf.relation(:users)
+      end
+
+      it 'selects all qualified columns and sorts by pk' do
+        expect(relation.dataset).to eql(dataset.select(*relation.columns).order(:users__id))
+      end
+    end
+  end
+end

data/spec/unit/relation/distinct_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe ROM::Relation, '#distinct' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    if !metadata[:sqlite]
+      it 'delegates to dataset and returns a new relation' do
+        expect(relation.dataset).to receive(:distinct).with(:name).and_call_original
+        expect(relation.distinct(:name)).to_not eql(relation)
+      end
+    end
+  end
+end

data/spec/unit/relation/exclude_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe ROM::Relation, '#exclude' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'delegates to dataset and returns a new relation' do
+      expect(relation.dataset)
+        .to receive(:exclude).with(name: 'Jane').and_call_original
+      expect(relation.exclude(name: 'Jane')).to_not eq(relation)
+    end
+  end
+end

data/spec/unit/relation/fetch_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe ROM::Relation, '#fetch' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    describe '#fetch' do
+      it 'returns a single tuple identified by the pk' do
+        expect(relation.fetch(1)).to eql(id: 1, name: 'Jane')
+      end
+
+      it 'raises when tuple was not found' do
+        expect { relation.fetch(535315412) }.to raise_error(ROM::TupleCountMismatchError)
+      end
+
+      it 'raises when more tuples were returned' do
+        expect { relation.fetch([1, 2]) }.to raise_error(ROM::TupleCountMismatchError)
+      end
+    end
+  end
+end

data/spec/unit/relation/having_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe ROM::Relation, '#having' do
+  subject(:relation) do
+    container.relations.users
+      .inner_join(:tasks, user_id: :id)
+      .select_group(:users__id, :users__name)
+      .select_append { count(:tasks).as(:task_count) }
+  end
+
+  include_context 'users and tasks'
+
+  with_adapters :postgres do
+    before do
+      conn[:tasks].insert(id: 3, user_id: 2, title: "Joe's another task")
+    end
+
+    it 'restricts a relation using HAVING clause' do
+      expect(relation.having { count(:tasks__id) >= 2 }.to_a).to eq([{ id: 2, name: 'Joe', task_count: 2 }])
+    end
+  end
+end

data/spec/unit/relation/inner_join_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe ROM::Relation, '#inner_join' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'joins relations using inner join' do
+      result = relation.inner_join(:tasks, user_id: :id).select(:name, :title)
+
+      expect(result.to_a).to eql([
+        { name: 'Jane', title: "Jane's task" },
+        { name: 'Joe', title: "Joe's task" }
+      ])
+    end
+
+    it 'raises error when column names are ambiguous' do
+      expect {
+        relation.inner_join(:tasks, user_id: :id).to_a
+      }.to raise_error(Sequel::DatabaseError, /ambiguous/)
+    end
+  end
+end

data/spec/unit/relation/inspect_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe ROM::Relation, '#inspect' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'includes dataset' do
+      expect(relation.inspect).to include('dataset')
+    end
+  end
+end

data/spec/unit/relation/invert_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe ROM::Relation, '#invert' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'delegates to dataset and returns a new relation' do
+      expect(relation.dataset).to receive(:invert).and_call_original
+      expect(relation.invert).to_not eq(relation)
+    end
+  end
+end

data/spec/unit/relation/left_join_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe ROM::Relation, '#left_join' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'joins relations using left outer join' do
+      result = relation.left_join(:tasks, user_id: :id).select(:name, :title)
+
+      expect(result.to_a).to match_array([
+        { name: 'Joe', title: "Joe's task" },
+        { name: 'Jane', title: "Jane's task" }
+      ])
+    end
+  end
+end

data/spec/unit/relation/map_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe ROM::Relation, '#map' do
+  subject(:relation) { container.relations.users }
+
+  include_context 'users and tasks'
+
+  with_adapters do
+    it 'yields tuples' do
+      result = relation.map { |tuple| tuple[:name] }
+      expect(result).to eql(%w(Jane Joe))
+    end
+
+    it 'plucks value' do
+      expect(relation.map(:name)).to eql(%w(Jane Joe))
+    end
+  end
+end