to_factory 2.0.0 → 3.0.0.pre.pre

data/spec/integration/to_factory_method_spec.rb

@@ -1,30 +1,31 @@
 describe ToFactory do
   let!(:user)    { create_user! }
-  let!(:project) { create_project!}
-
-  before { FileUtils.rm_rf "./tmp/factories" }
+  let!(:project) { create_project! }
 
   def user_file
-    File.read("./tmp/factories/to_factory/user.rb") rescue nil
+    File.read("./tmp/factories/to_factory/user.rb")
+  rescue
+    nil
   end
 
   def project_file
-    File.read("./tmp/factories/to_factory/project.rb") rescue nil
+    File.read("./tmp/factories/to_factory/project.rb")
+  rescue
+    nil
   end
 
-  let(:expected_user_file) { File.read "./spec/example_factories/user_with_header.rb"}
-  let(:expected_project_file) { File.read "./spec/example_factories/project_with_header.rb"}
+  let(:expected_user_file) { File.read "./spec/example_factories/user_with_header.rb" }
+  let(:expected_project_file) { File.read "./spec/example_factories/project_with_header.rb" }
 
   describe "ToFactory.definitions" do
     it do
       ToFactory()
       expect(ToFactory.definitions).to match_array ["to_factory/user", "to_factory/project"]
     end
-
   end
 
   describe "ToFactory.definition_for" do
-  let(:expected_user_file) { File.read "./spec/example_factories/user.rb"}
+    let(:expected_user_file) { File.read "./spec/example_factories/user.rb" }
     it do
       expect(ToFactory.definition_for user).to match_sexp expected_user_file
     end
@@ -35,35 +36,35 @@ describe ToFactory do
     end
 
     it "raises a not found error" do
-      expect(lambda{ToFactory.definition_for :"to_factory/user"}).to raise_error ToFactory::NotFoundError
+      expect { ToFactory.definition_for :"to_factory/user" }.to raise_error ToFactory::NotFoundError
     end
   end
 
   describe "Object#ToFactory" do
     context "with multiple levels of parent classes" do
-      let(:filename) { "spec/example_factories/#{'user_admin_super_admin'}.rb"}
+      let(:filename) { "spec/example_factories/#{'user_admin_super_admin'}.rb" }
 
       it "gets the output order correct" do
         output = "./tmp/factories/to_factory/user.rb"
         `mkdir -p ./tmp/factories/to_factory`
         `cp #{filename} #{output}`
 
-        ToFactory(:root => user)
+        ToFactory(root: user)
 
         expected = File.read "spec/example_factories/#{'user_admin_root'}.rb"
 
-        #user, admin, super_admin, root
+        # user, admin, super_admin, root
         expect(File.read(output)).to match_sexp expected
       end
     end
 
     it "generates all factories" do
       ToFactory()
-      #simple check for equivalent ruby
+      # simple check for equivalent ruby
       expect(user_file)   .to match_sexp expected_user_file
       expect(project_file).to match_sexp expected_project_file
 
-      #once we are sure output is equivalent ruby, check output is identical
+      # once we are sure output is equivalent ruby, check output is identical
       expect(user_file.chomp)   .to eq expected_user_file.chomp
       expect(project_file.chomp).to eq expected_project_file.chomp
     end
@@ -79,13 +80,13 @@ describe ToFactory do
       end
 
       it "ignores specified classes" do
-        ToFactory(:exclude => ToFactory::User)
+        ToFactory(exclude: ToFactory::User)
         expect(user_file).to be_nil
         expect(project_file).to be_present
       end
 
       it "ignores specified classes - sanity check" do
-        ToFactory(:exclude => ToFactory::Project)
+        ToFactory(exclude: ToFactory::Project)
         expect(user_file).to be_present
         expect(project_file).to be_nil
       end
@@ -117,14 +118,14 @@ describe ToFactory do
       context "with a name for the factory" do
         it "appends to the file" do
           user_file_includes('factory(:"to_factory/user"')
-          ToFactory(:specific_user => user)
+          ToFactory(specific_user: user)
           user_file_includes('factory(:specific_user, :parent => :"to_factory/user"')
         end
       end
 
       it "without a name" do
-        expect(lambda{ToFactory(user)}).
-               to raise_error ToFactory::AlreadyExists
+        expect { ToFactory(user) }
+          .to raise_error ToFactory::AlreadyExists
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,26 +1,17 @@
 begin
-  require "codeclimate-test-reporter"
-  CodeClimate::TestReporter.start
+  require 'simplecov'
+  SimpleCov.start
 rescue LoadError
-  #ignore on ruby 1.8.x
+  # ignore on ruby 1.8.x
 end
 
-require 'active_record'
-require 'active_support/core_ext/string'
-require 'active_support/core_ext/hash'
+require "active_record"
+require "active_support/core_ext/string"
+require "active_support/core_ext/hash"
 require "sqlite3"
 require "database_cleaner"
 
-begin
-  require "pry-byebug"
-rescue LoadError
-  begin
-    require "ruby-debug"
-  rescue LoadError
-    $stderr.puts "No debugger available for #{RUBY_VERSION}"
-  end
-end
-
+require "byebug"
 require "to_factory"
 
 require "./spec/support/models/user"
@@ -33,8 +24,8 @@ RSpec.configure do |config|
 
   config.before :suite do
     ActiveRecord::Base.tap do |base|
-      config = {:adapter => "sqlite3", :database => "spec/db/test.sqlite3"}
-      base.configurations = {:test => config}.with_indifferent_access
+      config = { adapter: "sqlite3", database: "spec/db/test.sqlite3" }
+      base.configurations = { test: config }.with_indifferent_access
       base.establish_connection :test
     end
 

data/spec/support/broken_models/invalid_ruby_file.rb

@@ -0,0 +1 @@
+class Egg < ActiveRecord::Base

data/spec/support/broken_models/project.rb

@@ -0,0 +1,3 @@
+class ToFactory::Project < ActiveRecord::Base
+  self.table_name = "projects"
+end

data/spec/support/data_creation.rb

@@ -5,7 +5,7 @@ module ToFactory::DataCreation
   end
 
   def create_project!
-    ToFactory::Project.create({:name => "My Project", :objective => "easy testing", :some_id => 9 })
+    ToFactory::Project.create(name: "My Project", objective: "easy testing", some_id: 9)
   end
 
   def birthday
@@ -14,23 +14,21 @@ module ToFactory::DataCreation
 
   def create_user!
     ToFactory::User.create(
-      :name            => "Jeff",
-      :email           => "test@example.com",
-      :some_attributes => {:a => 1},
-      :some_id         => 8,
-      :birthday        => birthday
+      name: "Jeff",
+      email: "test@example.com",
+      some_attributes: { a: 1 },
+      some_id: 8,
+      birthday: birthday
     )
   end
 
   def create_admin!
     ToFactory::User.create(
-      :name            => "Admin",
-      :email           => "admin@example.com",
-      :some_attributes => {:a => 1},
-      :some_id         => 9,
-      :birthday        => birthday
+      name: "Admin",
+      email: "admin@example.com",
+      some_attributes: { a: 1 },
+      some_id: 9,
+      birthday: birthday
     )
   end
 end
-
-

data/spec/support/match_sexp.rb

@@ -8,7 +8,6 @@ RSpec::Matchers.define :match_sexp do |expected|
       @raised = e
       false
     end
-
   end
 
   failure_message do |actual|

data/spec/support/non_active_record/inherited_project.rb

@@ -0,0 +1,3 @@
+class ToFactory::InheritedProject < ToFactory::Project
+  self.table_name = "projects"
+end

data/spec/support/non_active_record/project.rb

@@ -0,0 +1,3 @@
+class ToFactory::Project < ActiveRecord::Base
+  self.table_name = "projects"
+end

data/spec/support/non_active_record/some_other_service_inheriting_from_something_else.rb

@@ -0,0 +1,4 @@
+require_relative "something_else"
+
+class SomeOtherService < SomethingElse
+end

data/spec/support/non_active_record/some_service.rb

@@ -0,0 +1,2 @@
+class SomeService
+end

data/spec/support/non_active_record/something_else.rb

@@ -0,0 +1,2 @@
+class SomethingElse
+end

data/spec/support/ruby_parser_exception_causing_string.rb

@@ -1,31 +1,31 @@
-"               
-                                      \ \ \                 -           \ \   
-                                                                             
-                                                                               
-                                                                    ,      
-                                                                           
-                                                                   
-                                                                             
-                                                                   
-                                                                         \    
-                                                                       
-                                                                      
-                                              \                              
-                                                                              
-                                                                               
-                                                                             
-                                                                             
-                                                                       
-                                                                        
-                                                                             
-                                                                          
-                                                                         
-                                                    ,                  
-                                                                        
-                                                               \ \    
-                                                                               
-                                                                          
-                                                                           
-                                                                         
+"
+                                      \ \ \                 -           \ \
+
+
+                                                                    ,
+
+
+
+
+                                                                         \
+
+
+                                              \
+
+
+
+
+
+
+
+
+
+                                                    ,
+
+                                                               \ \
+
+
+
+
 
                                                                  \ "

data/spec/unit/collation_spec.rb

@@ -1,20 +1,20 @@
 describe ToFactory::Collation do
   describe "detect_collisions!" do
-    let(:collation) { ToFactory::Collation.new(a,b) }
-    let(:a) { [double(:name => "a")]}
-    let(:b) { [double(:name => "a")]}
+    let(:collation) { ToFactory::Collation.new(a, b) }
+    let(:a) { [double(name: "a")] }
+    let(:b) { [double(name: "a")] }
 
     def perform
       collation.detect_collisions!(a, b)
     end
 
     it do
-      expect(lambda{perform}).to raise_error ToFactory::AlreadyExists
+      expect { perform }.to raise_error ToFactory::AlreadyExists
     end
 
     context "non matching keys" do
-      let(:a) { [double(:name => "a")]}
-      let(:b) { [double(:name => "b")]}
+      let(:a) { [double(name: "a")] }
+      let(:b) { [double(name: "b")] }
 
       it do
         expect(perform).to eq nil
@@ -29,14 +29,13 @@ describe ToFactory::Collation do
     let(:super_admin) { ToFactory::Representation.new("super_admin", "admin", "Factory.define(:super_admin, :parent => :admin) { |o| o.name(\"Super Admin\") }") }
 
     it do
-      new_definitions = [ root ]
-      pre_existing    = [ admin, user, super_admin ]
+      new_definitions = [root]
+      pre_existing    = [admin, user, super_admin]
 
       result = ToFactory::Collation.organize(new_definitions, pre_existing)
       result = result["to_factory/user"]
-      expect(result.map &:hierarchy_order).to eq [1,2,3,4]
+      expect(result.map &:hierarchy_order).to eq [1, 2, 3, 4]
       expect(result).to eq [user, admin, super_admin, root]
     end
   end
 end
-

data/spec/unit/file_writer_spec.rb

@@ -12,17 +12,13 @@ describe ToFactory::FileWriter do
 
     it "adds factories for all models" do
       user_representation = double :name => :user, "definition" => "factory a"
-      project_representation = double :name => "project", :definition =>"factory b"
-      fw.write({"to_factory/user" =>[user_representation],
-                "to_factory/project" => [project_representation]
-      })
+      project_representation = double name: "project", definition: "factory b"
+      fw.write("to_factory/user" => [user_representation],
+               "to_factory/project" => [project_representation])
 
-      expect(user_file).to match /FactoryGirl.define do/
+      expect(user_file).to match /FactoryBot.define do/
       expect(user_file).to include "factory a"
       expect(project_file).to include "factory b"
     end
   end
-
-
-
 end

data/spec/unit/finders/factory_spec.rb

@@ -3,24 +3,22 @@ describe ToFactory::Finders::Factory do
     before do
       FileUtils.mkdir_p "./tmp/factories/to_factory"
       FileUtils.cp "./spec/example_factories/user_admin_with_header.rb",
-        "./tmp/factories/to_factory/user.rb"
+                   "./tmp/factories/to_factory/user.rb"
     end
 
-    let(:user_file_contents) { File.read "./spec/example_factories/user.rb"}
-    let(:admin_file_contents){ File.read "./spec/example_factories/admin.rb" }
+    let(:user_file_contents) { File.read "./spec/example_factories/user.rb" }
+    let(:admin_file_contents) { File.read "./spec/example_factories/admin.rb" }
 
     it "reads all the factories" do
       finder = ToFactory::Finders::Factory.new
 
       result = finder.call
 
-      expect(result[0].definition).
-        to match_sexp user_file_contents
+      expect(result[0].definition)
+        .to match_sexp user_file_contents
 
-      expect(result[1].definition).
-        to match_sexp admin_file_contents
+      expect(result[1].definition)
+        .to match_sexp admin_file_contents
     end
   end
-
 end
-

data/spec/unit/finders/model_spec.rb

@@ -4,10 +4,17 @@ describe ToFactory::Finders::Model do
   end
 
   let(:finder) { ToFactory::Finders::Model.new }
+  let(:path) { "./spec/support/models" }
 
   describe "#call" do
-    let!(:user) { ToFactory::User.create! :name => "a user"}
-    let!(:project) { ToFactory::Project.create! :name => "a project"}
+    let!(:user) { ToFactory::User.create! name: "a user" }
+    let!(:project) { ToFactory::Project.create! name: "a project" }
+
+    context "with a match" do
+      it do
+        expect(finder.call).to match_array [user, project]
+      end
+    end
 
     context "no match"do
       let(:path) { "./tmp/doesnt_exist" }
@@ -15,14 +22,34 @@ describe ToFactory::Finders::Model do
         expect(finder.call).to eq []
       end
     end
-    context "with a match" do
-      let(:path) { "./spec/support/models" }
-      it do
-        expect(finder.call).to match_array [user, project]
+
+    context "with an invalid model file" do
+      let(:path) { "./spec/support/broken_models" }
+      before do
+        allow(finder).to receive(:warn)
+      end
+
+      it "displays a warning" do
+        expect(finder.call).to eq [project]
+
+        expect(finder).to have_received(:warn)
+          .with("Failed to eval ./spec/support/broken_models/invalid_ruby_file.rb")
       end
     end
-  end
 
-end
+    context "with an invalid class" do
+      before do
+        allow(finder).to receive(:warn)
+      end
 
+      it "displays a warning" do
+        klass = double("BrokenClass", inspect: "BrokenClass")
+        expect(klass).to receive(:ancestors).and_raise("Some error")
+        finder.call(klasses: [klass])
 
+        expect(finder).to have_received(:warn)
+          .with("Failed to get record from BrokenClass \"Some error\"")
+      end
+    end
+  end
+end

data/spec/unit/generation/attribute_spec.rb

@@ -1,16 +1,16 @@
 describe ToFactory::Generation::Attribute do
-  let(:attribute) { ToFactory::Generation::Attribute.new(:some_attributes, {:a => 1}) }
+  let(:attribute) { ToFactory::Generation::Attribute.new(:some_attributes, a: 1) }
 
   describe "#to_s" do
     it do
-      expect(attribute.to_s).to include "some_attributes({:a => 1})"
+      expect(attribute.to_s).to include "some_attributes { {:a => 1} }"
     end
   end
 
   describe "#format" do
     it "formats Date, Time, DateTime" do
-      Time.zone= "UTC"
-      time_string ="2011-12-13T14:15 UTC"
+      Time.zone = "UTC"
+      time_string = "2011-12-13T14:15 UTC"
 
       expect(attribute.format(Time    .parse(time_string))).to eq "2011-12-13T14:15 UTC".inspect
       expect(attribute.format(Date    .parse(time_string))).to eq "2011-12-13".inspect
@@ -21,20 +21,33 @@ describe ToFactory::Generation::Attribute do
       expect(attribute.format(123))  .to eq "123"
       expect(attribute.format(123.0)).to eq "123.0"
     end
-  end
 
+    it "formats BigDecimal"do
+      expect(attribute.format(BigDecimal "123456789012345678900.0")).to eq "BigDecimal.new(\"123456789012345678900.0\")"
+    end
+
+    it "handles unparseable strings" do
+      # NB this spec may only have been relevant for ruby 1.8 i.e. older RubyParser versions
+      # see https://github.com/markburns/to_factory/issues/4
+      parser = double "RubyParser"
+      expect(parser).to receive(:parse).and_raise "some error"
+      attribute.parser = parser
+
+      expect(attribute.format("anything")).to eq "ToFactory: RubyParser exception parsing this attribute".inspect
+    end
+  end
 
   describe "#inspect_value" do
     it do
-      expect(attribute.inspect_value({:a => 1})).to eq "({:a => 1})"
+      expect(attribute.inspect_value(a: 1)).to eq " { {:a => 1} }"
     end
     it "formats hashes correctly" do
       hash = ActiveSupport::OrderedHash.new
-      hash[{"with" => :hash}] = "keys"
+      hash[{ "with" => :hash }] = "keys"
       hash[2] = "integers"
-      hash[:a] = {:nested => "hash"}
+      hash[:a] = { nested: "hash" }
 
-      expected = '({{"with" => :hash} => "keys", 2 => "integers", :a => {:nested => "hash"}})'
+      expected = ' { {{"with" => :hash} => "keys", 2 => "integers", :a => {:nested => "hash"}} }'
 
       expect(attribute.inspect_value(hash)).to eq expected
     end
@@ -46,17 +59,4 @@ describe ToFactory::Generation::Attribute do
       expect(attribute.format(input, false)).to eq expected
     end
   end
-
-  if RUBY_VERSION =~ /\A1\.8/
-    it "alters attributes that are unparseable by RubyParser" do
-      #when reparsing the generated files, we don't want the parser itself
-      #to raise an exception, rather than fix RubyParser now, a hotfix is to
-      #warn about these attributes and replace them with something parseable
-      value = File.read("./spec/support/ruby_parser_exception_causing_string.rb")
-      expect(lambda{RubyParser.new.parse(value)}).to raise_error StringScanner::Error
-      result = attribute.inspect_value(value)
-      expect(lambda{RubyParser.new.parse(result)}).not_to raise_error
-      expect(result).to match /ToFactory: RubyParser exception/
-    end
-  end
 end

data/spec/unit/generation/factory_spec.rb

@@ -11,13 +11,37 @@ describe ToFactory::Generation::Factory do
   let!(:user) { create_user! }
 
   let(:representation) { ToFactory::Representation.from(user) }
-  let(:generator) { ToFactory::Generation::Factory.new representation  }
+  let(:generator) { ToFactory::Generation::Factory.new representation }
 
+  describe "#name" do
+    context "with a simple name" do
+      let(:representation) { double "Representation", name: "some_name" }
 
+      it "adds just displays the name" do
+        expect(generator.name).to eq "some_name"
+      end
+    end
+
+    context "with a namespace" do
+      let(:representation) { double "Representation", name: "some_namespace/some_name" }
+
+      it "adds quotes to the name" do
+        expect(generator.name).to eq "some_namespace/some_name".inspect
+      end
+    end
+
+    context "with a an already quoted name in a namespace" do
+      let(:representation) { double "Representation", name: "some_namespace/some_name".inspect }
+
+      it "doesn't add extra adds quotes to the name" do
+        expect(generator.name).to eq "some_namespace/some_name".inspect
+      end
+    end
+  end
 
   describe "#header" do
     it do
-      expect(generator.header{}).to match_sexp  <<-eof.strip_heredoc
+      expect(generator.header {}).to match_sexp <<-eof.strip_heredoc
         factory(:"to_factory/user") do
         end
       eof
@@ -26,27 +50,27 @@ describe ToFactory::Generation::Factory do
 
   describe "#attributes" do
     let(:representation) do
-      double(:attributes => {"something" => "something",
-                             :id         => 123,
-                             :created_at => anything,
-                             :created_on => anything,
-                             :updated_at => anything,
-                             :updated_on => anything,
-                             nil => nil})
+      double(attributes: { "something" => "something",
+                           :id         => 123,
+                           :created_at => anything,
+                           :created_on => anything,
+                           :updated_at => anything,
+                           :updated_on => anything,
+                           nil => nil })
     end
     it "ignores blank keys, :id, :created_at, :updated_at, :created_on, :updated_on" do
-      expect(generator.attributes).to eq({"something" => "something"})
+      expect(generator.attributes).to eq("something" => "something")
     end
   end
   describe "#factory_attribute" do
     it do
-      expect(generator.factory_attribute(:name, nil))   .to eq '    name nil'
-      expect(generator.factory_attribute(:name, "Jeff")).to eq '    name "Jeff"'
-      expect(generator.factory_attribute(:id, 8))       .to eq '    id 8'
+      expect(generator.factory_attribute(:name, nil))   .to eq "    name { nil }"
+      expect(generator.factory_attribute(:name, "Jeff")).to eq '    name { "Jeff" }'
+      expect(generator.factory_attribute(:id, 8))       .to eq "    id { 8 }"
     end
     it "generates usable datetime strings" do
       output = generator.factory_attribute(:birthday, birthday)
-      expect(output).to eq '    birthday "2014-07-08T15:30 UTC"'
+      expect(output).to eq '    birthday { "2014-07-08T15:30 UTC" }'
     end
   end