rom-sql 0.3.2 → 0.4.0.beta1

data/spec/integration/commands/update_spec.rb

@@ -1,26 +1,77 @@
 require 'spec_helper'
 
 describe 'Commands / Update' do
-  include_context 'users and tasks'
+  include_context 'database setup'
 
   subject(:users) { rom.commands.users }
 
-  it 'works' do
+  let(:relation) { rom.relations.users }
+  let(:piotr) { relation.by_name('Piotr').first }
+  let(:peter) { { name: 'Peter' } }
+
+  before do
     setup.relation(:users) do
+      def by_id(id)
+        where(id: id).limit(1)
+      end
+
       def by_name(name)
         where(name: name)
       end
     end
 
     setup.commands(:users) do
-      define(:update) do
-        input Hash
-        validator proc {}
+      define(:update)
+    end
+
+    relation.insert(name: 'Piotr')
+  end
+
+  context '#transaction' do
+    it 'update record if there was no errors' do
+      result = users.update.transaction do
+        users.update.by_id(piotr[:id]).set(peter)
       end
+
+      expect(result.value).to eq([{ id: 1, name: 'Peter' }])
     end
 
-    result = users.try { update(:by_name, 'Piotr').set(name: 'Peter') }
+    it 'updates nothing if error was raised' do
+      users.update.transaction do
+        users.update.by_id(piotr[:id]).set(peter)
+        raise ROM::SQL::Rollback
+      end
+
+      expect(relation.first[:name]).to eq('Piotr')
+    end
+  end
+
+  it 'updates everything when there is no original tuple' do
+    result = users.try do
+      users.update.by_id(piotr[:id]).set(peter)
+    end
+
+    expect(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
+  end
+
+  it 'updates when attributes changed' do
+    result = users.try do
+      users.update.by_id(piotr[:id]).change(piotr).to(peter)
+    end
 
     expect(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
   end
+
+  it 'does not update when attributes did not change' do
+    piotr_rel = double('piotr_rel').as_null_object
+
+    expect(relation).to receive(:by_id).with(piotr[:id]).and_return(piotr_rel)
+    expect(piotr_rel).not_to receive(:update)
+
+    result = users.try do
+      users.update.by_id(piotr[:id]).change(piotr).to(name: piotr[:name])
+    end
+
+    expect(result.value.to_a).to be_empty
+  end
 end

data/spec/integration/read_spec.rb

@@ -4,7 +4,7 @@ require 'virtus'
 describe 'Reading relations' do
   include_context 'users and tasks'
 
-  it 'loads domain objects' do
+  before :each do
     class Task
       include Virtus.value_object(coerce: true)
 
@@ -24,6 +24,16 @@ describe 'Reading relations' do
       end
     end
 
+    class UserTaskCount
+      include Virtus.value_object(coerce: true)
+
+      values do
+        attribute :id, Integer
+        attribute :name, String
+        attribute :task_count, Integer
+      end
+    end
+
     setup.relation(:tasks)
 
     setup.relation(:users) do
@@ -42,6 +52,22 @@ describe 'Reading relations' do
       end
     end
 
+    setup.relation(:user_task_counts) do
+      dataset :users
+      register_as :user_task_counts
+      one_to_many :tasks, key: :user_id
+
+      def all
+        with_tasks.select_group(:users__id, :users__name).select_append {
+          count(:tasks).as(:task_count)
+        }
+      end
+
+      def with_tasks
+        association_left_join(:tasks, select: [:id, :title])
+      end
+    end
+
     setup.mappers do
       define(:users) do
         model User
@@ -53,8 +79,14 @@ describe 'Reading relations' do
           attribute :title
         end
       end
+
+      define(:user_task_counts) do
+        model UserTaskCount
+      end
     end
+  end
 
+  it 'loads domain objects' do
     user = rom.read(:users).with_tasks.by_name('Piotr').to_a.first
 
     expect(user).to eql(
@@ -62,4 +94,13 @@ describe 'Reading relations' do
         id: 1, name: 'Piotr', tasks: [Task.new(id: 1, title: 'Finish ROM')]
       ))
   end
+
+  it 'works with grouping and aggregates' do
+    rom.relations[:tasks].insert(id: 2, user_id: 1, title: 'Get Milk')
+
+    users_with_task_count = rom.read(:user_task_counts).all
+    expect(users_with_task_count.to_a).to eq([
+      UserTaskCount.new(id: 1, name: "Piotr", task_count: 2)
+    ])
+  end
 end

data/spec/shared/database_setup.rb

@@ -1,17 +1,22 @@
 shared_context 'database setup' do
   subject(:rom) { setup.finalize }
 
-  let(:setup) { ROM.setup(postgres: 'postgres://localhost/rom') }
-  let(:conn) { setup.postgres.connection }
+  let(:uri) { 'postgres://localhost/rom' }
+  let(:conn) { Sequel.connect(uri) }
+  let(:setup) { ROM.setup(:sql, uri) }
+
+  def drop_tables
+    [:users, :tasks, :tags, :task_tags].each { |name| conn.drop_table?(name) }
+  end
 
   before do
-    setup.postgres.use_logger(LOGGER)
+    conn.loggers << LOGGER
 
-    [:users, :tasks, :tags, :task_tags].each { |name| conn.drop_table?(name) }
+    drop_tables
 
     conn.create_table :users do
       primary_key :id
-      String :name
+      String :name, null: false
       index :name, unique: true
     end
 

data/spec/spec_helper.rb

@@ -1,11 +1,17 @@
 # encoding: utf-8
 
+require 'bundler'
+Bundler.setup
+
 if RUBY_ENGINE == 'rbx'
   require "codeclimate-test-reporter"
   CodeClimate::TestReporter.start
 end
 
 require 'rom-sql'
+require 'rom/sql/rake_task'
+# FIXME: why do we need to require it manually??
+require 'sequel/adapters/postgres'
 require 'logger'
 
 LOGGER = Logger.new(File.open('./log/test.log', 'a'))
@@ -13,3 +19,14 @@ LOGGER = Logger.new(File.open('./log/test.log', 'a'))
 root = Pathname(__FILE__).dirname
 
 Dir[root.join('shared/*.rb').to_s].each { |f| require f }
+
+RSpec.configure do |config|
+  config.before do
+    @constants = Object.constants
+  end
+
+  config.after do
+    added_constants = Object.constants - @constants
+    added_constants.each { |name| Object.send(:remove_const, name) }
+  end
+end

data/spec/support/active_support_notifications_spec.rb

@@ -7,16 +7,17 @@ describe 'ActiveSupport::Notifications support' do
   include_context 'database setup'
 
   it 'works' do
-    rom.postgres.use_logger(LOGGER)
+    rom.repositories[:default].use_logger(LOGGER)
 
     sql = nil
 
-    ActiveSupport::Notifications.subscribe('sql.rom') do |_name, _start, _finish, _id, payload|
+    ActiveSupport::Notifications.subscribe('sql.rom') do |*, payload|
       sql = payload[:sql]
     end
 
-    rom.postgres.connection.run(%(SELECT * FROM "users" WHERE name = 'notification test'))
+    query = %(SELECT * FROM "users" WHERE name = 'notification test')
+    conn.run(query)
 
-    expect(sql).to eql(%(SELECT * FROM "users" WHERE name = 'notification test'))
+    expect(sql).to eql(query)
   end
 end

data/spec/support/rails_log_subscriber_spec.rb

@@ -18,11 +18,11 @@ describe 'Rails log subscriber' do
 
   before do
     set_logger(logger)
-    rom.postgres.use_logger(logger)
+    rom.repositories[:default].use_logger(logger)
   end
 
   it 'works' do
-    rom.postgres.connection.run(test_query)
+    conn.run(test_query)
 
     expect(logger.logged(:debug).last).to include(test_query)
   end

data/spec/unit/logger_spec.rb

@@ -1,12 +1,14 @@
 require 'spec_helper'
 
 describe 'Logger' do
-  include_context 'users and tasks'
+  include_context 'database setup'
 
   it 'sets up a logger for sequel' do
-    repository = rom.postgres
+    repository = rom.repositories[:default]
+
+    repository.use_logger(LOGGER)
 
     expect(repository.logger).to be(LOGGER)
-    expect(repository.connection.loggers).to include(LOGGER)
+    expect(conn.loggers).to include(LOGGER)
   end
 end

data/spec/unit/many_to_many_spec.rb

@@ -20,8 +20,8 @@ describe 'Defining many-to-one association' do
 
       def with_tags_and_tag_id
         association_left_join(:tags, select: {
-          tags: [:name], task_tags: [:tag_id]
-        })
+                                tags: [:name], task_tags: [:tag_id]
+                              })
       end
 
       def by_tag(name)

data/spec/unit/migration_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe ROM::SQL::Migration do
+  let(:migration) { ROM::SQL::Migration }
+
+  context '#run' do
+    it 'calls Sequel migration code' do
+      migration.path = 'foo/bar'
+      migration.connection = double
+      opts = { foo: 'bar' }
+
+      expect(Sequel::Migrator).to receive(:run)
+        .with(migration.connection, migration.path, opts)
+
+      migration.run(opts)
+    end
+  end
+
+  context '#path' do
+    it 'returns default path if non provided' do
+      migration.path = nil
+
+      expect(migration.path).to eq ROM::SQL::Migration::DEFAULT_PATH
+    end
+  end
+
+  context '.create' do
+    it 'calls Sequel migration block' do
+      expect(Sequel).to receive(:migration)
+
+      ROM::SQL::Migration.create {}
+    end
+  end
+end

data/spec/unit/migration_tasks_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+namespace :db do
+  task :load_setup  do
+  end
+end
+
+describe 'MigrationTasks' do
+  context 'db:reset' do
+    it 'calls proper commands' do
+      expect(ROM::SQL::Migration).to receive(:run).with(target: 0)
+      expect(ROM::SQL::Migration).to receive(:run)
+
+      expect {
+        Rake::Task["db:reset"].invoke
+      }.to output("<= db:reset executed\n").to_stdout
+    end
+  end
+
+  context 'db:migrate' do
+    context 'with VERSION' do
+      it 'calls proper commands' do
+        expect(ROM::SQL::Migration).to receive(:run).with(target: 1)
+
+        expect {
+          Rake::Task["db:migrate"].invoke(1)
+        }.to output("<= db:migrate version=[1] executed\n").to_stdout
+      end
+    end
+
+    context 'without VERSION' do
+      it 'calls proper commands' do
+        expect(ROM::SQL::Migration).to receive(:run)
+
+        expect {
+          Rake::Task["db:migrate"].execute
+        }.to output("<= db:migrate executed\n").to_stdout
+      end
+    end
+  end
+
+  context 'db:clean' do
+    it 'calls proper commands' do
+      expect(ROM::SQL::Migration).to receive(:run).with(target: 0)
+
+      expect {
+        Rake::Task["db:clean"].invoke
+      }.to output("<= db:clean executed\n").to_stdout
+    end
+  end
+
+  context 'db:create_migration' do
+    context 'without NAME' do
+      it 'exit without creating any file' do
+        expect(File).to_not receive(:write)
+
+        expect {
+          expect {
+            Rake::Task["db:create_migration"].execute
+          }.to output(/No NAME specified/).to_stdout
+        }.to raise_error(SystemExit)
+      end
+    end
+
+    context 'with NAME' do
+      let(:dirname) { 'db/migration' }
+      let(:name) { 'foo_bar' }
+      let(:version) { '001' }
+      let(:filename) { "#{version}_#{name}.rb" }
+      let(:path) { File.join(dirname, filename) }
+
+      before do
+        expect(ROM::SQL::Migration).to receive(:path).and_return(dirname)
+      end
+
+      it 'calls proper commands with default VERSION' do
+        time = double(utc: double(strftime: '001'))
+        expect(Time).to receive(:now).and_return(time)
+        expect(FileUtils).to receive(:mkdir_p).with(dirname)
+        expect(File).to receive(:write).with(path, /ROM::SQL::Migration/)
+
+        expect {
+          Rake::Task["db:create_migration"].execute(
+            Rake::TaskArguments.new([:name], [name]))
+        }.to output(path+"\n").to_stdout
+      end
+
+      it 'calls proper commands with manualy set VERSION' do
+        expect(FileUtils).to receive(:mkdir_p).with(dirname)
+        expect(File).to receive(:write).with(path, /ROM::SQL::Migration/)
+
+        expect {
+          Rake::Task["db:create_migration"].execute(
+            Rake::TaskArguments.new([:name, :version], [name, version]))
+        }.to output(path+"\n").to_stdout
+      end
+    end
+  end
+end

data/spec/unit/one_to_many_spec.rb

@@ -4,8 +4,6 @@ describe 'Defining one-to-many association' do
   include_context 'users and tasks'
 
   it 'extends relation with association methods' do
-    setup.relation(:tasks)
-
     setup.relation(:users) do
       one_to_many :tasks, key: :user_id
 

data/spec/unit/plugin/pagination_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+require 'rom/sql/plugin/pagination'
+
+describe 'Plugin / Pagination' do
+  include_context 'database setup'
+
+  before do
+    9.times { |i| conn[:users].insert(name: "User #{i}") }
+
+    setup.relation(:users) do
+      include ROM::SQL::Plugin::Pagination # meh such constants not wow
+
+      per_page 4
+    end
+  end
+
+  describe '#page' do
+    it 'allow to call with stringify number' do
+      expect {
+        rom.relation(:users).page('5')
+      }.to_not raise_error
+    end
+  end
+
+  describe '#per_page' do
+    it 'allow to call with stringify number' do
+      expect {
+        rom.relation(:users).per_page('5')
+      }.to_not raise_error
+    end
+
+    it 'returns paginated relation with provided limit' do
+      users = rom.relation(:users).page(2).per_page(5)
+
+      expect(users.relation.dataset.opts[:offset]).to eql(5)
+      expect(users.relation.dataset.opts[:limit]).to eql(5)
+
+      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.next_page).to be(nil)
+      expect(users.pager.prev_page).to be(1)
+      expect(users.pager.limit_value).to eql(5)
+    end
+  end
+
+  describe '#pager' do
+    it 'returns a pager with pagination meta-info' do
+      users = rom.relation(:users).page(1)
+
+      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)
+
+      users = rom.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)
+
+      users = rom.relation(:users).page(3)
+
+      expect(users.pager.next_page).to be(nil)
+      expect(users.pager.prev_page).to be(2)
+    end
+  end
+end