gamera-sequel-fixture 2.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ad175fb0feeef3d7e4fa04a58ffaee472d3bb50
+  data.tar.gz: 5bb282e8f9f34cef02086c064a5978c7b2bcc443
+SHA512:
+  metadata.gz: 0c8f74bb95113cc35b25440eb5780c421fc18d2891bef2b9658a63552c988a4b43ba178764a2ff8db306497ea116d2d5834b03e9aed91ded64a8d55f0fc6d053
+  data.tar.gz: d574389e41b423fc029cc74f1d74a9923b0809d8897d85ff0606c57fd65fae37c152336fca6baa8ff84a3c7e3dfa40e1f8307ecb981cfd319ae70753e862a2d4

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+Gemfile.lock
+.bundle
+.config
+coverage
+vendor/
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+.bin/
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sequel-fixture.gemspec
+gemspec
+
+group :test do
+  gem "rspec", ">=3.2"
+  gem "byebug"
+  gem "sqlite3"
+  gem "rake"
+end
+

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright (C) 2012 Fetcher
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README.md

@@ -0,0 +1,133 @@
+_This is a (hopefully temporary) fork of https://github.com/whitepages/sequel-fixture which incorporates some changes from @diminish7 that we need for https://github.com/gamera-team/gamera_
+
+Sequel::Fixture
+===============
+
+Just like Rails fixtures, but for Sequel.
+
+This  version includes support for defining the fixture schemas
+and uses sqlite3 adapter to inject data into memory.
+
+Usage
+=====
+Each fixture file defines the schema and data for a single table which
+is named after the file name.
+
+Schema definition is optional, but note that db inserts will fail if the tables do
+not exist.
+
+Assuming you have a fixture for the table users with:
+```yaml
+# fixtures/simple/users.yaml
+schema:
+  - name: name
+    type: string
+    primary_key: true
+  - name: last_name
+    type: string
+  - name: empty
+    type: string
+data:
+  - name: John
+    last_name: Doe
+    email: john@doe.com
+  - name: Jane
+    last_name: Doe
+    email: jane@doe.com
+```
+
+and for messages:
+```yaml
+# fixtures/simple/messages.yaml
+schema:
+  - name: sender_id
+    type: integer
+    primary_key: true
+  - name: receiver_id
+    type: integer
+  - name: text
+    type: string
+data:
+  - sender_id: 1
+    receiver_id: 2
+    text: Hi Jane! Long time no see.
+  - sender_id: 2
+    receiver_id: 1
+    text: John! Long time indeed. How are you doing?
+```
+
+and the ruby script
+
+```ruby
+# script.rb
+require "sequel-fixture"
+
+DB = Sequel.sqlite # Just a simple example, needs sqlite3 gem
+
+## Set the path of the fixture yaml files to be [script.rb]/fixtures/
+Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+
+fixture = Sequel::Fixture.new :simple, DB # Will load all the data in the fixture into the database
+
+fixture.users               # == fixture[:users]
+fixture.users[0].name     # => "John"
+                            # The YAML files are parsed into a SymbolMatrix
+                            # http://github.com/Fetcher/symbolmatrix
+                            # Each table contains an array of Rows.
+                            # Within each row the columns can be accessed by name (.name)
+
+fixture.rollback            # returns users and messages to pristine status ('TRUNCATE')
+
+
+fixture = Sequel::Fixture.new :simple, DB, false    # The `false` flag prevent the constructor to automatically push
+                                                    # the fixture into the database
+
+fixture.check               # Will fail if the user or messages table
+                            # were already occupied with something
+
+fixture.push                # Inserts the fixture in the database
+
+fixture.rollback            # Don't forget to rollback
+
+```
+
+...naturally, `sequel-fixture` makes a lot more sense within some testing framework.
+
+
+Contributing
+------------
+
+```
+bundle install --binstubs .bin --path vendor/bundle
+```
+
+Installation
+------------
+
+    gem install sequel-fixture
+
+### Or using Bundler
+
+    gem 'sequel-fixture'
+
+And then execute:
+
+    bundle
+
+
+## License
+
+Copyright (C) 2012 Whitepages
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+t.pattern = "./spec/**/*_spec.rb"
+end
+
+task :default => :spec

data/lib/sequel-fixture.rb

@@ -0,0 +1,194 @@
+require "sequel"
+require "symbolmatrix"
+require "fast"
+
+require "sequel-fixture/version"
+require "sequel-fixture/exceptions"
+require "sequel-fixture/util"
+require "sequel-fixture/table"
+
+module Sequel; end
+
+class Sequel::Fixture
+
+  # === Description
+  # Returns the current path to the fixtures folder
+  #
+  def self.path
+    @@path ||= "test/fixtures"
+  end
+
+
+  # === Description
+  # Set the current path of the fixtures folder
+  #
+  def self.path=(path)
+    @@path = path
+  end
+
+  # === Description
+  # Initializes the fixture handler
+  # Accepts optionally a symbol as a reference to the fixture
+  # and a Sequel::Database connection
+  def initialize(fixture = nil, connection = nil, option_push = true)
+    @schema = {}
+    @data = {}
+
+    load(fixture) if fixture
+
+    @connection = connection if connection
+    push if fixture && connection && option_push
+  end
+
+
+  # === Description
+  # Loads the fixture files into this instance
+  #
+  def load(fixture)
+    raise LoadingFixtureIllegal, "A check has already been made, loading a different fixture is illegal" if @checked
+
+    Fast.dir("#{fixtures_path}/#{fixture}").files.each do |file|
+      key = file.split('.').first.to_sym
+      @data ||= {}
+      @schema ||= {}
+
+      file_data = SymbolMatrix.new "#{fixtures_path}/#{fixture}/#{file}"
+
+      if file_data
+        @data[key] = Table.new(file_data[:data]) if file_data.key?(:data)
+        @schema[key] = file_data[:schema] if file_data.key?(:schema)
+      end
+    end
+  end
+
+  # === Description
+  # Returns the current fixtures path where Sequel::Fixture looks for fixture folders
+  #
+  def fixtures_path
+    Sequel::Fixture.path
+  end
+
+
+  # === Description
+  # For enabling discovery of tables
+  #
+  def method_missing(key, *args)
+    return @data[key] if @data && @data.has_key?(key)
+    return super
+  end
+
+  # === Description
+  # Returns the SymbolMatrix with the data referring to that table
+  #
+  def [](reference)
+    @data[reference]
+  end
+
+
+  # === Description
+  # Forces the check to pass. Dangerous!
+  #
+  def force_checked!
+    @checked = true
+  end
+
+
+  # === Description
+  # Assures that the tables are empty before proceeding
+  #
+  def check
+    return @checked if @checked # If already checked, it's alright
+
+    raise MissingFixtureError, "No fixture has been loaded, nothing to check" unless @data.length > 0
+    raise MissingConnectionError, "No connection has been provided, impossible to check" unless @connection
+
+    return @checked = true
+  end
+
+
+  # === Description
+  # Initializes fixture schema and Inserts the fixture data into the corresponding
+  # tables
+  #
+  def push
+    check
+
+    @schema.each do |table, matrix|
+      push_schema(table, matrix)
+    end
+
+    @data.each do |table_name, table_data|
+      table_data.rows.each do |values|
+        begin
+          @connection[table_name].insert(simplify(values.to_h))
+        rescue MissingProcessedValueError => m
+          rollback
+          raise MissingProcessedValueError, "In record '#{values.to_h}' to be inserted into '#{table_name}', the processed value of field '#{m.field}' is missing, aborting."
+        rescue NoMethodError => e
+          raise IllegalFixtureFormat, "In record '#{values}', data must be formatted as arrays of hashes. Check 'data' section in '#{table_name}.yaml'"
+        rescue Sequel::DatabaseError => sde
+          raise Sequel::Fixture::DatabaseError, "DB table: #{table_name}, #{sde.message}"
+        end
+      end
+    end
+  end
+
+
+  # === Description
+  # Create the schema in our DB connection based on the schema values
+  #
+  def push_schema(table, values)
+    ## Lets passively ignore the schema if the table already exists
+    return if @connection.table_exists?(table.to_sym)
+
+    ## Find the primary key
+    pkey_data = nil
+    values.each do |column_def|
+      pkey_data = column_def if column_def["primary_key"]
+    end
+
+    ## Create the table with the primary key
+    @connection.create_table(table) do
+      column(pkey_data["name"].to_sym, pkey_data["type"].to_sym)
+    end
+
+    ## Add the rest of the columns
+    values.each do |column_def|
+      unless column_def["primary_key"]
+        @connection.alter_table(table) { add_column(column_def["name"].to_sym, column_def["type"].to_sym) }
+      end
+    end
+  end
+
+
+  # === Description
+  # Empties the tables, only if they were empty to begin with
+  #
+  def rollback
+    begin
+      check
+
+      @data.each_key do |table|
+        @connection[table].truncate
+      end
+    rescue TablesNotEmptyError => e
+      raise RollbackIllegalError, "The tables weren't empty to begin with, rollback aborted."
+    end
+  end
+
+
+  # === Description
+  # Sets the connection. Raises an ChangingConnectionIllegal exception if this fixture has
+  # already been checked
+  #
+  def connection=(the_connection)
+    if @checked
+      raise ChangingConnectionIllegal, "Illegal to change connection after check has already been performed"
+    end
+    @connection = the_connection
+  end
+
+  attr_reader :connection
+  attr_reader :data
+  attr_reader :schema
+end

data/lib/sequel-fixture/exceptions.rb

@@ -0,0 +1,18 @@
+class Sequel::Fixture
+  class IllegalFixtureFormat < StandardError; end
+  class TablesNotEmptyError < StandardError; end
+  class RollbackIllegalError < StandardError; end
+  class MissingFixtureError < StandardError; end
+  class MissingConnectionError < StandardError; end
+  class LoadingFixtureIllegal < StandardError; end
+  class ChangingConnectionIllegal < StandardError; end
+  class DatabaseError < StandardError; end
+
+  class MissingProcessedValueError < StandardError
+    attr_accessor :field
+    def initialize message, field = nil
+      @field = field
+      super message
+    end
+  end
+end

data/lib/sequel-fixture/table.rb

@@ -0,0 +1,40 @@
+module Sequel; end
+
+class Sequel::Fixture
+  
+  # === Description
+  # Class which represents the actual fixture data in a table
+  #
+  class Table
+    def initialize(data)
+      @data = data
+    end
+
+    def [](row)
+      Sequel::Fixture::Row.new(@data[row])
+    end
+    
+    def rows
+      @data
+    end
+  end
+
+  
+  # === Description
+  # Class which represents a single row in a fixture table.
+  #
+  class Row
+    def initialize(row)
+      @data = row
+    end
+    
+    # === Description
+    # Method missing, for enabling discovery of columns within a row
+    #
+    def method_missing(s, *args)
+      key = s.to_s
+      return @data[key] if @data && @data.has_key?(key)
+      return super
+    end    
+  end
+end

data/lib/sequel-fixture/util.rb

@@ -0,0 +1,22 @@
+class Sequel::Fixture
+  
+  # === Description
+  # Simplifies the hash in order to insert it into the database
+  # (Note: I'm well aware that this functionality belongs in a dependency)
+  #
+  def simplify(the_hash)    
+    the_returned_hash = {}
+    
+    the_hash.each do |key, value|
+      if value.is_a? Hash
+        unless value.has_key?("processed") || value.has_key?(:processed)
+          raise MissingProcessedValueError.new "The processed value to insert into the db is missing from the field '#{key}', aborting", key 
+        end
+        the_returned_hash[key] = value["processed"] || value[:processed]
+      else
+        the_returned_hash[key] = value
+      end
+    end
+    return the_returned_hash
+  end  
+end

data/lib/sequel-fixture/version.rb

@@ -0,0 +1,5 @@
+module Sequel
+  class Fixture
+    VERSION = "2.0.3"
+  end
+end

data/sequel-fixture.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sequel-fixture/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'gamera-sequel-fixture'
+  gem.authors       = ['Eric Dobbs', 'Glen Aultman-Bettridge', 'Jillian Rosile']
+  gem.email         = ['eric@dobbse.net', 'glenab@koansolutions.net', 'jillian.rosile@gmail.com']
+  gem.description   = %q{Flexible fixtures for the Sequel Gem inspired in Rails 2 fixtures}
+  gem.summary       = %q{Flexible fixtures for the Sequel Gem inspired in Rails 2 fixtures. Temporary fork of https://github.com/whitepages/sequel-fixture to add ERB support}
+  gem.homepage      = "http://github.com/gamera-team/sequel-fixture"
+
+  gem.add_dependency "sequel"         # Stating the obvious
+  gem.add_dependency "gamera-symbolmatrix"   # Because its easy to use
+  gem.add_dependency "fast"           # Fast was needed. This is a testing gem, there's no problem with extra load
+
+  gem.add_development_dependency "rspec"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.version       = Sequel::Fixture::VERSION
+end

data/spec/sequel/fixture_spec.rb

@@ -0,0 +1,462 @@
+require "sequel-fixture"
+require "fast"
+require "sequel/exceptions"
+
+describe Sequel::Fixture do
+  describe ".path" do
+    it "returns 'test/fixtures'" do
+      expect(Sequel::Fixture.path).to eq "test/fixtures"
+    end
+
+    it "is configurable" do
+      Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+      expect(Sequel::Fixture.path).to eq File.join(File.dirname(__FILE__), "fixtures")
+    end
+  end
+
+  describe ".new" do
+    context "return a DatabaseError" do
+      it "calls load_fixture" do
+        expect_any_instance_of(Sequel::Fixture).to receive(:simplify).and_raise(Sequel::DatabaseError.new(StandardError.new("created_at: cannot be null")))
+
+        table    = double
+        database = double :[] => @table
+        Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+        expect {
+          Sequel::Fixture.new(:test, database, true)
+        }.to raise_error Sequel::Fixture::DatabaseError,
+          "DB table: actions, created_at: cannot be null"
+      end
+    end
+
+    context "a symbol is sent representing a fixture" do
+      it "calls load_fixture" do
+        expect_any_instance_of(Sequel::Fixture).to receive(:load).with :test
+        Sequel::Fixture.new :test
+      end
+    end
+
+    context "a database connection is passed" do
+      it "calls push" do
+        allow(Sequel).to receive(:connect).and_return Sequel::Database.new
+        allow_any_instance_of(Sequel::Fixture).to receive :load
+        expect_any_instance_of(Sequel::Fixture).to receive :push
+        Sequel::Fixture.new :test, Sequel.connect
+      end
+    end
+
+    context "a database is provided but no fixture" do
+      it "does not call push" do
+        database = double 'database'
+        expect_any_instance_of(Sequel::Fixture).to_not receive :push
+        Sequel::Fixture.new nil, database
+      end
+    end
+
+    context "a database connection and a valid fixture are passed but a false flag is passed at the end" do
+      it "does not push" do
+        database = double 'database'
+        allow_any_instance_of(Sequel::Fixture).to receive :load
+        expect_any_instance_of(Sequel::Fixture).to_not receive :push
+        Sequel::Fixture.new :test, database, false
+      end
+    end
+  end
+
+  describe "#load" do
+    context "there is a valid fixture folder setup" do
+      shared_examples_for "valid fixture folder setup" do
+
+        around do |example|
+          Sequel::Fixture.path = "test/fixtures"
+          Fast.file! file1
+          Fast.file! file2
+
+          example.run
+
+          Fast.dir.remove! :test
+        end
+
+        it "loads the fixture YAML files using SymbolMatrix (third-party)" do
+          fix = Sequel::Fixture.new
+          allow(fix).to receive :check
+          expect(SymbolMatrix).to receive(:new).with file1
+          expect(SymbolMatrix).to receive(:new).with file2
+          fix.load :test
+        end
+      end
+
+      context "with files having a .yaml extension" do
+        let(:file1) { "test/fixtures/test/users.yaml" }
+        let(:file2) { "test/fixtures/test/actions.yaml" }
+
+        it_behaves_like "valid fixture folder setup"
+      end
+
+      context "with files having a .yml extension" do
+        let(:file1) { "test/fixtures/test/users.yml" }
+        let(:file2) { "test/fixtures/test/actions.yml" }
+
+        it_behaves_like "valid fixture folder setup"
+      end
+
+      context "with files having a .erb extension" do
+        let(:file1) { "test/fixtures/test/users.yml.erb" }
+        let(:file2) { "test/fixtures/test/actions.yml.erb" }
+
+        it_behaves_like "valid fixture folder setup"
+      end
+    end
+
+    context "the check has been performed and I attempt to load another fixture" do
+      before do
+        Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+      end
+
+      it "fails" do
+        allow_any_instance_of(Sequel::Fixture).to receive :push
+        database = double 'database'
+        allow(database).to receive(:[]).and_return double(:count => 0 )
+        fix = Sequel::Fixture.new :test, database
+        fix.check
+        expect { fix.load :another
+        }.to raise_error Sequel::Fixture::LoadingFixtureIllegal,
+          "A check has already been made, loading a different fixture is illegal"
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+  end
+
+  describe "#force_checked!" do
+    it "check returns true and does not call [] in the passed database" do
+      database = double 'database'
+      expect(database).to_not receive :[]
+
+      allow_any_instance_of(Sequel::Fixture).to receive :load
+      fix = Sequel::Fixture.new :anything, database, false
+      expect(fix.force_checked!).to eq true
+      expect(fix.check).to be_truthy
+    end
+  end
+
+  describe "#[]" do
+    context "a valid fixture has been loaded" do
+      before do
+        Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+
+        @fix = Sequel::Fixture.new
+        allow(@fix).to receive :check
+        @fix.load :test
+      end
+
+      context "a table key is passed" do
+        it "returns the Fixture::Table containing the same info as in the matching YAML file" do
+          expect(@fix[:users]).to be_a Sequel::Fixture::Table
+          expect(@fix[:users][0].name).to eq "John Doe"
+          expect(@fix[:users][0].last_name).to eq "Wayne"
+          expect(@fix[:actions][0].action).to eq "Walks"
+        end
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+  end
+
+  describe "#method_missing" do
+    context "a valid fixture has been loaded" do
+      context "a table key is passed" do
+        before do
+          Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+          @fix = Sequel::Fixture.new
+          allow(@fix).to receive :check
+          @fix.load :test
+        end
+
+        it "returns the SymbolMatrix containing the same info as in the matching YAML file" do
+          expect(@fix.users).to be_a Sequel::Fixture::Table
+          expect(@fix.users[0].name).to eq "John Doe"
+          expect(@fix.users[0].last_name).to eq "Wayne"
+          expect(@fix.actions[0].action).to eq "Walks"
+        end
+
+        after do
+          Fast.dir.remove! :test
+        end
+      end
+    end
+
+    it "raises no method error if matches nothing" do
+      expect { Sequel::Fixture.new.nothing = "hola"
+      }.to raise_error NoMethodError
+    end
+  end
+
+  describe "#fixtures_path" do
+    it "calls Sequel::Fixture.path" do
+      expect(Sequel::Fixture).to receive :path
+      Sequel::Fixture.new.fixtures_path
+    end
+  end
+
+  describe "#check" do
+
+    context "the check has been done and it passed before" do
+      it "returns true even if now tables don't pass" do
+        allow_any_instance_of(Sequel::Fixture).to receive :push
+
+        @counter = double 'counter'
+        allow(@counter).to receive :count do
+          @amount ||= 0
+          @amount += 1
+          0 unless @amount > 5
+        end
+
+        @database = double 'database'
+        allow(@database).to receive(:[]).and_return @counter
+
+        @fix = Sequel::Fixture.new nil, @database
+        def @fix.stub_data
+          @data = { :users => nil, :tables => nil, :actions => nil, :schemas => nil }
+        end
+        @fix.stub_data
+        expect(@fix.check).to be_truthy
+        expect(@fix.check).to be_truthy # This looks confusing: let's explain. The #count method as defined for the mock
+                                        # runs 4 times in the first check. In the second check, it runs 4 times again.
+                                        # After time 6 it returns a large amount, making the check fail.
+                                        # Of course, the fourth time is never reached since the second check is skipped
+      end
+    end
+
+    context "no fixture has been loaded" do
+      it "fails with a missing fixture exception" do
+        fix = Sequel::Fixture.new
+        expect { fix.check
+        }.to raise_error Sequel::Fixture::MissingFixtureError,
+          "No fixture has been loaded, nothing to check"
+      end
+    end
+
+    context "a valid fixture has been loaded but no connection has been provided" do
+      before do
+        Fast.file.write "test/fixtures/test/users.yaml", "jane { name: Jane Doe }"
+      end
+      it "fails with a missing database connection exception" do
+        fix = Sequel::Fixture.new :test
+        expect { fix.check
+        }.to raise_error Sequel::Fixture::MissingConnectionError,
+          "No connection has been provided, impossible to check"
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+
+    context "a database is provided but no fixture" do
+      it "fails with a missing fixture exception" do
+        database = double 'database'
+        fix = Sequel::Fixture.new nil, database
+        expect {fix.check
+        }.to raise_error Sequel::Fixture::MissingFixtureError,
+          "No fixture has been loaded, nothing to check"
+      end
+    end
+  end
+
+  describe "#connection" do
+    it "returns the Sequel connection passed as argument to the constructor" do
+      allow_any_instance_of(Sequel::Fixture).to receive :push
+      connection = double
+      fix = Sequel::Fixture.new nil, connection
+      expect(fix.connection).to eq connection
+    end
+  end
+
+  describe "#connection=" do
+    it "sets the connection" do
+      fix = Sequel::Fixture.new
+      connection = double
+      fix.connection = connection
+      expect(fix.connection).to eq connection
+    end
+
+    context "a check has been performed and I attempt to change the connection" do
+      before do
+        Fast.file.write "test/fixtures/test/users.yaml", "jane { name: Secret }"
+      end
+
+      it "fails" do
+        database = double 'database'
+        allow(database).to receive(:[]).and_return double(:count => 0)
+        allow_any_instance_of(Sequel::Fixture).to receive :push
+        fix = Sequel::Fixture.new :test, database
+        fix.check
+        expect { fix.connection = double 'database'
+        }.to raise_error Sequel::Fixture::ChangingConnectionIllegal,
+          "Illegal to change connection after check has already been performed"
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+  end
+
+  describe "#data" do
+    context "a fixture has been loaded" do
+      before do
+        Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+      end
+
+      it "returns the fixture data" do
+        fix = Sequel::Fixture.new :test
+        expect(fix.data).to have_key :users
+        expect(fix.data[:users]).to be_a Sequel::Fixture::Table
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+
+    context "no fixture has been loaded" do
+      it "returns nil" do
+        fix = Sequel::Fixture.new
+        expect(fix.data).to be {}
+      end
+    end
+  end
+
+  describe "#push" do
+    it "calls #check" do
+      fix = Sequel::Fixture.new
+      def fix.stub_data
+        @data = {}
+      end
+      fix.stub_data
+      expect(fix).to receive :check
+      fix.push
+    end
+
+    context "a valid fixture and a database connection are provided" do
+      before do
+        Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+
+        @table    = double
+        @database = double :[] => @table
+        @fix = Sequel::Fixture.new
+        @fix.load :test
+        @fix.connection = @database
+      end
+
+      it "attempts to insert the data into the database" do
+        allow(@table).to receive(:count).and_return(0)
+        expect(@table).to receive(:insert).with "name" => "John Doe", "last_name" => "Wayne"
+        expect(@table).to receive(:insert).with "user_id" => 1, "action" => "Walks"
+        @fix.push
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+
+    context "a fixture with a field with a <raw> and a <processed> alternative" do
+      before do
+        Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+      end
+
+      it "inserts the <processed> alternative" do
+        database = double 'database'
+        insertable = double 'table'
+        allow(insertable).to receive(:count).and_return(0)
+        expect(insertable).to receive(:insert).with "password" => '35ferwt352'
+        allow(database).to receive(:[]).and_return insertable
+
+        fix = Sequel::Fixture.new :processed, database, false
+
+        fix.push
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+
+    context "a fixture with a field with alternatives yet missing the <processed> one" do
+      before do
+        Sequel::Fixture.path = File.join(File.dirname(__FILE__), "fixtures")
+      end
+
+      it "fails" do
+        database = double 'database', :[] => double( 'table', :count => 0, :truncate => nil  )
+        fix = Sequel::Fixture.new :invalid, database, false
+
+        expect { fix.push }.to raise_error Sequel::Fixture::MissingProcessedValueError
+      end
+
+
+      it "calls the rollback" do
+        database = double 'database', :[] => double( 'table', :count => 0, :truncate => nil )
+        fix = Sequel::Fixture.new :invalid, database, false
+        expect(fix).to receive :rollback
+        expect { fix.push }.to raise_error Sequel::Fixture::MissingProcessedValueError
+      end
+
+      after do
+        Fast.dir.remove! :test
+      end
+    end
+  end
+
+
+  describe "#rollback" do
+    it "checks" do
+      fix = Sequel::Fixture.new
+      def fix.stub_data
+        @data = {}
+      end
+      fix.stub_data
+      expect(fix).to receive :check
+      fix.rollback
+    end
+
+    context "the check is failing" do
+      it "raises a custom error for the rollback" do
+        fix = Sequel::Fixture.new
+        allow(fix).to receive(:check).and_raise Sequel::Fixture::TablesNotEmptyError
+        expect { fix.rollback
+        }.to raise_error Sequel::Fixture::RollbackIllegalError,
+          "The tables weren't empty to begin with, rollback aborted."
+      end
+    end
+
+    context "a check has been done and is passing" do
+      before do
+        @database = double
+        @truncable = double
+        allow(@truncable).to receive(:count).and_return(0)
+        allow(@database).to receive(:[]).and_return @truncable
+
+        @fix = Sequel::Fixture.new
+        @fix.connection = @database
+        def @fix.stub_data
+          @data = { :users => nil, :actions => nil, :extras => nil }
+        end
+        @fix.stub_data
+
+        expect(@fix.check).to be_truthy
+      end
+
+      it "calls truncate on each of the used tables" do
+        expect(@truncable).to receive(:truncate).exactly(3).times
+        @fix.rollback
+      end
+    end
+  end
+end

data/spec/sequel/fixtures/another/users.yaml

@@ -0,0 +1,2 @@
+data:
+  - name: John Doe

data/spec/sequel/fixtures/invalid/users.yaml

@@ -0,0 +1,4 @@
+data:
+  - name: Hey
+    pass:
+      raw: secret

data/spec/sequel/fixtures/processed/users.yaml

@@ -0,0 +1,4 @@
+data:
+  - password:
+      raw: secret
+      processed: 35ferwt352 

data/spec/sequel/fixtures/test/actions.yaml

@@ -0,0 +1,4 @@
+data:
+  - user_id: 1
+    action: Walks
+  

data/spec/sequel/fixtures/test/users.yaml

@@ -0,0 +1,3 @@
+data:
+  - name: John Doe
+    last_name: Wayne

data/spec/sequel/util_spec.rb

@@ -0,0 +1,54 @@
+require "sequel-fixture"
+require "fast"
+
+describe Sequel::Fixture do
+  # This should go in a dependency, pending refactoring TODO
+  describe "#simplify" do
+    context "when receiving a multidimensional hash containing a field with raw and processed" do
+      it "converts it in a simple hash using the processed value as replacement" do
+        base_hash = {
+          :name => "Jane",
+          :band => "Witherspoons",
+          :pass => {
+            :raw => "secret",
+            :processed => "53oih7fhjdgj3f8="
+          },
+          :email => {
+            :raw => "Jane@gmail.com ",
+            :processed => "jane@gmail.com"
+          }
+        }
+
+        fix = Sequel::Fixture.new
+        simplified = fix.simplify(base_hash)
+        expect(simplified).to eq({
+          :name => "Jane",
+          :band => "Witherspoons",
+          :pass => "53oih7fhjdgj3f8=",
+          :email => "jane@gmail.com"
+        })
+      end
+    end
+
+    context "the multidimensional array is missing the processed part of the field" do
+      it "raises an exception" do
+        base_hash = {
+          :name => "Jane",
+          :pass => {
+            :raw => "secret",
+            :not_processed => "53oih7fhjdgj3f8="
+          },
+          :email => {
+            :raw => "Jane@gmail.com ",
+            :processed => "jane@gmail.com"
+          }
+        }
+
+        fix = Sequel::Fixture.new
+        expect { fix.simplify(base_hash)
+        }.to raise_error Sequel::Fixture::MissingProcessedValueError,
+          "The processed value to insert into the db is missing from the field 'pass', aborting"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: gamera-sequel-fixture
+version: !ruby/object:Gem::Version
+  version: 2.0.3
+platform: ruby
+authors:
+- Eric Dobbs
+- Glen Aultman-Bettridge
+- Jillian Rosile
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  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'
+- !ruby/object:Gem::Dependency
+  name: gamera-symbolmatrix
+  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'
+- !ruby/object:Gem::Dependency
+  name: fast
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Flexible fixtures for the Sequel Gem inspired in Rails 2 fixtures
+email:
+- eric@dobbse.net
+- glenab@koansolutions.net
+- jillian.rosile@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/sequel-fixture.rb
+- lib/sequel-fixture/exceptions.rb
+- lib/sequel-fixture/table.rb
+- lib/sequel-fixture/util.rb
+- lib/sequel-fixture/version.rb
+- sequel-fixture.gemspec
+- spec/sequel/fixture_spec.rb
+- spec/sequel/fixtures/another/users.yaml
+- spec/sequel/fixtures/invalid/users.yaml
+- spec/sequel/fixtures/processed/users.yaml
+- spec/sequel/fixtures/test/actions.yaml
+- spec/sequel/fixtures/test/users.yaml
+- spec/sequel/util_spec.rb
+homepage: http://github.com/gamera-team/sequel-fixture
+licenses: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Flexible fixtures for the Sequel Gem inspired in Rails 2 fixtures. Temporary
+  fork of https://github.com/whitepages/sequel-fixture to add ERB support
+test_files:
+- spec/sequel/fixture_spec.rb
+- spec/sequel/fixtures/another/users.yaml
+- spec/sequel/fixtures/invalid/users.yaml
+- spec/sequel/fixtures/processed/users.yaml
+- spec/sequel/fixtures/test/actions.yaml
+- spec/sequel/fixtures/test/users.yaml
+- spec/sequel/util_spec.rb
+has_rdoc: