consistency_fail 0.3.3 → 0.3.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NTdkY2IwZWQ2ZjI5Mzk1ZDc3NTMxNzFhM2IyNDllZWVhMmUwZWQ4OQ==
-  data.tar.gz: !binary |-
-    YzQzNDRjODdhN2RhN2UzZmVhMjIwYzkxMDQ5NTY3NjEyMDM2NWM5Mw==
+SHA1:
+  metadata.gz: e39eaf9c01eac716941d478876cccf815cac17df
+  data.tar.gz: ea14788fa3224a69441d52803d69992d910b360c
 SHA512:
-  metadata.gz: !binary |-
-    OGVlNzc3MTFlMDEyNzk5YmViM2UwOTI4YzAzNGMwY2U0Y2M4MGQ0MjRmMTM4
-    ZDgwZGM1YmE1MjhlMzA1MzVlZDU2YzJlNGJmNmQ2ZjMxNWQ0YzE4OTY5YjEx
-    Y2ZiNWFjMThkODRjMGNiMzY4ZjYwNDFjMzU0Yzk3MDBiNTViZWM=
-  data.tar.gz: !binary |-
-    MzJmNWE4YTU4MWRjMTExMDYwN2JkNGQyYzBhMWNiOWRjNGY3ZmJlYjg5MzQ0
-    NzBlNDY3N2I2OWJiMWU1OWEzNDFkYzliZDkzYzcwZDA1ZmY4ZWUzOTBhODky
-    NzI4NTA5OWM0YjY3ZDYyNmNhMmVjMjM4N2U4MWRmY2VjNzlmMzc=
+  metadata.gz: c60df52fb547fc080706b1e38f550fc26fd4aacf9cfbae471f8d39cebce76e9f03df7b782df0df7fe13ab5496d27650d526a815e481786900dc0c523d8802aa6
+  data.tar.gz: d999a4beba6dddf954b7f5c670c117222b42247a64e92015bd4bae13ebc648df82988a49294eaac5bca22992a4b9daa719b98e997d06738c106b258a462cb35a

data/.rspec

@@ -1 +1,2 @@
 --color
+--require spec_helper

data/bin/consistency_fail

@@ -13,37 +13,7 @@ require File.join(Dir.pwd, "config", "environment")
 $:<< File.join(File.dirname(__FILE__), "..", "lib")
 require "consistency_fail"
 
-def problems(models, introspector)
-  models.map do |m|
-    [m, introspector.missing_indexes(m)]
-  end.reject do |m, indexes|
-    indexes.empty?
-  end
-end
-
-models = ConsistencyFail::Models.new($LOAD_PATH)
-models.preload_all
-
-reporter = ConsistencyFail::Reporter.new
-
-success = true
-
-introspector = ConsistencyFail::Introspectors::ValidatesUniquenessOf.new
-problems = problems(models.all, introspector)
-reporter.report_validates_uniqueness_problems(problems)
-success &&= problems.empty?
-
-introspector = ConsistencyFail::Introspectors::HasOne.new
-problems = problems(models.all, introspector)
-reporter.report_has_one_problems(problems)
-success &&= problems.empty?
-
-introspector = ConsistencyFail::Introspectors::Polymorphic.new
-problems = problems(models.all, introspector)
-reporter.report_polymorphic_problems(problems)
-success &&= problems.empty?
-
-if success
+if ConsistencyFail.run
   exit 0
 else
   exit 1

data/consistency_fail.gemspec

@@ -22,7 +22,8 @@ EOF
   s.license = "MIT"
 
   s.add_development_dependency "activerecord", "~>3.0"
-  s.add_development_dependency "rspec", "~>3.1"
+  s.add_development_dependency "sqlite3", "~>1.3"
+  s.add_development_dependency "rspec", "~>3.2"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/consistency_fail.rb

@@ -4,3 +4,41 @@ require 'consistency_fail/introspectors/validates_uniqueness_of'
 require 'consistency_fail/introspectors/has_one'
 require 'consistency_fail/introspectors/polymorphic'
 require 'consistency_fail/reporter'
+
+module ConsistencyFail
+  def self.run
+    models = ConsistencyFail::Models.new($LOAD_PATH)
+    models.preload_all
+
+    reporter = ConsistencyFail::Reporter.new
+
+    success = true
+
+    introspector = ConsistencyFail::Introspectors::ValidatesUniquenessOf.new
+    problems = problems(models.all, introspector)
+    reporter.report_validates_uniqueness_problems(problems)
+    success &&= problems.empty?
+
+    introspector = ConsistencyFail::Introspectors::HasOne.new
+    problems = problems(models.all, introspector)
+    reporter.report_has_one_problems(problems)
+    success &&= problems.empty?
+
+    introspector = ConsistencyFail::Introspectors::Polymorphic.new
+    problems = problems(models.all, introspector)
+    reporter.report_polymorphic_problems(problems)
+    success &&= problems.empty?
+    
+    success
+  end
+  
+  private
+  
+  def self.problems(models, introspector)
+    models.map do |m|
+      [m, introspector.missing_indexes(m)]
+    end.reject do |m, indexes|
+      indexes.empty?
+    end
+  end
+end

data/lib/consistency_fail/index.rb

@@ -5,11 +5,29 @@ module ConsistencyFail
       @model = model
       @table_name = table_name
       @columns = columns.map(&:to_s)
+      handle_associations
     end
 
     def ==(other)
       self.table_name == other.table_name &&
         self.columns.sort == other.columns.sort
     end
+
+    private
+
+    def handle_associations
+      references = @model.reflect_on_all_associations(:belongs_to)
+      names = references.map(&:name).map(&:to_s)
+      @columns.map! do |column|
+        next column unless names.include?(column)
+        reflection = @model.reflect_on_association(column.to_sym)
+        if reflection.options[:polymorphic]
+          [reflection.foreign_key, reflection.foreign_type]
+        else
+          reflection.foreign_key
+        end
+      end
+      @columns.flatten!
+    end
   end
 end

data/lib/consistency_fail/introspectors/has_one.rb

@@ -17,7 +17,7 @@ module ConsistencyFail
           else
             foreign_key = a.primary_key_name
           end
-          ConsistencyFail::Index.new(a.class_name.constantize,
+          ConsistencyFail::Index.new(a.klass,
                                      a.table_name.to_s,
                                      [foreign_key])
         end.compact

data/lib/consistency_fail/introspectors/polymorphic.rb

@@ -16,7 +16,7 @@ module ConsistencyFail
           as_id   = "#{as}_id"
 
           ConsistencyFail::Index.new(
-            a.class_name.constantize,
+            a.klass,
             a.table_name.to_s,
             [as_type, as_id]
           )
@@ -37,7 +37,6 @@ module ConsistencyFail
           existing_indexes.include?(index)
         end
       end
-
     end
   end
 end

data/lib/consistency_fail/introspectors/validates_uniqueness_of.rb

@@ -22,6 +22,7 @@ module ConsistencyFail
       private :desired_indexes
 
       def missing_indexes(model)
+        return [] unless model.connection.tables.include? model.table_name
         existing_indexes = TableData.new.unique_indexes(model)
 
         desired_indexes(model).reject do |index|

data/lib/consistency_fail/models.rb

@@ -26,6 +26,5 @@ module ConsistencyFail
     def all
       ActiveRecord::Base.send(:descendants).sort_by(&:name)
     end
-
   end
 end

data/lib/consistency_fail/version.rb

@@ -1,3 +1,3 @@
 module ConsistencyFail
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/spec/index_spec.rb

@@ -1,40 +1,59 @@
-require 'spec_helper'
-require 'consistency_fail/index'
-
 describe ConsistencyFail::Index do
-
+  
+  let(:index) do
+    ConsistencyFail::Index.new(
+      CorrectAddress, 
+      CorrectAddress.table_name, 
+      ["city", "state"]
+    )
+  end
+  
   describe "value objectiness" do
     it "holds onto model, table name, and columns" do
-      model = double("model")
-      index = ConsistencyFail::Index.new(model, "addresses", ["city", "state"])
-      expect(index.model).to eq(model)
-      expect(index.table_name).to eq("addresses")
-      expect(index.columns).to eq(["city", "state"])
+      expect(index.model).to eq(CorrectAddress)
+      expect(index.table_name).to eq("correct_addresses")
+      expect(index.columns).to eq(
+        ["city", "state"]
+      )
     end
 
     it "leaves columns in the initial order (since we only care about presence, not performance)" do
-      index = ConsistencyFail::Index.new(double('model'), "addresses", ["state", "city"])
-      expect(index.columns).to eq(["state", "city"])
+      expect(index.columns).to eq(
+        ["city", "state"]
+      )
     end
   end
 
-  describe "equality test" do
+  describe "equality test" do  
     it "passes when everything matches" do
-      expect(ConsistencyFail::Index.new(double('model'), "addresses", ["city", "state"])).to eq(
-        ConsistencyFail::Index.new(double('model'),"addresses", ["city", "state"])
+      expect(index).to eq(
+        ConsistencyFail::Index.new(
+          "CorrectAddress".constantize, 
+          "correct_addresses", 
+          ["city", "state"]
+        )
       )
     end
 
     it "fails when tables are different" do
-      expect(ConsistencyFail::Index.new(double('model'),"locations", ["city", "state"])).not_to eq(
-        ConsistencyFail::Index.new(double('model'),"addresses", ["city", "state"])
+      expect(index).not_to eq(
+        ConsistencyFail::Index.new(
+          CorrectAttachment, 
+          CorrectAttachment.table_name, 
+          ["attachable_id", "attachable_type"]
+        )
       )
     end
 
     it "fails when columns are different" do
-      expect(ConsistencyFail::Index.new(double('model'),"addresses", ["city", "state"])).not_to eq(
-        ConsistencyFail::Index.new(double('model'),"addresses", ["state", "zip"])
+      expect(index).not_to eq(
+        ConsistencyFail::Index.new(
+          CorrectAddress, 
+          CorrectAddress.table_name, 
+          ["correct_user_id"]
+        )
       )
     end
   end
+  
 end

data/spec/introspectors/has_one_spec.rb

@@ -1,96 +1,21 @@
-require 'spec_helper'
-require 'consistency_fail/introspectors/table_data'
-require 'consistency_fail/introspectors/has_one'
-
 describe ConsistencyFail::Introspectors::HasOne do
-  def introspector(model)
-    ConsistencyFail::Introspectors::HasOne.new(model)
-  end
-
-  describe "instances of has_one" do
-    it "finds none" do
-      model = fake_ar_model("User")
-      allow(model).to receive(:reflect_on_all_associations).and_return([])
-
-      expect(subject.instances(model)).to eq([])
-    end
-
-    it "finds one" do
-      model = fake_ar_model("User")
-      association = double("association", :macro => :has_one, :options => {})
-      allow(model).to receive(:reflect_on_all_associations).and_return([association])
-
-      expect(subject.instances(model)).to eq([association])
-    end
-
-    it "finds other associations, but not has_one" do
-      model = fake_ar_model("User")
-      validation = double("validation", :macro => :has_many)
-      allow(model).to receive(:reflect_on_all_associations).and_return([validation])
-
-      expect(subject.instances(model)).to eq([])
-    end
-
-    it "finds one, but it's a polymorphic association" do
-      model = fake_ar_model("User")
-      association = double("association", :macro => :has_one, :options => {:as => "addressable"})
-      allow(model).to receive(:reflect_on_all_associations).and_return([association])
-
-      expect(subject.instances(model)).to eq([])
-    end
-
-    it "finds one, but it's a :through association" do
-      model = fake_ar_model("User")
-      association = double("association", :macro => :has_one, :options => {:through => :amodel})
-      allow(model).to receive(:reflect_on_all_associations).and_return([association])
-
-      expect(subject.instances(model)).to eq([])
-    end
-  end
-
+  
   describe "finding missing indexes" do
-    before do
-      @association = double("association", :macro => :has_one, :options => {})
-      @model = fake_ar_model("User", :table_exists? => true,
-                                     :table_name => "users",
-                                     :class_name => "User",
-                                     :reflect_on_all_associations => [@association])
-      @address_class = double("Address Class")
-      @address_string = "Address"
-      allow(@address_string).to receive(:constantize).and_return(@address_class)
-    end
-
     it "finds one" do
-      allow(@association).to receive_messages(:table_name => :addresses, :class_name => @address_string, :foreign_key => "user_id")
-      allow(@address_class).to receive_message_chain(:connection, :indexes).with("addresses").and_return([])
-
-      indexes = subject.missing_indexes(@model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(fake_ar_model("Address"), "addresses", ["user_id"])])
-    end
-
-    it "finds one in Rails 3.0.x (where foreign_key is not defined)" do
-      allow(@association).to receive_messages(:table_name => :addresses, :class_name => @address_string, :primary_key_name => "user_id")
-      allow(@address_class).to receive_message_chain(:connection, :indexes).with("addresses").and_return([])
-
-      indexes = subject.missing_indexes(@model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(fake_ar_model("Address"), "addresses", ["user_id"])])
-    end
-
+      indexes = subject.missing_indexes(WrongUser)
+      
+      expect(indexes).to eq([
+        ConsistencyFail::Index.new(
+          WrongAddress, 
+          WrongAddress.table_name, 
+          ["wrong_user_id"]
+        )
+      ])
+    end
+    
     it "finds none when they're already in place" do
-      allow(@association).to receive_messages(:table_name => :addresses, :class_name => @address_string, :foreign_key => "user_id")
-      index = ConsistencyFail::Index.new(double('model'), "addresses", ["user_id"])
-
-      fake_connection = double("connection")
-      allow(@address_class).to receive_message_chain(:connection).and_return(fake_connection)
-
-      allow(ConsistencyFail::Introspectors::TableData).to receive_message_chain(:new, :unique_indexes_by_table).
-        with(@address_class, fake_connection, "addresses").
-        and_return([index])
-
-      expect(subject.missing_indexes(@model)).to eq([])
+      expect(subject.missing_indexes(CorrectUser)).to be_empty
     end
-
   end
+  
 end
-
-

data/spec/introspectors/polymorphic_spec.rb

@@ -1,77 +1,26 @@
-require 'spec_helper'
-require 'consistency_fail/introspectors/table_data'
-require 'consistency_fail/introspectors/polymorphic'
-
 describe ConsistencyFail::Introspectors::Polymorphic do
-  def introspector(model)
-    ConsistencyFail::Introspectors::Polymorphic.new(model)
-  end
-
-  describe "instances of polymorphic" do
-    it "finds none" do
-      model = fake_ar_model("User")
-      allow(model).to receive(:reflect_on_all_associations).and_return([])
-
-      expect(subject.instances(model)).to eq([])
-    end
-
-    it "finds one" do
-      model = fake_ar_model("User")
-      association = double("association", :macro => :has_one, :options => {:as => "addressable"})
-      allow(model).to receive(:reflect_on_all_associations).and_return([association])
-
-      expect(subject.instances(model)).to eq([association])
-    end
-
-    it "finds other has_one associations, but not polymorphic" do
-      model = fake_ar_model("User")
-      validation = double("association", :macro => :has_one, :options => {})
-      allow(model).to receive(:reflect_on_all_associations).and_return([validation])
-
-      expect(subject.instances(model)).to eq([])
-    end
-
-    it "finds other non has_one associations" do
-      model = fake_ar_model("User")
-      validation = double("association", :macro => :has_many)
-      allow(model).to receive(:reflect_on_all_associations).and_return([validation])
-
-      expect(subject.instances(model)).to eq([])
-    end
-  end
 
   describe "finding missing indexes" do
-    before do
-      @association = double("association", :macro => :has_one, :options => {:as => "addressable"})
-      @model = fake_ar_model("User", :table_exists? => true,
-                                     :table_name => "users",
-                                     :class_name => "User",
-                                     :reflect_on_all_associations => [@association])
-      @address_class = double("Address Class")
-      @address_string = "Address"
-      allow(@address_string).to receive(:constantize).and_return(@address_class)
-    end
-
     it "finds one" do
-      allow(@association).to receive_messages(:table_name => :addresses, :class_name => @address_string)
-      allow(@address_class).to receive_message_chain(:connection, :indexes).with("addresses").and_return([])
-
-      indexes = subject.missing_indexes(@model)
-      expect(indexes).to eq([ConsistencyFail::Index.new(fake_ar_model("Address"), "addresses", ["addressable_type", "addressable_id"])])
+      indexes = subject.missing_indexes(WrongPost)
+
+      expect(indexes).to eq([
+        ConsistencyFail::Index.new(
+          WrongAttachment,
+          WrongAttachment.table_name,
+          ["attachable_type", "attachable_id"]
+        )
+      ])
     end
 
     it "finds none when they're already in place" do
-      allow(@association).to receive_messages(:table_name => :addresses, :class_name => @address_string)
-      index = ConsistencyFail::Index.new(double('model'), "addresses", ["addressable_type", "addressable_id"])
-
-      fake_connection = double("connection")
-      allow(@address_class).to receive_message_chain(:connection).and_return(fake_connection)
-
-      allow(ConsistencyFail::Introspectors::TableData).to receive_message_chain(:new, :unique_indexes_by_table).
-        with(@address_class, fake_connection, "addresses").
-        and_return([index])
+      expect(subject.missing_indexes(CorrectPost)).to be_empty
+    end
 
-      expect(subject.missing_indexes(@model)).to eq([])
+    it "finds none with nested modules" do
+      expect(subject.missing_indexes(CorrectUser)).to eq([])
     end
+
   end
+
 end