machinist_redux 3.0.0

data/lib/machinist/exceptions.rb

@@ -0,0 +1,30 @@
+module Machinist
+  # Raised when make! is called on a class whose blueprints don't support
+  # saving.
+  class BlueprintCantSaveError < RuntimeError
+    attr_reader :blueprint
+
+    def initialize(blueprint)
+      @blueprint = blueprint
+    end
+
+    def message
+      "make! is not supported by blueprints for class #{@blueprint.klass.name}"
+    end
+  end
+
+  # Raised when calling make on a class with no corresponding blueprint
+  # defined.
+  class NoBlueprintError < RuntimeError
+    attr_reader :klass, :name
+
+    def initialize(klass, name)
+      @klass = klass
+      @name  = name
+    end
+
+    def message
+      "No #{@name} blueprint defined for class #{@klass.name}"
+    end
+  end
+end

data/lib/machinist/lathe.rb

@@ -0,0 +1,65 @@
+module Machinist
+  # When you make an object, the blueprint for that object is instance-evaled
+  # against a Lathe.
+  #
+  # The Lathe implements all the methods that are available to the blueprint,
+  # including method_missing to let the blueprint define attributes.
+  class Lathe
+    def initialize(klass, serial_number, attributes = {})
+      @klass               = klass
+      @serial_number       = serial_number
+      @assigned_attributes = {}
+
+      @object              = @klass.new
+      attributes.each { |key, value| assign_attribute(key, value) }
+    end
+
+    # Returns a unique serial number for the object under construction.
+    def sn
+      @serial_number
+    end
+
+    # Returns the object under construction.
+    attr_reader :object
+
+    def method_missing(attribute, *args, &block) #:nodoc:
+      unless attribute_assigned?(attribute)
+        assign_attribute(attribute, make_attribute(attribute, args, &block))
+      end
+    end
+
+    # Undef a couple of methods that are common ActiveRecord attributes.
+    # (Both of these are deprecated in Ruby 1.8 anyway.)
+    undef_method :id   if respond_to?(:id)
+    undef_method :type if respond_to?(:type)
+
+    protected
+
+    def make_attribute(attribute, args, &block) #:nodoc:
+      count = args.shift if args.first.is_a?(0.class)
+      if count
+        Array.new(count) { make_one_value(attribute, args, &block) }
+      else
+        make_one_value(attribute, args, &block)
+      end
+    end
+
+    def make_one_value(attribute, args) #:nodoc:
+      raise_argument_error(attribute) unless args.empty?
+      yield
+    end
+
+    def assign_attribute(key, value) #:nodoc:
+      @assigned_attributes[key.to_sym] = value
+      @object.send("#{key}=", value)
+    end
+
+    def attribute_assigned?(key) #:nodoc:
+      @assigned_attributes.key?(key.to_sym)
+    end
+
+    def raise_argument_error(attribute) #:nodoc:
+      raise ArgumentError, "Invalid arguments to attribute #{attribute} in blueprint"
+    end
+  end
+end

data/lib/machinist/machinable.rb

@@ -0,0 +1,100 @@
+module Machinist
+  # Extend classes with this module to define the blueprint and make methods.
+  module Machinable
+    # Define a blueprint with the given name for this class.
+    #
+    # e.g.
+    #   Post.blueprint do
+    #     title { "A Post" }
+    #     body  { "Lorem ipsum..." }
+    #   end
+    #
+    # If you provide the +name+ argument, a named blueprint will be created.
+    # See the +blueprint_name+ argument to the make method.
+    def blueprint(name = :master, &block)
+      @blueprints ||= {}
+      if block_given?
+        parent = (name == :master ? superclass : self) # Where should we look for the parent blueprint?
+        @blueprints[name] = blueprint_class.new(self, parent: parent, &block)
+      end
+      @blueprints[name]
+    end
+
+    # Construct an object from a blueprint.
+    #
+    # :call-seq:
+    #   make([count], [blueprint_name], [attributes = {}])
+    #
+    # [+count+]
+    #   The number of objects to construct. If +count+ is provided, make
+    #   returns an array of objects rather than a single object.
+    # [+blueprint_name+]
+    #   Construct the object from the named blueprint, rather than the master
+    #   blueprint.
+    # [+attributes+]
+    #   Override the attributes from the blueprint with values from this hash.
+    def make(*args)
+      decode_args_to_make(*args) do |blueprint, attributes|
+        blueprint.make(attributes)
+      end
+    end
+
+    # Construct and save an object from a blueprint, if the class allows saving.
+    #
+    # :call-seq:
+    #   make!([count], [blueprint_name], [attributes = {}])
+    #
+    # Arguments are the same as for make.
+    def make!(*args)
+      decode_args_to_make(*args) do |blueprint, attributes|
+        raise BlueprintCantSaveError, blueprint unless blueprint.respond_to?(:make!)
+        blueprint.make!(attributes)
+      end
+    end
+
+    # Remove all blueprints defined on this class.
+    def clear_blueprints!
+      @blueprints = {}
+    end
+
+    # Classes that include Machinable can override this method if they want to
+    # use a custom blueprint class when constructing blueprints.
+    #
+    # The default is Machinist::Blueprint.
+    def blueprint_class
+      Machinist::Blueprint
+    end
+
+    private
+
+    # Parses the arguments to make.
+    #
+    # Yields a blueprint and an attributes hash to the block, which should
+    # construct an object from them. The block may be called multiple times to
+    # construct multiple objects.
+    def decode_args_to_make(*args) #:nodoc:
+      count, name, attributes = *decode_args(args)
+      blueprint = ensure_blueprint(name)
+
+      if count.nil?
+        yield(blueprint, attributes)
+      else
+        Array.new(count) { yield(blueprint, attributes) }
+      end
+    end
+
+    def decode_args(args)
+      shift_arg  = ->(klass) { args.shift if args.first.is_a?(klass) }
+      count      = shift_arg[0.class]
+      name       = shift_arg[Symbol] || :master
+      attributes = shift_arg[Hash]   || {}
+      raise ArgumentError, "Couldn't understand arguments" unless args.empty?
+      [count, name, attributes]
+    end
+
+    def ensure_blueprint(name)
+      @blueprints ||= {}
+      @blueprints[name] || raise(NoBlueprintError.new(self, name))
+    end
+  end
+end

data/lib/machinist/version.rb

@@ -0,0 +1,3 @@
+module Machinist
+  VERSION = '3.0.0'.freeze
+end

data/machinist.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'machinist/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'machinist_redux'
+  gem.version       = Machinist::VERSION
+  gem.authors       = ['Pete Yandell', 'Attila Györffy', 'Dominic Sayers']
+  gem.email         = ['dominic@sayers.cc']
+  gem.description   = 'Machinist makes it easy to create objects for use in tests. It generates data for the ' \
+                      "attributes you don't care about, and constructs any necessary associated objects, leaving you "\
+                      'to specify only the fields you care about in your test.'
+  gem.summary       = "Fixtures aren't fun. Machinist was."
+  gem.homepage      = 'http://github.com/dominicsayers/machinist'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  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']
+end

data/spec/machinist/active_record_spec.rb

@@ -0,0 +1,106 @@
+require 'support/active_record_environment'
+
+RSpec.describe Machinist::ActiveRecord do
+  include ActiveRecordEnvironment
+
+  before do
+    empty_database!
+  end
+
+  context 'make' do
+    it 'returns an unsaved object' do
+      Post.blueprint {}
+      post = Post.make
+      expect(post).to be_a(Post)
+      expect(post).to be_new_record
+    end
+  end
+
+  context 'make!' do
+    it 'makes and saves objects' do
+      Post.blueprint {}
+      post = Post.make!
+      expect(post).to be_a(Post)
+      expect(post).not_to be_new_record
+    end
+
+    it 'raises an exception for an invalid object' do
+      User.blueprint {}
+      expect do
+        User.make!(username: '')
+      end.to raise_error(ActiveRecord::RecordInvalid)
+    end
+  end
+
+  context 'associations support' do
+    it 'handles belongs_to associations' do
+      User.blueprint do
+        username { "user_#{sn}" }
+      end
+      Post.blueprint do
+        author
+      end
+      post = Post.make!
+      expect(post).to be_a(Post)
+      expect(post).not_to be_new_record
+      expect(post.author).to be_a(User)
+      expect(post.author).not_to be_new_record
+    end
+
+    it 'handles has_many associations' do
+      Post.blueprint do
+        comments(3)
+      end
+      Comment.blueprint {}
+      post = Post.make!
+      expect(post).to be_a(Post)
+      expect(post).not_to be_new_record
+      expect(post.comments.size).to eq(3)
+      post.comments.each do |comment|
+        expect(comment).to be_a(Comment)
+        expect(comment).not_to be_new_record
+      end
+    end
+
+    it 'handles habtm associations' do
+      Post.blueprint do
+        tags(3)
+      end
+      Tag.blueprint do
+        name { "tag_#{sn}" }
+      end
+      post = Post.make!
+      expect(post).to be_a(Post)
+      expect(post).not_to be_new_record
+      expect(post.tags.size).to eq(3)
+      post.tags.each do |tag|
+        expect(tag).to be_a(Tag)
+        expect(tag).not_to be_new_record
+      end
+    end
+
+    it 'handles overriding associations' do
+      User.blueprint do
+        username { "user_#{sn}" }
+      end
+      Post.blueprint do
+        author { User.make(username: "post_author_#{sn}") }
+      end
+      post = Post.make!
+      expect(post).to be_a(Post)
+      expect(post).not_to be_new_record
+      expect(post.author).to be_a(User)
+      expect(post.author).not_to be_new_record
+      expect(post.author.username).to match(/^post_author_\d+$/)
+    end
+  end
+
+  context 'error handling' do
+    it 'raises an exception for an attribute with no value' do
+      User.blueprint { username }
+      expect do
+        User.make
+      end.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/machinist/blueprint_inheritance_spec.rb

@@ -0,0 +1,101 @@
+require 'ostruct'
+
+module InheritanceSpecs
+  class Grandpa
+    extend Machinist::Machinable
+    attr_accessor :name, :age
+  end
+
+  class Dad < Grandpa
+    extend Machinist::Machinable
+    attr_accessor :name, :age
+  end
+
+  class Son < Dad
+    extend Machinist::Machinable
+    attr_accessor :name, :age
+  end
+end
+
+RSpec.describe Machinist::Blueprint do
+  describe 'explicit inheritance' do
+    it 'inherits attributes from the parent blueprint' do
+      parent_blueprint = described_class.new(OpenStruct) do
+        name { 'Fred' }
+        age  { 97 }
+      end
+
+      child_blueprint = described_class.new(OpenStruct, parent: parent_blueprint) do
+        name { 'Bill' }
+      end
+
+      child = child_blueprint.make
+      expect(child.name).to eq('Bill')
+      expect(child.age).to eq(97)
+    end
+
+    it 'takes the serial number from the parent' do
+      parent_blueprint = described_class.new(OpenStruct) do
+        parent_serial { sn }
+      end
+
+      child_blueprint = described_class.new(OpenStruct, parent: parent_blueprint) do
+        child_serial { sn }
+      end
+
+      expect(parent_blueprint.make.parent_serial).to eq('0001')
+      expect(child_blueprint.make.child_serial).to eq('0002')
+      expect(parent_blueprint.make.parent_serial).to eq('0003')
+    end
+  end
+
+  describe 'class inheritance' do
+    before do
+      [InheritanceSpecs::Grandpa, InheritanceSpecs::Dad, InheritanceSpecs::Son].each(&:clear_blueprints!)
+    end
+
+    it 'inherits blueprinted attributes from the parent class' do
+      InheritanceSpecs::Dad.blueprint do
+        name { 'Fred' }
+      end
+      InheritanceSpecs::Son.blueprint {}
+      expect(InheritanceSpecs::Son.make.name).to eq('Fred')
+    end
+
+    it 'overrides blueprinted attributes in the child class' do
+      InheritanceSpecs::Dad.blueprint do
+        name { 'Fred' }
+      end
+      InheritanceSpecs::Son.blueprint do
+        name { 'George' }
+      end
+      expect(InheritanceSpecs::Dad.make.name).to eq('Fred')
+      expect(InheritanceSpecs::Son.make.name).to eq('George')
+    end
+
+    it 'inherits from blueprinted attributes in ancestor class' do
+      InheritanceSpecs::Grandpa.blueprint do
+        name { 'Fred' }
+      end
+      InheritanceSpecs::Son.blueprint {}
+      expect(InheritanceSpecs::Grandpa.make.name).to eq('Fred')
+      expect { InheritanceSpecs::Dad.make }.to raise_error(RuntimeError)
+      expect(InheritanceSpecs::Son.make.name).to eq('Fred')
+    end
+
+    it 'follows inheritance for named blueprints correctly' do
+      InheritanceSpecs::Dad.blueprint do
+        name { 'John' }
+        age  { 56 }
+      end
+      InheritanceSpecs::Dad.blueprint(:special) do
+        name { 'Paul' }
+      end
+      InheritanceSpecs::Son.blueprint(:special) do
+        age { 37 }
+      end
+      expect(InheritanceSpecs::Son.make(:special).name).to eq('John')
+      expect(InheritanceSpecs::Son.make(:special).age).to eq(37)
+    end
+  end
+end

data/spec/machinist/blueprint_spec.rb

@@ -0,0 +1,76 @@
+require 'ostruct'
+
+RSpec.describe Machinist::Blueprint do
+  it 'makes an object of the given class' do
+    blueprint = described_class.new(OpenStruct) {}
+    expect(blueprint.make).to be_an(OpenStruct)
+  end
+
+  it 'constructs an attribute from the blueprint' do
+    blueprint = described_class.new(OpenStruct) do
+      name { 'Fred' }
+    end
+    expect(blueprint.make.name).to eq('Fred')
+  end
+
+  it 'constructs an array for an attribute in the blueprint' do
+    blueprint = described_class.new(OpenStruct) do
+      things(3) { Object.new }
+    end
+    things = blueprint.make.things
+    expect(things).to be_an(Array)
+    expect(things.size).to eq(3)
+    things.each { |thing| expect(thing).to be_an(Object) }
+    expect(things.uniq).to eq(things)
+  end
+
+  it 'allows passing in attributes to override the blueprint' do
+    block_called = false
+    blueprint = described_class.new(OpenStruct) do
+      name do
+        block_called = true
+        'Fred'
+      end
+    end
+    expect(blueprint.make(name: 'Bill').name).to eq('Bill')
+    expect(block_called).to be_falsey
+  end
+
+  it 'provides a serial number within the blueprint' do
+    blueprint = described_class.new(OpenStruct) do
+      name { "Fred #{sn}" }
+    end
+    expect(blueprint.make.name).to eq('Fred 0001')
+    expect(blueprint.make.name).to eq('Fred 0002')
+  end
+
+  it 'provides access to the object being constructed within the blueprint' do
+    blueprint = described_class.new(OpenStruct) do
+      title { 'Test' }
+      body  { object.title }
+    end
+    expect(blueprint.make.body).to eq('Test')
+  end
+
+  it 'allows attribute names to be strings' do
+    blueprint = described_class.new(OpenStruct) do
+      name { 'Fred' }
+    end
+    expect(blueprint.make('name' => 'Bill').name).to eq('Bill')
+  end
+
+  # These are normally a problem because of name clashes with the standard (but
+  # deprecated) Ruby methods. This test makes sure we work around this.
+  it 'works with type and id attributes' do
+    klass = Class.new do
+      attr_accessor :id, :type
+    end
+    blueprint = described_class.new(klass) do
+      id   { 'custom id' }
+      type { 'custom type' }
+    end
+    object = blueprint.make
+    expect(object.id).to eq('custom id')
+    expect(object.type).to eq('custom type')
+  end
+end