fixpoints 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: accfd17194594b7b1f83144d68a15930991a6aa0369fe695bd4ac769d247abbe
+  data.tar.gz: 831f6c9c694d96173175b7b1082600947575f54864161fac52cf5dabdd039e7c
+SHA512:
+  metadata.gz: 5684b274d7118189c284c483816e6f18059529f08ce92585fd8c94dec3360106a9a77238cc6348d9b25f8daa4f4d9f2de227ef0daffe8fd511b7eb0ceddee05a
+  data.tar.gz: 626a9395a2472992c02c18c0e6bf51a5502b29d460023034ef13501221b0312b5e35fd493b7d9661a0f8ddccee13c1755345e5ca4e0521c14b37bb9f3ba1f828

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in fixpoints.gemspec
+gemspec
+
+gem "rspec"
+gem "activerecord", ">=5.0.0"
+gem "sqlite3"
+
+gem "pry"

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    fixpoints (0.1.0)
+      activerecord (>= 5.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.4.4)
+      activesupport (= 5.2.4.4)
+    activerecord (5.2.4.4)
+      activemodel (= 5.2.4.4)
+      activesupport (= 5.2.4.4)
+      arel (>= 9.0)
+    activesupport (5.2.4.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.14.2)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    sqlite3 (1.4.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 5.0.0)
+  fixpoints!
+  pry
+  rspec
+  sqlite3
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Tom Rothe
+
+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,67 @@
+# Fixpoints
+
+Fixpoints enables saving, restoring and comparing the database state before & after tests.
+
+## Motivation
+
+TODO
+
+Link to `https://tomrothe.de/posts/behaviour-driven-test-data.html`
+
+## Usage
+
+Add this line to your application's Gemfile: `gem 'fixpoints'`
+
+TODO: Write usage instructions here
+
+
+```ruby
+# TODO: update this code
+it 'registers a user' do
+  visit new_user_path
+  fill_in 'Name', with: 'Hans'
+  click_on 'Save'
+
+  store_fixpoint :registred_user
+  # creates YAML files containing all records (/spec/fixpoints/[table_name].yml)
+end
+
+it 'posts an item' do
+  restore_fixpoint :registered_user
+  
+  user = User.find_by(name: 'Hans')
+  visit new_item_path(user)
+  fill_in 'Item', with: '...'
+  click_on 'Post'
+
+  compare_fixpoint(:posted_item, ignore_columns: [:release_date], store_fixpoint_and_fail: true)
+  # compares the database state with the previously saved fixpoint and
+  # raises if there is a difference. when there is no previous fixpoint,
+  # it writes it and fails the test (so it can be re-run)  
+end
+```
+
+## Development
+
+```bash
+docker run --rm -ti -v (pwd):/app -w /app ruby:2.7 bash
+bundle install
+rspec
+pry # require_relative 'lib/fixpoints.rb'
+
+gem build
+gem install fixpoints-0.1.0.gem
+pry -r fixpoints
+gem uninstall fixpoints
+```
+
+
+## Development
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/motine/fixpoints.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/fixpoints.gemspec

@@ -0,0 +1,27 @@
+require_relative 'lib/fixpoints/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fixpoints"
+  spec.version       = Fixpoints::VERSION
+  spec.authors       = ["Tom Rothe"]
+  spec.email         = ["info@tomrothe.de"]
+
+  spec.summary       = "Don't discard the database state at the end of your test. Use it!"
+  spec.description   = 'Fixpoints enables saving, restoring and comparing the database state before & after tests'
+  spec.homepage      = "https://github.com/motine/fixpoints"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.add_runtime_dependency "activerecord", ">=5.0.0"
+  spec.add_runtime_dependency "rspec"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+end

data/lib/fixpoint.rb

@@ -0,0 +1,171 @@
+# A fixpoint is a snapshot of the database contents.
+# It is saved to the +spec/fixpoints+ folder.
+# A fixpoint (file) contains a mapping of table names to a list if their records.
+#
+# Empty tables are stripped from files.
+#
+# Make sure to run the tests in the right order: In a single RSpec file, you can use the order in which the tests are defined (`RSpec.describe 'MyFeature', order: :defined do`).
+# However, tests in groups might follow a slightly different order (see https://relishapp.com/rspec/rspec-core/docs/configuration/overriding-global-ordering)
+#
+# If you did a lot of changes to a test, you can remove a fixpoint file from its directory.
+# It will be recreated when the test producing it runs again.
+# Don't forget re-running the tests _based on_ it because their fixpoints might have to change too.
+# Example: You need to add something to the database's seeds.rb. All subsequent fixpoints are missing the required entry.
+# To update all fixpoints, just remove the whole `spec/fixpoints` folder and re-run all tests. Now all fixpoints should be updated.
+# Be careful though, don't just remove the fixpoints if you are not sure what is going on.
+# A change in a fixpoint might point to an unintended change in code.
+#
+# We need to be be careful to use +let+ and +let!+ with factories.
+# Records might be created twice when using create in there (once by the fixpoint and once by the factory).
+#
+# KNOWN ISSUES
+# Under certain conditions you may get `duplicate key value violates unique constraint` because the primary key sequences are not updated correctly.
+# If this happens, just add a Fixpoint.reset_pk_sequences! at the beginning of your test. We need to dig a little deeper here at some point...
+#
+# LIMITATIONS
+# The records in tables are ordered by their id.
+# If there is no id for a table, we use database's order (what the SELECT query returns).
+# This order may be instable.
+class Fixpoint
+  class Error < StandardError; end
+
+  FIXPOINT_FOLDER = 'fixpoints'
+  TABLES_TO_SKIP = %w[ar_internal_metadata delayed_jobs schema_info schema_migrations].freeze
+
+  class << self
+    def exists?(fixname)
+      File.exist?(fixpoint_path(fixname))
+    end
+
+    def from_file(fixname)
+      raise Fixpoint::Error, "The requested fixpoint (\"#{fixname}\") could not be found. Re-run the test which stores the fixpoint." unless exists?(fixname)
+
+      file_path = fixpoint_path(fixname)
+      new(YAML.load_file(file_path))
+    end
+
+    # Creates a Fixpoint from the database contents. Empty tables are skipped.
+    def from_database
+      new(read_database_records)
+    end
+
+    def remove(fixname)
+      FileUtils.rm_f(fixpoint_path(fixname))
+    end
+
+    # reset primary key sequences for all tables
+    # useful when tests sometimes run before the storing the first fixpoint.
+    # these test might have incremented the id sequence already, so the ids in the fixpoints chance (which leads to differences).
+    def reset_pk_sequences!
+      return unless conn.respond_to?(:reset_pk_sequence!)
+      conn.tables.each { |table_name| conn.reset_pk_sequence!(table_name) }
+    end
+
+    def fixpoint_path(fixname)
+      fspath = self.fixpoints_path
+      raise Fixpoint::Error, 'Can not automatically infer the base path for the specs, please set `rspec_config.fixpoints_path` explicitly' if fspath.nil?
+      raise Fixpoint::Error, "Please create the fixpoints folder (and maybe create a .gitkeep): #{fspath}" if !File.exist?(fspath)
+
+      File.join(fspath, "#{fixname}.yml")
+    end
+
+    def conn
+      ActiveRecord::Base.connection
+    end
+
+    protected
+
+    def fixpoints_path
+      return RSpec.configuration.fixpoints_path unless RSpec.configuration.fixpoints_path.nil?
+      return Rails.root.join(RSpec.configuration.default_path, FIXPOINT_FOLDER) if defined?(Rails)
+      # now this is ugly, but necessary. we go up from the current example's path until we find the spec folder...
+      return nil if RSpec.current_example.nil?
+      spec_path = Pathname.new(RSpec.current_example.file_path).ascend.find { |pn| pn.basename.to_s == RSpec.configuration.default_path }.expand_path
+
+      File.join(spec_path, FIXPOINT_FOLDER)
+    end
+
+    def read_database_records
+      # adapted from: https://yizeng.me/2017/07/16/generate-rails-test-fixtures-yaml-from-database-dump/
+      tables = conn.tables
+      tables.reject! { |table_name| TABLES_TO_SKIP.include?(table_name) }
+
+      tables.each_with_object({}) do |table_name, acc|
+        result = conn.select_all("SELECT * FROM #{table_name}")
+        next if result.count.zero?
+
+        rows = result.to_a
+        rows.sort_by! { |row| row['id'] } if result.columns.include?('id') # let's make the order of items stable
+        acc[table_name] = rows
+      end
+    end
+  end
+
+  attr_reader :records_in_tables # the complete records in the tables
+
+  def initialize(records_in_tables)
+    @records_in_tables = records_in_tables
+  end
+
+  def load_into_database
+    # Here some more pointers on implementation details of fixtures:
+    # - https://github.com/rails/rails/blob/2998672fc22f0d5e1a79a29ccb60d0d0e627a430/activerecord/lib/active_record/fixtures.rb#L612
+    # - http://api.rubyonrails.org/v5.2.4/classes/ActiveRecord/FixtureSet.html#method-c-create_fixtures
+    # - https://github.com/rails/rails/blob/67feba0c822d64741d574dfea808c1a2feedbcfc/activerecord/test/cases/fixtures_test.rb
+    #
+    # Note from the past (useful if we want to get back to using Rails' +create_fixtures+ method)
+    # we used to do: ActiveRecord::FixtureSet.create_fixtures(folder_path, filename_without_extension) # this will also clear the table
+    # but we abandoned this approach because we want to one file per fixpoint (not one file per table)
+    # ActiveRecord::FixtureSet.reset_cache # create_fixtures does use only the table name as cache key. we always invalidate the cache because we may want to read different fixpoints but with the same table names
+
+    # let's remove all data
+    conn.tables.each { |table| conn.select_all("DELETE FROM #{conn.quote_table_name(table)}") }
+
+    # actually insert
+    conn.insert_fixtures_set(@records_in_tables)
+    self.class.reset_pk_sequences!
+  end
+
+  def save_to_file(fixname)
+    file_path = self.class.fixpoint_path(fixname)
+    FileUtils.mkdir_p(File.dirname(file_path))
+    File.write(file_path, contents_for_file)
+  end
+
+  def table_names
+    @records_in_tables.keys
+  end
+
+  # Returns the records for the given +table_name+ as a list of Hashes.
+  # +ignore_columns+ array of columns to remove from each record Hash.
+  #     Aside from having the form <tt>[:created_at, :updated_at]</tt>,
+  #     it can contain attributes scoped by a table name <tt>[:created_at, :updated_at, users: [:password_hash]]</tt>
+  def records_for_table(table_name, ignore_columns = [])
+    strip_columns_from_records(@records_in_tables[table_name], table_name, ignore_columns)
+  end
+
+  protected
+
+  delegate :conn, to: :class
+
+  def contents_for_file
+    YAML.dump(@records_in_tables)
+  end
+
+  # see #records_for_table
+  def strip_columns_from_records(records, table_name, columns)
+    return nil if records.nil?
+
+    if columns.last.is_a?(Hash) # columns has the a table names at the end (e.g. [:created_at, :updated_at, users: [:password_hash]])
+      columns = columns.dup
+      all_table_scoped = columns.pop.stringify_keys
+      table_scoped = all_table_scoped[table_name]
+      columns += table_scoped if table_scoped
+    end
+    columns = columns.collect(&:to_s)
+
+    records.collect do |attributes|
+      attributes.reject { |col, _value| columns.include?(col) }
+    end
+  end
+end

data/lib/fixpoint_diff.rb

@@ -0,0 +1,58 @@
+# Helper module which implements diff-ing for fixpoints
+module FixpointDiff
+  DELETED_KEY = '++DELETED++'
+  IGNORE_ATTRIBUTES = ['updated_at']
+
+
+  def apply_changes(parent_records_in_tables, changes_in_tables)
+    tables = (parent_records_in_tables.keys + changes_in_tables.keys).uniq
+
+    tables.each_with_object({}) do |table, records|
+      records[table] = apply_records_changes(parent_records_in_tables[table], changes_in_tables[table])
+    end
+  end
+
+  def extract_changes(parent_records_in_tables, records_in_tables)
+    tables = (parent_records_in_tables.keys + records_in_tables.keys).uniq
+
+    tables.each_with_object({}) do |table, changes_in_tables|
+      changes_in_tables[table] = extract_records_changes(parent_records_in_tables[table], records_in_tables[table])
+    end
+  end
+
+  module_function :apply_changes, :extract_changes
+
+  protected
+
+  def apply_records_changes(parent_records, changes)
+    return parent_records if changes.blank?
+
+    parent_records ||= [] # the table was not part of an earlier fixpoint
+    changes.zip(parent_records).collect do |change, parent_record| # we can rely on the fact that changes has always more entries than parent_records
+      next change if parent_record.nil? # we do have a new record
+      next nil if change[DELETED_KEY]
+
+      parent_record.merge(change)
+    end.compact
+  end
+
+  def extract_records_changes(parent_records, records)
+    return records if parent_records.blank?
+    records ||= []
+
+    # we pad parent_records with nil values so we can zip them together
+    parent_records = parent_records + [nil] * (records.count - parent_records.count) if parent_records.count < records.count
+    
+    parent_records.zip(records).collect do |parent, record|
+      next { DELETED_KEY => true } if record.nil?
+      next record if parent.nil? # newly added record
+
+      parent.each_with_object({}) do |(parent_key, parent_value), changes| # we can rely on the fact that both hashes have the same attributes
+        record_value = record[parent_key]
+        changes[parent_key] = record_value unless record_value == parent_value || IGNORE_ATTRIBUTES.include?(parent_key)
+      end
+    end
+  end
+
+  module_function :apply_records_changes, :extract_records_changes
+end

data/lib/fixpoints.rb

@@ -0,0 +1,9 @@
+require_relative "fixpoints/version"
+require_relative "fixpoint_diff"
+
+require_relative "fixpoint"
+require_relative "incremental_fixpoint"
+
+if defined?(RSpec)
+  RSpec.configure { |c| c.add_setting :fixpoints_path }
+end

data/lib/fixpoints/version.rb

@@ -0,0 +1,3 @@
+module Fixpoints
+  VERSION = "0.1.0"
+end

data/lib/incremental_fixpoint.rb

@@ -0,0 +1,109 @@
+# Enhances Fixpoint to only save incremental changes.
+#
+# A fixpoint can be saved fully, where all records are saved to the file or one can give a parent fixpoint.
+# When doing so, only the difference (aka. changes) to the parent is saved in the file.
+# Yet, if a record does not change parent an empty hash is saved. This is done, so removals from the database can be tracked.
+#
+# LIMITATIONS
+# Assume you remove a record at the end of a table and then add another one.
+# Then the fixpoint diff will complain that an entry has changed instead of noticing the addition/removal.
+class IncrementalFixpoint < Fixpoint
+  PARENT_YAML_KEY = '++parent_fixpoint++'
+
+  attr_reader :changes_in_tables # only the difference to the parent (in tables)
+
+  def initialize(changes_in_tables, parent_fixname=nil)
+    @parent_fixname = parent_fixname
+    @changes_in_tables = changes_in_tables
+    if parent_fixname.nil?
+      super(changes_in_tables)
+    else
+      parent = self.class.from_file(parent_fixname)
+      super(FixpointDiff.apply_changes(parent.records_in_tables, @changes_in_tables))
+    end
+  end
+
+  def self.from_file(fixname)
+    raise Fixpoint::Error, "The requested fixpoint (\"#{fixname}\") could not be found. Re-run the test which stores the fixpoint." unless exists?(fixname)
+
+    file_path = fixpoint_path(fixname)
+    changes_in_tables = YAML.load_file(file_path)
+    parent_fixname = changes_in_tables.delete(PARENT_YAML_KEY)
+    new(changes_in_tables, parent_fixname)
+  end
+
+  # Creates a Fixpoint from the database contents. Empty tables are skipped.
+  def self.from_database(parent_fixname=nil)
+    return super() if parent_fixname.nil?
+
+    parent = from_file(parent_fixname)
+    changes_in_tables = FixpointDiff.extract_changes(parent.records_in_tables, read_database_records)
+    new(changes_in_tables, parent_fixname)
+  end
+
+  protected
+
+  def contents_for_file
+    file_contents = @changes_in_tables.dup
+    file_contents[PARENT_YAML_KEY] = @parent_fixname unless @parent_fixname.nil?
+    return YAML.dump(file_contents)
+  end
+end
+
+# Helper methods to be included into RSpec
+module FixpointTestHelpers
+  def restore_fixpoint(fixname)
+    IncrementalFixpoint.from_file(fixname).load_into_database
+  end
+
+  # Compares the fixpoint with the records in the database.
+  # If there is no such fixpoint yet, it will write a new one to the file system.
+  # The latter is useful if the fixpoint was deleted to accommodate changes to it (see example in class description).
+  #
+  # +tables_to_compare+ can either be +:all+ or a list of table names (e.g. ['users', 'posts'])
+  # +ignored_columns+ see Fixnum#records_for_table
+  # +not_exists_handler+ when given and the fixpoint does not exists, it will be called with the fixname as argument
+  # 
+  # ---
+  # If we refactor this to a gem, we should rely on rspec (e.g. use minitest or move comparison logic to Fixpoint class).
+  # Anyhow, we keep it like this for now, because the expectations give much nicer output than the minitest assertions.
+  def compare_fixpoint(fixname, ignored_columns=[:updated_at, :created_at], tables_to_compare=:all, &not_exists_handler)
+    if !IncrementalFixpoint.exists?(fixname)
+      not_exists_handler.call(fixname) if not_exists_handler
+      return
+    end
+
+    database_fp = IncrementalFixpoint.from_database
+    fixpoint_fp = IncrementalFixpoint.from_file(fixname)
+
+    tables_to_compare = (database_fp.table_names + fixpoint_fp.table_names).uniq if tables_to_compare == :all
+    tables_to_compare.each do |table_name|
+      db_records = database_fp.records_for_table(table_name, ignored_columns)
+      fp_records = fixpoint_fp.records_for_table(table_name, ignored_columns)
+
+      # if a table is present in a fixpoint, there must be records in it because empty tables are stripped from fixpoints
+      expect(db_records).not_to be_empty, "#{table_name} not in database, but in fixpoint"
+      expect(fp_records).not_to be_empty, "#{table_name} not in fixpoint, but in database"
+      # we assume that the order of records returned by SELECT is stable (so we do not do any sorting)
+      expect(db_records).to eq(fp_records), "Database records for table \"#{table_name}\" did not match fixpoint \"#{fixname}\". Consider removing the fixpoint and re-running the test if the change is intended."
+    end
+  end
+
+  def store_fixpoint_and_fail(fixname, parent_fixname = nil)
+    store_fixpoint(fixname, parent_fixname)
+    pending("Fixpoint \"#{fixname}\" did not exist yet. Skipping comparison, but created fixpoint from database")
+    fail
+  end
+
+  # it is not a good idea to overwrite the fixpoint each time because timestamps may change (which then shows up in version control).
+  # Hence we only provide a method to write to it if it does not exist.
+  def store_fixpoint_unless_present(fixname, parent_fixname = nil)
+    store_fixpoint(fixname, parent_fixname) unless IncrementalFixpoint.exists?(fixname)
+  end
+
+  # +parent_fixname+ when given, only the (incremental) changes to the parent are saved
+  # please see store_fixpoint_unless_present for note on why not to use this method
+  def store_fixpoint(fixname, parent_fixname = nil)
+    IncrementalFixpoint.from_database(parent_fixname).save_to_file(fixname)
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: fixpoints
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Rothe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-09-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fixpoints enables saving, restoring and comparing the database state
+  before & after tests
+email:
+- info@tomrothe.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- fixpoints.gemspec
+- lib/fixpoint.rb
+- lib/fixpoint_diff.rb
+- lib/fixpoints.rb
+- lib/fixpoints/version.rb
+- lib/incremental_fixpoint.rb
+homepage: https://github.com/motine/fixpoints
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/motine/fixpoints
+  source_code_uri: https://github.com/motine/fixpoints
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Don't discard the database state at the end of your test. Use it!
+test_files: []