blueprints_boy 1.0.0

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rspec'
+require 'blueprints_boy'
+
+ROOT = Pathname.new('../../').expand_path(__FILE__)
+
+require_relative 'support/fixtures'
+
+RSpec.configure do |config|
+  config.include Fixtures
+
+  config.after do
+    BlueprintsBoy.instance_eval do
+      @manager = nil
+      @config = nil
+      @factories = nil
+    end
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = :should, :expect
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = :should, :expect
+  end
+end

data/spec/support/fixtures.rb

@@ -0,0 +1,41 @@
+module Fixtures
+  def self.fixture(name, &block)
+    iv_name = :"@#{name}"
+    define_method(name) do |*args|
+      instance_variable_set(iv_name, instance_exec(*args, &block)) unless instance_variable_defined?(iv_name)
+      instance_variable_get(iv_name)
+    end
+  end
+
+  def create_env(klass)
+    klass.new.tap do |object|
+      object.extend(BlueprintsBoy::Helper)
+      object.instance_variable_set(:@_blueprint_data, {})
+    end
+  end
+
+  def create_blueprint(name, &block)
+    BlueprintsBoy::Blueprint.new(empty_context, name, &block)
+  end
+
+  fixture :env do
+    create_env(Object)
+  end
+
+  [1, 2, 3].each do |n|
+    fixture("mock#{n}") { "mock#{n}" }
+
+    fixture "blueprint#{n}" do |result|
+      result ||= send("mock#{n}")
+      create_blueprint("blueprint#{n}") { result }
+    end
+  end
+
+  fixture :manager do
+    BlueprintsBoy::Manager.new
+  end
+
+  fixture :empty_context do
+    BlueprintsBoy::Context.new(ROOT.join('spec/support/empty_file.rb').to_s)
+  end
+end

data/spec/support/manager_fixture.rb

@@ -0,0 +1,3 @@
+blueprint :test do
+  nil
+end

data/spec/unit/blueprint_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe BlueprintsBoy::Blueprint do
+  describe "name" do
+    it "should return name" do
+      blueprint1.name.should == :blueprint1
+    end
+  end
+
+  describe "build" do
+    it "should build blueprint" do
+      blueprint1.build(env, :create)
+      env.blueprint1.should == mock1
+    end
+
+    it "should not replace existing method" do
+      env.set :blueprint1, :correct
+      blueprint1.build(env, :create)
+      env.blueprint1.should == :correct
+    end
+  end
+
+  describe "depends_on" do
+    it "should return blueprint" do
+      blueprint1.depends_on(:blueprint2).should equal(blueprint1)
+    end
+
+    it "should allow setting dependencies" do
+      blueprint1.depends_on(:blueprint2)
+      blueprint1.context.dependencies.should == [:blueprint2]
+    end
+  end
+
+  describe "attributes & options" do
+    it "should allow creating blueprint with attributes" do
+      blueprint = described_class.new(empty_context, :blueprint, attr: 'value')
+      blueprint.context.attrs.should == {attr: 'value'}
+    end
+
+    it "should adding attributes to blueprint later" do
+      blueprint = described_class.new(empty_context, :blueprint).attributes(attr: 'value')
+      blueprint.context.attrs.should == {attr: 'value'}
+    end
+
+    it "should allow passing options" do
+      blueprint = described_class.new(empty_context, :blueprint) { |data| data.options }
+      blueprint.build(env, :create, attr: 'value')
+      env.blueprint.should == {attr: 'value'}
+    end
+
+    it "should allow using attributes with merged options in blueprint" do
+      blueprint = described_class.new(empty_context, :blueprint, attr1: 'value1', attr2: 'value2') { |data| data.attributes }
+      blueprint.build(env, :create, attr2: 'v2', attr3: 'v3')
+      env.blueprint.should == {attr1: 'value1', attr2: 'v2', attr3: 'v3'}
+    end
+
+    it "should use normalized attributes when building" do
+      BlueprintsBoy.manager.add blueprint1
+      BlueprintsBoy.manager.setup(env)
+      blueprint = described_class.new(empty_context, :blueprint, attr: empty_context.blueprint1) { |data| data.attributes }
+      blueprint.build(env, :create)
+      env.blueprint.should == {attr: mock1}
+    end
+  end
+
+  describe "name" do
+    it "should put name in data" do
+      blueprint = create_blueprint(:blueprint1) { |data| data.name }
+      blueprint.build(env, :create)
+      env.blueprint1.should == :blueprint1
+    end
+  end
+
+  describe "strategies" do
+    it "should allow having multiple strategies" do
+      blueprint1.blueprint(:options) { |data| data.options }
+      blueprint1.build(env, :options, option: 'val')
+      env.blueprint1.should == {option: 'val'}
+    end
+
+    it "should have attributes strategy" do
+      blueprint1.attributes(attr: 'val')
+      blueprint1.build(env, :attributes)
+      env.blueprint1.should == {attr: 'val'}
+    end
+
+    it "should raise error if blueprint doesn't define strategy" do
+      expect {
+        blueprint1.build(env, :not_existing_strategy)
+      }.to raise_error(BlueprintsBoy::StrategyNotFound, 'Blueprint :blueprint1 does not define strategy :not_existing_strategy')
+    end
+  end
+
+  describe "factory" do
+    it "should use factory when building blueprint" do
+      BlueprintsBoy.factories.add(Array, :create) { |data| data.factory.new(data.attributes[:size]) }
+      blueprint = create_blueprint('blueprint1').factory(Array)
+      blueprint.build(env, :create, size: 3)
+      env.blueprint1.should == Array.new(3)
+    end
+  end
+end

data/spec/unit/blueprints_boy_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe BlueprintsBoy do
+  it "should return manager" do
+    BlueprintsBoy.manager.should be_instance_of(BlueprintsBoy::Manager)
+  end
+
+  it "should return configuration" do
+    BlueprintsBoy.config.should be_instance_of(BlueprintsBoy::Configuration)
+  end
+
+  it "should return factories" do
+    BlueprintsBoy.factories.should be_instance_of(BlueprintsBoy::Factories)
+  end
+end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe BlueprintsBoy::Configuration do
+  it "should have filename with default value" do
+    subject.filenames.should == %w{blueprints.rb blueprints/*.rb spec/blueprints.rb spec/blueprints/*.rb test/blueprints.rb test/blueprints/*.rb}.collect do |f|
+      Pathname.new(f)
+    end
+  end
+
+  it "should have correct attribute values" do
+    subject.prebuild.should == []
+    subject.transactions.should be_truthy
+    subject.root.should == Pathname.pwd
+  end
+
+  it "should use Rails root for root if it's defined" do
+    module Rails
+      def self.root
+        Pathname.new('rails/root')
+      end
+    end
+    subject.root.should == Pathname.new('rails/root')
+    Object.send(:remove_const, :Rails)
+  end
+
+  it "should set root to pathname" do
+    subject.root = "root"
+    subject.root.should == Pathname.new("root")
+  end
+
+  it "should automatically set filename to array of path names" do
+    subject.filenames = "my_file.rb"
+    subject.filenames.should == [Pathname.new("my_file.rb")]
+  end
+
+  it "should set global to array of global blueprints" do
+    subject.global.should == []
+    subject.global = :cherry
+    subject.global.should == [:cherry]
+  end
+end

data/spec/unit/context_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe BlueprintsBoy::Context do
+  let :manager do
+    BlueprintsBoy::Manager.new
+  end
+
+  describe "initialize" do
+    it "should read file and callback for each blueprint" do
+      blueprints = []
+      described_class.new(ROOT.join('spec/support/manager_fixture.rb').to_s) { |blueprint| blueprints << blueprint }
+      blueprints.size.should == 1
+      blueprints.first.name.should == :test
+    end
+  end
+
+  describe "blueprint" do
+    it "should add new blueprint" do
+      blueprint = empty_context.blueprint(:blueprint1) {}
+      blueprint.should be_instance_of(BlueprintsBoy::Blueprint)
+      blueprint.name.should == :blueprint1
+    end
+
+    it "should set context" do
+      blueprint = empty_context.depends_on(:blueprint2).blueprint(:blueprint1) {}
+      blueprint.context.should be_instance_of(BlueprintsBoy::Context)
+      blueprint.context.dependencies.should == [:blueprint2]
+    end
+  end
+
+  describe "depends_on" do
+    it "should set dependencies to empty array" do
+      empty_context.dependencies.should == []
+    end
+
+    it "should create new context with dependencies set" do
+      context = empty_context.depends_on(:blueprint, :blueprint2)
+      context.should be_instance_of(BlueprintsBoy::Context)
+      context.should_not equal(empty_context)
+      context.dependencies.should == [:blueprint, :blueprint2]
+    end
+
+    it "should allow chaining dependencies" do
+      context = empty_context.depends_on(:blueprint).depends_on(:blueprint2)
+      context.dependencies.should == [:blueprint, :blueprint2]
+    end
+
+    it "should allow using block form to chain dependencies" do
+      context = nil
+      empty_context.depends_on(:blueprint) do
+        context = depends_on(:blueprint2)
+      end
+      context.dependencies.should == [:blueprint, :blueprint2]
+    end
+
+    it "should only keep uniq dependencies" do
+      context = empty_context.depends_on(:blueprint).depends_on(:blueprint)
+      context.dependencies.should == [:blueprint]
+    end
+
+    it "should not modify original dependencies" do
+      empty_context.depends_on(:blueprint)
+      empty_context.dependencies.should == []
+    end
+  end
+
+  describe "attributes" do
+    it "should set attributes to empty hash" do
+      empty_context.attrs.should == {}
+    end
+
+    it "should create new context with attributes set" do
+      context = empty_context.attributes(attr: 'val')
+      context.should be_instance_of(BlueprintsBoy::Context)
+      context.should_not equal(empty_context)
+      context.attrs.should == {attr: 'val'}
+    end
+
+    it "should allow chaining attributes using block form" do
+      context = nil
+      empty_context.attributes(attr1: 'val1', attr2: 'val2') do
+        context = attributes(attr2: 'v2', attr3: 'v3')
+      end
+      context.attrs.should == {attr1: 'val1', attr2: 'v2', attr3: 'v3'}
+    end
+
+    it "should not modify original attributes" do
+      empty_context.attributes(attr: 'val')
+      empty_context.attrs.should == {}
+    end
+  end
+
+  describe "factories" do
+    it "should set block to nil" do
+      empty_context.factory_class.should be_nil
+    end
+
+    it "should create new context with block" do
+      context = empty_context.factory(Fixnum)
+      context.factory_class.should == Fixnum
+    end
+
+    it "should allow chaining after factory" do
+      context = empty_context.factory(Fixnum).attributes(attr: 'value')
+      context.factory_class.should == Fixnum
+    end
+  end
+
+  describe "creating dependencies" do
+    it "should allow dependencies in attributes" do
+      dependency = empty_context.blueprint1
+      dependency.should be_a(BlueprintsBoy::Dependency)
+    end
+
+    it "should pass blueprint_name and options" do
+      dependency = empty_context.blueprint1(:blueprint_name, option: 'value')
+      dependency.instance_eval do
+        @name.should == :blueprint1
+        @blueprint_name.should == :blueprint_name
+        @options.should == {option: 'value'}
+      end
+    end
+  end
+
+  describe "group" do
+    before do
+      BlueprintsBoy.manager.add blueprint1
+      BlueprintsBoy.manager.add blueprint2
+      BlueprintsBoy.manager.setup env
+    end
+
+    it "should allow grouping blueprints" do
+      group, = empty_context.group(:blueprints => [:blueprint1, :blueprint2])
+      group.build(env, :create)
+      env.blueprints.should == [mock1, mock2]
+    end
+
+    it "should allow multiple groups" do
+      BlueprintsBoy.manager.add blueprint3
+      _, group2 = empty_context.group(:group1 => [:blueprint1, :blueprint2], :group2 => [:blueprint2, :blueprint3])
+      group2.build(env, :create)
+      env.group2.should == [mock2, mock3]
+    end
+  end
+end

data/spec/unit/dependency_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe BlueprintsBoy::Dependency do
+  before do
+    BlueprintsBoy.manager.add blueprint1
+    BlueprintsBoy.manager.setup env
+  end
+
+  def value(dep)
+    env.instance_eval(&dep)
+  end
+
+  it "should allow getting instance variable value" do
+    value(described_class.new(:blueprint1)).should == mock1
+  end
+
+  it "should allow getting another instance variable" do
+    preset_mock = double
+    env.set(:preset_key, preset_mock)
+    value(described_class.new(:preset_key, :blueprint1)).should == preset_mock
+  end
+
+  it "should allow passing options for building" do
+    BlueprintsBoy.manager.add(create_blueprint(:options_blueprint) { |data| data.options })
+    value(described_class.new(:options_blueprint, :option => 'value')).should == {:option => 'value'}
+  end
+
+  describe "missing methods" do
+    subject { described_class.new(:blueprint1) }
+
+    it "should record all missing methods" do
+      subject.missing_method
+      mock1.should_receive(:missing_method).and_return(mock2)
+      value(subject).should == mock2
+    end
+
+    it "should allow chaining methods" do
+      subject.missing_method.another_missing_method
+      mock1.should_receive(:missing_method).and_return(mock2)
+      mock2.should_receive(:another_missing_method).and_return(mock3)
+      value(subject).should == mock3
+    end
+
+    it "should remember parameters" do
+      subject.missing_method(1, 2)
+      mock1.should_receive(:missing_method).with(1, 2).and_return(mock2)
+      value(subject).should == mock2
+    end
+
+    it "should remember block" do
+      subject.missing_method { |value| value + 2 }
+      mock1.should_receive(:missing_method).and_yield(1)
+      value(subject).should == 3
+    end
+  end
+end

data/spec/unit/factories_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../spec_helper'
+
+describe BlueprintsBoy::Factories do
+  describe "finding" do
+    before do
+      subject.add(Integer, :create) { 5 }
+    end
+
+    it "should allow defining and finding a factory" do
+      factory = subject[Integer, :create]
+      factory.should be_instance_of(Proc)
+      factory.call.should == 5
+    end
+
+    it "should find factory for child class" do
+      factory = subject[Fixnum, :create]
+      factory.should be_instance_of(Proc)
+      factory.call.should == 5
+    end
+
+    it "should raise error if factory can't be found" do
+      expect {
+        subject[Float, :create]
+      }.to raise_error(BlueprintsBoy::FactoryNotFound, "Factory for Float can't be located")
+    end
+  end
+end

data/spec/unit/manager_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe BlueprintsBoy::Manager do
+  describe "add" do
+    it "should add blueprint" do
+      subject.add(blueprint1)
+      subject.blueprints.should == {:blueprint1 => blueprint1}
+    end
+  end
+
+  describe "find" do
+    it "should find added blueprint" do
+      subject.add(blueprint1)
+      subject.find(:blueprint1).should equal(blueprint1)
+      subject[:blueprint1].should equal(blueprint1)
+    end
+
+    it "should raise error if blueprint is not found" do
+      expect {
+        subject.find(:blueprint_not_existing)
+      }.to raise_error(BlueprintsBoy::BlueprintNotFound, 'Blueprint :blueprint_not_existing cannot be found')
+    end
+  end
+
+  describe "build" do
+    before do
+      subject.add(blueprint1)
+      subject.push_registry
+    end
+
+    it "should build blueprint" do
+      subject.build(env, [:blueprint1])
+      env.blueprint1.should == mock1
+    end
+
+    it "should add blueprint to built blueprints" do
+      subject.build(env, [:blueprint1])
+      subject.registry.built.should include(:blueprint1)
+    end
+
+    it "should not build same blueprint twice" do
+      env.should_receive(:autoset).once
+      subject.build(env, [:blueprint1, :blueprint1])
+    end
+
+    it "should use update strategy if options are present and blueprint is already built" do
+      mock1.should_receive(:update)
+      blueprint1.blueprint(:update) { blueprint1.update }
+      subject.build(env, [:blueprint1, {:blueprint1 => {option: 'value'}}])
+    end
+
+    it "should build dependencies of blueprint" do
+      subject.add blueprint2.depends_on(:blueprint1)
+      subject.build env, [:blueprint2]
+      subject.registry.built.to_a.should == [:blueprint2, :blueprint1]
+    end
+
+    it "should allow passing options" do
+      subject.add(create_blueprint(:options_blueprint) { |data| data.options[:name] })
+      subject.build(env, [{:options_blueprint => {name: 'success'}}])
+      env.options_blueprint.should == 'success'
+    end
+
+    it "should return results" do
+      subject.add(blueprint2)
+      subject.build(env, [:blueprint1, :blueprint2 => {attr: 'val'}]).should == [mock1, mock2]
+    end
+
+    it "should return 1 result if only one blueprint was built" do
+      subject.build(env, [:blueprint1]).should == mock1
+    end
+
+    it "should return results for already built blueprints" do
+      subject.build(env, [:blueprint1])
+      subject.build(env, [:blueprint1]).should == mock1
+    end
+
+    it "should allow passing strategy" do
+      blueprint1.blueprint(:new) { :new_strat }
+      subject.build(env, [:blueprint1], strategy: :new)
+      env.blueprint1.should == :new_strat
+    end
+
+    it "does not overwrite strategy with :update" do
+      counter = 0
+      blueprint1.blueprint(:counter) { counter += 1 }
+      2.times { subject.build(env, [:blueprint1], strategy: :counter) }
+      counter.should == 2
+    end
+  end
+
+  describe "setup" do
+    it "should set @_blueprint_data to {}" do
+      subject.setup(env)
+      env.instance_variable_get(:@_blueprint_data).should == {}
+    end
+
+    it "should restore blueprints from registry to @_blueprint_data" do
+      blueprint1
+      blueprint2
+      subject.add(blueprint1)
+      subject.add(blueprint2)
+
+      subject.push_registry([:blueprint1])
+      subject.push_registry([:blueprint2])
+
+      subject.setup(env)
+      env.instance_variable_get(:@_blueprint_data).should == {blueprint1: mock1, blueprint2: mock2}
+    end
+  end
+
+  describe "teardown" do
+    it "should pop registry" do
+      subject.add(blueprint1)
+      subject.push_registry
+      subject.build(env, [:blueprint1])
+
+      subject.teardown
+      subject.registry.should be_nil
+    end
+  end
+end

data/spec/unit/registry_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe BlueprintsBoy::Registry do
+  let :names do
+    [:mock1, :mock2]
+  end
+
+  subject do
+    described_class.new(names, nil)
+  end
+
+  describe "built" do
+    it "should initialize built with empty set" do
+      subject.built.should == Set.new
+    end
+
+    it "should inherit built from parent" do
+      subject.built.add :blueprint1
+      child = described_class.new(names, subject)
+      child.built.should == Set.new([:blueprint1])
+    end
+  end
+
+  describe "store/restore" do
+    it "should return {} by default" do
+      subject.restore.should == {}
+    end
+
+    it "should restore results of blueprints" do
+      subject.store mock1: mock1, mock2: mock2
+      subject.restore.should == {mock1: mock1, mock2: mock2}
+    end
+
+    it "should revert changes to restored objects" do
+      subject.store mock1: mock1, mock2: mock2
+      mock1 << ' has failed us'
+      subject.restore[:mock1].should == 'mock1'
+    end
+
+    it "should restore parent objects too" do
+      child = described_class.new([], subject)
+      subject.store mock1: mock1
+      child.store mock2: mock2
+      child.restore.should == {mock1: mock1, mock2: mock2}
+    end
+  end
+end