sprig 0.1.6 → 0.3.1

data/spec/lib/sprig/null_record_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Sprig::NullRecord do
+RSpec.describe Sprig::NullRecord do
   let(:error_msg) { 'Something bad happened.' }
   subject { described_class.new(error_msg) }
 
@@ -14,7 +14,7 @@ describe Sprig::NullRecord do
 
   describe "#method_missing" do
     it "returns nil for undefined method calls" do
-      subject.enhance_your_calm.should == nil
+      expect(subject.enhance_your_calm).to eq(nil)
     end
   end
 

data/spec/lib/sprig/parser/base_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Sprig::Parser::Base do
+RSpec.describe Sprig::Parser::Base do
   describe "#parse" do
     it "enforces implementation in a subclass" do
       expect {

data/spec/lib/sprig/process_notifier_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Sprig::ProcessNotifier do
+RSpec.describe Sprig::ProcessNotifier do
   it_behaves_like "a logging entity" do
     subject { described_class.new }
   end
@@ -79,10 +79,12 @@ describe Sprig::ProcessNotifier do
   end
 
   describe "#in_progress" do
+    let(:seed) { Sprig::Seed::Entry.new(Post, { title: "Hello World!", content: "Stuff", sprig_id: 1 }, {}) }
+
     it "logs an in-progress message" do
-      log_should_receive(:debug, with: "Planting those seeds...\r")
+      log_should_receive(:debug, with: "Planting Post with sprig_id 1")
 
-      subject.in_progress
+      subject.in_progress(seed)
     end
   end
 end

data/spec/lib/sprig/seed/entry_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Sprig::Seed::Entry do
+RSpec.describe Sprig::Seed::Entry do
   describe ".success_log_text" do
     context "on a new record" do
       it "indicates the record was 'saved'" do
         subject = described_class.new(Post, { title: "Hello World!", content: "Stuff", sprig_id: 1 }, {})
         subject.save_record
 
-        subject.success_log_text.should == "Post with sprig_id 1 successfully saved."
+        expect(subject.success_log_text).to eq("Saved")
       end
     end
 
@@ -24,7 +24,7 @@ describe Sprig::Seed::Entry do
         subject = described_class.new(Post, { title: "Existing title", content: "Existing content", sprig_id: 1 }, { find_existing_by: [:title] })
         subject.save_record
 
-        subject.success_log_text.should == "Post with sprig_id 1 successfully updated."
+        expect(subject.success_log_text).to eq("Updated")
       end
     end
   end

data/spec/lib/sprig/seed/record_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Sprig::Seed::Record do
+RSpec.describe Sprig::Seed::Record do
   describe ".existing?" do
     let!(:existing) do
       Post.create(
@@ -13,13 +13,13 @@ describe Sprig::Seed::Record do
     it "returns true if the record has already been saved to the database" do
       subject = described_class.new_or_existing(Post, { title: "Existing title" }, { title: "Existing title" })
 
-      subject.existing?.should == true
+      expect(subject.existing?).to eq(true)
     end
 
     it "returns false if the record is new" do
       subject = described_class.new_or_existing(Post, { title: "New title" }, { title: "New title" })
 
-      subject.existing?.should == false
+      expect(subject.existing?).to eq(false)
     end
   end
 end

data/spec/lib/sprig/source_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Sprig::NullRecord do
+RSpec.describe Sprig::NullRecord do
   let(:error_msg) { 'Something bad happened.' }
   subject { described_class.new(error_msg) }
 
@@ -14,7 +14,7 @@ describe Sprig::NullRecord do
 
   describe "#method_missing" do
     it "returns nil for undefined method calls" do
-      subject.enhance_your_calm.should == nil
+      expect(subject.enhance_your_calm).to eq(nil)
     end
   end
 

data/spec/lib/sprig_spec.rb

@@ -1,16 +1,67 @@
 require 'spec_helper'
 
-describe Sprig do
+RSpec.describe Sprig do
   let(:configuration) { double('Configuration') }
 
   before do
-    Sprig::Configuration.stub(:new).and_return(configuration)
+    allow(Sprig::Configuration).to receive(:new).and_return(configuration)
+  end
+
+  describe '.adapter' do
+    it { expect(described_class).to respond_to(:adapter).with(0).arguments }
+
+    it { expect(described_class.adapter).not_to be nil }
+  end
+
+  describe '.adapter=' do
+    let(:value) { :mongo_mapper }
+
+    around(:each) do |example|
+      previous_value = described_class.adapter
+
+      example.run
+
+      described_class.adapter = previous_value
+    end
+
+    it { expect(described_class).to respond_to(:adapter=).with(1).argument }
+
+    it 'changes the value' do
+      expect { described_class.adapter = value }.to change(described_class, :adapter).to(value)
+    end
+  end
+
+  describe '.adapter_model_class' do
+    let(:expected_class) do
+      case Sprig.adapter
+      when :active_record
+        ActiveRecord::Base
+      when :mongoid
+        Mongoid::Document
+      end
+    end
+
+    before(:each) { described_class.instance_variable_set(:@adapter_model_class, nil) }
+
+    it { expect(described_class).to respond_to(:adapter_model_class).with(0).arguments }
+
+    it { expect(described_class.adapter_model_class).to be expected_class }
+
+    describe 'with an unrecognized adapter' do
+      let(:value) { :mongo_mapper }
+
+      it 'raises an error' do
+        allow(described_class).to receive(:adapter).and_return(value)
+
+        expect { described_class.adapter_model_class }.to raise_error(/unknown model class/i)
+      end
+    end
   end
 
   describe ".configuration" do
     context "when there is not yet a Configuration instance" do
       it "returns a new Configuration instance" do
-        described_class.configuration.should == configuration
+        expect(described_class.configuration).to eq(configuration)
       end
     end
 
@@ -21,9 +72,9 @@ describe Sprig do
 
       it "returns the existing Configuration instance" do
         new_configuration = double('Configuration')
-        Sprig::Configuration.stub(:new).and_return(new_configuration)
+        allow(Sprig::Configuration).to receive(:new).and_return(new_configuration)
 
-        described_class.configuration.should == configuration
+        expect(described_class.configuration).to eq(configuration)
       end
     end
   end
@@ -36,16 +87,16 @@ describe Sprig do
     it "clears the existing configuration" do
       described_class.reset_configuration
       new_configuration = double('Configuration')
-      Sprig::Configuration.stub(:new).and_return(new_configuration)
+      allow(Sprig::Configuration).to receive(:new).and_return(new_configuration)
 
-      described_class.configuration.should == new_configuration
+      expect(described_class.configuration).to eq(new_configuration)
     end
   end
 
   describe ".configure" do
     it "yields the configuration" do
       described_class.configure do |config|
-        config.should == configuration
+        expect(config).to eq(configuration)
       end
     end
   end

data/spec/spec_helper.rb

@@ -7,8 +7,6 @@ SimpleCov.formatter = Coveralls::SimpleCov::Formatter
 SimpleCov.start "rails"
 
 require "rails"
-require "active_record"
-require "database_cleaner"
 require "webmock"
 require "vcr"
 require "pry"
@@ -17,25 +15,21 @@ require "generator_spec"
 require "sprig"
 include Sprig::Helpers
 
-Dir[File.dirname(__FILE__) + '/fixtures/models/*.rb'].each {|file| require file }
 Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each {|file| require file}
 
 RSpec.configure do |c|
   c.include ColoredText
   c.include LoggerMock
 
-  c.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
-  end
+  c.disable_monkey_patching!
+
+  c.order = :random
 
-  c.before(:each) do
-    DatabaseCleaner.start
+  c.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
   end
 
   c.after(:each) do
-    DatabaseCleaner.clean
-
     Sprig.reset_configuration
   end
 end
@@ -46,51 +40,61 @@ VCR.configure do |c|
   c.hook_into :webmock
 end
 
-# Database
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "spec/db/activerecord.db")
+# ActiveRecord (via SQlite3)
+begin
+  require 'active_record'
+  require 'sqlite3'
 
-User.connection.execute "DROP TABLE IF EXISTS users;"
-User.connection.execute "CREATE TABLE users (id INTEGER PRIMARY KEY , first_name VARCHAR(255), last_name VARCHAR(255), type VARCHAR(255));"
+  Sprig.adapter = :active_record
+rescue LoadError; end
 
-Post.connection.execute "DROP TABLE IF EXISTS posts;"
-Post.connection.execute "CREATE TABLE posts (id INTEGER PRIMARY KEY AUTOINCREMENT, title VARCHAR(255), content VARCHAR(255), photo VARCHAR(255), published BOOLEAN , user_id INTEGER);"
+# Mongoid
+begin
+  require 'mongoid'
 
-Comment.connection.execute "DROP TABLE IF EXISTS comments;"
-Comment.connection.execute "CREATE TABLE comments (id INTEGER PRIMARY KEY , post_id INTEGER, body VARCHAR(255));"
+  Sprig.adapter = :mongoid
+rescue LoadError; end
 
-Tag.connection.execute "DROP TABLE IF EXISTS tags;"
-Tag.connection.execute "CREATE TABLE tags (id INTEGER PRIMARY KEY , name VARCHAR(255));"
+# Require model files.
+Dir[File.dirname(__FILE__) + "/fixtures/models/#{Sprig.adapter}/*.rb"].each {|file| require file}
 
-Tag.connection.execute "DROP TABLE IF EXISTS posts_tags;"
-Tag.connection.execute "CREATE TABLE posts_tags (id INTEGER PRIMARY KEY , post_id INTEGER, tag_id INTEGER);"
+require "adapters/#{Sprig.adapter}.rb"
 
 # Helpers
 #
 # Setup fake `Rails.root`
 def stub_rails_root(path='./spec/fixtures')
-  Rails.stub(:root).and_return(Pathname.new(path))
+  allow(Rails).to receive(:root).and_return(Pathname.new(path))
 end
 
 # Setup fake `Rails.env`
 def stub_rails_env(env='development')
-  Rails.stub(:env).and_return(env)
+  allow(Rails).to receive(:env).and_return(env)
 end
 
 # Copy and Remove Seed files around a spec
-def load_seeds(*files)
+def load_seeds(*files, &block)
   env = Rails.env
+  prepare_seeds(env, *files, &block)
+end
+
+# Copy and Remove shared seed files around a spec
+def load_shared_seeds(*files, &block)
+  prepare_seeds('shared', *files, &block)
+end
 
-  `cp -R ./spec/fixtures/seeds/#{env}/files ./spec/fixtures/db/seeds/#{env}`
+def prepare_seeds(directory, *files, &block)
+  `cp -R ./spec/fixtures/seeds/#{directory}/files ./spec/fixtures/db/seeds/#{directory}`
 
   files.each do |file|
-    `cp ./spec/fixtures/seeds/#{env}/#{file} ./spec/fixtures/db/seeds/#{env}`
+    `cp ./spec/fixtures/seeds/#{directory}/#{file} ./spec/fixtures/db/seeds/#{directory}`
   end
 
-  yield
+  block.call
 
-  `rm -R ./spec/fixtures/db/seeds/#{env}/files`
+  `rm -R ./spec/fixtures/db/seeds/#{directory}/files`
 
   files.each do |file|
-    `rm ./spec/fixtures/db/seeds/#{env}/#{file}`
+    `rm ./spec/fixtures/db/seeds/#{directory}/#{file}`
   end
 end

data/spec/sprig_shared_spec.rb

@@ -0,0 +1,467 @@
+require 'spec_helper'
+require 'open-uri'
+
+RSpec.describe "Seeding an application with shared seeds" do
+  let(:missing_record_error) do
+    if defined?(ActiveRecord) && Post < ActiveRecord::Base
+      ActiveRecord::RecordNotFound
+    elsif defined?(Mongoid) && Post < Mongoid::Document
+      Mongoid::Errors::DocumentNotFound
+    end
+  end
+
+  before do
+    stub_rails_root
+  end
+
+  context "with a yaml file" do
+    around do |example|
+      load_shared_seeds('posts.yml', &example)
+    end
+
+    it "seeds the db" do
+      sprig_shared [Post]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:title)).to eq(['Yaml title'])
+    end
+  end
+
+  context "with a csv file" do
+    around do |example|
+      load_shared_seeds('posts.csv', &example)
+    end
+
+    it "seeds the db" do
+      sprig_shared [Post]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:title)).to eq(['Csv title'])
+    end
+  end
+
+  context "with a json file" do
+    around do |example|
+      load_shared_seeds('posts.json', &example)
+    end
+
+    it "seeds the db" do
+      sprig_shared [Post]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:title)).to eq(['Json title'])
+    end
+  end
+
+  context "with a partially-dynamic value" do
+    around do |example|
+      load_shared_seeds('posts_partially_dynamic_value.yml', &example)
+    end
+
+    it "seeds the db with the full value" do
+      sprig_shared [
+        {
+          :class  => Post,
+          :source => open('spec/fixtures/seeds/shared/posts_partially_dynamic_value.yml')
+        }
+      ]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:title)).to eq(['Partially Dynamic Title'])
+    end
+  end
+
+  context "with a symlinked file" do
+    around do |example|
+      `ln -s ./spec/fixtures/seeds/shared/posts.yml ./spec/fixtures/db/seeds/shared/`
+      example.call
+      `rm ./spec/fixtures/db/seeds/shared/posts.yml`
+    end
+
+    it "seeds the db" do
+      sprig_shared [Post]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:title)).to eq(['Yaml title'])
+    end
+  end
+
+  context "with a google spreadsheet" do
+    it "seeds the db", :vcr => { :cassette_name => 'google_spreadsheet_json_posts' } do
+      sprig_shared [
+        {
+          :class  => Post,
+          :parser => Sprig::Parser::GoogleSpreadsheetJson,
+          :source => open('https://spreadsheets.google.com/feeds/list/0AjVLPMnHm86rdDVHQ2dCUS03RTN5ZUtVNzVOYVBwT0E/1/public/values?alt=json'),
+        }
+      ]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:title)).to eq(['Google spreadsheet json title'])
+    end
+  end
+
+  context "with an invalid custom parser" do
+    around do |example|
+      load_shared_seeds('posts.yml', &example)
+    end
+
+    it "fails with an argument error" do
+      expect {
+        sprig_shared [
+          {
+            :class  => Post,
+            :source => open('spec/fixtures/seeds/shared/posts.yml'),
+            :parser => Object # Not a valid parser
+          }
+        ]
+      }.to raise_error(ArgumentError, 'Parsers must define #parse.')
+    end
+  end
+
+  context "with a custom source" do
+    around do |example|
+      load_shared_seeds('legacy_posts.yml', &example)
+    end
+
+    it "seeds" do
+      sprig_shared [
+        {
+          :class  => Post,
+          :source => open('spec/fixtures/seeds/shared/legacy_posts.yml')
+        }
+      ]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:title)).to eq(['Legacy yaml title'])
+    end
+  end
+
+  context "with a custom source that cannot be parsed by native parsers" do
+    around do |example|
+      load_shared_seeds('posts.md', &example)
+    end
+
+    it "fails with an unparsable file error" do
+      expect {
+        sprig_shared [
+          {
+            :class  => Post,
+            :source => open('spec/fixtures/seeds/shared/posts.md')
+          }
+        ]
+      }.to raise_error(Sprig::Source::ParserDeterminer::UnparsableFileError)
+    end
+  end
+
+  context "with an invalid custom source" do
+    it "fails with an argument error" do
+      expect {
+        sprig_shared [ { :class => Post, :source => 42 } ]
+      }.to raise_error(ArgumentError, 'Data sources must act like an IO.')
+    end
+  end
+
+  context "with multiple file relationships" do
+    around do |example|
+      load_shared_seeds('posts.yml', 'comments.yml', &example)
+    end
+
+    it "seeds the db" do
+      sprig_shared [Post, Comment]
+
+      expect(Post.count).to eq(1)
+      expect(Comment.count).to eq(1)
+      expect(Comment.first.post).to eq(Post.first)
+    end
+  end
+
+  context "with missing seed files" do
+    it "raises a missing file error" do
+      expect {
+        sprig_shared [Post]
+      }.to raise_error(Sprig::Source::SourceDeterminer::FileNotFoundError)
+    end
+  end
+
+  context "with a relationship to an undefined record" do
+    around do |example|
+      load_shared_seeds('posts.yml', 'posts_missing_dependency.yml', &example)
+    end
+
+    it "raises a helpful error message" do
+      expect {
+        sprig_shared [
+          {
+            :class  => Post,
+            :source => open('spec/fixtures/seeds/shared/posts_missing_dependency.yml')
+          }
+        ]
+      }.to raise_error(
+        Sprig::DependencySorter::MissingDependencyError,
+        "Undefined reference to 'sprig_record(Comment, 42)'"
+      )
+    end
+  end
+
+  context "with a relationship to a record that didn't save" do
+    around do |example|
+      load_shared_seeds('invalid_users.yml', 'posts_missing_record.yml', &example)
+    end
+
+    it "does not error, but carries on with the seeding" do
+      expect {
+        sprig_shared [
+          {
+            :class  => Post,
+            :source => open('spec/fixtures/seeds/shared/posts_missing_record.yml')
+          },
+          {
+            :class  => User,
+            :source => open('spec/fixtures/seeds/shared/invalid_users.yml')
+          }
+        ]
+      }.to_not raise_error
+    end
+  end
+
+  context "with multiple files for a class" do
+    around do |example|
+      load_shared_seeds('posts.yml', 'legacy_posts.yml', &example)
+    end
+
+    it "seeds the db" do
+      sprig_shared [
+        Post,
+        {
+          :class  => Post,
+          :source => open('spec/fixtures/seeds/shared/legacy_posts.yml')
+        }
+      ]
+
+      expect(Post.count).to eq(2)
+      expect(Post.pluck(:title)).to eq(['Yaml title', 'Legacy yaml title'])
+    end
+  end
+
+  context "with files defined as attributes" do
+    around do |example|
+      load_shared_seeds('posts_with_files.yml', &example)
+    end
+
+    it "seeds the db" do
+      sprig_shared [
+        {
+          :class  => Post,
+          :source => open('spec/fixtures/seeds/shared/posts_with_files.yml')
+        }
+      ]
+
+      expect(Post.count).to eq(1)
+      expect(Post.pluck(:photo)).to eq(['cat.png'])
+    end
+  end
+
+  context "with has_and_belongs_to_many relationships" do
+    around do |example|
+      load_shared_seeds('posts_with_habtm.yml', 'tags.yml', &example)
+    end
+
+    it "saves the habtm relationships" do
+      sprig_shared [
+        Tag,
+        {
+          :class  => Post,
+          :source => open('spec/fixtures/seeds/shared/posts_with_habtm.yml')
+        }
+      ]
+
+      expect(Post.first.tags.map(&:name)).to eq(['Botany', 'Biology'])
+    end
+  end
+
+  context "with cyclic dependencies" do
+    around do |example|
+      load_shared_seeds('comments.yml', 'posts_with_cyclic_dependencies.yml', &example)
+    end
+
+    it "raises an cyclic dependency error" do
+      expect {
+        sprig_shared [
+          {
+            :class  => Post,
+            :source => open('spec/fixtures/seeds/shared/posts_with_cyclic_dependencies.yml')
+          },
+          Comment
+        ]
+      }.to raise_error(Sprig::DependencySorter::CircularDependencyError)
+    end
+  end
+
+  context "with a malformed directive" do
+    let(:expected_error_message) { "Sprig::Directive must be instantiated with a(n) #{Sprig.adapter_model_class} class or a Hash with :class defined" }
+
+    context "including a class that is not a subclass of AR" do
+      it "raises an argument error" do
+        expect {
+          sprig_shared [
+            Object
+          ]
+        }.to raise_error(ArgumentError, expected_error_message)
+      end
+    end
+
+    context "including a non-class, non-hash" do
+      it "raises an argument error" do
+        expect {
+          sprig_shared [
+            42
+          ]
+        }.to raise_error(ArgumentError, expected_error_message)
+      end
+    end
+  end
+
+
+  context "with custom seed options" do
+    context "using delete_existing_by" do
+      around do |example|
+        load_shared_seeds('posts_delete_existing_by.yml', &example)
+      end
+
+      context "with an existing record" do
+        let!(:existing_match) do
+          Post.create(
+            :title    => "Such Title",
+            :content  => "Old Content")
+        end
+
+        let!(:existing_nonmatch) do
+          Post.create(
+            :title    => "Wow Title",
+            :content  => "Much Content")
+        end
+
+        it "replaces only the matching existing record" do
+          sprig_shared [
+            {
+              :class  => Post,
+              :source => open("spec/fixtures/seeds/shared/posts_delete_existing_by.yml")
+            }
+          ]
+
+          expect(Post.count).to eq(2)
+
+          expect {
+            existing_match.reload
+          }.to raise_error(missing_record_error)
+
+          expect {
+            existing_nonmatch.reload
+          }.to_not raise_error
+        end
+      end
+    end
+
+    context "using find_existing_by" do
+      context "with a missing attribute" do
+        around do |example|
+          load_shared_seeds('posts_find_existing_by_missing.yml', &example)
+        end
+
+        it "raises a missing attribute error" do
+          expect {
+            sprig_shared [
+              {
+                :class  => Post,
+                :source => open("spec/fixtures/seeds/shared/posts_find_existing_by_missing.yml")
+              }
+            ]
+          }.to raise_error(Sprig::Seed::AttributeCollection::AttributeNotFoundError, "Attribute 'unicorn' is not present.")
+        end
+      end
+
+      context "with a single attribute" do
+        around do |example|
+          load_shared_seeds('posts.yml', 'posts_find_existing_by_single.yml', &example)
+        end
+
+        context "with an existing record" do
+          let!(:existing) do
+            Post.create(
+              :title    => "Existing title",
+              :content  => "Existing content")
+          end
+
+          it "updates the existing record" do
+            sprig_shared [
+              {
+                :class  => Post,
+                :source => open("spec/fixtures/seeds/shared/posts_find_existing_by_single.yml")
+              }
+            ]
+
+            expect(Post.count).to eq(1)
+            expect(existing.reload.content).to eq("Updated content")
+          end
+        end
+      end
+
+      context "with multiple attributes" do
+        around do |example|
+          load_shared_seeds('posts.yml', 'posts_find_existing_by_multiple.yml', &example)
+        end
+
+        context "with an existing record" do
+          let!(:existing) do
+            Post.create(
+              :title      => "Existing title",
+              :content    => "Existing content",
+              :published  => false
+            )
+          end
+
+          it "updates the existing record" do
+            sprig_shared [
+              {
+                :class  => Post,
+                :source => open("spec/fixtures/seeds/shared/posts_find_existing_by_multiple.yml")
+              }
+            ]
+
+            expect(Post.count).to eq(1)
+            expect(existing.reload.published).to eq(true)
+          end
+        end
+      end
+    end
+
+    context "defined within the directive" do
+      let!(:existing) do
+        Post.create(
+          :title    => "Yaml title",
+          :content  => "Existing content")
+      end
+
+      around do |example|
+        load_shared_seeds('posts.yml', &example)
+      end
+
+      it "respects the directive option" do
+        sprig_shared [
+          {
+            :class   => Post,
+            :source  => open("spec/fixtures/seeds/shared/posts.yml"),
+            :delete_existing_by => :title
+          }
+        ]
+
+        expect(Post.count).to eq(1)
+
+        expect {
+          existing.reload
+        }.to raise_error(missing_record_error)
+      end
+    end
+  end
+end