minitest-sequel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba7809791b48d3d37abf55385778ff37b31a0743
+  data.tar.gz: eb4eca066d3a6a7e39a975a85f5587ad5f6faecc
+SHA512:
+  metadata.gz: 73425aa76579e6118327dc672089e9725451551a00bf80d39b388c666eb31d6f1f26ba905935cf38ed0aad0446813783db0f6cc34d126befdd9b405ad1035007
+  data.tar.gz: 101c5b1c3c9b2d8e0be36353e63f8e9c84e7e371952fb7c7a8b17770e7bdc6f38aacd61e450e8df9b324e0ac9ba143b47035c1c86190daae4c65ad11f993a931

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,20 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting  issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of 
+level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, 
+body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory 
+comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki 
+edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not 
+follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or 
+contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, 
+available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in minitest-sequel.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Kematzy
+
+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,345 @@
+# Minitest-Sequel
+
+[Minitest](https://github.com/seattlerb/minitest) assertions to speed-up development and testing of 
+[Sequel](http://sequel.jeremyevans.net/) database setups.
+
+The general hope is that this gem will contain a variety of useful assertions in all areas of testing Sequel database 
+code within your apps, gems, etc.
+
+Please help out with missing features / functionality.
+
+-----
+
+## Model Definitions
+
+
+### `assert_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>)
+
+
+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
+
+
+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)' }
+
+
+**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.
+
+
+<br>
+<br>
+
+----
+
+<br>
+
+
+## Associations 
+
+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>
+<br>
+
+
+### `:one_to_one` association
+
+
+A model defined with an association like this:
+
+    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 }
+    
+    it { assert_association_one_to_one(m, :first_comment) }    
+    
+    
+    # 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
+    
+    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>
+
+### `:one_to_many` association
+
+A model defined with an association like this:
+
+    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) }
+    
+
+As above the assertion provides an extensive error message if something is wrong.
+
+<br>
+<br>
+
+### `:many_to_one`  association
+
+A model defined with an association like this:
+
+    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) }
+    
+
+
+As above the assertion provides an extensive error message if something is wrong.
+
+<br>
+<br>
+
+### `:many_to_many`  association
+
+A model defined with an association like this:
+
+    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) }
+    
+
+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' }
+  
+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]
+        } 
+      ]
+
+
+<br>
+<br>
+
+### `assert_association() assertion`
+
+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>
+    )
+
+
+<br>
+<br>
+
+----
+
+<br>
+
+## Validations
+
+**NOTE! NOT YET IMPLEMENTED! WORK IN PROGRESS**
+
+
+If you are using the recommended `:validation_helpers` plugin in your app, the following instance validation methods 
+are supported:
+
+ * `validates_presence`
+ 
+ * `validates_exact_length`
+ 
+ * `validates_length_range`
+ 
+ * `validates_max_length`
+ 
+ * `validates_min_length`
+ 
+ * `validates_format`
+ 
+ * `validates_includes`
+ 
+ * `validates_integer`
+ 
+ * `validates_not_string`
+ 
+ * `validates_numeric`
+ 
+ * `validates_unique`
+
+
+The following valid options will be checked:
+
+ * `: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
+
+Can be quickly tested like this:
+
+    <snip...>
+    
+    let(:m) { Post.first }
+    
+    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
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'minitest-sequel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ 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:
+
+    
+    require 'minitest/autorun'
+    require 'minitest/sequel'
+    require 'sqlite3' # using sqlite for tests
+    
+    # The preferred default validations plugin, which uses instance-level methods.
+    Sequel::Model.plugin(:validation_helpers)
+    
+    # connect to database
+    DB = Sequel.sqlite # :memory
+    
+    ## add migrations and seeds below
+    
+    DB.create_table(:posts) do
+      primary_key :id
+      <snip...>
+    end
+    
+
+Then in your tests you should be good to go when using the sequel assertions.
+
+
+
+## Development
+
+After checking out the repo, run `bundle install` to install all dependencies. Then, run `rake spec` to run the tests. 
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, 
+which will create a git tag for the version, push git commits and tags, and push the `.gem` file to 
+[rubygems.org](https://rubygems.org).
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kematzy/minitest-sequel/issues. 
+
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere 
+to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/lib/minitest/sequel.rb

@@ -0,0 +1,276 @@
+require "minitest/sequel/version"
+require 'sequel'
+
+module Minitest
+  module Sequel
+    
+    
+    # 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 ) }
+    #
+    #       # assert_have_column(<instance>, <column_name>, <options>, <custom_error_message>)
+    #
+    #
+    # `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
+    #  * :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)' }
+    #
+    #
+    # **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.
+    #
+    #
+    def assert_have_column(obj, attribute, opts={}, msg=nil)
+      msg = msg.nil? ? '' : "#{msg}\n"
+      msg << "Expected #{obj.class} model to have column: :#{attribute.to_s}"
+      err_msg = []; conf_msg = []
+      # check if column exists
+      col = obj.db.schema(obj.class.table_name).detect{|col| col[0]==attribute}
+      matching = !col.nil?
+      
+      # bail out if no matching column
+      unless matching
+        msg << " but no such column exists" 
+        assert matching, msg
+      end
+      
+      # bail out if options provided are invalid
+      valid_opts    = [:type, :db_type, :allow_null, :max_length, :default, :primary_key, :auto_increment]
+      invalid_opts  = opts.keys.reject { |o| valid_opts.include?(o) }
+      unless invalid_opts.empty?
+        msg << " : ERROR: invalid option(s) provided: { "
+        invalid_opts.each{|o| msg << "#{o.inspect}; " }
+        msg << " } valid options are: #{valid_opts.inspect}"
+        assert false, msg
+      end
+      
+      # carry on...  
+      
+      # check type
+      unless opts[:type].nil?
+        expected = (col[1][:type].to_s == opts[:type].to_s)
+         conf_msg << "type: '#{opts[:type]}'" 
+        unless expected
+          err_msg << "type: '#{col[1][:type]}'" 
+        end
+        matching &&= expected
+      end
+      
+      # check db_type
+      unless opts[:db_type].nil?
+        expected = (col[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]}'" 
+        end
+        matching &&= expected
+      end
+      
+      # check :allow_null
+      unless opts[:allow_null].nil?
+        _v = _convert_value(opts[:allow_null])
+        expected = (opts[:allow_null] === _v)
+        conf_msg << "allow_null: '#{opts[:allow_null]}'" 
+        unless expected
+          err_msg << "allow_null: '#{col[1][:allow_null]}'"
+        end
+        matching &&= expected
+      end
+      
+      # check :max_length
+      unless opts[:max_length].nil?
+        expected = (col[1][:max_length] === opts[:max_length])
+        conf_msg << "max_length: '#{opts[:max_length]}'" 
+        unless expected
+          err_msg << "max_length: '#{col[1][:max_length]}'" 
+        end
+        matching &&= expected
+      end
+      
+      # check :default
+      unless opts[:default].nil?
+        _v = _convert_value(opts[:default])
+        expected = (col[1][:default] === _v )
+        conf_msg << "default: '#{opts[:default]}'" 
+        unless expected
+          err_msg << "default: '#{col[1][:default].inspect}'" 
+        end
+        matching &&= expected
+      end
+      
+      # check :primary_key
+      unless opts[:primary_key].nil?
+        _v = _convert_value(opts[:primary_key])
+        expected = (col[1][:primary_key] === _v)
+        conf_msg << "primary_key: '#{opts[:primary_key]}'"
+        unless expected
+          err_msg << "primary_key: '#{col[1][:primary_key]}'"
+        end
+        matching &&= expected
+      end
+      
+      # check :auto_increment
+      unless opts[:auto_increment].nil?
+        _v = _convert_value(opts[:auto_increment])
+        expected = (col[1][:auto_increment] === _v)
+        conf_msg << "auto_increment: '#{opts[:auto_increment]}'" 
+        unless expected
+          err_msg << "auto_increment: '#{col[1][:auto_increment]}'"
+        end
+        matching &&= expected
+      end
+      
+      msg = msg << " with: { #{conf_msg.join(', ')} } but found: { #{err_msg.join(', ')} }"
+      assert matching, msg
+      
+    end
+    
+    def assert_association_one_to_one(obj, attribute, opts={}, msg=nil)
+      assert_association(obj.class, :one_to_one, attribute, opts, msg)
+    end
+  
+    def assert_association_one_to_many(obj, attribute, opts={}, msg=nil)
+      assert_association(obj.class, :one_to_many, attribute, opts, msg)
+    end
+  
+    def assert_association_many_to_one(obj, attribute, opts={}, msg=nil)
+      assert_association(obj.class, :many_to_one, attribute, opts, msg)
+    end
+  
+    def assert_association_many_to_many(obj, attribute, opts={}, msg=nil)
+      assert_association(obj.class, :many_to_many, attribute, opts, msg)
+    end
+  
+    def assert_association(klass, association_type, attribute, opts={}, msg=nil)
+      msg = msg.nil? ? '' : "#{msg}\n"
+      msg << "Expected #{klass.inspect} to have a #{association_type.inspect} association #{attribute.inspect}"
+      assoc = klass.association_reflection(attribute) || {}
+      if assoc.empty?
+        msg << " but no association '#{attribute.inspect}' was found"
+        arr = []
+        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] }
+          else
+            arr << { attribute: o[:name], type: o[:type], class: o[:class_name].to_sym, keys: o[:keys] }
+          end
+        end
+        msg << " - \navailable associations are: [ #{arr.join(', ')} ]\n"
+        assert false, msg
+      else
+        matching = assoc[:type] == association_type
+        err_msg = []; conf_msg = []
+        opts.each { |key, value|
+          conf_msg << { key => value } 
+          if assoc[key]!= value
+            err_msg << { key => assoc[key] }
+            matching = false
+          end
+        }
+        msg << " with given options: #{conf_msg.join(', ')} but should be #{err_msg.join(', ')}"
+        assert matching, msg
+      end
+    end
+    
+    ## VALIDATIONS
+    
+    def assert_validates_presence(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :presence, attribute, opts, msg)
+    end
+    
+    def assert_validates_length(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :length, attribute, opts, msg)
+    end
+    
+    def assert_validates_exact_length(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :exact_length, attribute, opts, msg)
+    end
+    
+    def assert_validates_length_range(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :length_range, attribute, opts, msg)
+    end
+    
+    def assert_validates_max_length(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :max_length, attribute, opts, msg)
+    end
+    
+    def assert_validates_min_length(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :min_length, attribute, opts, msg)
+    end
+    
+    def assert_validates_format(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :format, attribute, opts, msg)
+    end
+    
+    def assert_validates_includes(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :includes, attribute, opts, msg)
+    end
+    
+    def assert_validates_integer(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :integer, attribute, opts, msg)
+    end
+    
+    def assert_validates_numeric(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :numeric, attribute, opts, msg)
+    end
+    
+    def assert_validates_not_string(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :not_string, attribute, opts, msg)
+    end
+    
+    def assert_validates_unique(obj, attribute, opts={}, msg=nil)
+      assert_validates(obj, :unique, attribute, opts, msg)
+    end
+    
+    def assert_validates(obj, validation_type, attribute, opts={}, msg=nil) 
+      
+    end
+    
+    
+    private 
+    
+    def _convert_value(val)
+      _v = case val
+            when :nil
+              nil
+            when :false
+              false
+            when :true
+              true
+            else
+              val
+           end
+      _v
+    end
+    
+    def _valid_validation_options
+      [ :allow_blank, :allow_missing, :allow_nil, :message ]
+    end
+    
+  end
+  
+  module Assertions
+    include Minitest::Sequel
+  end
+  
+end

data/lib/minitest/sequel/version.rb

@@ -0,0 +1,5 @@
+module Minitest
+  module Sequel
+    VERSION = "0.1.0"
+  end
+end

data/minitest-sequel.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minitest/sequel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "minitest-sequel"
+  spec.version       = Minitest::Sequel::VERSION
+  spec.authors       = ["Kematzy"]
+  spec.email         = ["kematzy@gmail.com"]
+
+  spec.summary       = %q{Minitest assertions to speed-up development and testing of Sequel database setups.}
+  spec.description   = %q{A collection of convenient assertions to enable faster DRY'er testing of Sequel database apps/gems.}
+  spec.homepage      = "https://github.com/kematzy/minitest-sequel"
+  spec.license       = "MIT"
+
+  # # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'minitest', '~> 5.7', '>= 5.7.0'
+  spec.add_runtime_dependency 'sequel', '~> 4.26'
+  
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: minitest-sequel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kematzy
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.7.0
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.26'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.26'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A collection of convenient assertions to enable faster DRY'er testing
+  of Sequel database apps/gems.
+email:
+- kematzy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/minitest/sequel.rb
+- lib/minitest/sequel/version.rb
+- minitest-sequel.gemspec
+homepage: https://github.com/kematzy/minitest-sequel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Minitest assertions to speed-up development and testing of Sequel database
+  setups.
+test_files: []