database_cleaner 1.6.2 → 1.7.0

data/spec/database_cleaner/neo4j/base_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/neo4j/base'
-require 'database_cleaner/shared_strategy'
-
-module DatabaseCleaner
-  describe Neo4j do
-    it { should respond_to(:available_strategies) }
-  end
-
-  module Neo4j
-    class ExampleStrategy
-      include ::DatabaseCleaner::Neo4j::Base
-    end
-
-    describe ExampleStrategy do
-
-      it_should_behave_like "a generic strategy"
-      it { should respond_to(:db) }
-      it { should respond_to(:db=) }
-
-      it "should store my describe db" do
-        db_conf = {:connection => {:type => :server_db, :path => 'http://localhost:7474'}}
-        subject.db = db_conf
-        subject.db.should eq db_conf
-      end
-
-      it "should respect additional connection parameters" do
-        db_conf = {:type => :server_db, :path => 'http://localhost:7474', basic_auth: {username: 'user', password: 'pass'}}
-        subject.db = db_conf
-        stub_const("Neo4j::Session", double()).should_receive(:open).with(:server_db, 'http://localhost:7474', {basic_auth: {username: 'user', password: 'pass'}}) { true }
-        subject.start
-      end
-
-      it "should default to nil" do
-        subject.db.should be_nil
-      end
-
-      it "should return default configuration" do
-        subject.database.should eq(:type => :server_db, :path => 'http://localhost:7475/')
-      end
-    end
-  end
-end

data/spec/database_cleaner/neo4j/transaction_spec.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'neo4j-core'
-require 'database_cleaner/neo4j/transaction'
-
-module DatabaseCleaner
-  module Neo4j
-
-    describe Transaction do
-      before(:all) do
-        DatabaseCleaner[:neo4j, :connection => {:type => :server_db, :path => 'http://localhost:7474'}]
-      end
-
-      it_should_behave_like "a generic strategy"
-      it_should_behave_like "a generic transaction strategy"
-
-      describe "start" do
-        it "should start a transaction"
-      end
-
-      describe "clean" do
-        it "should finish a transaction"
-      end
-    end
-  end
-end

data/spec/database_cleaner/null_strategy_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module DatabaseCleaner
-  describe NullStrategy do
-      it 'responds to .start' do
-        expect { NullStrategy.start }.not_to raise_error(NoMethodError)
-      end
-
-      it 'responds to .clean' do
-        expect { NullStrategy.clean }.not_to raise_error(NoMethodError)
-      end
-
-      describe '.cleaning' do
-        it 'fails without a block' do
-          expect { NullStrategy.cleaning }.to raise_error(LocalJumpError)
-        end
-
-        it 'no-ops with a block' do
-          effect = double
-          expect(effect).to receive(:occur).once
-
-          NullStrategy.cleaning do
-            effect.occur
-          end
-        end
-      end
-  end
-end

data/spec/database_cleaner/ohm/truncation_spec.rb

@@ -1,70 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'ohm'
-require 'database_cleaner/ohm/truncation'
-
-module DatabaseCleaner
-  module Ohm
-
-    class Widget < ::Ohm::Model
-      attribute :name
-    end
-
-    class Gadget < ::Ohm::Model
-      attribute :name
-    end
-
-    describe Truncation do
-      before(:all) do
-        config = YAML::load(File.open("#{File.dirname(__FILE__)}/../../../examples/config/redis.yml"))
-        ::Ohm.connect :url => config['test']['url']
-        @redis = ::Ohm.redis
-      end
-
-      before(:each) do
-        @redis.flushdb
-      end
-
-      it "should flush the database" do
-        Truncation.new.clean
-      end
-
-      def create_widget(attrs={})
-        Widget.new({:name => 'some widget'}.merge(attrs)).save
-      end
-
-      def create_gadget(attrs={})
-        Gadget.new({:name => 'some gadget'}.merge(attrs)).save
-      end
-
-      it "truncates all keys by default" do
-        create_widget
-        create_gadget
-        @redis.keys.size.should eq 6
-        Truncation.new.clean
-        @redis.keys.size.should eq 0
-      end
-
-      context "when keys are provided to the :only option" do
-        it "only truncates the specified keys" do
-          create_widget
-          create_gadget
-          @redis.keys.size.should eq 6
-          Truncation.new(:only => ['*Widget*']).clean
-          @redis.keys.size.should eq 3
-          @redis.get('DatabaseCleaner::Ohm::Gadget:id').should eq '1'
-        end
-      end
-
-      context "when keys are provided to the :except option" do
-        it "truncates all but the specified keys" do
-          create_widget
-          create_gadget
-          @redis.keys.size.should eq 6
-          Truncation.new(:except => ['*Widget*']).clean
-          @redis.keys.size.should eq 3
-          @redis.get('DatabaseCleaner::Ohm::Widget:id').should eq '1'
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/redis/base_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'redis'
-require 'database_cleaner/redis/base'
-require 'database_cleaner/shared_strategy'
-
-module DatabaseCleaner
-  describe Redis do
-    it { should respond_to(:available_strategies) }
-  end
-
-  module Redis
-    class ExampleStrategy
-      include ::DatabaseCleaner::Redis::Base
-    end
-
-    describe ExampleStrategy do
-
-      it_should_behave_like "a generic strategy"
-      it { should respond_to(:db) }
-      it { should respond_to(:db=) }
-
-      context "when passing url" do
-        it "should store my describe db" do
-          url = 'redis://localhost:6379/2'
-          subject.db = 'redis://localhost:6379/2'
-          subject.db.should eq url
-        end
-      end
-
-      context "when passing connection" do
-        it "should store my describe db" do
-          connection = ::Redis.new :url => 'redis://localhost:6379/2'
-          subject.db = connection
-          subject.db.should eq connection
-        end
-      end
-
-      it "should default to :default" do
-        subject.db.should eq :default
-      end
-    end
-  end
-end

data/spec/database_cleaner/redis/truncation_spec.rb

@@ -1,63 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'redis'
-require 'database_cleaner/redis/truncation'
-
-
-module DatabaseCleaner
-  module Redis
-
-    describe Truncation do
-      before(:all) do
-        config = YAML::load(File.open("#{File.dirname(__FILE__)}/../../../examples/config/redis.yml"))
-      @redis = ::Redis.new :url => config['test']['url']
-      end
-
-      before(:each) do
-        @redis.flushdb
-      end
-
-      it "should flush the database" do
-        Truncation.new.clean
-      end
-
-      def create_widget(attrs={})
-        @redis.set 'Widget', 1
-      end
-
-      def create_gadget(attrs={})
-        @redis.set 'Gadget', 1
-      end
-
-      it "truncates all keys by default" do
-        create_widget
-        create_gadget
-        @redis.keys.size.should eq 2
-        Truncation.new.clean
-        @redis.keys.size.should eq 0
-      end
-
-      context "when keys are provided to the :only option" do
-        it "only truncates the specified keys" do
-          create_widget
-          create_gadget
-          @redis.keys.size.should eq 2
-          Truncation.new(:only => ['Widge*']).clean
-          @redis.keys.size.should eq 1
-          @redis.get('Gadget').should eq '1'
-        end
-      end
-
-      context "when keys are provided to the :except option" do
-        it "truncates all but the specified keys" do
-          create_widget
-          create_gadget
-          @redis.keys.size.should eq 2
-          Truncation.new(:except => ['Widg*']).clean
-          @redis.keys.size.should eq 1
-          @redis.get('Widget').should eq '1'
-        end
-      end
-    end
-  end
-end
-

data/spec/database_cleaner/sequel/base_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/sequel/base'
-require 'database_cleaner/shared_strategy'
-require 'sequel'
-
-module DatabaseCleaner
-  describe Sequel do
-    it { should respond_to(:available_strategies) }
-  end
-
-  module Sequel
-    class ExampleStrategy
-      include ::DatabaseCleaner::Sequel::Base
-    end
-
-    describe ExampleStrategy do
-      it_should_behave_like "a generic strategy"
-      it { should respond_to(:db)  }
-      it { should respond_to(:db=) }
-
-      it "should store my desired db" do
-        subject.db = :my_db
-        subject.db.should eq :my_db
-      end
-
-      it "should default to :default" do
-        pending "I figure out how to use Sequel and write some real tests for it..."
-        subject.db.should eq :default
-      end
-    end
-  end
-end

data/spec/database_cleaner/sequel/deletion_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/sequel/deletion'
-require 'database_cleaner/shared_strategy'
-require 'sequel'
-require 'support/active_record/database_setup'
-
-module DatabaseCleaner
-  module Sequel
-    describe Deletion do
-      it_should_behave_like "a generic strategy"
-    end
-
-    shared_examples 'a Sequel deletion strategy' do
-      let(:deletion) do
-        d = Deletion.new
-        d.db = db
-        d
-      end
-
-      context 'when several tables have data' do
-        before(:each) do
-          db.create_table!(:precious_stones) { primary_key :id }
-          db.create_table!(:replaceable_trifles)  { primary_key :id }
-          db.create_table!(:worthless_junk)  { primary_key :id }
-
-          db[:precious_stones].insert
-          db[:replaceable_trifles].insert
-          db[:worthless_junk].insert
-        end
-
-        context 'by default' do
-          it 'deletes all the tables' do
-            d = Deletion.new
-            d.db = db
-            d.clean
-
-            expect(db[:replaceable_trifles]).to have(0).rows
-            expect(db[:worthless_junk]).to have(0).rows
-            expect(db[:precious_stones]).to have(0).rows
-          end
-        end
-      end
-    end
-
-    supported_configurations = [
-      { :url => 'mysql:///', :connection_options => db_config['mysql'] },
-      { :url => 'postgres:///', :connection_options => db_config['postgres'] }
-    ]
-
-    supported_configurations.each do |config|
-      describe "Sequel deletion (using a #{config[:url]} connection)" do
-        let(:db) { ::Sequel.connect(config[:url], config[:connection_options]) }
-
-        it_behaves_like 'a Sequel deletion strategy'
-      end
-    end
-  end
-end

data/spec/database_cleaner/sequel/transaction_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/sequel/transaction'
-require 'database_cleaner/shared_strategy'
-require 'sequel'
-
-module DatabaseCleaner
-  module Sequel
-    describe Transaction do
-      it_should_behave_like "a generic strategy"
-      it_should_behave_like "a generic transaction strategy"
-
-      describe "start" do
-        it "should start a transaction"
-      end
-
-      describe "clean" do
-        it "should finish a transaction"
-      end
-    end
-  end
-end

data/spec/database_cleaner/sequel/truncation_spec.rb

@@ -1,182 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/sequel/truncation'
-require 'database_cleaner/shared_strategy'
-require 'sequel'
-
-# XXX: use ActiveRecord's db_config (`db/config.yml`) for CI/dev convenience
-require 'support/active_record/database_setup'
-
-module DatabaseCleaner
-  module Sequel
-    describe Truncation do
-      it_should_behave_like "a generic strategy"
-      it_should_behave_like "a generic truncation strategy"
-    end
-
-    shared_examples 'a Sequel truncation strategy' do
-
-      # XXX: it'd be really nice if Truncation accepted db: constructor parameter
-      let(:truncation) do
-        t = Truncation.new
-        t.db = db
-        t
-      end
-
-      context 'when several tables have data' do
-        before(:each) do
-          db.create_table!(:precious_stones) { primary_key :id }
-          db.create_table!(:replaceable_trifles)  { primary_key :id }
-          db.create_table!(:worthless_junk)  { primary_key :id }
-
-          db[:precious_stones].insert
-          db[:replaceable_trifles].insert
-          db[:worthless_junk].insert
-        end
-        context 'by default' do
-          it 'truncates all the tables' do
-            t = Truncation.new
-            t.db = db
-            t.clean
-
-            expect(db[:replaceable_trifles]).to have(0).rows
-            expect(db[:worthless_junk]).to have(0).rows
-            expect(db[:precious_stones]).to have(0).rows
-          end
-        end
-        context 'when the Truncation is restricted to "only: [...]" some tables' do
-          it 'truncates only the mentioned tables (and leaves the rest alone)' do
-            t = Truncation.new(only: ['worthless_junk', 'replaceable_trifles'])
-            t.db = db
-            t.clean
-
-            expect(db[:replaceable_trifles]).to have(0).rows
-            expect(db[:worthless_junk]).to have(0).rows
-            expect(db[:precious_stones]).to have(1).rows
-          end
-        end
-        context 'when the Truncation is restricted to "except: [...]" some tables' do
-          it 'leaves the mentioned tables alone (and truncates the rest)' do
-            t = Truncation.new(except: ['precious_stones']) # XXX: Strings only, symbols are ignored
-            t.db = db
-            t.clean
-
-            expect(db[:replaceable_trifles]).to be_empty
-            expect(db[:worthless_junk]).to be_empty
-            expect(db[:precious_stones]).to have(1).item
-          end
-        end
-      end
-    end
-
-    shared_examples_for 'a truncation strategy without autoincrement resets' do
-      it "leaves AUTO_INCREMENT index alone by default (BUG: it should be reset instead)" do
-        # Jordan Hollinger made everything reset auto increment IDs
-        # in commit 6a0104382647e5c06578aeac586c0333c8944492 so I'm pretty sure
-        # everything is meant to reset by default.
-        #
-        # For Postgres, db[:mytable].truncate(restart: true) should work.
-        # For SQLite, db[:sqlite_sequence].where(name: 'mytable').delete
-
-        db.create_table!(:replaceable_trifles) { primary_key :id }
-        table = db[:replaceable_trifles]
-        2.times { table.insert }
-
-        truncation.clean
-
-        id_after_clean = table.insert
-        pending('the bug being fixed') do
-          expect(id_after_clean).to eq 1
-        end
-      end
-      # XXX: it'd be really nice if Truncation accepted db: constructor parameter
-      let(:truncation) do
-        t = Truncation.new
-        t.db = db
-        t
-      end
-    end
-
-    shared_examples_for 'a truncation strategy that resets autoincrement keys by default' do
-      it "resets AUTO_INCREMENT primary keys" do
-        db.create_table!(:replaceable_trifles) { primary_key :id }
-        table = db[:replaceable_trifles]
-        2.times { table.insert }
-
-        truncation.clean
-
-        id_after_clean = table.insert
-        expect(id_after_clean).to eq 1
-      end
-
-      # XXX: it'd be really nice if Truncation accepted db: constructor parameter
-      let(:truncation) do
-        t = Truncation.new
-        t.db = db
-        t
-      end
-    end
-
-    half_supported_configurations = [
-      {url: 'sqlite:///',   connection_options: db_config['sqlite3']},
-      {url: 'postgres:///', connection_options: db_config['postgres']},
-    ]
-    supported_configurations = [
-      {url: 'mysql:///',    connection_options: db_config['mysql']},
-      {url: 'mysql2:///',   connection_options: db_config['mysql2']}
-    ]
-    supported_configurations.each do |config|
-      describe "Sequel truncation (using a #{config[:url]} connection)" do
-        let(:db) { ::Sequel.connect(config[:url], config[:connection_options]) }
-
-        it_behaves_like 'a Sequel truncation strategy'
-        it_behaves_like 'a truncation strategy that resets autoincrement keys by default'
-
-        describe '#pre_count?' do
-          subject { Truncation.new.tap { |t| t.db = db } }
-
-          its(:pre_count?) { should eq false }
-
-          it 'should return true if @reset_id is set and non false or nil' do
-            subject.instance_variable_set(:"@pre_count", true)
-            subject.send(:pre_count?).should eq true
-          end
-
-          it 'should return false if @reset_id is set to false' do
-            subject.instance_variable_set(:"@pre_count", false)
-            subject.send(:pre_count?).should eq false
-          end
-        end
-
-        describe "relying on #pre_count_truncate_tables if asked to" do
-          subject { Truncation.new.tap { |t| t.db = db } }
-
-          it "should rely on #pre_count_truncate_tables if #pre_count? returns true" do
-            subject.instance_variable_set(:"@pre_count", true)
-
-            subject.should_not_receive(:truncate_tables)
-            subject.should_receive(:pre_count_truncate_tables)
-
-            subject.clean
-          end
-
-          it "should not rely on #pre_count_truncate_tables if #pre_count? return false" do
-            subject.instance_variable_set(:"@pre_count", false)
-
-            subject.should_not_receive(:pre_count_truncate_tables)
-            subject.should_receive(:truncate_tables)
-
-            subject.clean
-          end
-        end
-      end
-    end
-    half_supported_configurations.each do |config|
-      describe "Sequel truncation (using a #{config[:url]} connection)" do
-        let(:db) { ::Sequel.connect(config[:url], config[:connection_options]) }
-
-        it_behaves_like 'a Sequel truncation strategy'
-        it_behaves_like 'a truncation strategy without autoincrement resets'
-      end
-    end
-  end
-end