sequel-rails 0.7.0 → 0.8.0

data/spec/lib/sequel_rails/configuration_spec.rb

@@ -1,14 +1,14 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe SequelRails do
 
-  describe ".setup" do
-    let(:environment) { "development" }
+  describe '.setup' do
+    let(:environment) { 'development' }
     let(:configuration) { SequelRails::Configuration.new }
 
-    it "delegates to current configuration" do
+    it 'delegates to current configuration' do
       SequelRails.configuration = configuration
-      configuration.should_receive(:connect).with(environment)
+      expect(configuration).to receive(:connect).with(environment)
       SequelRails.setup environment
     end
   end
@@ -17,152 +17,126 @@ end
 
 describe SequelRails::Configuration do
 
-  describe "#schema_dump" do
-    before{ Rails.stub(:env).and_return environment }
-    subject{ described_class.new }
+  describe '#schema_dump' do
+    before { allow(Rails).to receive(:env).and_return(environment) }
+    subject { described_class.new }
 
-    context "in test environment" do
-      let(:environment) { "test" }
-      it "defaults to false" do
-        subject.schema_dump.should be_false
+    context 'in test environment' do
+      let(:environment) { 'test' }
+      it 'defaults to false' do
+        expect(subject.schema_dump).to be_false
       end
-      it "can be assigned" do
+      it 'can be assigned' do
         subject.schema_dump = true
-        subject.schema_dump.should be_true
+        expect(subject.schema_dump).to be_true
       end
-      it "can be set from merging another hash" do
+      it 'can be set from merging another hash' do
         subject.merge!(:schema_dump => true)
-        subject.schema_dump.should be_true
+        expect(subject.schema_dump).to be_true
       end
     end
 
-    context "in production environment" do
-      let(:environment) { "production" }
-      it "defaults to false" do
-        subject.schema_dump.should be_false
+    context 'in production environment' do
+      let(:environment) { 'production' }
+      it 'defaults to false' do
+        expect(subject.schema_dump).to be_false
       end
-      it "can be assigned" do
+      it 'can be assigned' do
         subject.schema_dump = true
-        subject.schema_dump.should be_true
+        expect(subject.schema_dump).to be_true
       end
-      it "can be set from merging another hash" do
+      it 'can be set from merging another hash' do
         subject.merge!(:schema_dump => true)
-        subject.schema_dump.should be_true
+        expect(subject.schema_dump).to be_true
       end
     end
 
-    context "in other environments" do
-      let(:environment) { "development" }
-      it "defaults to true" do
-        subject.schema_dump.should be_true
+    context 'in other environments' do
+      let(:environment) { 'development' }
+      it 'defaults to true' do
+        expect(subject.schema_dump).to be_true
       end
-      it "can be assigned" do
+      it 'can be assigned' do
         subject.schema_dump = false
-        subject.schema_dump.should be_false
+        expect(subject.schema_dump).to be_false
       end
-      it "can be set from merging another hash" do
+      it 'can be set from merging another hash' do
         subject.merge!(:schema_dump => false)
-        subject.schema_dump.should be_false
+        expect(subject.schema_dump).to be_false
       end
     end
   end
 
-  describe "#load_database_tasks" do
-    subject{ described_class.new }
+  describe '#load_database_tasks' do
+    subject { described_class.new }
 
-    it "defaults to true" do
-      subject.load_database_tasks.should be_true
+    it 'defaults to true' do
+      expect(subject.load_database_tasks).to be_true
     end
-    it "can be assigned" do
+    it 'can be assigned' do
       subject.load_database_tasks = false
-      subject.load_database_tasks.should be_false
+      expect(subject.load_database_tasks).to be_false
     end
-    it "can be set from merging another hash" do
+    it 'can be set from merging another hash' do
       subject.merge!(:load_database_tasks => false)
-      subject.load_database_tasks.should be_false
+      expect(subject.load_database_tasks).to be_false
     end
   end
 
-  describe "#connect" do
+  describe '#connect' do
     let(:environments) do
       {
-        "development" => {
-          "adapter" => "postgres",
-          "owner" => (ENV["TEST_OWNER"] || ENV["USER"]),
-          "username" => (ENV["TEST_OWNER"] || ENV["USER"]),
-          "database" => "sequel_rails_test_storage_dev",
-          "host" => "127.0.0.1",
+        'development' => {
+          'adapter' => 'postgres',
+          'owner' => (ENV['TEST_OWNER'] || ENV['USER']),
+          'username' => (ENV['TEST_OWNER'] || ENV['USER']),
+          'database' => 'sequel_rails_test_storage_dev',
+          'host' => '127.0.0.1',
         },
-        "test" => {
-          "adapter" => "postgres",
-          "owner" => (ENV["TEST_OWNER"] || ENV["USER"]),
-          "username" => (ENV["TEST_OWNER"] || ENV["USER"]),
-          "database" => "sequel_rails_test_storage_test",
-          "host" => "127.0.0.1",
+        'test' => {
+          'adapter' => 'postgres',
+          'owner' => (ENV['TEST_OWNER'] || ENV['USER']),
+          'username' => (ENV['TEST_OWNER'] || ENV['USER']),
+          'database' => 'sequel_rails_test_storage_test',
+          'host' => '127.0.0.1',
         },
-        "remote" => {
-          "adapter" => "mysql",
-          "host" => "10.0.0.1",
-          "database" => "sequel_rails_test_storage_remote",
+        'remote' => {
+          'adapter' => 'mysql',
+          'host' => '10.0.0.1',
+          'database' => 'sequel_rails_test_storage_remote',
         },
-        "production" => {
-          "host" => "10.0.0.1",
-          "database" => "sequel_rails_test_storage_production",
+        'production' => {
+          'host' => '10.0.0.1',
+          'database' => 'sequel_rails_test_storage_production',
         },
-        "url_already_constructed" => {
-          "adapter" => "adapter_name",
-          "url" => "jdbc:adapter_name://HOST/DB?user=U&password=P&ssl=true&sslfactory=sslFactoryOption"
+        'url_already_constructed' => {
+          'adapter' => 'adapter_name',
+          'url' => 'jdbc:adapter_name://HOST/DB?user=U&password=P&ssl=true&sslfactory=sslFactoryOption'
         },
-        "bogus" => {},
+        'bogus' => {},
       }
     end
-    let(:is_jruby) { false }
-
-    subject do
-      config = described_class.new
-      config.raw = environments
-      config
-    end
 
-    before { SequelRails.stub(:jruby?).and_return is_jruby }
-
-    shared_examples "max_connections" do
-      context "with max_connections config option" do
-        let(:max_connections) { 31337 }
-        before do
-          environments[environment]["max_connections"] = 7
-          subject.max_connections = max_connections
-        end
+    subject { described_class.new.tap { |config| config.raw = environments } }
 
-        it "overrides the option from the configuration" do
-          ::Sequel.should_receive(:connect) do |hash_or_url, *_|
-            if hash_or_url.is_a? Hash
-              hash_or_url['max_connections'].should == max_connections
-            else
-              hash_or_url.should include("max_connections=#{max_connections}")
-            end
-          end
-          subject.connect environment
-        end
-      end
-    end
+    context 'when stubbing SequelRails.jruby?' do
 
-    context "for a postgres connection" do
+      before { allow(SequelRails).to receive(:jruby?).and_return(is_jruby) }
 
-      shared_examples "search_path" do
-        context "with search_path config option" do
-          let(:search_path) { ['secret', 'private', 'public'] }
+      shared_examples 'max_connections' do
+        context 'with max_connections config option' do
+          let(:max_connections) { 31_337 }
           before do
-            environments[environment]["search_path"] = "private, public"
-            subject.search_path = search_path
+            environments[environment]['max_connections'] = 7
+            subject.max_connections = max_connections
           end
 
-          it "overrides the option from the configuration" do
-            ::Sequel.should_receive(:connect) do |hash_or_url, *_|
+          it 'overrides the option from the configuration' do
+            expect(::Sequel).to receive(:connect) do |hash_or_url, *_|
               if hash_or_url.is_a? Hash
-                hash_or_url['search_path'].should == search_path
+                expect(hash_or_url['max_connections']).to eq(max_connections)
               else
-                hash_or_url.should include("search_path=secret,private,public")
+                expect(hash_or_url).to include("max_connections=#{max_connections}")
               end
             end
             subject.connect environment
@@ -170,109 +144,135 @@ describe SequelRails::Configuration do
         end
       end
 
-      let(:environment) { 'development' }
-
-      context "in C-Ruby" do
+      context 'for a postgres connection' do
 
-        include_examples "max_connections"
-        include_examples "search_path"
+        shared_examples 'search_path' do
+          context 'with search_path config option' do
+            let(:search_path) { %w(secret private public) }
+            before do
+              environments[environment]['search_path'] = 'private, public'
+              subject.search_path = search_path
+            end
 
-        it "produces a sane config without url" do
-          ::Sequel.should_receive(:connect) do |hash|
-            hash['adapter'].should == 'postgres'
+            it 'overrides the option from the configuration' do
+              expect(::Sequel).to receive(:connect) do |hash_or_url, *_|
+                if hash_or_url.is_a? Hash
+                  expect(hash_or_url['search_path']).to eq(search_path)
+                else
+                  expect(hash_or_url).to include('search_path=secret,private,public')
+                end
+              end
+              subject.connect environment
+            end
           end
-          subject.connect environment
         end
 
-      end
+        let(:environment) { 'development' }
 
-      context "in JRuby" do
+        context 'in C-Ruby' do
 
-        include_examples "max_connections"
-        include_examples "search_path"
+          include_examples 'max_connections'
+          include_examples 'search_path'
 
-        let(:is_jruby) { true }
+          let(:is_jruby) { false }
 
-        it "produces an adapter config with a url" do
-          ::Sequel.should_receive(:connect) do |url, hash|
-            url.should =~ /^jdbc:postgresql:\/\//
-            hash['adapter'].should == 'jdbc:postgresql'
-            hash['host'].should    == '127.0.0.1'
+          it 'produces a sane config without url' do
+            expect(::Sequel).to receive(:connect) do |hash|
+              expect(hash['adapter']).to eq('postgres')
+            end
+            subject.connect environment
           end
-          subject.connect environment
+
         end
 
-        context "when url is already given" do
+        context 'in JRuby' do
 
-          let(:environment) { "url_already_constructed" }
+          include_examples 'max_connections'
+          include_examples 'search_path'
 
-          it "does not change the url" do
-            ::Sequel.should_receive(:connect) do |url, hash|
-              url.should == "jdbc:adapter_name://HOST/DB?user=U&password=P&ssl=true&sslfactory=sslFactoryOption"
-              hash['adapter'].should == 'jdbc:adapter_name'
+          let(:is_jruby) { true }
+
+          it 'produces an adapter config with a url' do
+            expect(::Sequel).to receive(:connect) do |url, hash|
+              expect(url).to start_with('jdbc:postgresql://')
+              expect(hash['adapter']).to eq('jdbc:postgresql')
+              expect(hash['host']).to eq('127.0.0.1')
             end
             subject.connect environment
           end
 
-        end
-      end
-    end
-
-    context "for a mysql connection" do
+          context 'when url is already given' do
 
-      let(:environment) { 'remote' }
+            let(:environment) { 'url_already_constructed' }
 
-      context "in C-Ruby" do
-
-        include_examples "max_connections"
+            it 'does not change the url' do
+              expect(::Sequel).to receive(:connect) do |url, hash|
+                expect(url).to eq('jdbc:adapter_name://HOST/DB?user=U&password=P&ssl=true&sslfactory=sslFactoryOption')
+                expect(hash['adapter']).to eq('jdbc:adapter_name')
+              end
+              subject.connect environment
+            end
 
-        it "produces a config without url" do
-          ::Sequel.should_receive(:connect) do |hash|
-            hash['adapter'].should == 'mysql'
           end
-          subject.connect environment
         end
       end
 
-      context "in JRuby" do
+      context 'for a mysql connection' do
+
+        let(:environment) { 'remote' }
+
+        context 'in C-Ruby' do
 
-        include_examples "max_connections"
+          include_examples 'max_connections'
 
-        let(:is_jruby) { true }
+          let(:is_jruby) { false }
 
-        it "produces a jdbc mysql config" do
-          ::Sequel.should_receive(:connect) do |url, hash|
-            url.should =~ /^jdbc:mysql:\/\//
-            hash['adapter'].should  == 'jdbc:mysql'
-            hash['database'].should == 'sequel_rails_test_storage_remote'
+          it 'produces a config without url' do
+            expect(::Sequel).to receive(:connect) do |hash|
+              expect(hash['adapter']).to eq('mysql')
+            end
+            subject.connect environment
           end
-          subject.connect environment
         end
 
-        context "when url is already given" do
+        context 'in JRuby' do
+
+          include_examples 'max_connections'
 
-          let(:environment) { "url_already_constructed" }
+          let(:is_jruby) { true }
 
-          it "does not change the url" do
-            ::Sequel.should_receive(:connect) do |url, hash|
-              url.should == "jdbc:adapter_name://HOST/DB?user=U&password=P&ssl=true&sslfactory=sslFactoryOption"
-              hash['adapter'].should == 'jdbc:adapter_name'
+          it 'produces a jdbc mysql config' do
+            expect(::Sequel).to receive(:connect) do |url, hash|
+              expect(url).to start_with('jdbc:mysql://')
+              expect(hash['adapter']).to eq('jdbc:mysql')
+              expect(hash['database']).to eq('sequel_rails_test_storage_remote')
             end
             subject.connect environment
           end
 
+          context 'when url is already given' do
+
+            let(:environment) { 'url_already_constructed' }
+
+            it 'does not change the url' do
+              expect(::Sequel).to receive(:connect) do |url, hash|
+                expect(url).to eq('jdbc:adapter_name://HOST/DB?user=U&password=P&ssl=true&sslfactory=sslFactoryOption')
+                expect(hash['adapter']).to eq('jdbc:adapter_name')
+              end
+              subject.connect environment
+            end
+          end
         end
       end
     end
 
-    describe "after connect hook" do
+    describe 'after connect hook' do
       let(:hook) { double }
-      let(:environment) { "development" }
-      before { SequelRails.unstub :jruby? }
+      let(:environment) { 'development' }
 
-      it "runs hook if provided" do
+      it 'runs hook if provided' do
         subject.after_connect = hook
-        hook.should_receive(:call)
+        expect(hook).to receive(:call)
         subject.connect environment
       end
     end

data/spec/lib/sequel_rails/jdbc_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe SequelRails::Storage::Jdbc do
   let(:adapter)             { 'jdbc:mysql' }
@@ -26,14 +26,14 @@ describe SequelRails::Storage::Jdbc do
   end
   let(:store) { described_class.new(config) }
 
-  describe "#_root_url" do
+  describe '#_root_url' do
     subject { store._root_url }
     let(:expected) { "jdbc:mysql://#{host}" }
 
     it { should == expected }
 
-    context "with ip addresses" do
-      let(:host) { '127.0.0.1'}
+    context 'with ip addresses' do
+      let(:host) { '127.0.0.1' }
 
       it { should == expected }
     end

data/spec/lib/sequel_rails/migrations_spec.rb

@@ -1,64 +1,64 @@
-require "spec_helper"
-require "fakefs/spec_helpers"
+require 'spec_helper'
+require 'fakefs/spec_helpers'
 
 describe SequelRails::Migrations do
   let!(:db) { ::Sequel::Model.db }
 
   [:migrate_up!, :migrate_down!].each do |migration_method|
     describe ".#{migration_method}" do
-      let(:result) { mock :result }
-      context "with no version specified" do
+      let(:result) { double(:result) }
+      context 'with no version specified' do
         let(:opts) { {} }
-        it "runs migrations using Sequel::Migrator" do
-          ::Sequel::Migrator.should_receive(:run).with(
-            db, Rails.root.join("db/migrate"), opts
+        it 'runs migrations using Sequel::Migrator' do
+          expect(::Sequel::Migrator).to receive(:run).with(
+            db, Rails.root.join('db/migrate'), opts
           ).and_return result
-          described_class.send(migration_method).should be result
+          expect(described_class.send(migration_method)).to be(result)
         end
       end
-      context "with version specified" do
-        let(:opts) { {:target => 1} }
-        it "runs migrations using Sequel::Migrator" do
-          ::Sequel::Migrator.should_receive(:run).with(
-            db, Rails.root.join("db/migrate"), opts
+      context 'with version specified' do
+        let(:opts) { { :target => 1 } }
+        it 'runs migrations using Sequel::Migrator' do
+          expect(::Sequel::Migrator).to receive(:run).with(
+            db, Rails.root.join('db/migrate'), opts
           ).and_return result
-          described_class.send(migration_method, 1).should be result
+          expect(described_class.send(migration_method, 1)).to be(result)
         end
       end
     end
   end
 
-  describe ".pending_migrations?" do
+  describe '.pending_migrations?' do
     include FakeFS::SpecHelpers
-    let(:path) { Rails.root.join("db/migrate") }
+    let(:path) { Rails.root.join('db/migrate') }
 
-    it "returns false if no db/migrate directory exists" do
-      described_class.pending_migrations?.should == false
+    it 'returns false if no db/migrate directory exists' do
+      expect(described_class).to_not be_pending_migrations
     end
 
-    it "returns false if db/migrate directory exists, but is empty" do
+    it 'returns false if db/migrate directory exists, but is empty' do
       FileUtils.mkdir_p path
-      described_class.pending_migrations?.should == false
+      expect(described_class.pending_migrations?).to be_false
     end
 
-    context "when db/migrate directory exists and contains migrations" do
+    context 'when db/migrate directory exists and contains migrations' do
       before do
         FileUtils.mkdir_p path
         FileUtils.touch(File.join(path, 'test_migration.rb'))
       end
 
-      it "returns true if any pending migration" do
-        ::Sequel::Migrator.should_receive(:is_current?).with(
-          db, Rails.root.join("db/migrate")
+      it 'returns true if any pending migration' do
+        expect(::Sequel::Migrator).to receive(:is_current?).with(
+          db, Rails.root.join('db/migrate')
         ).and_return false
-        described_class.pending_migrations?.should == true
+        expect(described_class).to be_pending_migrations
       end
 
-      it "returns false if no pending migration" do
-        ::Sequel::Migrator.should_receive(:is_current?).with(
-          db, Rails.root.join("db/migrate")
+      it 'returns false if no pending migration' do
+        expect(::Sequel::Migrator).to receive(:is_current?).with(
+          db, Rails.root.join('db/migrate')
         ).and_return true
-        described_class.pending_migrations?.should == false
+        expect(described_class).to_not be_pending_migrations
       end
     end
   end