rom-sql 0.7.0 → 0.8.0

data/spec/unit/association_errors_spec.rb

@@ -1,11 +1,9 @@
-require 'spec_helper'
-
-describe 'Association errors' do
+RSpec.describe 'Association errors' do
   include_context 'users and tasks'
 
   describe 'accessing an undefined association' do
     specify do
-      configuration.relation(:users) do
+      conf.relation(:users) do
         use :assoc_macros
 
         def with_undefined

data/spec/unit/gateway_spec.rb

@@ -10,7 +10,16 @@ describe ROM::SQL::Gateway do
   it_behaves_like 'a rom gateway' do
     let(:identifier) { :sql }
     let(:gateway) { ROM::SQL::Gateway }
-    let(:uri) { DB_URI }
+    let(:uri) { POSTGRES_DB_URI }
+  end
+
+  describe 'sqlite with a file db' do
+    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
   end
 
   describe '#dataset?' do
@@ -28,10 +37,10 @@ describe ROM::SQL::Gateway do
       migrator = double('migrator')
 
       expect(Sequel).to receive(:connect)
-        .with(DB_URI, host: '127.0.0.1')
+        .with(POSTGRES_DB_URI, host: '127.0.0.1')
         .and_return(conn)
 
-      gateway = ROM::SQL::Gateway.new(DB_URI, migrator: migrator, host: '127.0.0.1')
+      gateway = ROM::SQL::Gateway.new(POSTGRES_DB_URI, migrator: migrator, host: '127.0.0.1')
 
       expect(gateway.options).to eql(migrator: migrator)
     end

data/spec/unit/migration_tasks_spec.rb

@@ -7,12 +7,12 @@ namespace :db do
 end
 
 describe 'MigrationTasks' do
-  let(:configuration) { ROM::Configuration.new(:sql, DB_URI) }
-  let!(:container) { ROM.container(configuration) }
+  let(:conf) { ROM::Configuration.new(:sql, POSTGRES_DB_URI) }
+  let!(:container) { ROM.container(conf) }
   let(:migrator) { container.gateways[:default].migrator }
 
   before do
-    ROM::SQL::RakeSupport.stub(:env) { configuration }
+    allow(ROM::SQL::RakeSupport).to receive(:env) { conf }
   end
 
   context 'db:reset' do

data/spec/unit/migrator_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
-
-describe ROM::SQL::Migration::Migrator do
+RSpec.describe ROM::SQL::Migration::Migrator do
   subject(:migrator) { ROM::SQL::Migration::Migrator.new(conn, options) }
 
-  let(:conn) { Sequel.connect(DB_URI) }
+  let(:conn) { Sequel.connect(POSTGRES_DB_URI) }
   let(:options) { { path: TMP_PATH.join('test/migrations') } }
 
   describe '#create_file' do

data/spec/unit/{combined_associations_spec.rb → plugin/assoc_macros/combined_associations_spec.rb}

@@ -1,18 +1,12 @@
-require 'spec_helper'
-
-describe 'Defining multiple associations' do
+RSpec.describe 'Defining multiple associations' do
   include_context 'users and tasks'
 
-  before do
-    conn[:tasks].insert id: 2, user_id: 1, title: 'Go to sleep'
-  end
-
   it 'extends relation with association methods' do
-    configuration.relation(:users) { use :assoc_macros }
+    conf.relation(:users) { use :assoc_macros }
 
-    configuration.relation(:tags) { use :assoc_macros }
+    conf.relation(:tags) { use :assoc_macros }
 
-    configuration.relation(:tasks) do
+    conf.relation(:tasks) do
       use :assoc_macros
 
       many_to_one :users, key: :user_id
@@ -54,26 +48,26 @@ describe 'Defining multiple associations' do
     tasks = container.relations.tasks
 
     expect(tasks.with_user_and_tags.to_a).to eql([
-      { id: 1, title: 'Finish ROM', name: 'Piotr', tags_name: 'important' },
-      { id: 2, title: 'Go to sleep', name: 'Piotr',  tags_name: nil }
+      { id: 1, title: "Joe's task", name: 'Joe', tags_name: 'important' },
+      { id: 2, title: "Jane's task", name: 'Jane',  tags_name: nil }
     ])
 
     expect(tasks.with_user_and_tags.sorted_by_tags_name.to_a).to eql([
-      { id: 2, title: 'Go to sleep', name: 'Piotr',  tags_name: nil },
-      { id: 1, title: 'Finish ROM', name: 'Piotr', tags_name: 'important' }
+      { id: 2, title: "Jane's task", name: 'Jane',  tags_name: nil },
+      { id: 1, title: "Joe's task", name: 'Joe', tags_name: 'important' }
     ])
 
     expect(tasks.with_user_and_tags.by_tag('important').to_a).to eql([
-      { id: 1, title: 'Finish ROM', name: 'Piotr', tags_name: 'important' }
+      { id: 1, title: "Joe's task", name: 'Joe', tags_name: 'important' }
     ])
 
     expect(tasks.all.with_user.to_a).to eql([
-      { id: 1, title: 'Finish ROM', name: 'Piotr' },
-      { id: 2, title: 'Go to sleep', name: 'Piotr' }
+      { id: 1, title: "Joe's task", name: 'Joe' },
+      { id: 2, title: "Jane's task", name: 'Jane' }
     ])
 
-    expect(tasks.by_title('Go to sleep').to_a).to eql(
-      [{ id: 2, user_id: 1, title: 'Go to sleep' }]
+    expect(tasks.by_title("Jane's task").to_a).to eql(
+      [{ id: 2, user_id: 1, title: "Jane's task" }]
     )
   end
 end

data/spec/unit/{many_to_many_spec.rb → plugin/assoc_macros/many_to_many_spec.rb}

@@ -1,17 +1,11 @@
-require 'spec_helper'
-
-describe 'Defining many-to-one association' do
+RSpec.describe 'Defining many-to-one association' do
   include_context 'users and tasks'
 
-  before do
-    conn[:tasks].insert id: 2, user_id: 1, title: 'Go to sleep'
-  end
-
   it 'extends relation with association methods' do
-    configuration.relation(:tags) { use :assoc_macros }
-    configuration.relation(:task_tags) { use :assoc_macros }
+    conf.relation(:tags) { use :assoc_macros }
+    conf.relation(:task_tags) { use :assoc_macros }
 
-    configuration.relation(:tasks) do
+    conf.relation(:tasks) do
       use :assoc_macros
 
       many_to_many :tags,
@@ -41,17 +35,17 @@ describe 'Defining many-to-one association' do
     tasks = container.relations.tasks
 
     expect(tasks.all.with_tags.to_a).to eql([
-      { id: 1, title: 'Finish ROM', name: 'important' },
-      { id: 2, title: 'Go to sleep', name: nil }
+      { id: 1, title: "Joe's task", name: 'important' },
+      { id: 2, title: "Jane's task", name: nil }
     ])
 
     expect(tasks.all.with_tags_and_tag_id.to_a).to eql([
-      { id: 1, title: 'Finish ROM', tag_id: 1, name: 'important' },
-      { id: 2, title: 'Go to sleep', tag_id: nil, name: nil }
+      { id: 1, title: "Joe's task", tag_id: 1, name: 'important' },
+      { id: 2, title: "Jane's task", tag_id: nil, name: nil }
     ])
 
     expect(tasks.all.by_tag("important").to_a).to eql([
-      { id: 1, title: 'Finish ROM', name: 'important' }
+      { id: 1, title: "Joe's task", name: 'important' }
     ])
 
     expect(tasks.by_tag("not-here").to_a).to be_empty

data/spec/unit/{many_to_one_spec.rb → plugin/assoc_macros/many_to_one_spec.rb}

@@ -1,20 +1,15 @@
-require 'spec_helper'
-
-describe 'Defining many-to-one association' do
+RSpec.describe 'Defining many-to-one association' do
   include_context 'users and tasks'
 
   before do
-    conn[:users].insert id: 2, name: 'Jane'
-    conn[:tasks].insert id: 2, user_id: 2, title: 'Task one'
-
-    configuration.relation(:users) { use :assoc_macros }
+    conf.relation(:users) { use :assoc_macros }
   end
 
   it 'extends relation with association methods' do
-    configuration.relation(:tasks) do
+    conf.relation(:tasks) do
       use :assoc_macros
 
-      many_to_one :users, key: :user_id, on: { name: 'Piotr' }
+      many_to_one :users, key: :user_id, on: { name: 'Jane' }
 
       def all
         select(:id, :title)
@@ -25,7 +20,7 @@ describe 'Defining many-to-one association' do
       end
     end
 
-    configuration.mappers do
+    conf.mappers do
       define(:tasks)
 
       define(:with_user, parent: :tasks) do
@@ -38,16 +33,16 @@ describe 'Defining many-to-one association' do
     tasks = container.relations.tasks
 
     expect(tasks.all.with_user.to_a).to eql(
-      [{ id: 1, name: 'Piotr', title: 'Finish ROM' }]
+      [{ id: 2, name: 'Jane', title: "Jane's task" }]
     )
 
     expect(container.relation(:tasks).map_with(:with_user).all.with_user.to_a).to eql(
-      [{ id: 1, title: 'Finish ROM', user: { name: 'Piotr' } }]
+      [{ id: 2, title: "Jane's task", user: { name: 'Jane' } }]
     )
   end
 
   it "joins on specified key" do
-    configuration.relation(:task_tags) do
+    conf.relation(:task_tags) do
       use :assoc_macros
 
       many_to_one :tags, key: :tag_id
@@ -57,7 +52,7 @@ describe 'Defining many-to-one association' do
       end
     end
 
-    configuration.relation(:tags) { use :assoc_macros }
+    conf.relation(:tags) { use :assoc_macros }
 
     expect(container.relation(:task_tags).with_tags.to_a).to eq(
       [{ tag_id: 1, task_id: 1, id: 1, name: "important" }]

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

@@ -0,0 +1,78 @@
+RSpec.describe 'Defining one-to-many association' do
+  include_context 'users and tasks'
+
+  before do
+    conf.mappers do
+      define(:users)
+
+      define(:with_tasks, parent: :users) do
+        group tasks: [:tasks_id, :title]
+      end
+    end
+
+    conf.relation(:tasks) { use :assoc_macros }
+  end
+
+  it 'extends relation with association methods' do
+    conf.relation(:users) do
+      use :assoc_macros
+
+      one_to_many :tasks, key: :user_id, on: { title: "Jane's task" }
+
+      def by_name(name)
+        where(name: name)
+      end
+
+      def with_tasks
+        association_left_join(:tasks, select: [:id, :title])
+      end
+
+      def all
+        select(:id, :name)
+      end
+    end
+
+    users = container.relations.users
+
+    expect(users.with_tasks.by_name("Jane").to_a).to eql(
+      [{ id: 1, name: 'Jane', tasks_id: 2, title: "Jane's task" }]
+    )
+
+    result = container.relation(:users).map_with(:with_tasks)
+             .all.with_tasks.by_name("Jane").to_a
+
+    expect(result).to eql(
+      [{ id: 1, name: 'Jane', tasks: [{ tasks_id: 2, title: "Jane's task" }] }]
+    )
+  end
+
+  it 'allows setting :conditions' do
+    conf.relation(:users) do
+      use :assoc_macros
+
+      one_to_many :janes_tasks, relation: :tasks, key: :user_id,
+                                 conditions: { name: 'Jane' }
+
+      def with_janes_tasks
+        association_left_join(:janes_tasks, select: [:id, :title])
+      end
+
+      def all
+        select(:id, :name)
+      end
+    end
+
+    users = container.relations.users
+
+    expect(users.with_janes_tasks.to_a).to eql(
+      [{ id: 1, name: 'Jane', tasks_id: 2, title: "Jane's task" }]
+    )
+
+    result = container.relation(:users).map_with(:with_tasks)
+             .all.with_janes_tasks.to_a
+
+    expect(result).to eql(
+      [{ id: 1, name: 'Jane', tasks: [{ tasks_id: 2, title: "Jane's task" }] }]
+    )
+  end
+end

data/spec/unit/plugin/base_view_spec.rb

@@ -1,18 +1,18 @@
-require 'spec_helper'
-
-describe 'Plugin / Base View' do
+RSpec.describe 'Plugin / Base View' do
   include_context 'database setup'
 
-  it 'defines base view' do
-    module Test
-      class Users < ROM::Relation[:sql]
-        dataset :users
-        register_as :users
+  with_adapters do
+    it 'defines base view' do
+      module Test
+        class Users < ROM::Relation[:sql]
+          dataset :users
+          register_as :users
+        end
       end
-    end
 
-    configuration.register_relation(Test::Users)
+      conf.register_relation(Test::Users)
 
-    expect(container.relation(:users).base.header).to match_array([:id, :name])
+      expect(container.relation(:users).base.header).to match_array([:id, :name])
+    end
   end
 end

data/spec/unit/plugin/pagination_spec.rb

@@ -1,91 +1,91 @@
-require 'spec_helper'
-
 require 'rom/sql/plugin/pagination'
 
-describe 'Plugin / Pagination' do
+RSpec.describe 'Plugin / Pagination' do
   include_context 'database setup'
 
-  before do
-    9.times { |i| conn[:users].insert(name: "User #{i}") }
+  with_adapters do
+    before do
+      9.times { |i| conn[:users].insert(name: "User #{i}") }
 
-    configuration.relation(:users) do
-      use :pagination
+      conf.relation(:users) do
+        use :pagination
 
-      per_page 4
+        per_page 4
+      end
     end
-  end
 
-  describe '#page' do
-    it 'allow to call with stringify number' do
-      expect {
-        container.relation(:users).page('5')
-      }.to_not raise_error
+    describe '#page' do
+      it 'allow to call with stringify number' do
+        expect {
+          container.relation(:users).page('5')
+        }.to_not raise_error
+      end
+
+      it 'preserves existing modifiers' do
+        expect(
+          container.relation(:users).send(:where, name: 'User 2').page(1).to_a.size
+        ).to be(1)
+      end
     end
 
-    it 'preserves existing modifiers' do
-      expect(
-        container.relation(:users).send(:where, name: 'User 2').page(1).to_a.size
-      ).to be(1)
-    end
-  end
+    describe '#per_page' do
+      it 'allow to call with stringify number' do
+        expect {
+          container.relation(:users).per_page('5')
+        }.to_not raise_error
+      end
 
-  describe '#per_page' do
-    it 'allow to call with stringify number' do
-      expect {
-        container.relation(:users).per_page('5')
-      }.to_not raise_error
-    end
+      it 'returns paginated relation with provided limit' do
+        users = container.relation(:users).page(2).per_page(5)
 
-    it 'returns paginated relation with provided limit' do
-      users = container.relation(:users).page(2).per_page(5)
+        expect(users.dataset.opts[:offset]).to eql(5)
+        expect(users.dataset.opts[:limit]).to eql(5)
 
-      expect(users.dataset.opts[:offset]).to eql(5)
-      expect(users.dataset.opts[:limit]).to eql(5)
+        expect(users.pager.current_page).to eql(2)
 
-      expect(users.pager.current_page).to eql(2)
+        expect(users.pager.total).to be(9)
+        expect(users.pager.total_pages).to be(2)
 
-      expect(users.pager.total).to be(9)
-      expect(users.pager.total_pages).to be(2)
-
-      expect(users.pager.next_page).to be(nil)
-      expect(users.pager.prev_page).to be(1)
-      expect(users.pager.limit_value).to eql(5)
+        expect(users.pager.next_page).to be(nil)
+        expect(users.pager.prev_page).to be(1)
+        expect(users.pager.limit_value).to eql(5)
+      end
     end
-  end
 
-  describe '#total_pages' do
-    it 'returns a single page when elements are a perfect fit' do
-      users = container.relation(:users).page(1).per_page(3)
-      expect(users.pager.total_pages).to eql(3)
-    end
+    describe '#total_pages' do
+      it 'returns a single page when elements are a perfect fit' do
+        users = container.relation(:users).page(1).per_page(3)
+        expect(users.pager.total_pages).to eql(3)
+      end
 
-    it 'returns the exact number of pages to accommodate all elements' do
-      users = container.relation(:users).per_page(9)
-      expect(users.pager.total_pages).to eql(1)
+      it 'returns the exact number of pages to accommodate all elements' do
+        users = container.relation(:users).per_page(9)
+        expect(users.pager.total_pages).to eql(1)
+      end
     end
-  end
 
-  describe '#pager' do
-    it 'returns a pager with pagination meta-info' do
-      users = container.relation(:users).page(1)
+    describe '#pager' do
+      it 'returns a pager with pagination meta-info' do
+        users = container.relation(:users).page(1)
 
-      expect(users.pager.total).to be(9)
-      expect(users.pager.total_pages).to be(3)
+        expect(users.pager.total).to be(9)
+        expect(users.pager.total_pages).to be(3)
 
-      expect(users.pager.current_page).to be(1)
-      expect(users.pager.next_page).to be(2)
-      expect(users.pager.prev_page).to be(nil)
+        expect(users.pager.current_page).to be(1)
+        expect(users.pager.next_page).to be(2)
+        expect(users.pager.prev_page).to be(nil)
 
-      users = container.relation(:users).page(2)
+        users = container.relation(:users).page(2)
 
-      expect(users.pager.current_page).to be(2)
-      expect(users.pager.next_page).to be(3)
-      expect(users.pager.prev_page).to be(1)
+        expect(users.pager.current_page).to be(2)
+        expect(users.pager.next_page).to be(3)
+        expect(users.pager.prev_page).to be(1)
 
-      users = container.relation(:users).page(3)
+        users = container.relation(:users).page(3)
 
-      expect(users.pager.next_page).to be(nil)
-      expect(users.pager.prev_page).to be(2)
+        expect(users.pager.next_page).to be(nil)
+        expect(users.pager.prev_page).to be(2)
+      end
     end
   end
 end