consistency_fail 0.3.3 → 0.3.4

data/spec/introspectors/table_data_spec.rb

@@ -1,52 +1,63 @@
-require 'spec_helper'
-require 'consistency_fail/introspectors/table_data'
-
 describe ConsistencyFail::Introspectors::TableData do
+  
   describe "finding unique indexes" do
     it "finds none when the table does not exist" do
-      model = fake_ar_model("User", :table_exists? => false)
-
-      expect(subject.unique_indexes(model)).to eq([])
+      expect(subject.unique_indexes(Nonexistent)).to be_empty
     end
 
     it "gets one" do
-      model = fake_ar_model("User", :table_exists? => true,
-                                    :table_name => "users")
-
-      allow(model).to receive_message_chain(:connection, :indexes).
-            with("users").
-            and_return([fake_index_on(["a"], :unique => true)])
-
-      indexes = subject.unique_indexes(model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(double('model'), "users", ["a"])])
+      index = ConsistencyFail::Index.new(
+        CorrectAccount,
+        CorrectAccount.table_name,
+        ["email"]
+      )
+
+      expect(
+        ConsistencyFail::Introspectors::TableData.new.unique_indexes_by_table(
+          CorrectAccount,
+          ActiveRecord::Base.connection,
+          CorrectAccount.table_name
+        )
+      ).to eq [index]
     end
 
     it "doesn't get non-unique indexes" do
-      model = fake_ar_model("User", :table_exists? => true,
-                                    :table_name => "users")
-
-      allow(model).to receive_message_chain(:connection, :indexes).
-            with("users").
-            and_return([fake_index_on(["a"], :unique => false)])
-
-      expect(subject.unique_indexes(model)).to eq([])
+      expect(
+        ConsistencyFail::Introspectors::TableData.new.unique_indexes_by_table(
+          WrongAddress,
+          ActiveRecord::Base.connection,
+          WrongAddress.table_name
+        )
+      ).to be_empty
     end
 
     it "gets multiple unique indexes" do
-      model = fake_ar_model("User", :table_exists? => true,
-                                    :table_name => "users")
-
-      allow(model).to receive_message_chain(:connection, :indexes).
-            with("users").
-            and_return([fake_index_on(["a"], :unique => true),
-                        fake_index_on(["b", "c"], :unique => true)])
-
-      indexes = subject.unique_indexes(model)
-      expect(indexes.size).to eq(2)
-      expect(indexes).to eq([ConsistencyFail::Index.new(double('model'), "users", ["a"]),
-                         ConsistencyFail::Index.new(double('model'), "users", ["b", "c"])])
+      indexes = [
+        ConsistencyFail::Index.new(
+          CorrectAttachment,
+          CorrectAttachment.table_name,
+          ["name"]
+        ),
+        ConsistencyFail::Index.new(
+          CorrectAttachment,
+          CorrectAttachment.table_name,
+          ["attachable_id", "attachable_type"]
+        ),
+        ConsistencyFail::Index.new(
+          CorrectAttachment,
+          CorrectAttachment.table_name,
+          ["name", "attachable_id", "attachable_type"]
+        )
+      ]
+
+      expect(
+        ConsistencyFail::Introspectors::TableData.new.unique_indexes_by_table(
+          CorrectAttachment,
+          ActiveRecord::Base.connection,
+          CorrectAttachment.table_name
+        )
+      ).to eq indexes
     end
   end
 
 end
-

data/spec/introspectors/validates_uniqueness_of_spec.rb

@@ -1,93 +1,68 @@
-require 'spec_helper'
-require 'consistency_fail/introspectors/validates_uniqueness_of'
-
 describe ConsistencyFail::Introspectors::ValidatesUniquenessOf do
-  def introspector(model)
-    ConsistencyFail::Introspectors::ValidatesUniquenessOf.new(model)
-  end
-
-  describe "instances of validates_uniqueness_of" do
-    it "finds none" do
-      model = fake_ar_model("User")
-      allow(model).to receive(:validators).and_return([])
-
-      expect(subject.instances(model)).to eq([])
-    end
-
-    it "finds one" do
-      model = fake_ar_model("User")
-      validation = double("validation", :class => ActiveRecord::Validations::UniquenessValidator)
-      allow(model).to receive(:validators).and_return([validation])
-
-      expect(subject.instances(model)).to eq([validation])
-    end
-
-    it "finds other validations, but not uniqueness" do
-      model = fake_ar_model("User")
-      validation = double("validation", :class => ActiveModel::Validations::FormatValidator)
-      allow(model).to receive(:validators).and_return([validation])
-
-      expect(subject.instances(model)).to eq([])
-    end
-  end
 
   describe "finding missing indexes" do
-    before do
-      @validation = double("validation", :class => ActiveRecord::Validations::UniquenessValidator)
-      @model = fake_ar_model("User", :table_exists? => true,
-                                     :table_name => "users",
-                                     :validators => [@validation])
-    end
-
     it "finds one" do
-      allow(@validation).to receive_messages(:attributes => [:email], :options => {})
-      allow(@model).to receive_message_chain(:connection, :indexes).with("users").and_return([])
-
-      indexes = subject.missing_indexes(@model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(double('model'), "users", ["email"])])
+      indexes = subject.missing_indexes(WrongAccount)
+
+      expect(indexes).to eq([
+        ConsistencyFail::Index.new(
+          WrongAccount,
+          WrongAccount.table_name,
+          ["email"]
+        )
+      ])
     end
 
     it "finds one where the validation has scoped columns" do
-      allow(@validation).to receive_messages(:attributes => [:city], :options => {:scope => [:email, :state]})
-      allow(@model).to receive_message_chain(:connection, :indexes).with("users").and_return([])
-
-      indexes = subject.missing_indexes(@model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(double('model'), "users", ["city", "email", "state"])])
-    end
-
-    it "leaves the columns in the given order" do
-      allow(@validation).to receive_messages(:attributes => [:email], :options => {:scope => [:city, :state]})
-      allow(@model).to receive_message_chain(:connection, :indexes).with("users").and_return([])
-
-      indexes = subject.missing_indexes(@model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(double('model'), "users", ["email", "city", "state"])])
+      indexes = subject.missing_indexes(WrongBusiness)
+
+      expect(indexes).to eq([
+        ConsistencyFail::Index.new(
+          WrongBusiness,
+          WrongBusiness.table_name,
+          ["name", "city", "state"]
+        )
+      ])
     end
 
     it "finds two where there are multiple attributes" do
-      allow(@validation).to receive_messages(:attributes => [:email, :name], :options => {:scope => [:city, :state]})
-      allow(@model).to receive_message_chain(:connection, :indexes).with("users").and_return([])
-
-      indexes = subject.missing_indexes(@model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(double('model'), "users", ["email", "city", "state"]),
-                         ConsistencyFail::Index.new(double('model'), "users", ["name", "city", "state"])])
+      indexes = subject.missing_indexes(WrongPerson)
+
+      expect(indexes).to eq(
+        [
+          ConsistencyFail::Index.new(
+            WrongPerson,
+            WrongPerson.table_name,
+            ["email", "city", "state"]
+          ),
+          ConsistencyFail::Index.new(
+            WrongPerson,
+            WrongPerson.table_name,
+            ["name", "city", "state"]
+          )
+        ]
+      )
     end
 
     it "finds none when they're already in place" do
-      allow(@validation).to receive_messages(:attributes => [:email], :options => {})
-      index = fake_index_on(["email"], :unique => true)
-      allow(@model).to receive_message_chain(:connection, :indexes).with("users").
-             and_return([index])
+      expect(subject.missing_indexes(CorrectAccount)).to be_empty
+    end
+
+    it "finds none even if scoped by association" do
+      expect(subject.missing_indexes(CorrectAddress)).to be_empty
+    end
 
-      expect(subject.missing_indexes(@model)).to eq([])
+    it "finds none even if scoped by polymorphic association" do
+      expect(subject.missing_indexes(CorrectAttachment)).to be_empty
     end
 
     it "finds none when indexes are there but in a different order" do
-      allow(@validation).to receive_messages(:attributes => [:email], :options => {:scope => [:city, :state]})
-      index = fake_index_on(["state", "email", "city"], :unique => true)
-      allow(@model).to receive_message_chain(:connection, :indexes).with("users").
-             and_return([index])
+      expect(subject.missing_indexes(CorrectPerson)).to be_empty
+    end
 
-      expect(subject.missing_indexes(@model)).to eq([])
+    it "finds none when the model is an SQL view" do
+      expect(subject.missing_indexes(NewCorrectPerson)).to be_empty
     end
   end
+
 end

data/spec/models_spec.rb

@@ -1,7 +1,5 @@
-require 'spec_helper'
-require 'consistency_fail/models'
-
 describe ConsistencyFail::Models do
+  
   def models(load_path)
     ConsistencyFail::Models.new(load_path)
   end
@@ -46,4 +44,5 @@ describe ConsistencyFail::Models do
 
     expect(models([]).all).to eq([model_a, model_c, model_b])
   end
+  
 end

data/spec/reporter_spec.rb

@@ -1,90 +1,129 @@
-require 'spec_helper'
-require 'consistency_fail/reporter'
-require 'consistency_fail/index'
-
 describe ConsistencyFail::Reporter do
-  before(:each) do
-    @real_out = $stdout
-    @fake_out = StringIO.new
-    $stdout = @fake_out
-  end
-  after(:each) do
-    $stdout = @real_out
-  end
-
+  
   context "validates_uniqueness_of" do
     it "says everything's good" do
-      subject.report_validates_uniqueness_problems([])
-
-      expect(@fake_out.string).to match(/Hooray!/)
+      expect { 
+        subject.report_validates_uniqueness_problems([]) 
+      }.to output(/Hooray!/).to_stdout
     end
 
     it "shows a missing single-column index on a single model" do
-      missing_indexes = [ConsistencyFail::Index.new(double('model'), "users", ["email"])]
-
-      subject.report_validates_uniqueness_problems(fake_ar_model("User", :table_name => "users") => missing_indexes)
+      missing_indexes = [
+        ConsistencyFail::Index.new(
+          WrongAccount, 
+          WrongAccount.table_name, 
+          ["email"]
+        )
+      ]
 
-      expect(@fake_out.string).to match(/users\s+\(email\)/)
+      expect { 
+        subject.report_validates_uniqueness_problems(
+          WrongAccount => missing_indexes
+        )
+      }.to output(/wrong_accounts\s+\(email\)/).to_stdout
     end
 
     it "shows a missing multiple-column index on a single model" do
-      missing_indexes = [ConsistencyFail::Index.new(double('model'),"addresses", ["number", "street", "zip"])]
-
-      subject.report_validates_uniqueness_problems(fake_ar_model("Address", :table_name => "addresses") => missing_indexes)
+      missing_indexes = [
+        ConsistencyFail::Index.new(
+          WrongBusiness, 
+          WrongBusiness.table_name, 
+          ["name", "city", "state"]
+        )
+      ]
 
-      expect(@fake_out.string).to match(/addresses\s+\(number, street, zip\)/)
+      expect {
+        subject.report_validates_uniqueness_problems(
+          WrongBusiness => missing_indexes
+        )
+      }.to output(/wrong_businesses\s+\(name, city, state\)/).to_stdout
     end
 
     context "with problems on multiple models" do
-      before(:each) do
-        subject.report_validates_uniqueness_problems(
-          fake_ar_model("User", :table_name => "users") =>
-            [ConsistencyFail::Index.new(double('model'),"users", ["email"])],
-          fake_ar_model("Citizen", :table_name => "citizens") =>
-            [ConsistencyFail::Index.new(double('model'),"citizens", ["ssn"])]
-        )
+      def report
+        missing_indices = {
+          WrongAccount => [
+            ConsistencyFail::Index.new(
+              WrongAccount, 
+              WrongAccount.table_name, 
+              ["email"]
+            )
+          ],
+          WrongBusiness => [
+            ConsistencyFail::Index.new(
+              WrongBusiness, 
+              WrongBusiness.table_name, 
+              ["name", "city", "state"]
+            )
+          ]
+        }
+        
+        subject.report_validates_uniqueness_problems(missing_indices)
       end
 
       it "shows all problems" do
-        expect(@fake_out.string).to match(/users\s+\(email\)/m)
-        expect(@fake_out.string).to match(/citizens\s+\(ssn\)/m)
+        expect { report }.to output(/wrong_accounts\s+\(email\)/).to_stdout
+        expect { report }.to output(
+          /wrong_businesses\s+\(name, city, state\)/
+        ).to_stdout
       end
 
       it "orders the models alphabetically" do
-        expect(@fake_out.string).to match(/citizens\s+\(ssn\).*users\s+\(email\)/m)
+        expect { report }.to output(/
+          wrong_accounts\s+\(email\)
+          (\s|\S)*
+          wrong_businesses\s+\(name,\scity,\sstate\)
+        /x).to_stdout
       end
     end
   end
 
   context "has_one" do
     it "says everything's good" do
-      subject.report_has_one_problems([])
-
-      expect(@fake_out.string).to match(/Hooray!/)
+      expect { 
+        subject.report_has_one_problems([]) 
+      }.to output(/Hooray!/).to_stdout
     end
 
     it "shows a missing single-column index on a single model" do
-      missing_indexes = [ConsistencyFail::Index.new(double('model'),"users", ["email"])]
-
-      subject.report_has_one_problems(fake_ar_model("Friend", :table_name => "users") => missing_indexes)
+      missing_indexes = [
+        ConsistencyFail::Index.new(
+          WrongAddress, 
+          WrongAddress.table_name, 
+          ["wrong_user_id"]
+        )
+      ]
 
-      expect(@fake_out.string).to match(/Friend\s+users\s+\(email\)/m)
+      expect {
+        subject.report_has_one_problems(WrongAddress => missing_indexes)
+      }.to output(/wrong_addresses\s+\(wrong_user_id\)/).to_stdout
     end
   end
 
   context "polymorphic" do
     it "says everything's good" do
-      subject.report_polymorphic_problems([])
-
-      expect(@fake_out.string).to match(/Hooray!/)
+      expect {
+        subject.report_polymorphic_problems([])
+      }.to output(/Hooray!/).to_stdout
     end
 
     it "shows a missing compound index on a single model" do
-      missing_indexes = [ConsistencyFail::Index.new(double('model'), "addresses", ["addressable_type", "addressable_id"])]
-
-      subject.report_polymorphic_problems(fake_ar_model("Address", :table_name => "addresses") => missing_indexes)
-
-      expect(@fake_out.string).to match(/Address\s+addresses\s+\(addressable_type, addressable_id\)/m)
+      missing_indexes = [
+        ConsistencyFail::Index.new(
+          WrongAttachment, 
+          WrongAttachment.table_name, 
+          ["attachable_type", "attachable_id"]
+        )
+      ]
+
+      expect {
+        subject.report_polymorphic_problems(WrongAttachment => missing_indexes)
+      }.to(
+        output(
+          /wrong_attachments\s+\(attachable_type, attachable_id\)/
+        ).to_stdout
+      )
     end
   end
+  
 end

data/spec/spec_helper.rb

@@ -1,13 +1,14 @@
-$:<< File.expand_path('..', __FILE__)
-$:<< File.expand_path('../../lib', __FILE__)
+require 'bundler/setup'
 
-require 'rubygems'
+Bundler.require(:default, :test)
 
-def fake_ar_model(name, options = {})
-  double("AR model: #{name}", options.merge(:name => name))
-end
-
-def fake_index_on(columns, options = {})
-  double("index on #{columns.inspect}", options.merge(:columns => columns))
-end
+Dir['./spec/support/**/*.rb'].each { |file| require file }
 
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end