minitest-sequel 0.2.0 → 0.3.0

data/Rakefile

@@ -1,25 +1,27 @@
 OSX = RUBY_PLATFORM.match(/darwin/)
 
-require 'bundler/gem_tasks'
-require 'rake/testtask'
+require "bundler/gem_tasks"
+require "rake/testtask"
 
 Rake::TestTask.new(:spec) do |t|
-  t.libs << 'spec'
-  t.libs << 'lib'
+  ENV["TESTOPTS"] = "--color"
+  t.libs << "spec"
+  t.libs << "lib"
   t.test_files = FileList['spec/**/*_spec.rb']
 end
 
 task :default => :spec
+task :test => :spec
 
 desc "Run specs with coverage"
 task :coverage do
-  ENV['COVERAGE'] = '1'
-  Rake::Task['spec'].invoke
+  ENV["COVERAGE"] = "1"
+  Rake::Task["spec"].invoke
   `open coverage/index.html` if OSX
 end
 
 
-desc 'Run Rubocop report'
+desc "Run Rubocop report"
 task :rubocop do
   res = `which rubocop`
   if res != ""

data/lib/minitest/sequel.rb

@@ -1,15 +1,14 @@
-require 'minitest'
-require 'minitest/sequel/version'
-require 'sequel'
-require 'sequel/extensions/inflector' unless ''.respond_to?(:classify)
+require "minitest"
+require "minitest/sequel/version"
+require "sequel"
+require "sequel/extensions/inflector" unless "".respond_to?(:classify)
 
 # reopening to add additional functionality
 module Minitest::Assertions
-  
-  
+
   private
-  
-  # handles converting `:nil`, `:false` values  
+
+  # handles converting `:nil`, `:false` values
   def _convert_value(val)
     v = case val
         when :nil    then nil
@@ -20,9 +19,11 @@ module Minitest::Assertions
         end
     v
   end
-  
+
 end
 
-require 'minitest/sequel/columns'
-require 'minitest/sequel/associations'
-require 'minitest/sequel/validations'
+require "minitest/sequel/columns"
+require "minitest/sequel/associations"
+require "minitest/sequel/validations"
+require "minitest/sequel/plugins"
+require "minitest/sequel/helpers"

data/lib/minitest/sequel/associations.rb

@@ -1,58 +1,58 @@
-require 'minitest/sequel'
+require "minitest/sequel"
 
 # reopening to add association functionality
 module Minitest::Assertions
-  
+
   # Test for a :one_to_one association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { assert_association_one_to_one(m, :first_comment, { class: :Comment, order: :id }) }
   #     it { m.must_have_one_to_one_association(:first_comment, { class: :Comment, order: :id }) }
-  # 
+  #
   def assert_association_one_to_one(obj, attribute, opts = {}, msg = nil)
     assert_association(obj.class, :one_to_one, attribute, opts, msg)
   end
-  
+
   # Test for a :one_to_many association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { assert_association_one_to_many(m, :comments) }
   #     it { m.must_have_one_to_many_association(:comments) }
-  # 
+  #
   def assert_association_one_to_many(obj, attribute, opts = {}, msg = nil)
     assert_association(obj.class, :one_to_many, attribute, opts, msg)
   end
-  
+
   # Test for a :many_to_one association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { assert_association_many_to_one(m, :author) }
   #     it { m.must_have_many_to_one_association(:author) }
-  # 
+  #
   def assert_association_many_to_one(obj, attribute, opts = {}, msg = nil)
     assert_association(obj.class, :many_to_one, attribute, opts, msg)
   end
-  
+
   # Test for a :many_to_many association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { assert_association_many_to_many(m, :tags) }
   #     it { m.must_have_many_to_many_association(:tags) }
-  # 
+  #
   def assert_association_many_to_many(obj, attribute, opts = {}, msg = nil)
     assert_association(obj.class, :many_to_many, attribute, opts, msg)
   end
-  
+
   # Test for associations for the current model by passing the :association_type
-  # 
+  #
   #     it { assert_association(Post, :many_to_many, :tags) }
-  # 
+  #
   def assert_association(klass, association_type, attribute, opts = {}, msg = nil)
-    msg = msg.nil? ? '' : "#{msg}\n"
+    msg = msg.nil? ? "" : "#{msg}\n"
     msg << "Expected #{klass.inspect} to have a #{association_type.inspect}"
     msg << " association #{attribute.inspect}"
     assoc = klass.association_reflection(attribute) || {}
@@ -62,20 +62,20 @@ module Minitest::Assertions
       klass.associations.each do |a|
         o = klass.association_reflection(a)
         if o[:type] == :many_to_many
-          arr << { 
-            attribute:    o[:name], 
-            type:         o[:type], 
-            class:        o[:class_name].to_sym, 
-            join_table:   o[:join_table], 
-            left_keys:    o[:left_keys], 
-            right_keys:   o[:right_keys] 
+          arr << {
+            attribute:    o[:name],
+            type:         o[:type],
+            class:        o[:class_name].to_s,
+            join_table:   o[:join_table],
+            left_keys:    o[:left_keys],
+            right_keys:   o[:right_keys]
           }
         else
-          arr << { 
-            attribute:  o[:name], 
-            type:       o[:type], 
-            class:      o[:class_name].to_sym, 
-            keys:       o[:keys] 
+          arr << {
+            attribute:  o[:name],
+            type:       o[:type],
+            class:      o[:class_name].to_s,
+            keys:       o[:keys]
           }
         end
       end
@@ -86,9 +86,9 @@ module Minitest::Assertions
       err_msg = []
       conf_msg = []
       opts.each do |key, value|
-        conf_msg << { key => value } 
+        conf_msg << { key => value }
         if assoc[key] != value
-          err_msg << { key => assoc[key] }
+          err_msg << { key => assoc[key].to_s }
           matching = false
         end
       end
@@ -96,62 +96,62 @@ module Minitest::Assertions
       assert(matching, msg)
     end
   end
-  
-  
+
+
   # Test to ensure there is no :one_to_one association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { refute_association_one_to_one(m, :first_comment, { class: :Comment, order: :id }) }
   #     it { m.must_have_one_to_one_association(:first_comment, { class: :Comment, order: :id }) }
-  # 
-  def refute_association_one_to_one(obj, attribute, opts = {}, msg = nil)
-    refute_association(obj.class, :one_to_one, attribute, opts, msg)
+  #
+  def refute_association_one_to_one(obj, attribute, msg = nil)
+    refute_association(obj.class, :one_to_one, attribute, msg)
   end
-  
+
   # Test to ensure there is no :one_to_many association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { refute_association_one_to_many(m, :comments) }
   #     it { m.must_have_one_to_many_association(:comments) }
-  # 
-  def refute_association_one_to_many(obj, attribute, opts = {}, msg = nil)
-    refute_association(obj.class, :one_to_many, attribute, opts, msg)
+  #
+  def refute_association_one_to_many(obj, attribute, msg = nil)
+    refute_association(obj.class, :one_to_many, attribute, msg)
   end
-  
+
   # Test to ensure there is no :many_to_one association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { refute_association_many_to_one(m, :author) }
   #     it { m.must_have_many_to_one_association(:author) }
-  # 
-  def refute_association_many_to_one(obj, attribute, opts = {}, msg = nil)
-    refute_association(obj.class, :many_to_one, attribute, opts, msg)
+  #
+  def refute_association_many_to_one(obj, attribute, msg = nil)
+    refute_association(obj.class, :many_to_one, attribute, msg)
   end
-  
+
   # Test to ensure there is no :many_to_many association for the current model
-  # 
+  #
   #     let(:m) { Post.first }
-  #     
+  #
   #     it { refute_association_many_to_many(m, :tags) }
   #     it { m.must_have_many_to_many_association(:tags) }
-  # 
-  def refute_association_many_to_many(obj, attribute, opts = {}, msg = nil)
-    refute_association(obj.class, :many_to_many, attribute, opts, msg)
+  #
+  def refute_association_many_to_many(obj, attribute, msg = nil)
+    refute_association(obj.class, :many_to_many, attribute, msg)
   end
-  
+
   # Test to ensure the current model does NOT have an association by type :association_type
-  # 
+  #
   #     it { refute_association(Post, :many_to_many, :tags) }
-  # 
-  def refute_association(klass, association_type, attribute, opts = {}, msg = nil)
-    msg = msg.nil? ? '' : "#{msg}\n"
+  #
+  def refute_association(klass, association_type, attribute, msg = nil)
+    msg = msg.nil? ? "" : "#{msg}\n"
     msg << "Expected #{klass.inspect} to NOT have a #{association_type.inspect}"
     msg << " association #{attribute.inspect}"
     assoc = klass.association_reflection(attribute) || {}
-    
+
     if assoc.empty?
       assert(true, msg)
     else
@@ -159,25 +159,24 @@ module Minitest::Assertions
       msg << ", but such an association was found"
       assert(matching, msg)
     end
-    
   end
-  
+
 end
 
 
 # add support for Spec syntax
 module Minitest::Expectations
-  
+
   infect_an_assertion :assert_association,              :must_have_association,             :reverse
   infect_an_assertion :assert_association_one_to_one,   :must_have_one_to_one_association,  :reverse
   infect_an_assertion :assert_association_one_to_many,  :must_have_one_to_many_association, :reverse
   infect_an_assertion :assert_association_many_to_one,  :must_have_many_to_one_association, :reverse
   infect_an_assertion :assert_association_many_to_many, :must_have_many_to_many_association, :reverse
-  
+
   infect_an_assertion :refute_association,              :wont_have_association,             :reverse
   infect_an_assertion :refute_association_one_to_one,   :wont_have_one_to_one_association,  :reverse
   infect_an_assertion :refute_association_one_to_many,  :wont_have_one_to_many_association, :reverse
   infect_an_assertion :refute_association_many_to_one,  :wont_have_many_to_one_association, :reverse
   infect_an_assertion :refute_association_many_to_many, :wont_have_many_to_many_association, :reverse
-  
+
 end

data/lib/minitest/sequel/columns.rb

@@ -1,8 +1,8 @@
-require 'minitest/sequel'
+# require "minitest/sequel"
 
 # reopening to add schema validation functionality
 module Minitest::Assertions
-  
+
   # Conveniently test your Model definitions as follows:
   #
   #     let(:m) { Post.first }
@@ -11,11 +11,11 @@ module Minitest::Assertions
   #     it { m.must_have_column(:title, type: :string, db_type: 'varchar(250)') }
   #
   #     # assert_have_column(<instance>, <column_name>, <options>, <custom_error_message>)
-  #     
+  #
   #     # <instance>.must_have_column(<column_name>, <options>, <custom_error_message>)
   #
   #
-  # `assert_have_column()` first tests if the column name is defined in the Model and then checks 
+  # `assert_have_column()` first tests if the column name is defined in the Model and then checks
   # all passed options. The following options are valid and checked:
   #
   #  * :type
@@ -26,7 +26,7 @@ module Minitest::Assertions
   #  * :primary_key
   #  * :auto_increment
   #
-  # In the event the specs differ from the actual database implementation an extensive error 
+  # In the event the specs differ from the actual database implementation an extensive error
   # message with the differing option(s) is provided to help speed up debugging the issue:
   #
   #     Expected Post model to have column: :title with: \
@@ -36,123 +36,122 @@ module Minitest::Assertions
   #
   # **Please NOTE!**
   #
-  # To test options with a value that is either `nil`, `true` or `false`, please use `:nil`, 
+  # To test options with a value that is either `nil`, `true` or `false`, please use `:nil`,
   # `:false` or `:true` and provide numbers as 'strings' instead.
   #
   #
   def assert_have_column(obj, attribute, opts = {}, msg = nil)
-    msg = msg.nil? ? '' : "#{msg}\n"
+    msg = msg.nil? ? "" : "#{msg}\n"
     msg << "Expected #{obj.class} model to have column: :#{attribute}"
     err_msg  = []
     conf_msg = []
     # check if column exists
-    col = obj.db.schema(obj.class.table_name).detect { |c| c[0] == attribute }
-    matching = !col.nil?
-    
+    dcol = obj.db.schema(obj.class.table_name).detect { |c| c[0] == attribute }
+    matching = !dcol.nil?
+
     # bail out if no matching column
     unless matching
-      msg << ' but no such column exists' 
+      msg << " but no such column exists"
       assert(false, msg)
     end
-    
+
     # bail out if options provided are invalid
     val_opts = [:type, :db_type, :allow_null, :max_length, :default, :primary_key, :auto_increment]
-    invalid_opts  = opts.keys.reject { |o| val_opts.include?(o) }
+    invalid_opts = opts.keys.reject { |o| val_opts.include?(o) }
     unless invalid_opts.empty?
-      msg << ', but the following invalid option(s) was found: { '
+      msg << ", but the following invalid option(s) was found: { "
       invalid_opts.each { |o| msg << "#{o.inspect}; " }
       msg << " }. Valid options are: #{val_opts.inspect}"
       assert(false, msg)
     end
-    
+
     # TODO: simplify this mess. quick fix didn't work, so look at it again when time permits.
-    
+
     unless opts[:type].nil?
-      expected = (col[1][:type].to_s == opts[:type].to_s)
+      expected = (dcol[1][:type].to_s == opts[:type].to_s)
       conf_msg << "type: '#{opts[:type]}'"
       unless expected
-        err_msg << "type: '#{col[1][:type]}'"
+        err_msg << "type: '#{dcol[1][:type]}'"
       end
       matching &&= expected
     end
-    
+
     unless opts[:db_type].nil?
-      expected = (col[1][:db_type].to_s == opts[:db_type].to_s)
+      expected = (dcol[1][:db_type].to_s == opts[:db_type].to_s)
       conf_msg << "db_type: '#{opts[:db_type]}'"
       unless expected
-        err_msg << "db_type: '#{col[1][:db_type]}'"
+        err_msg << "db_type: '#{dcol[1][:db_type]}'"
       end
       matching &&= expected
     end
-    
+
     unless opts[:max_length].nil?
-      expected = (col[1][:max_length] === opts[:max_length])
+      expected = (dcol[1][:max_length] === opts[:max_length])
       conf_msg << "max_length: '#{opts[:max_length]}'"
       unless expected
-        err_msg << "max_length: '#{col[1][:max_length]}'"
+        err_msg << "max_length: '#{dcol[1][:max_length]}'"
       end
       matching &&= expected
     end
-    
+
     unless opts[:allow_null].nil?
       v = _convert_value(opts[:allow_null])
-      expected = (opts[:allow_null] === v)
+      expected = (dcol[1][:allow_null] === v)
       conf_msg << "allow_null: '#{opts[:allow_null]}'"
       unless expected
-        err_msg << "allow_null: '#{col[1][:allow_null]}'"
+        err_msg << "allow_null: '#{dcol[1][:allow_null]}'"
       end
       matching &&= expected
     end
-    
+
     unless opts[:default].nil?
       v = _convert_value(opts[:default])
-      expected = (col[1][:default] === v)
+      expected = (dcol[1][:default] === v)
       conf_msg << "default: '#{opts[:default]}'"
       unless expected
-        err_msg << "default: '#{col[1][:default].inspect}'"
+        err_msg << "default: '#{dcol[1][:default].inspect}'"
       end
       matching &&= expected
     end
-    
+
     unless opts[:primary_key].nil?
       v = _convert_value(opts[:primary_key])
-      expected = (col[1][:primary_key] === v)
+      expected = (dcol[1][:primary_key] === v)
       conf_msg << "primary_key: '#{opts[:primary_key]}'"
       unless expected
-        err_msg << "primary_key: '#{col[1][:primary_key]}'"
+        err_msg << "primary_key: '#{dcol[1][:primary_key]}'"
       end
       matching &&= expected
     end
-    
+
     unless opts[:auto_increment].nil?
       v = _convert_value(opts[:auto_increment])
-      expected = (col[1][:auto_increment] === v)
+      expected = (dcol[1][:auto_increment] === v)
       conf_msg << "auto_increment: '#{opts[:auto_increment]}'"
       unless expected
-        err_msg << "auto_increment: '#{col[1][:auto_increment]}'"
+        err_msg << "auto_increment: '#{dcol[1][:auto_increment]}'"
       end
       matching &&= expected
     end
-    
+
     msg = msg << " with: { #{conf_msg.join(', ')} } but found: { #{err_msg.join(', ')} }"
     assert(matching, msg)
   end
-  
+
   #
-  def refute_have_column(obj, attribute, opts = {}, msg = nil)
-    msg = msg.nil? ? '' : "#{msg}\n"
+  def refute_have_column(obj, attribute, msg = nil)
+    msg = msg.nil? ? "" : "#{msg}\n"
     msg << "Expected #{obj.class} model to NOT have column: :#{attribute}"
     # check if column exists
-    col = obj.db.schema(obj.class.table_name).detect { |col| col[0] == attribute }
-    matching = col.nil?
+    dcol = obj.db.schema(obj.class.table_name).detect { |col| col[0] == attribute }
+    matching = dcol.nil?
     unless matching
-      msg << ' but such a column was found' 
+      msg << " but such a column was found"
       assert(matching, msg)
     end
   end
-  
-end
 
+end
 
 # add support for Spec syntax
 module Minitest::Expectations