schema_plus 0.1.0.pre1

data/spec/support/reference.rb

@@ -0,0 +1,66 @@
+module SchemaPlusMatchers
+
+  class Reference
+    def initialize(expected)
+      @column_names = nil
+      unless expected.empty?
+        @references_column_names = Array(expected).collect(&:to_s)
+        @references_table_name = @references_column_names.shift 
+      end
+    end
+
+    def matches?(model)
+      @model = model
+      if @references_table_name
+        @result = @model.foreign_keys.select do |fk|
+          fk.references_table_name == @references_table_name && 
+            @references_column_names.empty? ? true : fk.references_column_names == @references_column_names
+        end
+      else
+        @result = @model.foreign_keys
+      end
+      if @column_names 
+        @result.any? do |fk| 
+          fk.column_names == @column_names &&
+            (@on_update ? fk.on_update == @on_update : true) &&
+            (@on_delete ? fk.on_delete == @on_delete : true)
+        end
+      else
+        !@result.empty?
+      end
+    end
+
+    def failure_message_for_should(should_not = false)
+      target_column_names = @column_names.present? ? "(#{@column_names.join(', ')})" : "" 
+      destinantion_column_names = @references_table_name ? "#{@references_table_name}(#{@references_column_names.join(', ')})" : "anything"
+      invert = should_not ? 'not' : ''
+      "Expected #{@model.table_name}#{target_column_names} to #{invert} reference #{destinantion_column_names}"
+    end
+
+    def failure_message_for_should_not
+      failure_message_for_should(true)
+    end
+  
+    def on(*column_names)
+      @column_names = column_names.collect(&:to_s)
+      self
+    end
+
+    def on_update(action)
+      @on_update = action
+      self
+    end
+
+    def on_delete(action)
+      @on_delete = action
+      self
+    end
+
+  end
+
+  def reference(*expect)
+    Reference.new(expect)
+  end
+
+end
+

data/spec/validations_spec.rb

@@ -0,0 +1,294 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Validations" do
+
+  before(:all) do
+    define_schema
+    # TODO: it should work regardless of auto-associations
+    SchemaPlus.config.associations.auto_create = false
+  end
+
+  after(:each) do
+    remove_all_models
+  end
+
+  context "auto-created" do
+    before(:each) do
+      with_auto_validations do
+        class Article < ActiveRecord::Base ; end
+
+        class Review < ActiveRecord::Base
+          belongs_to :article
+          belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+          schema_plus :validations => { :except => :content }
+        end
+      end
+    end
+
+    it "should be valid with valid attributes" do
+      Article.new(valid_attributes).should be_valid
+    end
+
+    it "should validate content presence" do
+      post = Article.new.should have(1).error_on(:content)
+    end
+
+    it "should check title length" do
+      Article.new(:title => 'a' * 100).should have(1).error_on(:title)
+    end
+
+    it "should validate state numericality" do
+      Article.new(:state => 'unknown').should have(1).error_on(:state)
+    end
+
+    it "should validate if state is integer" do
+      Article.new(:state => 1.23).should have(1).error_on(:state)
+    end
+
+    it "should validate average_mark numericality" do
+      Article.new(:average_mark => "high").should have(1).error_on(:average_mark)
+    end
+
+    it "should validate boolean fields" do
+      Article.new(:active => nil).should have(1).error_on(:active)
+    end
+
+    it "should validate title uniqueness" do
+      article1 = Article.create(valid_attributes)
+      article2 = Article.new(:title => valid_attributes[:title])
+      article2.should have(1).error_on(:title)
+      article1.destroy
+    end
+
+    it "should validate state uniqueness in scope of 'active' value" do
+      article1 = Article.create(valid_attributes)
+      article2 = Article.new(valid_attributes.merge(:title => 'SchemaPlus 2.0 released'))
+      article2.should_not be_valid
+      article2.toggle(:active)
+      article2.should be_valid
+      article1.destroy
+    end
+
+    it "should validate presence of belongs_to association" do
+      review = Review.new
+      review.should have(1).error_on(:article)
+    end
+
+    it "should validate uniqueness of belongs_to association" do
+      article = Article.create(valid_attributes)
+      article.should be_valid
+      review1 = Review.create(:article => article, :author => 'michal')
+      review1.should be_valid
+      review2 = Review.new(:article => article, :author => 'michal')
+      review2.should have_at_least(1).error_on(:article_id)
+    end
+
+    it "should validate associations with unmatched column and name" do
+      Review.new.should have(1).error_on(:news_article)
+    end
+
+    def valid_attributes
+      {
+        :title => 'SchemaPlus released!',
+        :content => "Database matters. Get full use of it but don't write unecessary code. Get SchemaPlus!",
+        :state => 3,
+        :average_mark => 9.78,
+        :active => true
+      }
+    end
+
+  end
+
+  context "auto-created but changed" do
+    before(:each) do
+      with_auto_validations do
+        class Article < ActiveRecord::Base ; end
+        class Review < ActiveRecord::Base
+          belongs_to :article
+          belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+        end
+      end
+      too_big_content = 'a' * 1000
+      @review = Review.new(:content => too_big_content)
+    end
+
+    it "would normally have an error" do
+      @review.should have(1).error_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "shouldn't validate fields passed to :except option" do
+      Review.schema_plus :validations => { :except => :content }
+      @review.should have(:no).errors_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "shouldn't validate types passed to :except_type option using full validation" do
+      Review.schema_plus :validations => { :except_type => :validates_length_of }
+      @review.should have(:no).errors_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "shouldn't validate types passed to :except_type option using shorthand" do
+      Review.schema_plus :validations => { :except_type => :length }
+      @review.should have(:no).errors_on(:content)
+      @review.should have(1).error_on(:author)
+    end
+
+    it "should only validate type passed to :only_type option" do
+      Review.schema_plus :validations => { :only_type => :length }
+      @review.should have(1).error_on(:content)
+      @review.should have(:no).errors_on(:author)
+    end
+
+
+    it "shouldn't create validations if locally disabled" do
+      Review.schema_plus :validations => { :auto_create => false }
+      @review.should have(:no).errors_on(:content)
+      @review.should have(:no).error_on(:author)
+    end
+  end
+
+  context "auto-created disabled" do
+    around(:each) do |example|
+      with_auto_validations(false, &example)
+    end
+
+    before(:each) do
+      class Article < ActiveRecord::Base ; end
+
+      class Review < ActiveRecord::Base
+        belongs_to :article
+        belongs_to :news_article, :class_name => 'Article', :foreign_key => :article_id
+      end
+      too_big_content = 'a' * 1000
+      @review = Review.new(:content => too_big_content)
+    end
+
+    it "should not create validation" do
+      @review.should have(:no).errors_on(:content)
+    end
+
+    it "should create validation if locally enabled" do
+      Review.schema_plus :validations => { :auto_create => true }
+      @review.should have(1).error_on(:content)
+    end
+
+  end
+
+  context "manually invoked" do
+    before(:each) do
+      class Article < ActiveRecord::Base ; end
+      Article.schema_plus :validations => { :only => [:title, :state] }
+
+      class Review < ActiveRecord::Base
+        belongs_to :dummy_association
+        schema_plus :validations => { :except => :content }
+      end
+    end
+
+    it "should validate fields passed to :only option" do
+      too_big_title = 'a' * 100
+      wrong_state = 'unknown'
+      article = Article.new(:title => too_big_title, :state => wrong_state)
+      article.should have(1).error_on(:title)
+      article.should have(1).error_on(:state)
+    end
+
+    it "shouldn't validate skipped fields" do
+      article = Article.new
+      article.should have(:no).errors_on(:content)
+      article.should have(:no).errors_on(:average_mark)
+    end
+
+    it "shouldn't validate association on unexisting column" do
+      Review.new.should have(:no).errors_on(:dummy_association)
+    end
+
+    it "shouldn't validate fields passed to :except option" do
+      Review.new.should have(:no).errors_on(:content)
+    end
+
+    it "should validate all fields but passed to :except option" do
+      Review.new.should have(1).error_on(:author)
+    end
+
+  end
+
+  context "manually invoked" do
+    before(:each) do
+      class Review < ActiveRecord::Base
+        belongs_to :article
+      end
+      @columns = Review.content_columns.dup
+      Review.schema_plus :validations => { :only => [:title] }
+    end
+
+    it "shouldn't validate associations not included in :only option" do
+      Review.new.should have(:no).errors_on(:article)
+    end
+
+    it "shouldn't change content columns of the model" do
+      @columns.should == Review.content_columns
+    end
+
+  end
+
+  context "when used with STI" do
+    around(:each) { |example| with_auto_validations(&example) }
+
+    it "should set validations on base class" do
+      class Review < ActiveRecord::Base ; end
+      class PremiumReview < Review ; end
+      PremiumReview.new
+      Review.new.should have(1).error_on(:author)
+    end
+
+    it "shouldn't create doubled validations" do
+      class Review < ActiveRecord::Base ; end
+      Review.new
+      class PremiumReview < Review ; end
+      PremiumReview.new.should have(1).error_on(:author)
+    end
+
+  end
+
+  protected
+  def with_auto_validations(value = true)
+    old_value = SchemaPlus.config.validations.auto_create
+    begin
+      SchemaPlus.config.validations.auto_create = value
+      yield
+    ensure
+      SchemaPlus.config.validations.auto_create = old_value
+    end
+  end
+
+  def define_schema
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Schema.define do
+        connection.tables.each do |table| drop_table table end
+
+        create_table :articles, :force => true do |t|
+          t.string :title, :limit => 50
+          t.text  :content, :null => false
+          t.integer :state
+          t.float   :average_mark, :null => false
+          t.boolean :active, :null => false
+        end
+        add_index :articles, :title, :unique => true
+        add_index :articles, [:state, :active], :unique => true
+
+        create_table :reviews, :force => true do |t|
+          t.integer :article_id, :null => false
+          t.string :author, :null => false
+          t.string :content, :limit => 200
+          t.string :type
+        end
+        add_index :reviews, :article_id, :unique => true
+
+      end
+    end
+  end
+
+end

data/spec/views_spec.rb

@@ -0,0 +1,140 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ActiveRecord do
+
+  let(:schema) { ActiveRecord::Schema }
+
+  let(:migration) { ActiveRecord::Migration }
+
+  let(:connection) { ActiveRecord::Base.connection }
+
+  let (:dump) {
+    StringIO.open { |stream|
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      stream.string
+    }
+  }
+
+  context "views" do
+
+    around (:each) do |example|
+      define_schema_and_data
+      example.run
+      drop_definitions
+    end
+
+    it "should query correctly" do
+      @a_ones.all.collect(&:s).should == %W[one_one one_two]
+      @ab_ones.all.collect(&:s).should == %W[one_one]
+    end
+
+    it "should instrospect" do
+      connection.views.sort.should == %W[a_ones ab_ones]
+      connection.view_definition('a_ones').should match(%r{^SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1}i)
+      connection.view_definition('ab_ones').should match(%r{^SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1}i)
+    end
+
+    it "should not be listed as a table" do
+      connection.tables.should_not include('a_ones')
+      connection.tables.should_not include('ab_ones')
+    end
+
+
+    it "should be included in schema dump" do
+      dump.should match(%r{create_view "a_ones", "SELECT .*b.*,.*s.* FROM .*items.* WHERE .*a.* = 1}i)
+      dump.should match(%r{create_view "ab_ones", "SELECT .*s.* FROM .*a_ones.* WHERE .*b.* = 1}i)
+    end
+
+    it "should be included in schema dump in dependency order" do
+      dump.should match(%r{create_table "items".*create_view "a_ones".*create_view "ab_ones"}m) 
+    end
+
+    it "dump should not reference current database" do
+      # why check this?  mysql default to providing the view definition
+      # with tables explicitly scoped to the current database, which
+      # resulted in the dump being bound to the current database.  this
+      # caused trouble for rails, in which creates the schema dump file
+      # when in the (say) development database, but then uses it to
+      # initialize the test database when testing.  this meant that the
+      # test database had views into the development database.
+      db = connection.respond_to?(:current_database)? connection.current_database : ActiveRecord::Base.configurations['schema_plus'][:database]
+      dump.should_not match(%r{#{connection.quote_table_name(db)}[.]})
+    end
+
+
+    if SchemaPlusHelpers.mysql?
+      context "in mysql" do
+
+        around(:each) do |example|
+          migration.suppress_messages do
+            begin
+              migration.drop_view :check if connection.views.include? 'check'
+              example.run
+            ensure
+              migration.drop_view :check if connection.views.include? 'check'
+            end
+          end
+        end
+
+        it "should introspect WITH CHECK OPTION" do
+          migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH CHECK OPTION'
+          connection.view_definition('check').should match(%r{WITH CASCADED CHECK OPTION$})
+        end
+
+        it "should introspect WITH CASCADED CHECK OPTION" do
+          migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH CASCADED CHECK OPTION'
+          connection.view_definition('check').should match(%r{WITH CASCADED CHECK OPTION$})
+        end
+
+        it "should introspect WITH LOCAL CHECK OPTION" do
+          migration.create_view :check, 'SELECT * FROM items WHERE (a=2) WITH LOCAL CHECK OPTION'
+          connection.view_definition('check').should match(%r{WITH LOCAL CHECK OPTION$})
+        end
+      end 
+    end
+  end
+
+  protected
+
+  def define_schema_and_data
+    migration.suppress_messages do
+
+      schema.define do
+
+        create_table :items, :force => true do |t|
+          t.integer :a
+          t.integer :b
+          t.string  :s
+        end
+
+        create_view :a_ones, "select b, s from items where a = 1"
+        create_view :ab_ones, "select s from a_ones where b = 1"
+      end
+    end
+    connection.execute "insert into items (a, b, s) values (1, 1, 'one_one')"
+    connection.execute "insert into items (a, b, s) values (1, 2, 'one_two')"
+    connection.execute "insert into items (a, b, s) values (2, 1, 'two_one')"
+    connection.execute "insert into items (a, b, s) values (2, 2, 'two_two')"
+
+    @a_ones = Class.new(ActiveRecord::Base) do set_table_name "a_ones" end
+    @ab_ones = Class.new(ActiveRecord::Base) do set_table_name "ab_ones" end
+  end
+
+  def drop_definitions
+    migration.suppress_messages do
+      schema.define do
+        drop_view "ab_ones"
+        drop_view "a_ones"
+        drop_table "items"
+      end
+    end
+  end
+
+  def dump
+    StringIO.open { |stream|
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      stream.string
+    }
+  end
+
+end