consistency_fail 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in consistency_fail.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Colin Jones
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,50 @@
+# Consistency Fail
+
+## Description
+consistency\_fail is a tool to detect missing unique indexes in Rails projects.
+
+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.
+
+consistency\_fail will find your missing unique indexes, so you can add them and
+stop ignoring the C in ACID.
+
+Similar problems arise with `has_one`, so consistency\_fail finds places where
+database-level enforcement is lacking there as well.
+
+
+## Installation
+
+    gem install consistency_fail
+
+## Limitations
+
+Currently only Rails 2.x is supported. Rails 3 support is coming soon.
+
+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.
+
+## Usage
+
+The only run mode for now is to generate a report of the problematic spots in
+your application. From your Rails project directory, run:
+
+    consistency_fail
+
+from your terminal / shell. This will spit a report to standard output, which
+you can view directly, redirect to a file as evidence to embarrass a teammate,
+or simply beam in happiness at your application's perfect record for
+`validates_uniqueness_of` and `has_one` usage.
+
+## Coming Soon
+
+* Rails 3 support
+* Super-fail mode that monkey-patches explosions into your naughty models
+
+## License
+
+Released under the MIT License. See the LICENSE file for further details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/consistency_fail

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require "consistency_fail"
+
+def problems(models, introspector)
+  problems = 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
+
+introspector = ConsistencyFail::Introspectors::ValidatesUniquenessOf.new
+problems = problems(models.all, introspector)
+reporter.report_validates_uniqueness_problems(problems)
+
+introspector = ConsistencyFail::Introspectors::HasOne.new
+problems = problems(models.all, introspector)
+reporter.report_has_one_problems(problems)
+

data/consistency_fail.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "consistency_fail/version"
+
+Gem::Specification.new do |s|
+  s.name        = "consistency_fail"
+  s.version     = ConsistencyFail::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Colin Jones"]
+  s.email       = ["colin@8thlight.com"]
+  s.homepage    = "http://github.com/trptcolin/consistency_fail"
+  s.summary     = %q{A tool to detect missing unique indexes}
+  s.description = <<-EOF
+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.
+
+consistency_fail will find your missing unique indexes, so you can add them and
+stop ignoring the C in ACID.
+EOF
+
+  s.add_dependency "validation_reflection", "~>0.3.8"
+  s.add_development_dependency "activerecord", "~>2.3"
+  s.add_development_dependency "rspec"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/consistency_fail.rb

@@ -0,0 +1,16 @@
+begin
+  require File.join(Dir.pwd, "config", "boot")
+rescue LoadError => e
+  puts "\nUh-oh! You must be in the root directory of a Rails project.\n"
+  raise
+end
+
+require 'active_record'
+require 'validation_reflection'
+require File.join(Dir.pwd, "config", "environment")
+
+require 'consistency_fail/models'
+require 'consistency_fail/introspectors/table_data'
+require 'consistency_fail/introspectors/validates_uniqueness_of'
+require 'consistency_fail/introspectors/has_one'
+require 'consistency_fail/reporter'

data/lib/consistency_fail/index.rb

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

data/lib/consistency_fail/introspectors/has_one.rb

@@ -0,0 +1,29 @@
+require 'consistency_fail/index'
+
+module ConsistencyFail
+  module Introspectors
+    class HasOne
+      def instances(model)
+        model.reflect_on_all_associations.select do |a|
+          a.macro == :has_one
+        end
+      end
+
+      # 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?
+        end.compact
+      end
+      private :desired_indexes
+
+      def missing_indexes(model)
+        existing_indexes = TableData.new.unique_indexes(model)
+
+        desired_indexes(model).reject do |index|
+          existing_indexes.include?(index)
+        end
+      end
+    end
+  end
+end

data/lib/consistency_fail/introspectors/table_data.rb

@@ -0,0 +1,16 @@
+require 'consistency_fail/index'
+
+module ConsistencyFail
+  module Introspectors
+    class TableData
+      def unique_indexes(model)
+        return [] if !model.table_exists?
+
+        ar_indexes = model.connection.indexes(model.table_name).select(&:unique)
+        ar_indexes.map do |index|
+          ConsistencyFail::Index.new(model.table_name, index.columns)
+        end
+      end
+    end
+  end
+end

data/lib/consistency_fail/introspectors/validates_uniqueness_of.rb

@@ -0,0 +1,29 @@
+require 'consistency_fail/index'
+
+module ConsistencyFail
+  module Introspectors
+    class ValidatesUniquenessOf
+      def instances(model)
+        model.reflect_on_all_validations.select do |v|
+          v.macro == :validates_uniqueness_of
+        end
+      end
+
+      def desired_indexes(model)
+        instances(model).map do |v|
+          scoped_columns = v.options[:scope] || []
+          ConsistencyFail::Index.new(model.table_name, [v.name, *scoped_columns])
+        end
+      end
+      private :desired_indexes
+
+      def missing_indexes(model)
+        existing_indexes = TableData.new.unique_indexes(model)
+
+        desired_indexes(model).reject do |index|
+          existing_indexes.include?(index)
+        end
+      end
+    end
+  end
+end

data/lib/consistency_fail/models.rb

@@ -0,0 +1,37 @@
+require 'active_record'
+require 'consistency_fail/index'
+
+module ConsistencyFail
+  class Models
+    MODEL_DIRECTORY_REGEXP = /models/
+
+    attr_reader :load_path
+
+    def initialize(load_path)
+      @load_path = load_path
+    end
+
+    def dirs
+      load_path.select { |lp| MODEL_DIRECTORY_REGEXP =~ lp }
+    end
+
+    def preload_all
+      self.dirs.each do |d|
+        Dir.glob(File.join(d, "**", "*.rb")).each do |model_filename|
+          Kernel.require_dependency model_filename
+        end
+      end
+    end
+
+    def all
+      models = []
+      ObjectSpace.each_object do |o|
+        models << o if o.class == Class &&
+                       o.ancestors.include?(ActiveRecord::Base) &&
+                       o != ActiveRecord::Base
+      end
+      models.sort_by(&:name)
+    end
+
+  end
+end

data/lib/consistency_fail/reporter.rb

@@ -0,0 +1,14 @@
+require 'consistency_fail/reporters/validates_uniqueness_of'
+require 'consistency_fail/reporters/has_one'
+
+module ConsistencyFail
+  class Reporter
+    def report_validates_uniqueness_problems(indexes_by_model)
+      ConsistencyFail::Reporters::ValidatesUniquenessOf.new.report(indexes_by_model)
+    end
+
+    def report_has_one_problems(indexes_by_model)
+      ConsistencyFail::Reporters::HasOne.new.report(indexes_by_model)
+    end
+  end
+end

data/lib/consistency_fail/reporters/base.rb

@@ -0,0 +1,81 @@
+module ConsistencyFail
+  module Reporters
+    class Base
+      TERMINAL_WIDTH = 80
+
+      RED = 31
+      GREEN = 32
+
+      def use_color(code)
+        print "\e[#{code}m"
+      end
+
+      def use_default_color
+        use_color(0)
+      end
+
+      def report_success(macro)
+        use_color(GREEN)
+        puts "Hooray! All calls to #{macro} are correctly backed by a unique index."
+        use_default_color
+      end
+
+      def divider(pad_to = TERMINAL_WIDTH)
+        puts "-" * [pad_to, TERMINAL_WIDTH].max
+      end
+
+      def report_failure_header(macro, longest_model_length)
+        puts
+        use_color(RED)
+        puts "There are calls to #{macro} that aren't backed by unique indexes."
+        use_default_color
+        divider(longest_model_length * 2)
+
+        column_1_header, column_2_header = column_headers
+        print column_1_header.ljust(longest_model_length + 2)
+        puts column_2_header
+
+        divider(longest_model_length * 2)
+      end
+
+      def report_index(model, index, column_1_length)
+        print model.name.ljust(column_1_length + 2)
+        puts "#{index.table_name} (#{index.columns.join(", ")})"
+      end
+
+      def column_1(model)
+        model.name
+      end
+
+      def column_headers
+        ["Model", "Table Columns"]
+      end
+
+      def report(indexes_by_model)
+        if indexes_by_model.empty?
+          report_success(macro)
+        else
+          indexes_by_table_name = indexes_by_model.map do |model, indexes|
+            [column_1(model), model, indexes]
+          end.sort_by(&:first)
+          longest_model_length = indexes_by_table_name.map(&:first).
+                                                       sort_by(&:length).
+                                                       last.
+                                                       length
+          column_1_header_length = column_headers.first.length
+          longest_model_length = [longest_model_length, column_1_header_length].max
+
+          report_failure_header(macro, longest_model_length)
+
+          indexes_by_table_name.each do |table_name, model, indexes|
+            indexes.each do |index|
+              report_index(model, index, longest_model_length)
+            end
+          end
+          divider(longest_model_length * 2)
+        end
+        puts
+      end
+    end
+  end
+end

data/lib/consistency_fail/reporters/has_one.rb

@@ -0,0 +1,13 @@
+require 'consistency_fail/reporters/base'
+
+module ConsistencyFail
+  module Reporters
+    class HasOne < Base
+      attr_reader :macro
+
+      def initialize
+        @macro = :has_one
+      end
+    end
+  end
+end

data/lib/consistency_fail/reporters/validates_uniqueness_of.rb

@@ -0,0 +1,13 @@
+require 'consistency_fail/reporters/base'
+
+module ConsistencyFail
+  module Reporters
+    class ValidatesUniquenessOf < Base
+      attr_reader :macro
+
+      def initialize
+        @macro = :validates_uniqueness_of
+      end
+    end
+  end
+end

data/lib/consistency_fail/version.rb

@@ -0,0 +1,3 @@
+module ConsistencyFail
+  VERSION = "0.1.0"
+end

data/spec/index_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+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"])
+      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.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"])
+    end
+
+    it "fails when tables are different" do
+      ConsistencyFail::Index.new("locations", ["city", "state"]).should_not ==
+        ConsistencyFail::Index.new("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"])
+    end
+  end
+end

data/spec/introspectors/has_one_spec.rb

@@ -0,0 +1,63 @@
+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")
+      model.stub(:reflect_on_all_associations).and_return([])
+
+      subject.instances(model).should == []
+    end
+
+    it "finds one" do
+      model = fake_ar_model("User")
+      association = double("association", :macro => :has_one)
+      model.stub!(:reflect_on_all_associations).and_return([association])
+
+      subject.instances(model).should == [association]
+    end
+
+    it "finds other associations, but not has_one" do
+      model = fake_ar_model("User")
+      validation = double("validation", :macro => :has_many)
+      model.stub!(:reflect_on_all_associations).and_return([validation])
+
+      subject.instances(model).should == []
+    end
+  end
+
+  describe "finding missing indexes" do
+    before do
+      @association = double("association", :macro => :has_one)
+      @model = fake_ar_model("User", :table_exists? => true,
+                                     :table_name => "users",
+                                     :reflect_on_all_associations => [@association])
+    end
+
+    it "finds one" do
+      @association.stub!(:table_name => :addresses, :primary_key_name => "user_id")
+      @model.stub_chain(:connection, :indexes).with("users").and_return([])
+
+      indexes = subject.missing_indexes(@model)
+      indexes.should == [ConsistencyFail::Index.new("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"])
+      ConsistencyFail::Introspectors::TableData.stub_chain(:new, :unique_indexes).
+        and_return([index])
+
+      subject.missing_indexes(@model).should == []
+    end
+
+  end
+end
+
+

data/spec/introspectors/table_data_spec.rb

@@ -0,0 +1,52 @@
+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)
+
+      subject.unique_indexes(model).should == []
+    end
+
+    it "gets one" do
+      model = fake_ar_model("User", :table_exists? => true,
+                                    :table_name => "users")
+
+      model.stub_chain(:connection, :indexes).
+            with("users").
+            and_return([fake_index_on(["a"], :unique => true)])
+
+      indexes = subject.unique_indexes(model)
+      indexes.should == [ConsistencyFail::Index.new("users", ["a"])]
+    end
+
+    it "doesn't get non-unique indexes" do
+      model = fake_ar_model("User", :table_exists? => true,
+                                    :table_name => "users")
+
+      model.stub_chain(:connection, :indexes).
+            with("users").
+            and_return([fake_index_on(["a"], :unique => false)])
+
+      subject.unique_indexes(model).should == []
+    end
+
+    it "gets multiple unique indexes" do
+      model = fake_ar_model("User", :table_exists? => true,
+                                    :table_name => "users")
+
+      model.stub_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)
+      indexes.size.should == 2
+      indexes.should == [ConsistencyFail::Index.new("users", ["a"]),
+                         ConsistencyFail::Index.new("users", ["b", "c"])]
+    end
+  end
+
+end
+

data/spec/introspectors/validates_uniqueness_of_spec.rb

@@ -0,0 +1,84 @@
+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")
+      model.stub!(:reflect_on_all_validations).and_return([])
+
+      subject.instances(model).should == []
+    end
+
+    it "finds one" do
+      model = fake_ar_model("User")
+      validation = double("validation", :macro => :validates_uniqueness_of)
+      model.stub!(:reflect_on_all_validations).and_return([validation])
+
+      subject.instances(model).should == [validation]
+    end
+
+    it "finds other validations, but not uniqueness" do
+      model = fake_ar_model("User")
+      validation = double("validation", :macro => :validates_format_of)
+      model.stub!(:reflect_on_all_validations).and_return([validation])
+
+      subject.instances(model).should == []
+    end
+  end
+
+  describe "finding missing indexes" do
+    before do
+      @validation = double("validation", :macro => :validates_uniqueness_of)
+      @model = fake_ar_model("User", :table_exists? => true,
+                                     :table_name => "users",
+                                     :reflect_on_all_validations => [@validation])
+    end
+
+    it "finds one" do
+      @validation.stub!(:name => :email, :options => {})
+      @model.stub_chain(:connection, :indexes).with("users").and_return([])
+
+      indexes = subject.missing_indexes(@model)
+      indexes.should == [ConsistencyFail::Index.new("users", ["email"])]
+    end
+
+    it "finds one where the validation has scoped columns" do
+      @validation.stub!(:name => :city, :options => {:scope => [:email, :state]})
+      @model.stub_chain(:connection, :indexes).with("users").and_return([])
+
+      indexes = subject.missing_indexes(@model)
+      indexes.should == [ConsistencyFail::Index.new("users", ["city", "email", "state"])]
+    end
+
+    it "sorts the scoped columns" do
+      @validation.stub!(:name => :email, :options => {:scope => [:city, :state]})
+      @model.stub_chain(:connection, :indexes).with("users").and_return([])
+
+      indexes = subject.missing_indexes(@model)
+      indexes.should == [ConsistencyFail::Index.new("users", ["email", "city", "state"])]
+    end
+
+    it "finds none when they're already in place" do
+      @validation.stub!(:name => :email, :options => {})
+      index = fake_index_on(["email"], :unique => true)
+      @model.stub_chain(:connection, :indexes).with("users").
+             and_return([index])
+
+      subject.missing_indexes(@model).should == []
+    end
+
+    it "finds none when indexes are there but in a different order" do
+      @validation.stub!(:name => :email, :options => {:scope => [:city, :state]})
+      index = fake_index_on(["state", "email", "city"], :unique => true)
+      @model.stub_chain(:connection, :indexes).with("users").
+             and_return([index])
+
+      subject.missing_indexes(@model).should == []
+    end
+  end
+end

data/spec/models_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'consistency_fail/models'
+
+describe ConsistencyFail::Models do
+  def models(load_path)
+    ConsistencyFail::Models.new(load_path)
+  end
+
+  it "gets the load path" do
+    models([:a, :b, :c]).load_path.should == [:a, :b, :c]
+  end
+
+  it "gets the directories matching /models/" do
+    models = models(["foo/bar/baz", "app/models", "some/other/models"])
+    models.dirs.should == ["app/models", "some/other/models"]
+  end
+
+  it "preloads models by calling require_dependency" do
+    models = models(["foo/bar/baz", "app/models", "some/other/models"])
+    Dir.stub(:glob).
+        with(File.join("app/models", "**", "*.rb")).
+        and_return(["app/models/user.rb", "app/models/address.rb"])
+    Dir.stub(:glob).
+        with(File.join("some/other/models", "**", "*.rb")).
+        and_return(["some/other/models/foo.rb"])
+
+    Kernel.should_receive(:require_dependency).with("app/models/user.rb")
+    Kernel.should_receive(:require_dependency).with("app/models/address.rb")
+    Kernel.should_receive(:require_dependency).with("some/other/models/foo.rb")
+
+    models.preload_all
+  end
+
+  it "gets all models" do
+    model_a = double("model_a",
+                     :ancestors => [ActiveRecord::Base],
+                     :class => Class,
+                     :name => "ModelA")
+    model_b = double("model_b",
+                     :ancestors => [ActiveRecord::Base],
+                     :class => Class,
+                     :name => "ModelB")
+    model_c = double("model_c",
+                     :ancestors => [ActiveRecord::Base],
+                     :class => ActiveRecord::Base,
+                     :name => "ModelC")
+
+    ObjectSpace.stub(:each_object).
+                and_yield(model_c).
+                and_yield(model_b).
+                and_yield(model_a)
+
+    models([]).all.should == [model_a, model_b]
+  end
+end

data/spec/reporter_spec.rb

@@ -0,0 +1,74 @@
+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([])
+
+      @fake_out.string.should =~ /Hooray!/
+    end
+
+    it "shows a missing single-column index on a single model" do
+      missing_indexes = [ConsistencyFail::Index.new("users", ["email"])]
+
+      subject.report_validates_uniqueness_problems(fake_ar_model("User", :table_name => "users") => missing_indexes)
+
+      @fake_out.string.should =~ /users\s+\(email\)/
+    end
+
+    it "shows a missing multiple-column index on a single model" do
+      missing_indexes = [ConsistencyFail::Index.new("addresses", ["number", "street", "zip"])]
+
+      subject.report_validates_uniqueness_problems(fake_ar_model("Address", :table_name => "addresses") => missing_indexes)
+
+      @fake_out.string.should =~ /addresses\s+\(number, street, zip\)/
+    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("users", ["email"])],
+          fake_ar_model("Citizen", :table_name => "citizens") =>
+            [ConsistencyFail::Index.new("citizens", ["ssn"])]
+        )
+      end
+
+      it "shows all problems" do
+        @fake_out.string.should =~ /users\s+\(email\)/m
+        @fake_out.string.should =~ /citizens\s+\(ssn\)/m
+      end
+
+      it "orders the models alphabetically" do
+        @fake_out.string.should =~ /citizens\s+\(ssn\).*users\s+\(email\)/m
+      end
+    end
+  end
+
+  context "has_one" do
+    it "says everything's good" do
+      subject.report_has_one_problems([])
+
+      @fake_out.string.should =~ /Hooray!/
+    end
+
+    it "shows a missing single-column index on a single model" do
+      missing_indexes = [ConsistencyFail::Index.new("users", ["email"])]
+
+      subject.report_has_one_problems(fake_ar_model("Friend", :table_name => "users") => missing_indexes)
+
+      @fake_out.string.should =~ /Friend\s+users\s+\(email\)/m
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$:<< File.expand_path('..', __FILE__)
+$:<< File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+
+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
+

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: consistency_fail
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Colin Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-10 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: validation_reflection
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 3
+        - 8
+        version: 0.3.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 3
+        version: "2.3"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+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.
+  
+  consistency_fail will find your missing unique indexes, so you can add them and
+  stop ignoring the C in ACID.
+
+email: 
+- colin@8thlight.com
+executables: 
+- consistency_fail
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/consistency_fail
+- consistency_fail.gemspec
+- lib/consistency_fail.rb
+- lib/consistency_fail/index.rb
+- lib/consistency_fail/introspectors/has_one.rb
+- lib/consistency_fail/introspectors/table_data.rb
+- lib/consistency_fail/introspectors/validates_uniqueness_of.rb
+- lib/consistency_fail/models.rb
+- lib/consistency_fail/reporter.rb
+- lib/consistency_fail/reporters/base.rb
+- 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
+- spec/introspectors/validates_uniqueness_of_spec.rb
+- spec/models_spec.rb
+- spec/reporter_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/trptcolin/consistency_fail
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A tool to detect missing unique indexes
+test_files: []
+