sequel-seed 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5a1af2b07c026c54b028ea8b4153e4523a44faa
-  data.tar.gz: 1e1a6ed02f2cf6b09f9f7e30c54e8eb36e2004e3
+  metadata.gz: da09d9ce979c91b83d60523a679e5f284d47bead
+  data.tar.gz: 9cfc115fbe4e8cddc8a63cc07a8314201a391e80
 SHA512:
-  metadata.gz: 5c10ccb47562c8bb4b6436a81220ebb9f8f88d6abca4388e6c6aa2350eb6f86a83feb97e20c7272817ca43479abf6c1086a7c2db476b8c02487ba5ccce85dcca
-  data.tar.gz: ba11dee2ccb4b7ccb28b05a0e79897462764e5701a33adc7430e886fe9f664992ae7c6c031034d40fbea2cba9f1f8def3d11159fb4ad462190889e01ae46b62f
+  metadata.gz: 57c5c5e645c3407808d4b77d17877aa31940e21152370978583852d653385be8df9a6e248b29a20a2711e5851623c0cd33038a143c5b2ae1fc8092327abce23d
+  data.tar.gz: 671cf4fd7f61cb15aeb3588ed461b8f39ab5ebbb785ac0ba4569712b96df3d203c88fd24da4dae67ab39dafcc4717de8b48f0703187549e0f4a53156b1b08086

data/CHANGELOG

@@ -1,5 +1,9 @@
 ## Changelog
 
+### 0.3.0
+- Add support for YAML files
+- Minor hotfixes
+
 ### 0.2.1
 - API changes to protect Sequel's namespace
 - `Sequel::Seed.environment = :env` is also `Sequel::Seed.setup(:env)`

data/README.md

@@ -4,7 +4,7 @@
 
 ## Usage
 
-Create a seed file (eg. `/path/to/seeds/20150928071637_currencies.rb`)
+Create a seed file (eg. `/path/to/seeds/20150928000000_initial_seed.rb`)
 
 ```rb
 Sequel.seed(:development, :test) do # Applies only to "development" and "test" environments
@@ -45,11 +45,12 @@ For more information, please check the [project website](//github.com/earaujoass
 
 ## Limitations
 
-Only timestamped seeds files
+- JSON and YAML files don't work with associations
+- Only timestamped seed/fixture files
 
 ## What's next?
 
-JSON & YAML files as fixtures/seeds
+Work with Model's associations inside JSON & YAML files
 
 ## Support
 

data/lib/sequel/extensions/seed.rb

@@ -1,3 +1,6 @@
+require 'yaml'
+require 'json'
+
 ##
 # Extension based upon Sequel::Migration and Sequel::Migrator
 #
@@ -52,6 +55,9 @@ module Sequel
   end
 
   module Seed
+    class Error < Sequel::Error
+    end
+
     class << self
       attr_reader :environment
 
@@ -84,6 +90,76 @@ module Sequel
       end
     end
 
+    ##
+    # Helper methods for the Sequel::Seed project.
+
+    module Helpers
+      class << self
+        def camelize(term, uppercase_first_letter = true)
+          string = term.to_s
+          if uppercase_first_letter
+            string.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+          else
+            string.first + camelize(string)[1..-1]
+          end
+        end
+      end
+    end
+
+    module SeedDescriptor
+      def apply_seed_descriptor(seed_descriptor)
+        case seed_descriptor
+        when Hash
+          apply_seed_hash(seed_descriptor)
+        when Array
+          seed_descriptor.each {|seed_hash| apply_seed_hash(seed_hash)}
+        end
+      end
+
+      private
+
+      def apply_seed_hash(seed_hash)
+        return unless seed_hash.class <= Hash
+        if seed_hash.has_key?('environment')
+          case seed_hash['environment']
+          when String, Symbol
+            return if seed_hash['environment'].to_sym != Seed.environment
+          when Array
+            return unless seed_hash_environment.map(&:to_sym).include?(Seed.environment)
+          end
+        end
+
+        keys = seed_hash.keys
+        keys.delete('environment')
+        keys.each do |key|
+          key_hash = seed_hash[key]
+          entries = nil
+          class_name = if key_hash.has_key?('class')
+            entries = key_hash['entries']
+            key_hash['class']
+          else
+            Helpers.camelize(key)
+          end
+          # It will raise an error if the class name is not defined
+          class_const = Kernel.const_get(class_name)
+          if entries
+            entries.each {|hash| create_model(class_const, hash)}
+          else
+            create_model(class_const, key_hash)
+          end
+        end
+      end
+
+      def create_model(class_const, hash)
+        object_instance = class_const.new
+        object_instance_attr = hash.each do |attr, value|
+          object_instance.set({attr.to_sym => value})
+        end
+        raise(Error, "Attempt to create invalid model instance of #{class_name}") unless object_instance.valid?
+        object_instance.save
+      end
+    end
+
     class Base
       class << self
         def apply
@@ -117,15 +193,14 @@ module Sequel
   end
 
   class Seeder
-    SEED_FILE_PATTERN = /\A(\d+)_.+\.(rb|json|yml)\z/i.freeze
+    SEED_FILE_PATTERN = /\A(\d+)_.+\.(rb|json|yml|yaml)\z/i.freeze
+    RUBY_SEED_FILE_PATTERN = /\A(\d+)_.+\.(rb)\z/i.freeze
+    YAML_SEED_FILE_PATTERN = /\A(\d+)_.+\.(yml|yaml)\z/i.freeze
+    JSON_SEED_FILE_PATTERN = /\A(\d+)_.+\.(json)\z/i.freeze
     SEED_SPLITTER = '_'.freeze
     MINIMUM_TIMESTAMP = 20000101
 
-    class Error < Sequel::Error
-    end
-
-    class NotCurrentError < Error
-    end
+    Error = Seed::Error
 
     def self.apply(db, directory, opts = {})
       seeder_class(directory).new(db, directory, opts).run
@@ -212,7 +287,7 @@ module Sequel
     DEFAULT_SCHEMA_COLUMN = :filename
     DEFAULT_SCHEMA_TABLE = :schema_seeds
 
-    Error = Seeder::Error
+    Error = Seed::Error
 
     attr_reader :applied_seeds
 
@@ -266,16 +341,57 @@ module Sequel
         f = File.basename(path)
         fi = f.downcase
         if !applied_seeds.include?(fi)
-          load(path)
+          #begin
+          load(path) if RUBY_SEED_FILE_PATTERN.match(f)
+          create_yaml_seed(path) if YAML_SEED_FILE_PATTERN.match(f)
+          create_json_seed(path) if JSON_SEED_FILE_PATTERN.match(f)
+          #rescue Exception => e
+            #raise(Error, "error while processing seed file #{path}: #{e.inspect}")
+          #end
           el = [ms.last, f]
-          if !ms.last.nil? && !seeds.include?(el)
-            seeds << [ms.last, f]
+          next if ms.last.nil?
+          if ms.last < Seed::Base && !seeds.include?(el)
+            seeds << el
           end
         end
       end
       seeds
     end
 
+    def create_yaml_seed(path)
+      seed_descriptor = YAML::load(File.open(path))
+      seed = Class.new(Seed::Base)
+      seed.const_set "YAML_SEED", seed_descriptor
+      seed.class_eval do
+        include Seed::SeedDescriptor
+
+        def run
+          seed_descriptor = self.class.const_get "YAML_SEED"
+          raise(Error, "YAML seed improperly defined") if seed_descriptor.nil?
+          self.apply_seed_descriptor(seed_descriptor)
+        end
+      end
+      Seed::Base.inherited(seed) unless Seed::Base.descendants.include?(seed)
+      seed
+    end
+
+    def create_json_seed(path)
+      seed_descriptor = JSON.parse(File.read(path))
+      seed = Class.new(Seed::Base)
+      seed.const_set "JSON_SEED", seed_descriptor
+      seed.class_eval do
+        include Seed::SeedDescriptor
+
+        def run
+          seed_descriptor = self.class.const_get "JSON_SEED"
+          raise(Error, "JSON seed improperly defined") if seed_descriptor.nil?
+          self.apply_seed_descriptor(seed_descriptor)
+        end
+      end
+      Seed::Base.inherited(seed) unless Seed::Base.descendants.include?(seed)
+      seed
+    end
+
     def schema_dataset
       c = column
       ds = db.from(table)

data/spec/extensions/seed_spec.rb

@@ -5,12 +5,12 @@ describe Sequel.seed do
     Sequel::Seed.setup(:test)
   end
 
-  it 'should create a Seed descendant according to the current environment' do
+  it 'should create a Seed descendant according to the given environment' do
     seed = Sequel.seed(:test) {}
     expect(Sequel::Seed::Base.descendants).to include seed
   end
 
-  it 'should ignore a Seed not applicable to the current environment' do
+  it 'should ignore a Seed not applicable to the given environment' do
     seed = Sequel.seed(:development) {}
     expect(Sequel::Seed::Base.descendants).not_to include seed
   end
@@ -55,6 +55,7 @@ end
 describe Sequel::Seeder do
   let(:DB) {Sequel.sqlite}
   let!(:environment) {"#{Faker::Lorem.word}_#{Faker::Lorem.word}"}
+  let!(:random_word) {Faker::Lorem.word}
 
   it "should raise an error when there is not any seed file to apply" do
     Sequel::Seed.setup environment
@@ -64,36 +65,118 @@ describe Sequel::Seeder do
     expect(SpecModel.dataset.all.length).to be 0
   end
 
-  describe 'environment references should be indistinguishable between Symbol and String' do
-    context 'when the environment is defined using a String' do
-      it 'should apply the Seed accordingly' do
-        Sequel::Seed.setup environment
+  describe "Seeds defined using Ruby code (.rb extension)" do
+    describe 'environment references should be indistinguishable between Symbol and String' do
+      context 'when the environment is defined using a String' do
+        it 'should apply the Seed accordingly' do
+          Sequel::Seed.setup environment
+
+          File.open("#{seed_test_dir}/#{seed_file_name}.rb", 'w+') do |f|
+            f.puts "Sequel.seed(:#{environment}) do"
+            f.puts '  def run'
+            f.puts '    SpecModel.create :sentence => \'environment defined by String\''
+            f.puts '  end'
+            f.puts 'end'
+          end
+
+          expect(Sequel::Seed::Base.descendants.length).to be 0
+          expect(Sequel::Seeder.seeder_class(seed_test_dir)).to be Sequel::TimestampSeeder
+          expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+          expect(Sequel::Seed::Base.descendants.length).to be 1
+          expect(SpecModel.dataset.all.length).to be 1
+          expect(SpecModel.dataset.first.sentence).to eq 'environment defined by String'
+        end
+      end
 
-        File.open("#{seed_test_dir}/#{seed_file_name}", 'w+') do |f|
-          f.puts "Sequel.seed(:#{environment}) do"
-          f.puts '  def run'
-          f.puts '    SpecModel.create :sentence => \'environment defined by String\''
-          f.puts '  end'
-          f.puts 'end'
+      context 'when the Seed is defined using a String' do
+        it 'should apply the Seed accordingly' do
+          Sequel::Seed.setup environment.to_sym
+
+          File.open("#{seed_test_dir}/#{seed_file_name}.rb", 'w+') do |f|
+            f.puts "Sequel.seed(\"#{environment}\") do"
+            f.puts '  def run'
+            f.puts '    SpecModel.create :sentence => \'Seed defined by String\''
+            f.puts '  end'
+            f.puts 'end'
+          end
+
+          expect(Sequel::Seed::Base.descendants.length).to be 0
+          expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+          expect(Sequel::Seed::Base.descendants.length).to be 1
+          expect(SpecModel.dataset.all.length).to be 1
+          expect(SpecModel.dataset.first.sentence).to eq 'Seed defined by String'
         end
+      end
 
-        expect(Sequel::Seed::Base.descendants.length).to be 0
-        expect(Sequel::Seeder.seeder_class(seed_test_dir)).to be Sequel::TimestampSeeder
-        expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
-        expect(Sequel::Seed::Base.descendants.length).to be 1
-        expect(SpecModel.dataset.all.length).to be 1
-        expect(SpecModel.dataset.first.sentence).to eq 'environment defined by String'
+      context 'when both Seed and environment are defined using a String' do
+        it 'should apply the Seed accordingly' do
+          Sequel::Seed.setup environment
+
+          File.open("#{seed_test_dir}/#{seed_file_name}.rb", 'w+') do |f|
+            f.puts "Sequel.seed(\"#{environment}\") do"
+            f.puts '  def run'
+            f.puts '    SpecModel.create :sentence => \'Seed and environment defined by String\''
+            f.puts '  end'
+            f.puts 'end'
+          end
+
+          expect(Sequel::Seed::Base.descendants.length).to be 0
+          expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+          expect(Sequel::Seed::Base.descendants.length).to be 1
+          expect(SpecModel.dataset.all.length).to be 1
+          expect(SpecModel.dataset.first.sentence).to eq 'Seed and environment defined by String'
+        end
+      end
+
+      context 'when both Seed and environment are defined using a Symbol' do
+        it 'should apply the Seed accordingly' do
+          Sequel::Seed.setup environment.to_sym
+
+          File.open("#{seed_test_dir}/#{seed_file_name}.rb", 'w+') do |f|
+            f.puts "Sequel.seed(:#{environment}) do"
+            f.puts '  def run'
+            f.puts '    SpecModel.create :sentence => \'Seed and environment defined by Symbol\''
+            f.puts '  end'
+            f.puts 'end'
+          end
+
+          expect(Sequel::Seed::Base.descendants.length).to be 0
+          expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+          expect(Sequel::Seed::Base.descendants.length).to be 1
+          expect(SpecModel.dataset.all.length).to be 1
+          expect(SpecModel.dataset.first.sentence).to eq 'Seed and environment defined by Symbol'
+        end
+      end
+
+      context 'when the environment is defined using a String and we have a wildcard Seed' do
+        it 'should apply the Seed accordingly' do
+          Sequel::Seed.setup environment
+
+          File.open("#{seed_test_dir}/#{seed_file_name}.rb", 'w+') do |f|
+            f.puts 'Sequel.seed do'
+            f.puts '  def run'
+            f.puts '    SpecModel.create :sentence => \'Wildcard Seed and environment defined by String\''
+            f.puts '  end'
+            f.puts 'end'
+          end
+
+          expect(Sequel::Seed::Base.descendants.length).to be 0
+          expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+          expect(Sequel::Seed::Base.descendants.length).to be 1
+          expect(SpecModel.dataset.all.length).to be 1
+          expect(SpecModel.dataset.first.sentence).to eq 'Wildcard Seed and environment defined by String'
+        end
       end
     end
 
-    context 'when the Seed is defined using a String' do
-      it 'should apply the Seed accordingly' do
-        Sequel::Seed.setup environment.to_sym
+    context 'when there\'s a Seed created' do
+      it 'should change the database accordingly only once' do
+        Sequel::Seed.setup environment
 
-        File.open("#{seed_test_dir}/#{seed_file_name}", 'w+') do |f|
-          f.puts "Sequel.seed(\"#{environment}\") do"
+        File.open("#{seed_test_dir}/#{seed_file_name}.rb", 'w+') do |f|
+          f.puts 'Sequel.seed do'
           f.puts '  def run'
-          f.puts '    SpecModel.create :sentence => \'Seed defined by String\''
+          f.puts '    SpecModel.create :sentence => \'should have changed (from Ruby file)\''
           f.puts '  end'
           f.puts 'end'
         end
@@ -102,110 +185,214 @@ describe Sequel::Seeder do
         expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
         expect(Sequel::Seed::Base.descendants.length).to be 1
         expect(SpecModel.dataset.all.length).to be 1
-        expect(SpecModel.dataset.first.sentence).to eq 'Seed defined by String'
+        expect(SpecModel.dataset.first.sentence).to eq 'should have changed (from Ruby file)'
+        # Once again
+        expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+        expect(Sequel::Seed::Base.descendants.length).to be 0
+        expect(SpecModel.dataset.all.length).to be 1
+        expect(SpecModel.dataset.first.sentence).to eq 'should have changed (from Ruby file)'
       end
     end
 
-    context 'when both Seed and environment are defined using a String' do
-      it 'should apply the Seed accordingly' do
+    context 'when the specified Seed is not applicable to the given environment' do
+      it 'should not make any change to the database' do
         Sequel::Seed.setup environment
 
-        File.open("#{seed_test_dir}/#{seed_file_name}", 'w+') do |f|
-          f.puts "Sequel.seed(\"#{environment}\") do"
+        File.open("#{seed_test_dir}/#{seed_file_name}.rb", 'w+') do |f|
+          f.puts "Sequel.seed(:another_#{Faker::Lorem.word}_word) do"
           f.puts '  def run'
-          f.puts '    SpecModel.create :sentence => \'Seed and environment defined by String\''
+          f.puts '    SpecModel.create :sentence => \'should not have changed (from Ruby file)\''
           f.puts '  end'
           f.puts 'end'
         end
 
         expect(Sequel::Seed::Base.descendants.length).to be 0
         expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
-        expect(Sequel::Seed::Base.descendants.length).to be 1
-        expect(SpecModel.dataset.all.length).to be 1
-        expect(SpecModel.dataset.first.sentence).to eq 'Seed and environment defined by String'
+        expect(SpecModel.dataset.all.length).to be 0
       end
     end
+  end
 
-    context 'when both Seed and environment are defined using a Symbol' do
-      it 'should apply the Seed accordingly' do
-        Sequel::Seed.setup environment.to_sym
+  describe 'Seeds defined using YAML code (.{yaml,yml} extension)' do
+    it 'should apply a basic YAML Seed if it was specified for the given environment' do
+      Sequel::Seed.setup environment
 
-        File.open("#{seed_test_dir}/#{seed_file_name}", 'w+') do |f|
-          f.puts "Sequel.seed(:#{environment}) do"
-          f.puts '  def run'
-          f.puts '    SpecModel.create :sentence => \'Seed and environment defined by Symbol\''
-          f.puts '  end'
-          f.puts 'end'
-        end
+      File.open("#{seed_test_dir}/#{seed_file_name}.yml", 'w+') do |f|
+        f.puts "environment: :#{environment}"
+        f.puts 'spec_model:'
+        f.puts "  sentence: 'should have changed (from YAML file) #{random_word}'"
+        f.puts ''
+      end
 
-        expect(Sequel::Seed::Base.descendants.length).to be 0
-        expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
-        expect(Sequel::Seed::Base.descendants.length).to be 1
-        expect(SpecModel.dataset.all.length).to be 1
-        expect(SpecModel.dataset.first.sentence).to eq 'Seed and environment defined by Symbol'
+      expect(Sequel::Seed::Base.descendants.length).to be 0
+      expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+      expect(Sequel::Seed::Base.descendants.length).to be 1
+      expect(SpecModel.dataset.all.length).to be 1
+      expect(SpecModel.dataset.first.sentence).to eq "should have changed (from YAML file) #{random_word}"
+    end
+
+    it 'should apply a YAML Seed if it was specified for the given environment' do
+      Sequel::Seed.setup environment
+
+      File.open("#{seed_test_dir}/#{seed_file_name}.yml", 'w+') do |f|
+        f.puts "environment: :#{environment}"
+        f.puts 'model:'
+        f.puts '  class: \'SpecModel\''
+        f.puts '  entries:'
+        f.puts '    -'
+        f.puts "      sentence: 'should have changed (from YAML file) #{random_word}'"
+        f.puts ''
       end
+
+      expect(Sequel::Seed::Base.descendants.length).to be 0
+      expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+      expect(Sequel::Seed::Base.descendants.length).to be 1
+      expect(SpecModel.dataset.all.length).to be 1
+      expect(SpecModel.dataset.first.sentence).to eq "should have changed (from YAML file) #{random_word}"
     end
 
-    context 'when the environment is defined using a String and we have a wildcard Seed' do
-      it 'should apply the Seed accordingly' do
-        Sequel::Seed.setup environment
+    it 'should apply a YAML file with multiple Seeds descriptors if they were specified for the given environment' do
+      Sequel::Seed.setup environment
 
-        File.open("#{seed_test_dir}/#{seed_file_name}", 'w+') do |f|
-          f.puts 'Sequel.seed do'
-          f.puts '  def run'
-          f.puts '    SpecModel.create :sentence => \'Wildcard Seed and environment defined by String\''
-          f.puts '  end'
-          f.puts 'end'
-        end
+      File.open("#{seed_test_dir}/#{seed_file_name}.yml", 'w+') do |f|
+        f.puts '-'
+        f.puts "  environment: :#{environment}"
+        f.puts '  model:'
+        f.puts '    class: \'SpecModel\''
+        f.puts '    entries:'
+        f.puts '      -'
+        f.puts "        sentence: 'should have changed (from YAML file) #{random_word}'"
+        f.puts '-'
+        f.puts "  environment: :another_#{environment}"
+        f.puts '  spec_model:'
+        f.puts "    sentence: 'should not have changed (from YAML file) #{random_word}'"
+        f.puts ''
+      end
 
-        expect(Sequel::Seed::Base.descendants.length).to be 0
-        expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
-        expect(Sequel::Seed::Base.descendants.length).to be 1
-        expect(SpecModel.dataset.all.length).to be 1
-        expect(SpecModel.dataset.first.sentence).to eq 'Wildcard Seed and environment defined by String'
+      expect(Sequel::Seed::Base.descendants.length).to be 0
+      expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+      expect(Sequel::Seed::Base.descendants.length).to be 1
+      expect(SpecModel.dataset.all.length).to be 1
+      expect(SpecModel.dataset.first.sentence).to eq "should have changed (from YAML file) #{random_word}"
+    end
+
+    it 'should not apply a basic Seed if it was not specified for the given environment' do
+      Sequel::Seed.setup environment
+
+      File.open("#{seed_test_dir}/#{seed_file_name}.yml", 'w+') do |f|
+        f.puts "environment: :another_environment_#{Faker::Lorem.word}"
+        f.puts 'spec_model:'
+        f.puts '  sentence: \'should not have changed (from YAML file)\''
+        f.puts ''
       end
+
+      expect(Sequel::Seed::Base.descendants.length).to be 0
+      expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+      expect(Sequel::Seed::Base.descendants.length).to be 1
+      expect(SpecModel.dataset.all.length).to be 0
     end
   end
 
-  context 'when there\'s a Seed created' do
-    it 'should change the database accordingly only once' do
+  describe 'Seeds defined using JSON code (.json extension)' do
+    it 'should apply a basic JSON Seed if it was specified for the given environment' do
       Sequel::Seed.setup environment
 
-      File.open("#{seed_test_dir}/#{seed_file_name}", 'w+') do |f|
-        f.puts 'Sequel.seed do'
-        f.puts '  def run'
-        f.puts '    SpecModel.create :sentence => \'should have changed\''
-        f.puts '  end'
-        f.puts 'end'
+      File.open("#{seed_test_dir}/#{seed_file_name}.json", 'w+') do |f|
+        f.puts '{'
+        f.puts "  \"environment\": \"#{environment}\","
+        f.puts "  \"spec_model\": {"
+        f.puts "    \"sentence\": \"should have changed (from JSON file) #{random_word}\""
+        f.puts '  }'
+        f.puts '}'
+        f.puts ''
       end
 
       expect(Sequel::Seed::Base.descendants.length).to be 0
       expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
       expect(Sequel::Seed::Base.descendants.length).to be 1
       expect(SpecModel.dataset.all.length).to be 1
-      expect(SpecModel.dataset.first.sentence).to eq 'should have changed'
-      # Once again
+      expect(SpecModel.dataset.first.sentence).to eq "should have changed (from JSON file) #{random_word}"
+    end
+
+    it 'should apply a JSON Seed if it was specified for the given environment' do
+      Sequel::Seed.setup environment
+
+      File.open("#{seed_test_dir}/#{seed_file_name}.json", 'w+') do |f|
+        f.puts '{'
+        f.puts "  \"environment\": \"#{environment}\","
+        f.puts "  \"model\": {"
+        f.puts "    \"class\": \"SpecModel\","
+        f.puts "    \"entries\": ["
+        f.puts '      {'
+        f.puts "        \"sentence\": \"should have changed (from JSON file) #{random_word}\""
+        f.puts '      }'
+        f.puts '    ]'
+        f.puts '  }'
+        f.puts '}'
+        f.puts ''
+      end
+
+      expect(Sequel::Seed::Base.descendants.length).to be 0
       expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+      expect(Sequel::Seed::Base.descendants.length).to be 1
+      expect(SpecModel.dataset.all.length).to be 1
+      expect(SpecModel.dataset.first.sentence).to eq "should have changed (from JSON file) #{random_word}"
+    end
+
+    it 'should apply a JSON file with multiple Seeds descriptors if they were specified for the given environment' do
+      Sequel::Seed.setup environment
+
+      File.open("#{seed_test_dir}/#{seed_file_name}.json", 'w+') do |f|
+        f.puts '['
+        f.puts '  {'
+        f.puts "    \"environment\": \"#{environment}\","
+        f.puts "    \"model\": {"
+        f.puts "      \"class\": \"SpecModel\","
+        f.puts "      \"entries\": ["
+        f.puts '        {'
+        f.puts "          \"sentence\": \"should have changed (from JSON file) #{random_word}\""
+        f.puts '        }'
+        f.puts '      ]'
+        f.puts '    }'
+        f.puts '  },'
+        f.puts '  {'
+        f.puts "    \"environment\": \"another_#{environment}\","
+        f.puts "    \"model\": {"
+        f.puts "      \"class\": \"SpecModel\","
+        f.puts "      \"entries\": ["
+        f.puts '        {'
+        f.puts "          \"sentence\": \"should have changed (from JSON file) #{random_word}\""
+        f.puts '        }'
+        f.puts '      ]'
+        f.puts '    }'
+        f.puts '  }'
+        f.puts ']'
+        f.puts ''
+      end
+
       expect(Sequel::Seed::Base.descendants.length).to be 0
+      expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+      expect(Sequel::Seed::Base.descendants.length).to be 1
       expect(SpecModel.dataset.all.length).to be 1
-      expect(SpecModel.dataset.first.sentence).to eq 'should have changed'
+      expect(SpecModel.dataset.first.sentence).to eq "should have changed (from JSON file) #{random_word}"
     end
-  end
 
-  context 'when the specified Seed is not applicable to the current environment' do
-    it 'should not make any change to the database' do
+    it 'should not apply a basic Seed if it was not specified for the given environment' do
       Sequel::Seed.setup environment
 
-      File.open("#{seed_test_dir}/#{seed_file_name}", 'w+') do |f|
-        f.puts "Sequel.seed(:another_#{Faker::Lorem.word}_word) do"
-        f.puts '  def run'
-        f.puts '    SpecModel.create :sentence => \'should have changed\''
-        f.puts '  end'
-        f.puts 'end'
+      File.open("#{seed_test_dir}/#{seed_file_name}.json", 'w+') do |f|
+        f.puts '{'
+        f.puts "  \"environment\": \"another_#{environment}\","
+        f.puts "  \"spec_model\": {"
+        f.puts "    \"sentence\": \"should not changed (from JSON file) #{random_word}\""
+        f.puts '  }'
+        f.puts '}'
+        f.puts ''
       end
 
       expect(Sequel::Seed::Base.descendants.length).to be 0
       expect {Sequel::Seeder.apply(DB, seed_test_dir)}.not_to raise_error
+      expect(Sequel::Seed::Base.descendants.length).to be 1
       expect(SpecModel.dataset.all.length).to be 0
     end
   end

data/spec/spec_helper.rb

@@ -16,7 +16,7 @@ module Sequel::Seed
     end
 
     def seed_file_name
-      "#{Time.now.strftime('%Y%m%d%H%M%S')}_testing_#{Faker::Lorem.word}_#{Faker::Lorem.word}.rb"
+      "#{Time.now.strftime('%Y%m%d%H%M%S')}_testing_#{Faker::Lorem.word}_#{Faker::Lorem.word}"
     end
   end
 end
@@ -49,4 +49,5 @@ RSpec.configure do |config|
   end
 end
 
-class SpecModel < Sequel::Model; end
+class SpecModel < Sequel::Model
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-seed
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Ewerton Assis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-30 00:00:00.000000000 Z
+date: 2015-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel