consistency_fail 0.2.2 → 0.3.0

data/README.md

@@ -19,16 +19,14 @@ subject](http://blog.8thlight.com/articles/2011/6/11/winning-at-consistency).
 
 ## Installation
 
-For Rails 3:
+I'm currently only maintaining consistency\_fail for Rails 3. If you need or
+want Rails 2.3 support, I'd be happy to take patches based off the 0.1.1
+branch.
 
     gem install consistency_fail
 
-For Rails 2.3:
-
-    gem install consistency_fail -v=0.1.1
-
 Or, even better if you're using bundler, add it to your Gemfile, with the
-appropriate version number for your Rails version.
+appropriate version number to match your Rails version.
 
 ## Limitations
 
@@ -36,7 +34,8 @@ consistency\_fail depends on being able to find all your `ActiveRecord::Base`
 subclasses with some `$LOAD_PATH` trickery. If any models are in a path either
 not on your project's load path or in a path that doesn't include the word
 "models", consistency\_fail won't be able to find or analyze them. I'm open to
-making the text "models" configurable if people want that.
+making the text "models" configurable if people want that. Please open an issue
+or pull request if so!
 
 ## Usage
 
@@ -64,9 +63,9 @@ Gemfile, or by some other mechanism.
 This mega-fail mode is nice to have if you have a large team and want to ensure
 that new models or validations/associations follow the rules.
 
-If you're using the `Enforcer`, depending on your project, you may need to 
+If you're using the `Enforcer`, depending on your project, you may need to
 delay the initializer until later, so that model files can be loaded only once
-gem dependencies have been satisfied. One possible way is to move the code above 
+gem dependencies have been satisfied. One possible way is to move the code above
 to the end of `environment.rb` or to the more specific `config/environment/*` files.
 
 ## License

data/bin/consistency_fail

@@ -26,11 +26,20 @@ 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?
 
+if success
+  exit 0
+else
+  exit 1
+end

data/lib/consistency_fail/index.rb

@@ -1,13 +1,15 @@
 module ConsistencyFail
   class Index
-    attr_reader :table_name, :columns
-    def initialize(table_name, columns)
+    attr_reader :model, :table_name, :columns
+    def initialize(model, table_name, columns)
+      @model = model
       @table_name = table_name
       @columns = columns.map(&:to_s)
     end
 
     def ==(other)
-      self.table_name == other.table_name && self.columns.sort == other.columns.sort
+      self.table_name == other.table_name &&
+        self.columns.sort == other.columns.sort
     end
   end
 end

data/lib/consistency_fail/introspectors/has_one.rb

@@ -12,7 +12,9 @@ module ConsistencyFail
       # TODO: handle has_one :through cases (multicolumn index on the join table?)
       def desired_indexes(model)
         instances(model).map do |a|
-          ConsistencyFail::Index.new(a.table_name.to_s, [a.primary_key_name]) rescue nil # TODO: why?
+          ConsistencyFail::Index.new(a.class_name.constantize,
+                                     a.table_name.to_s,
+                                     [a.foreign_key])
         end.compact
       end
       private :desired_indexes
@@ -21,8 +23,9 @@ module ConsistencyFail
         desired = desired_indexes(model)
 
         existing_indexes = desired.inject([]) do |acc, d|
-          # TODO: This assumes the models share a database. Need to make that configurable somehow.
-          acc += TableData.new.unique_indexes_by_table(model.connection, d.table_name)
+          acc += TableData.new.unique_indexes_by_table(d.model,
+                                                       d.model.connection,
+                                                       d.table_name)
         end
 
         desired.reject do |index|

data/lib/consistency_fail/introspectors/table_data.rb

@@ -6,14 +6,17 @@ module ConsistencyFail
       def unique_indexes(model)
         return [] if !model.table_exists?
 
-        unique_indexes_by_table(model.connection, model.table_name)
+        unique_indexes_by_table(model, model.connection, model.table_name)
       end
 
-      def unique_indexes_by_table(connection, table_name)
+      def unique_indexes_by_table(model, connection, table_name)
         ar_indexes = connection.indexes(table_name).select(&:unique)
-        ar_indexes.map do |index|
-          ConsistencyFail::Index.new(table_name, index.columns)
+        result = ar_indexes.map do |index|
+          ConsistencyFail::Index.new(model,
+                                     table_name,
+                                     index.columns)
         end
+        result
       end
     end
   end

data/lib/consistency_fail/introspectors/validates_uniqueness_of.rb

@@ -13,7 +13,9 @@ module ConsistencyFail
         instances(model).map do |v|
           v.attributes.map do |attribute|
             scoped_columns = v.options[:scope] || []
-            ConsistencyFail::Index.new(model.table_name, [attribute, *scoped_columns])
+            ConsistencyFail::Index.new(model,
+                                       model.table_name,
+                                       [attribute, *scoped_columns])
           end
         end.flatten
       end

data/lib/consistency_fail/version.rb

@@ -1,3 +1,3 @@
 module ConsistencyFail
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/spec/index_spec.rb

@@ -4,33 +4,34 @@ require 'consistency_fail/index'
 describe ConsistencyFail::Index do
 
   describe "value objectiness" do
-    it "holds onto table name and columns" do
-      index = ConsistencyFail::Index.new("addresses", ["city", "state"])
+    it "holds onto model, table name, and columns" do
+      model = double("model")
+      index = ConsistencyFail::Index.new(model, "addresses", ["city", "state"])
+      index.model.should == model
       index.table_name.should == "addresses"
       index.columns.should == ["city", "state"]
     end
 
     it "leaves columns in the initial order (since we only care about presence, not performance)" do
-      index = ConsistencyFail::Index.new("addresses", ["state", "city"])
-      index.table_name.should == "addresses"
+      index = ConsistencyFail::Index.new(double('model'), "addresses", ["state", "city"])
       index.columns.should == ["state", "city"]
     end
   end
 
   describe "equality test" do
     it "passes when everything matches" do
-      ConsistencyFail::Index.new("addresses", ["city", "state"]).should ==
-        ConsistencyFail::Index.new("addresses", ["city", "state"])
+      ConsistencyFail::Index.new(double('model'), "addresses", ["city", "state"]).should ==
+        ConsistencyFail::Index.new(double('model'),"addresses", ["city", "state"])
     end
 
     it "fails when tables are different" do
-      ConsistencyFail::Index.new("locations", ["city", "state"]).should_not ==
-        ConsistencyFail::Index.new("addresses", ["city", "state"])
+      ConsistencyFail::Index.new(double('model'),"locations", ["city", "state"]).should_not ==
+        ConsistencyFail::Index.new(double('model'),"addresses", ["city", "state"])
     end
 
     it "fails when columns are different" do
-      ConsistencyFail::Index.new("addresses", ["city", "state"]).should_not ==
-        ConsistencyFail::Index.new("addresses", ["state", "zip"])
+      ConsistencyFail::Index.new(double('model'),"addresses", ["city", "state"]).should_not ==
+        ConsistencyFail::Index.new(double('model'),"addresses", ["state", "zip"])
     end
   end
 end

data/spec/introspectors/has_one_spec.rb

@@ -37,26 +37,30 @@ describe ConsistencyFail::Introspectors::HasOne do
       @association = double("association", :macro => :has_one)
       @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"
+      @address_string.stub(:constantize).and_return(@address_class)
     end
 
     it "finds one" do
-      @association.stub!(:table_name => :addresses, :primary_key_name => "user_id")
-      @model.stub_chain(:connection, :indexes).with("addresses").and_return([])
+      @association.stub!(:table_name => :addresses, :class_name => @address_string, :foreign_key => "user_id")
+      @address_class.stub_chain(:connection, :indexes).with("addresses").and_return([])
 
       indexes = subject.missing_indexes(@model)
-      indexes.should == [ConsistencyFail::Index.new("addresses", ["user_id"])]
+      indexes.should == [ConsistencyFail::Index.new(fake_ar_model("Address"), "addresses", ["user_id"])]
     end
 
     it "finds none when they're already in place" do
-      @association.stub!(:table_name => :addresses, :primary_key_name => "user_id")
-      index = ConsistencyFail::Index.new("addresses", ["user_id"])
+      @association.stub!(:table_name => :addresses, :class_name => @address_string, :foreign_key => "user_id")
+      index = ConsistencyFail::Index.new(double('model'), "addresses", ["user_id"])
 
       fake_connection = double("connection")
-      @model.stub_chain(:connection).and_return(fake_connection)
+      @address_class.stub_chain(:connection).and_return(fake_connection)
 
       ConsistencyFail::Introspectors::TableData.stub_chain(:new, :unique_indexes_by_table).
-        with(fake_connection, "addresses").
+        with(@address_class, fake_connection, "addresses").
         and_return([index])
 
       subject.missing_indexes(@model).should == []

data/spec/introspectors/table_data_spec.rb

@@ -18,7 +18,7 @@ describe ConsistencyFail::Introspectors::TableData do
             and_return([fake_index_on(["a"], :unique => true)])
 
       indexes = subject.unique_indexes(model)
-      indexes.should == [ConsistencyFail::Index.new("users", ["a"])]
+      indexes.should == [ConsistencyFail::Index.new(double('model'), "users", ["a"])]
     end
 
     it "doesn't get non-unique indexes" do
@@ -43,8 +43,8 @@ describe ConsistencyFail::Introspectors::TableData do
 
       indexes = subject.unique_indexes(model)
       indexes.size.should == 2
-      indexes.should == [ConsistencyFail::Index.new("users", ["a"]),
-                         ConsistencyFail::Index.new("users", ["b", "c"])]
+      indexes.should == [ConsistencyFail::Index.new(double('model'), "users", ["a"]),
+                         ConsistencyFail::Index.new(double('model'), "users", ["b", "c"])]
     end
   end
 

data/spec/introspectors/validates_uniqueness_of_spec.rb

@@ -44,7 +44,7 @@ describe ConsistencyFail::Introspectors::ValidatesUniquenessOf do
       @model.stub_chain(:connection, :indexes).with("users").and_return([])
 
       indexes = subject.missing_indexes(@model)
-      indexes.should == [ConsistencyFail::Index.new("users", ["email"])]
+      indexes.should == [ConsistencyFail::Index.new(double('model'), "users", ["email"])]
     end
 
     it "finds one where the validation has scoped columns" do
@@ -52,7 +52,7 @@ describe ConsistencyFail::Introspectors::ValidatesUniquenessOf do
       @model.stub_chain(:connection, :indexes).with("users").and_return([])
 
       indexes = subject.missing_indexes(@model)
-      indexes.should == [ConsistencyFail::Index.new("users", ["city", "email", "state"])]
+      indexes.should == [ConsistencyFail::Index.new(double('model'), "users", ["city", "email", "state"])]
     end
 
     it "leaves the columns in the given order" do
@@ -60,7 +60,7 @@ describe ConsistencyFail::Introspectors::ValidatesUniquenessOf do
       @model.stub_chain(:connection, :indexes).with("users").and_return([])
 
       indexes = subject.missing_indexes(@model)
-      indexes.should == [ConsistencyFail::Index.new("users", ["email", "city", "state"])]
+      indexes.should == [ConsistencyFail::Index.new(double('model'), "users", ["email", "city", "state"])]
     end
 
     it "finds two where there are multiple attributes" do
@@ -68,8 +68,8 @@ describe ConsistencyFail::Introspectors::ValidatesUniquenessOf do
       @model.stub_chain(:connection, :indexes).with("users").and_return([])
 
       indexes = subject.missing_indexes(@model)
-      indexes.should == [ConsistencyFail::Index.new("users", ["email", "city", "state"]),
-                         ConsistencyFail::Index.new("users", ["name", "city", "state"])]
+      indexes.should == [ConsistencyFail::Index.new(double('model'), "users", ["email", "city", "state"]),
+                         ConsistencyFail::Index.new(double('model'), "users", ["name", "city", "state"])]
     end
 
     it "finds none when they're already in place" do

data/spec/reporter_spec.rb

@@ -20,7 +20,7 @@ describe ConsistencyFail::Reporter do
     end
 
     it "shows a missing single-column index on a single model" do
-      missing_indexes = [ConsistencyFail::Index.new("users", ["email"])]
+      missing_indexes = [ConsistencyFail::Index.new(double('model'), "users", ["email"])]
 
       subject.report_validates_uniqueness_problems(fake_ar_model("User", :table_name => "users") => missing_indexes)
 
@@ -28,7 +28,7 @@ describe ConsistencyFail::Reporter do
     end
 
     it "shows a missing multiple-column index on a single model" do
-      missing_indexes = [ConsistencyFail::Index.new("addresses", ["number", "street", "zip"])]
+      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)
 
@@ -39,9 +39,9 @@ describe ConsistencyFail::Reporter do
       before(:each) do
         subject.report_validates_uniqueness_problems(
           fake_ar_model("User", :table_name => "users") =>
-            [ConsistencyFail::Index.new("users", ["email"])],
+            [ConsistencyFail::Index.new(double('model'),"users", ["email"])],
           fake_ar_model("Citizen", :table_name => "citizens") =>
-            [ConsistencyFail::Index.new("citizens", ["ssn"])]
+            [ConsistencyFail::Index.new(double('model'),"citizens", ["ssn"])]
         )
       end
 
@@ -64,7 +64,7 @@ describe ConsistencyFail::Reporter do
     end
 
     it "shows a missing single-column index on a single model" do
-      missing_indexes = [ConsistencyFail::Index.new("users", ["email"])]
+      missing_indexes = [ConsistencyFail::Index.new(double('model'),"users", ["email"])]
 
       subject.report_has_one_problems(fake_ar_model("Friend", :table_name => "users") => missing_indexes)
 

metadata

@@ -1,69 +1,70 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: consistency_fail
-version: !ruby/object:Gem::Version 
-  hash: 19
+version: !ruby/object:Gem::Version
+  version: 0.3.0
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 2
-  version: 0.2.2
 platform: ruby
-authors: 
+authors:
 - Colin Jones
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-01-04 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 3
-        - 0
-        version: "3.0"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: |
-  With more than one application server, validates_uniqueness_of becomes a lie.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'With more than one application server, validates_uniqueness_of becomes
+  a lie.
+
   Two app servers -> two requests -> two near-simultaneous uniqueness checks ->
+
   two processes that commit to the database independently, violating this faux
-  constraint. You'll need a database-level constraint for cases like these.
-  
+
+  constraint. You''ll need a database-level constraint for cases like these.
+
+
   consistency_fail will find your missing unique indexes, so you can add them and
+
   stop ignoring the C in ACID.
 
-email: 
+'
+email:
 - colin@8thlight.com
-executables: 
+executables:
 - consistency_fail
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - LICENSE
@@ -83,7 +84,6 @@ files:
 - lib/consistency_fail/reporters/has_one.rb
 - lib/consistency_fail/reporters/validates_uniqueness_of.rb
 - lib/consistency_fail/version.rb
-- spec/consistency_fail_spec.rb
 - spec/index_spec.rb
 - spec/introspectors/has_one_spec.rb
 - spec/introspectors/table_data_spec.rb
@@ -93,36 +93,33 @@ files:
 - spec/spec_helper.rb
 homepage: http://github.com/trptcolin/consistency_fail
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A tool to detect missing unique indexes
-test_files: []
-
+test_files:
+- spec/index_spec.rb
+- spec/introspectors/has_one_spec.rb
+- spec/introspectors/table_data_spec.rb
+- spec/introspectors/validates_uniqueness_of_spec.rb
+- spec/models_spec.rb
+- spec/reporter_spec.rb
+- spec/spec_helper.rb