minitest-sequel 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba7809791b48d3d37abf55385778ff37b31a0743
-  data.tar.gz: eb4eca066d3a6a7e39a975a85f5587ad5f6faecc
+  metadata.gz: 2997e3b0fa5879eef663dc938c536c4ce8fd1fd3
+  data.tar.gz: 533196e4a81a67e333c4251d71b2aa48999497e8
 SHA512:
-  metadata.gz: 73425aa76579e6118327dc672089e9725451551a00bf80d39b388c666eb31d6f1f26ba905935cf38ed0aad0446813783db0f6cc34d126befdd9b405ad1035007
-  data.tar.gz: 101c5b1c3c9b2d8e0be36353e63f8e9c84e7e371952fb7c7a8b17770e7bdc6f38aacd61e450e8df9b324e0ac9ba143b47035c1c86190daae4c65ad11f993a931
+  metadata.gz: 10b33ee43a344c43568e2c7c6207a3bf8fda4fb048e75abe916029a49ab8646d1a3539b84fb3293290a9600f9e05d5a03a8a9650312c7c799428fb0c22a906a9
+  data.tar.gz: 37de04749d64329f6ba80d754643c1633e3880e037a037c54a570570a4165b0758221e1d603ee26dc8dd2f7a56396e3cca782ad1a9795761e744f440b8701293

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/rubocop/

data/README.md

@@ -13,44 +13,53 @@ Please help out with missing features / functionality.
 ## Model Definitions
 
 
-### `assert_have_column ()`
+### `assert_have_column ()` or `.must_have_column()`
 
 Conveniently test your Model definitions as follows:
 
-    let(:m) { Post.first }
-    
-    it { assert_have_column(m, :title, type: :string, db_type: 'varchar(250)', allow_null: :false ) }
-    
-    # definition of args
-    assert_have_column(<instance>, <column_name>, <options>, <custom_error_message>)
+```ruby
+let(:m) { Post.first }
 
+it { assert_have_column(m, :title, type: :string, db_type: 'varchar(250)', allow_null: :false) }
+
+it { m.must_have_column(:title, type: :string, allow_null: :false) }
+    
+ # definition of args
+assert_have_column(
+  <instance>, 
+  <column_name>, 
+  <options>, 
+  <custom_error_message>
+)
+```
 
 The `assert_have_column()` method 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
- * :db_type
- * :allow_null
- * :max_length
- * :default
- * :primary_key
- * :auto_increment
+ * `:type`
+ * `:db_type`
+ * `:allow_null`
+ * `:max_length`
+ * `:default`
+ * `:primary_key`
+ * `:auto_increment`
 
 
 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: \
-      { type: 'string', db_type: 'varchar(250)', allow_null: 'false' } \
-      but found: { db_type: 'varchar(255)' }
-
+```
+Expected Post model to have column: :title with: \
+  { type: 'string', db_type: 'varchar(250)', allow_null: 'false' } \
+  but found: { db_type: 'varchar(255)' }
+```
 
 **Please NOTE!**
 
 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, ie: '1' instead of 1.
+numbers as 'strings' instead, ie: `'1'` instead of `1`.
 
 
 <br>
@@ -66,9 +75,13 @@ numbers as 'strings' instead, ie: '1' instead of 1.
 Conveniently test model associations quickly and easily with these Minitest assertions:
 
 * `assert_association_one_to_one`
+
 * `assert_association_one_to_many`
+
 * `assert_association_many_to_one`
+
 * `assert_association_many_to_many`
+
 * `assert_association`
 
 <br>
@@ -80,35 +93,43 @@ Conveniently test model associations quickly and easily with these Minitest asse
 
 A model defined with an association like this:
 
-    class Post < Sequel::Model
-      one_to_one :first_comment, :class=>:Comment, :order=>:id
-    end
+
+```ruby
+class Post < Sequel::Model
+  one_to_one :first_comment, class: :Comment, order: :id
+end
+```
 
 Can be easily and quickly tested with `assert_association_one_to_one()` like this:
 
-    let(:m) { Post.first }
+```ruby
+let(:m) { Post.first }
     
-    it { assert_association_one_to_one(m, :first_comment) }    
+it { assert_association_one_to_one(m, :first_comment)
+ # or
+it { m.must_have_one_to_one_association(:first_comment) }
     
     
-    # definition of args
-    assert_association_one_to_one( 
-      <model_instance>, 
-      <association_name>,   # ie: :first_comment
-      <options>,
-      <custom_error_message>
-    )
-
+ # definition of args
+assert_association_one_to_one( 
+  <model_instance>, 
+  <association_name>,   # ie: :first_comment
+  <options>,
+  <custom_error_message>
+)
+```
 
 In the event of errors an extensive error message is provided:
 
-    # example error message
+```
+ # example error message
     
-    Expected Author to have a :one_to_one association :key_posts but no association ':key_posts' was found - 
-      available associations are: [ \
-        {:attribute=>:posts, :type=>:one_to_many, :class=>:Post, :keys=>[:author_id]}, \
-        {:attribute=>:key_post, :type=>:one_to_one, :class=>:Post, :keys=>[:author_id]} \
-      ]
+Expected Author to have a :one_to_one association :key_posts but no association \
+ ':key_posts' was found - available associations are: [ \
+  {:attribute=>:posts, :type=>:one_to_many, :class=>:Post, :keys=>[:author_id]}, \
+  {:attribute=>:key_post, :type=>:one_to_one, :class=>:Post, :keys=>[:author_id]} \
+ ]
+```
 
 <br>
 <br>
@@ -117,16 +138,21 @@ In the event of errors an extensive error message is provided:
 
 A model defined with an association like this:
 
-    class Post < Sequel::Model
-      one_to_many :comments
-    end
+```ruby
+class Post < Sequel::Model
+  one_to_many :comments
+end
+```
 
 Can be easily and quickly tested with `assert_association_one_to_many()` like this:
 
-    let(:p) { Post.first }
-    
-    it { assert_association_one_to_many(p, :comments) }
-    
+```ruby
+let(:p) { Post.first }
+  
+it { assert_association_one_to_many(p, :comments) }
+ # or
+it { m.must_have_one_to_many_association(:comments) }
+```    
 
 As above the assertion provides an extensive error message if something is wrong.
 
@@ -137,16 +163,21 @@ As above the assertion provides an extensive error message if something is wrong
 
 A model defined with an association like this:
 
-    class Post < Sequel::Model
-      many_to_one :author
-    end
+```ruby
+class Post < Sequel::Model
+  many_to_one :author
+end
+```
 
 Can be easily and quickly tested with `assert_association_many_to_one()` like this:
 
-    let(:p) { Post.first }
-    
-    it { assert_association_many_to_one(p, :author) }
-    
+```ruby
+let(:p) { Post.first }
+  
+it { assert_association_many_to_one(p, :author) }
+ # or
+it { m.must_have_many_to_one_association(:author) }
+```    
 
 
 As above the assertion provides an extensive error message if something is wrong.
@@ -158,49 +189,64 @@ As above the assertion provides an extensive error message if something is wrong
 
 A model defined with an association like this:
 
-    class Post < Sequel::Model
-      many_to_many :categories
-    end
+```ruby
+class Post < Sequel::Model
+  many_to_many :categories
+end
+```
 
 Can be easily and quickly tested with `assert_association_many_to_many()` like this:
 
-    let(:p) { Post.first }
-    
-    it { assert_association_many_to_many(p, :categories) }
-    
+```ruby
+let(:p) { Post.first }
+ 
+it { assert_association_many_to_many(p, :categories) }
+ # or
+it { m.must_have_many_to_many_association(:categories) }
+```    
 
 If something is wrong an extensive error message is provided:
 
-    Expected Category to have a :many_to_many association :posts with given options: \
-      {:class_name=>'Posts'} but should be {:class_name=>'Post' }
+```
+Expected Category to have a :many_to_many association :posts with given options: \
+  {:class_name=>'Posts'} but should be {:class_name=>'Post' }
+```
   
 or
   
-    Expected Category to have a :many_to_many association :post but no association ':post' was found - \
-      available associations are: [ \
-        { :attribute=>:posts, :type=>:many_to_many, :class=>:Post, :join_table=>:categories_posts, \
-          :left_keys=>[:category_id], :right_keys=>[:post_id]
-        } 
-      ]
-
+```
+Expected Category to have a :many_to_many association :post but no association \
+ ':post' was found - available associations are: [ \
+  { :attribute=>:posts, :type=>:many_to_many, :class=>:Post, :join_table=>:categories_posts, \
+    :left_keys=>[:category_id], :right_keys=>[:post_id]
+  } 
+ ]
+```
 
 <br>
 <br>
 
 ### `assert_association() assertion`
+spec: `.must_have_association()`
 
 if the above assertion methods are insufficient, you can use the base `assert_association` method instead.
 
-    it "should have a :one_through_one association" do
-      assert_association(Post, :one_through_one, :author)
-    end
-    
-    
-    # 
-    assert_association(
-      <model_class>, <association_type>, <association_name>, <options>, <custom_error_message>
-    )
-
+```ruby
+it "should have a :one_through_one association" do
+  assert_association(Post, :one_through_one, :author)
+   # or
+  Post.must_have_association(:one_through_one, :author)
+end
+
+ # definition of args
+assert_association(
+  <model_class>, 
+  <association_type>, 
+  <association_name>, 
+  <options>, 
+  <custom_error_message>
+)
+```
 
 <br>
 <br>
@@ -211,110 +257,310 @@ if the above assertion methods are insufficient, you can use the base `assert_as
 
 ## Validations
 
-**NOTE! NOT YET IMPLEMENTED! WORK IN PROGRESS**
-
+If you are using the recommended `:validation_class_methods` plugin in your app, the following instance validation methods are supported:
 
-If you are using the recommended `:validation_helpers` plugin in your app, the following instance validation methods 
-are supported:
-
- * `validates_presence`
+ * `assert_validates_presence()`
  
- * `validates_exact_length`
+ * `assert_validates_exact_length()`
  
- * `validates_length_range`
+ * `assert_validates_length_range()`
  
- * `validates_max_length`
+ * `assert_validates_max_length()`
  
- * `validates_min_length`
+ * `assert_validates_min_length()`
  
- * `validates_format`
+ * `assert_validates_format()`
  
- * `validates_includes`
+ * `assert_validates_inclusion()`
  
- * `validates_integer`
+ * `assert_validates_integer()`
  
- * `validates_not_string`
+ * `assert_validates_numericality()`
  
- * `validates_numeric`
+ * `assert_validates_uniqueness()`
+
+ * `assert_validates_acceptance()`
  
- * `validates_unique`
+ * `assert_validates_confirmation()`
+
+With all valid options checked
+
+---
+
+### `assert_validates_presence(obj, attribute, opts = {}, msg = nil)`
+alias: `:assert_validates_presence_of`
+
+Test for validating presence of a model attribute
+    
+```ruby
+it { assert_validates_presence(model, :title) }
+it { model.must_validate_presence_of(:title, { message: '...' }) }
+```
+<br>
+
+
+### `assert_validates_length(obj, attribute, opts = {}, msg = nil)`
+alias `:assert_validates_length_of`
+
+Test for validating the length of a model's attribute.
+
+Available options:
+
+* :message - The message to use (no default, overrides :nil_message, :too_long, :too_short, and :wrong_length options if present)
+
+* :nil_message - The message to use use if :maximum option is used and the value is nil (default: 'is not present')
+
+* :too_long - The message to use use if it the value is too long (default: 'is too long')
+
+* :too_short - The message to use use if it the value is too short (default: 'is too short')
+
+* :wrong_length - The message to use use if it the value is not valid (default: 'is the wrong length')
+
+Size related options:
+
+* :is - The exact size required for the value to be valid (no default)
+
+* :minimum - The minimum size allowed for the value (no default)
+
+* :maximum - The maximum size allowed for the value (no default)
+
+* :within - The array/range that must include the size of the value for it to be valid (no default)
+
+```ruby
+it { assert_validates_length(model, :title, { maximum: 12 }) }
+it { model.must_validate_length_of(:title, { within: 4..12 }) }
+```
+<br>
+
+
+### `assert_validates_exact_length(obj, attribute, exact_length, opts = {}, msg = nil)`
+alias: `:assert_validates_exact_length_of`
+
+Test for validating the exact length of a model's attribute.
+
+```ruby
+it { assert_validates_exact_length(model, :title, 12, { message: '...' }) }
+it { model.must_validate_exact_length_of(:title, 12, { message: '...' }) }
+```
+<br>
+
+
+### `assert_validates_length_range(obj, attribute, range, opts = {}, msg = nil)`
+alias: `:assert_validates_length_range_of`
+
+Test for validating the exact length of a model's attribute.
+
+```ruby
+it { assert_validates_length_range(model, :title, 4..12, { message: '...' }) }
+it { model.must_validate_length_range_of(:title, 4..12, { message: '...' }) }
+```
+
+<br>
 
 
-The following valid options will be checked:
+### `assert_validates_max_length(obj, attribute, max_length, opts = {}, msg = nil)`
+alias: `:assert_validates_max_length_of`
+
+Test for validating the maximum length of a model's attribute.
+
+```ruby
+it { assert_validates_max_length(model, :title, 12, { message: '...' }) }
+it { model.must_validate_max_length_of(:title, 12, { message: '...' }) }
+```
+
+<br>
+
+
+### `assert_validates_min_length(obj, attribute, min_length, opts = {}, msg = nil)`
+alias: `:assert_validates_min_length_of`
+
+Test for validating the minimum length of a model's attribute.
+
+```ruby
+it { assert_validates_min_length(model, :title, 12, { message: '...' }) }
+it { model.must_validate_min_length_of(:title, 12, { message: '...' }) }
+```
+
+<br>
+
+
+## `assert_validates_format(obj, attribute, opts = {}, msg = nil)`
+alias: `:assert_validates_format_of`
+
+Test for validating the format of a model's attribute with a regexp.
+
+```ruby
+it { assert_validates_format(model, :title, 12, { with: /[a-z+]/ }) }
+it { model.must_validate_format_of(:title, 12, { with: /[a-z]+/ }) }
+```
+
+<br>
+
+
+### `assert_validates_inclusion(obj, attribute, opts = {}, msg = nil)`
+alias: `:assert_validates_inclusion_of`
+
+Test for validating that a model's attribute is within a specified range or set of values.
+
+```ruby
+it { assert_validates_inclusion(model, :status, { in: [:a, :b, :c] }) }
+it { model.must_validate_inclusion_of(:status, { in: [:a, :b, :c] }) }
+```
+
+<br>
+
+
+### `assert_validates_integer(obj, attribute, opts = {}, msg = nil)`
+alias: none
+
+Test for validating that a a model's attribute is an integer.
+
+```ruby
+it { assert_validates_integer(model, :author_id, { message: '...' }) }
+it { model.must_validate_integer_of(:author_id, { message: '...' }) }
+```
+
+<br>
+
+
+### `assert_validates_numericality(obj, attribute, opts = {}, msg = nil)`
+alias: `:assert_validates_numericality_of`
+
+Test for validating that a model's attribute is numeric (number).
+
+```ruby
+it { assert_validates_numericality(model, :author_id, { message: '...' }) }
+it { model.must_validate_numericality_of(:author_id, { message: '...' }) }
+```
+
+<br>
+
+
+### `assert_validates_uniqueness(obj, attribute, opts = {}, msg = nil)`
+alias: `:assert_validates_uniqueness_of`
+
+Test for validating that a model's attribute is unique.
+
+```ruby
+it { assert_validates_uniqueness(model, :urlslug, { message: '...' }) }
+it { model.must_validate_uniqueness_of(:urlslug, { message: '...' }) }
+``` 
+
+<br>
+
+
+### `assert_validates_acceptance(obj, attribute, opts = {}, msg = nil)`
+alias: `assert_validates_acceptance_of`
+
+Test for validating the acceptance of a model's attribute.
+
+```ruby
+it { assert_validates_acceptance(Order.new, :toc, { message: '...' }) }
+it { model.must_validate_acceptance_of(:toc, { message: '...' }) }
+```
+
+<br>
+
+
+### `assert_validates_confirmation(obj, attribute, opts = {}, msg = nil)`
+alias: `:assert_validates_confirmation_of`
+
+Test for validating the confirmation of a model's attribute.
+
+```ruby
+it { assert_validates_confirmation(User.new, :password, { message: '...' }) }
+it { User.new.must_validate_confirmation_of(:password, { message: '...' }) }
+```
+
+<br>
+
+
+Each validation assertion have a responding negative test, ie: `refute_validate_presence()`
+
 
- * `:allow_blank`
- * `:allow_missing`
- * `:allow_nil`
- * `:message`
 
 
 ### Usage
 
 A model defined with validations like this:
 
-    class Post < Sequel::Model
-      plugin :validation_helpers
-      
-      def validate
-        super
-        validates_presence(:title)
-        validates_format(/\w+/, :title)
-      end
-    end
+```ruby
+class Post < Sequel::Model
+  plugin :validation_helpers
+  
+  def validate
+    super
+    validates_presence(:title)
+    validates_format(/\w+/, :title)
+  end
+end
+```
 
 Can be quickly tested like this:
 
-    <snip...>
+```ruby
+ # <snip...>
     
-    let(:m) { Post.first }
+let(:m) { Post.first }
     
-    it "shoud validate presence of :title column" do
-      assert_validates_presence(m, :title)
-    end
+it "shoud validate presence of :title column" do
+  assert_validates_presence(m, :title)
+end
     
-    it "shoud validate format of :title column with regexp" do
-      assert_validates_format(m, :title, /\w+/)
-    end
-
+it "shoud validate format of :title column with regexp" do
+  assert_validates_format(m, :title, /\w+/)
+end
+```
 
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'minitest-sequel'
+```ruby
+gem 'minitest-sequel'
+```
 
 And then execute:
 
-    $ bundle
+```bash
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install minitest-sequel
-
+```bash
+$ gem install minitest-sequel
+```
 
 ## Usage
 
 In your project's `spec/spec_helper.rb` or `test/test_helper.rb` file ensure the following code is present:
 
+ 
+```ruby   
+gem 'minitest'
     
-    require 'minitest/autorun'
-    require 'minitest/sequel'
-    require 'sqlite3' # using sqlite for tests
+require 'minitest/autorun'
+require 'minitest/sequel'  # NB!! can be loaded after minitest/autorun
+ 
+require 'sqlite3' # using sqlite for tests
     
-    # The preferred default validations plugin, which uses instance-level methods.
-    Sequel::Model.plugin(:validation_helpers)
+ # The preferred default validations plugin, which uses class-level methods.
+Sequel::Model.plugin(:validation_class_methods)
     
-    # connect to database
-    DB = Sequel.sqlite # :memory
+ # connect to database
+DB = Sequel.sqlite # :memory
     
-    ## add migrations and seeds below
+ ## add migrations and seeds below
     
-    DB.create_table(:posts) do
-      primary_key :id
-      <snip...>
-    end
+DB.create_table(:posts) do
+  primary_key :id
+  # <snip...>
+end
     
+ # <snip...>
+```
 
 Then in your tests you should be good to go when using the sequel assertions.