carlosbrando-remarkable 0.0.99

data/lib/remarkable/active_record/macros/associations/have_one.rb

@@ -0,0 +1,133 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveOne
+        include Remarkable::Private
+        
+        def initialize(*associations)
+          @dependent = get_options!(associations, :dependent)
+          @associations = associations
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @associations.each do |association|
+              reflection = klass.reflect_on_association(association)
+              fail("#{klass.name} does not have any relationship to #{association}") unless reflection && reflection.macro == :has_one
+
+              associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
+
+              if reflection.options[:foreign_key]
+                fk = reflection.options[:foreign_key]
+              elsif reflection.options[:as]
+                fk = reflection.options[:as].to_s.foreign_key
+                fk_type = fk.gsub(/_id$/, '_type')
+
+                fail("#{associated_klass.name} does not have a #{fk_type} column.") unless associated_klass.column_names.include?(fk_type)
+              else
+                fk = klass.name.foreign_key
+              end
+
+              fail("#{associated_klass.name} does not have a #{fk} foreign key.") unless associated_klass.column_names.include?(fk.to_s)
+
+              if @dependent
+                fail("#{association} should have #{@dependent} dependency") unless @dependent.to_s == reflection.options[:dependent].to_s
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          message = "have one #{@associations.to_sentence}"
+          message += " dependent => #{@dependent}" if @dependent
+          message
+        end
+
+        def failure_message
+          message = "expected #{@klass.name} to have one #{@associations.to_sentence}"
+          message += " dependent => #{@dependent}" if @dependent      
+          message += ", but it didn't"      
+          @failure_message || message
+        end
+
+        def negative_failure_message
+          message = "expected #{@klass.name} not to have one #{@associations.to_sentence}"
+          message += " dependent => #{@dependent}" if @dependent
+          message += ", but it did"
+          message
+        end
+      end
+
+      # Ensure that the has_one relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      #
+      # Options:
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Example:
+      #   it { User.should have_one(:address) }
+      #
+      def have_one(*associations)
+        Remarkable::Syntax::RSpec::HaveOne.new(*associations)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the has_one relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      #
+      # Options:
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Example:
+      #   should_have_one :god # unless hindu
+      #
+      def should_have_one(*associations)
+        dependent = get_options!(associations, :dependent)
+        klass = model_class
+        associations.each do |association|
+          name = "should have one #{association}"
+          name += " dependent => #{dependent}" if dependent
+          it name do
+            reflection = klass.reflect_on_association(association)
+            fail_with("#{klass.name} does not have any relationship to #{association}") unless reflection
+            reflection.macro.should == :has_one
+
+            associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
+
+            if reflection.options[:foreign_key]
+              fk = reflection.options[:foreign_key]
+            elsif reflection.options[:as]
+              fk = reflection.options[:as].to_s.foreign_key
+              fk_type = fk.gsub(/_id$/, '_type')
+              unless associated_klass.column_names.include?(fk_type)
+                fail_with "#{associated_klass.name} does not have a #{fk_type} column."
+              end
+            else
+              fk = klass.name.foreign_key
+            end
+            unless associated_klass.column_names.include?(fk.to_s)
+              fail_with "#{associated_klass.name} does not have a #{fk} foreign key."
+            end
+
+            if dependent
+              unless reflection.options[:dependent].to_s == dependent.to_s
+                fail_with "#{association} should have #{dependent} dependency"
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/database/have_db_column.rb

@@ -0,0 +1,81 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveDbColumn
+        def initialize(name, opts)
+          @name = name
+          @opts = opts
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          column = klass.columns.detect {|c| c.name == @name.to_s }
+          fail("#{klass.name} does not have column #{@name}") unless column
+
+          @opts.each do |k, v|
+            fail(":#{@name} column on table for #{klass} does not match option :#{k}") unless column.instance_variable_get("@#{k}").to_s == v.to_s
+          end
+        end
+
+        def description
+          message = "have column named :#{@name}"
+          message += " with options " + @opts.inspect unless @opts.empty?
+          message
+        end
+
+        def failure_message
+          message = "expected #{@klass.name} to have column named :#{@name}"
+          message += " with options " + @opts.inspect unless @opts.empty?
+          message += ", but it didn't"
+
+          @failure_message || message
+        end
+
+        def negative_failure_message
+          message = "expected #{@klass.name} not to have column named :#{@name}"
+          message += " with options " + @opts.inspect unless @opts.empty?
+          message += ", but it did"
+          message
+        end
+      end
+
+      # Ensure that the given column is defined on the models backing SQL table.  The options are the same as
+      # the instance variables defined on the column definition:  :precision, :limit, :default, :null,
+      # :primary, :type, :scale, and :sql_type.
+      #
+      #   it { User.should have_db_column(:email, :type => "string",  :default => nil,    :precision => nil,  :limit => 255,
+      #                                           :null => true,      :primary => false,  :scale => nil,      :sql_type => 'varchar(255)') }
+      # 
+      def have_db_column(name, opts = {})
+        Remarkable::Syntax::RSpec::HaveDbColumn.new(name, opts)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the given column is defined on the models backing SQL table.  The options are the same as
+      # the instance variables defined on the column definition:  :precision, :limit, :default, :null,
+      # :primary, :type, :scale, and :sql_type.
+      #
+      #   should_have_db_column :email, :type => "string", :default => nil,   :precision => nil, :limit    => 255,
+      #                                 :null => true,     :primary => false, :scale     => nil, :sql_type => 'varchar(255)'
+      #
+      def should_have_db_column(name, opts = {})
+        klass = model_class
+        test_name = "should have column named :#{name}"
+        test_name += " with options " + opts.inspect unless opts.empty?
+        it test_name do
+          column = klass.columns.detect {|c| c.name == name.to_s }
+          fail_with("#{klass.name} does not have column #{name}") unless column
+          opts.each do |k, v|
+            unless v.to_s == column.instance_variable_get("@#{k}").to_s
+              fail_with(":#{name} column on table for #{klass} does not match option :#{k}")
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/database/have_db_columns.rb

@@ -0,0 +1,73 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveDbColumns
+        include Remarkable::Private
+        
+        def initialize(*columns)
+          @column_type = get_options!(columns, :type)
+          @columns = columns
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          @columns.each do |name|
+            column = klass.columns.detect {|c| c.name == name.to_s }
+            fail("#{klass.name} does not have column #{name}") unless column
+          end
+        end
+
+        def description
+          message = "have columns #{@columns.to_sentence}"
+          message += " of type #{@column_type}" if @column_type
+          message
+        end
+
+        def failure_message
+          message = "expected to have columns #{@columns.to_sentence}"
+          message += " of type #{@column_type}" if @column_type
+          message += ", but it didn't"
+
+          @failure_message || message
+        end
+
+        def negative_failure_message
+          message = "expected not to have columns #{@columns.to_sentence}"
+          message += " of type #{@column_type}" if @column_type
+          message += ", but it did"
+          message
+        end
+      end
+
+      # Ensure that the given columns are defined on the models backing SQL table.
+      #
+      #   it { User.should have_db_columns(:id, :email, :name, :created_at) }
+      #
+      def have_db_columns(*columns)
+        Remarkable::Syntax::RSpec::HaveDbColumns.new(*columns)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the given columns are defined on the models backing SQL table.
+      #
+      #   should_have_db_columns :id, :email, :name, :created_at
+      #
+      def should_have_db_columns(*columns)
+        column_type = get_options!(columns, :type)
+        klass = model_class
+        columns.each do |name|
+          test_name = "should have column #{name}"
+          test_name += " of type #{column_type}" if column_type
+          it test_name do
+            column = klass.columns.detect {|c| c.name == name.to_s }
+            fail_with("#{klass.name} does not have column #{name}") unless column
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/database/have_indices.rb

@@ -0,0 +1,75 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveIndices
+        def initialize(*columns)
+          @columns = columns
+        end
+
+        def matches?(klass)
+          @table = klass.table_name
+          indices = ::ActiveRecord::Base.connection.indexes(@table).map(&:columns)
+
+          @columns.each do |column|
+            columns = [column].flatten.map(&:to_s)
+            return false unless indices.include?(columns)
+          end
+        end
+
+        def description
+          "have index on #{@table} for #{pretty_columns}"
+        end
+
+        def failure_message
+          "expected to have index on #{@table} for #{pretty_columns}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected not to have index on #{@table} for #{pretty_columns}, but it did"
+        end
+
+        private
+
+        def pretty_columns
+          @columns.collect { |col| col.is_a?(Array) ? "[#{col.join(', ')}]" : col }.to_sentence
+        end    
+      end
+
+      # Ensures that there are DB indices on the given columns or tuples of columns.
+      # Also aliased to should_have_index for readability
+      #
+      #   it { User.should have_indices(:email, :name, [:commentable_type, :commentable_id]) }
+      #   it { User.should have_index(:age) }
+      # 
+      def have_indices(*columns)
+        Remarkable::Syntax::RSpec::HaveIndices.new(*columns)
+      end
+
+      alias :have_index :have_indices
+    end
+
+    module Shoulda
+      # Ensures that there are DB indices on the given columns or tuples of columns.
+      # Also aliased to should_have_index for readability
+      #
+      #   should_have_indices :email, :name, [:commentable_type, :commentable_id]
+      #   should_have_index :age
+      #
+      def should_have_indices(*columns)
+        table = model_class.table_name
+        indices = ::ActiveRecord::Base.connection.indexes(table).map(&:columns)
+
+        columns.each do |column|
+          it "should have index on #{table} for #{column.inspect}" do
+            columns = [column].flatten.map(&:to_s)
+            assert_contains(indices, columns).should be_true
+          end
+        end
+      end
+
+      alias_method :should_have_index, :should_have_indices
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/validations/allow_values_for.rb

@@ -0,0 +1,103 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class AllowValuesFor
+        include Remarkable::Private
+        
+        def initialize(attribute, *good_values)
+          get_options!(good_values)
+
+          @attribute = attribute
+          @good_values = good_values
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @good_values.each do |v|
+              return false unless assert_good_value(klass, @attribute, v)
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "allow #{@attribute} to be set to #{@good_values.to_sentence}"
+        end
+
+        def failure_message
+          "expected allow #{@attribute} to be set to #{@good_values.to_sentence}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected allow #{@attribute} not to be set to #{@good_values.to_sentence}, but it did"
+        end
+      end
+
+      # Ensures that the attribute can be set to the given values.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Example:
+      #   it { Book.should allow_values_for(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
+      #   it { Book.should_not allow_values_for(:isbn, "bad 1", "bad 2") }
+      #
+      def allow_values_for(attribute, *good_values)
+        Remarkable::Syntax::RSpec::AllowValuesFor.new(attribute, *good_values)
+      end
+    end
+
+    module Shoulda
+      # Ensures that the attribute can be set to the given values.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Example:
+      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+      #
+      def should_allow_values_for(attribute, *good_values)
+        get_options!(good_values)
+        klass = model_class
+        good_values.each do |v|
+          it "should allow #{attribute} to be set to #{v.inspect}" do
+            assert_good_value(klass, attribute, v).should be_true
+          end
+        end
+      end
+      
+      # Ensures that the attribute cannot be set to the given values
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
+      #
+      # Example:
+      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
+      #
+      def should_not_allow_values_for(attribute, *bad_values)
+        message = get_options!(bad_values, :message)
+        message ||= default_error_message(:invalid)
+        klass = model_class
+        bad_values.each do |v|
+          it "should not allow #{attribute} to be set to #{v.inspect}" do
+            assert_bad_value(klass, attribute, v, message).should be_true
+          end
+        end
+      end
+    end
+
+  end
+end