faker_maker 1.1.4 → 1.1.9

data/docs/contributing.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Contributing
+nav_order: 3
+---
+
+# Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/BillyRuffian/faker_maker.

data/docs/credits.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Credits
+nav_order: 4
+---
+
+# Extra Credit
+
+Unipug logo by [1smr1](https://pixabay.com/users/1smr1-4646356/?utm_source=link-attribution&utm_medium=referral&utm_campaign=image&utm_content=2970825) from [Pixabay](https://pixabay.com/?utm_source=link-attribution&utm_medium=referral&utm_campaign=image&utm_content=2970825).

data/docs/index.md

@@ -0,0 +1,21 @@
+---
+layout: default
+title: Home
+nav_order: 1
+permalink: /
+---
+
+# Factories over fixtures
+{: .fs-9 }
+
+
+FakerMaker is a simple factory builder so you can throw away your fixtures and generate test data instead.
+{: .fs-6 .fw-300 }
+
+---
+
+Sometimes you need generate data; something testers need to do a lot. Often, a bunch of fixtures will be built by hand, carefully maintained and curated, until the API or schema or something changes and all the fixtures need to be pruned before the tests pass again. This drives testers into building fixtures which individually cover lots of acceptance critera just so that they can drive down the number of them they have to maintain until the fixtures don't resemble anything like realistic criteria.
+
+If you're testing a Rails application, you can use the awesome [FactoryBot](https://github.com/thoughtbot/factory_bot) to generate faked model instances but what if you're not using Rails or you don't have model classes or you're testing an API? This is what Faker Maker aims to help with.
+
+It is designed to resemble the Factory Bot gem but without needing an existing class definition to back its object and so it goes without saying that it offers no persistence mechanism. Its purpose is to provide a simple framework for generating data to test JSON APIs and is intended to be used with the [Faker](https://github.com/stympy/faker) gem (but has no dependency upon it).

data/docs/installation.md

@@ -0,0 +1,21 @@
+---
+layout: default
+title: Installation
+nav_order: 2
+---
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'faker_maker'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install faker_maker

data/docs/usage/arrays.md

@@ -0,0 +1,44 @@
+---
+layout: default
+title: Arrays
+parent: Usage
+nav_order: 2
+---
+
+# Arrays
+
+It is possible to declare an attribute as having multiple values.
+
+```ruby
+FakerMaker.factory :basket do
+  items( has: 10 ) { Faker::Commerce.product_name }
+end
+```
+
+or to pick random number of attributes from a range:
+
+```ruby
+FakerMaker.factory :basket do
+  items( has: 5..20 ) { Faker::Commerce.product_name }
+end
+```
+
+A range always generates an array, even if the range produces 1 items or the range is `0..1`.
+
+It is possible to force an attribute to always be an array, even if only produces one item.
+
+```ruby
+FakerMaker.factory :basket do
+  items( array: true ) { Faker::Commerce.product_name }
+end
+```
+
+You can always use long-form block syntax...
+
+```ruby
+FakerMaker.factory :basket do
+  items has: 5..20 do
+    Faker::Commerce.product_name
+  end
+end
+```

data/docs/usage/building_instances.md

@@ -0,0 +1,64 @@
+---
+layout: default
+title: Building Instances
+parent: Usage
+nav_order: 6
+---
+
+# Building Instances
+
+Instances are Plain Ol' Ruby Objects and the attributes are attached with getters and setters with their values assigned to the value return from their block at build time. 
+
+To build an object:
+
+```ruby
+result = FakerMaker[:basket].build
+```
+
+will generate a new instance using the Basket factory. Because an actual class is defined, you can instantiate an object directly through `Basket.new` but that will not populate any of the attributes.
+
+It's possible to override attributes at build-time, either by passing values as a hash:
+
+```ruby
+result = FakerMaker[:item].build( name: 'Electric Blanket' )
+```
+
+or by passing in a block:
+
+```ruby
+result = FakerMaker[:item].build{ |i| i.name = 'Electric Sheep' }
+```
+
+this is particularly useful for overriding nested values, since all the getters and setters of the embedded objects are already constructed:
+
+```ruby
+result = FakerMaker[:basket].build do |b| 
+  b.items.first.name = 'Neon Badger'
+end
+```
+
+if you're crazy enough to want to do both styles during creation, the values in the block will be preserved, e.g.
+
+```ruby
+result = FakerMaker[:item].build( name: 'Electric Blanket' ) do |i| 
+  i.name = 'Electric Sheep'
+end
+```
+
+then the value of `result.name` is 'Electric Sheep'.
+
+Beware when overriding values in this way: there is no type checking. You will get an exception if you try to set a value to an attribute that doesn't exist but you won't get one if you assign, say, an array of values where you would otherwise have a string and vice versa.
+
+Calling `result.to_json` will give a stringified JSON representation. Because ActiveSupport is used under the covers, `as_json` will give you a `Hash` rather than the stringified version.
+
+As a convenience, you can request a JSON representation directly:
+
+```ruby
+result = FakerMaker[:basket].to_json
+```
+
+As another convenience, `FakerMaker` is also assigned to the variable `FM` to it is possible to write just:
+
+```ruby
+result = FM[:basket].build
+```

data/docs/usage/dependencies.md

@@ -0,0 +1,10 @@
+---
+layout: default
+title: Managing Dependencies
+parent: Usage
+nav_order: 3
+---
+
+# Managing Dependencies
+
+Factory definition files are Plain Ol' Ruby. If you depend on another factory because you either extend from it or use it just add a `require` or (depending on your load path) `require_relative` to the top of your file. 

data/docs/usage/destroying_factories.md

@@ -0,0 +1,54 @@
+---
+layout: default
+title: Destroying Factories
+parent: Usage
+nav_order: 9
+---
+
+## A Cautionary Tale
+
+If you think you want to do this, you are probably wrong. This will not only de-register the factory from Faker Maker, but also delete the class definition from the interpreter. While it's cool that Ruby allows this, it's almost certainly going to hurt. 
+
+This functionality exists for experimenting with factories in REPLs.
+
+Seriously, don't use this in anger.
+
+# Destroying Factories
+
+Faker Maker deliberately does not allow you to redefine a factory by redeclaring it. It will also be silent about your attempt to do so. This is to avoid throwing up runtime warning from the Ruby interpreter if you are embedding one factory definition in another.
+
+For example, this might give you unexpected behavior:
+
+```ruby
+FakerMaker.factory :user do 
+  name {'Patsy Stone'}
+end
+
+FakerMaker.factory :user do 
+  name {'Patsy Stone'}
+  email {'patsy@fabulous.co.uk'}
+end
+
+FM[:user].as_json
+ => {:name=>"Patsy Stone"}
+```
+
+On the other hand, sometimes you really, really want to destroy a factory and start again (especially if you are experimenting in a REPL for example). FakerMaker allows you to shut a factory which will de-register it from the list of available factories and attempt to unload the class it has built from the Ruby interpreter.
+
+```ruby
+FakerMaker.factory :user do 
+  name {'Patsy Stone'}
+end
+
+FakerMaker.shut!(:user)
+
+FakerMaker.factory :user do 
+  name {'Patsy Stone'}
+  email {'patsy@fabulous.co.uk'}
+end
+
+FM[:user].as_json
+ => {:name=>"Patsy Stone", :email=>"patsy@fabulous.co.uk"}
+ ```
+ 
+ It also provides the `shut_all!` method to remove all factories.

data/docs/usage/embedding_factories.md

@@ -0,0 +1,23 @@
+---
+layout: default
+title: Embedding Factories
+parent: Usage
+nav_order: 8
+---
+
+# Embedding Factories
+
+To use factories with factories, the following pattern is recommended:
+
+```ruby
+FakerMaker.factory :item do
+  name { Faker::Commerce.product_name }
+  price { Faker::Commerce.price }
+end
+
+FakerMaker.factory :basket do
+  items( has: 10 ) { FakerMaker[:item].build }
+end
+```
+
+You might have to [manage your dependencies]({% link usage/dependencies.md %}) and `require` your referenced factory.

data/docs/usage/index.md

@@ -0,0 +1,52 @@
+---
+layout: default
+title: Usage
+nav_order: 3
+has_children: true
+---
+
+# Usage
+
+FakerMaker generates factories that build disposable objects for testing. Each factory has a name and a set of attributes.
+
+```ruby
+FakerMaker.factory :user do 
+  name {'Patsy Stone'}
+  email {'patsy@fabulous.co.uk'}
+  admin {false}
+end
+```
+
+This will generate a `User` class with the attributes `name`, `email` and `admin` which will always return the same value.
+
+It is possible to explicitly set the name of class which is particularly useful if there is a risk of redefining an existing one.
+
+```ruby
+FakerMaker.factory :user, class: 'EmailUser' do 
+  name {'Patsy Stone'}
+  email {'patsy@fabulous.co.uk'}
+  admin {false}
+end
+```
+
+The class name will always be turned into a Ruby-style class name so `email_user` would become `EmailUser`.
+
+Because of the block syntax in Ruby, defining attributes as `Hash`es requires two sets of curly brackets:
+
+```ruby
+FakerMaker.factory :response do 
+  body { { title: 'First Post', content: 'This is part of a hash' } }
+end
+```
+
+Blocks are executed in the context of their instance. This means you can refer to variables already defined:
+
+```ruby
+FakerMaker.factory :user, class: 'EmailUser' do 
+  title {'Ms'}
+  name {'Patsy Stone'}
+  formal_name {"#{title} #{name}"}
+  email {'patsy@fabulous.co.uk'}
+  admin {false}
+end
+```

data/docs/usage/inheritance.md

@@ -0,0 +1,37 @@
+---
+layout: default
+title: Inheritance
+parent: Usage
+nav_order: 1
+---
+
+# Inheritance
+
+FakerMaker can exploit the Ruby class hierarchy to provide additional specialisation or to override some behaviours:
+
+```ruby
+FakerMaker.factory :vehicle do
+  wheels { 4 }
+  colour { Faker::Color.color_name }
+  engine_capacity { rand( 600..2500 ) }
+end
+
+FakerMaker.factory :motorbike, parent: :vehicle do
+  wheels { 2 }
+  sidecar { [true, false].sample }
+end
+```
+
+This is the equivalent of: 
+
+```ruby
+class Vehicle < Object
+  # ...
+end
+
+class Motorbike < Vehicle
+  # ...
+end
+```
+
+so a motorbike will still have a colour and engine capacity between 600 and 2500.

data/docs/usage/json_field_names.md

@@ -0,0 +1,29 @@
+---
+layout: default
+title: JSON Field Names
+parent: Usage
+nav_order: 4
+---
+
+# JSON Field Names
+
+JavaScript likes to use camelCase, Ruby's idiom is to use snake_case. This can make make manipulating factory-built objects in ruby ugly. To avoid this, you can call your fields one thing and ask the JSON outputter to rename the field when generating JSON.
+
+```ruby
+FakerMaker.factory :vehicle do
+  wheels { 4 }
+  colour { Faker::Color.color_name }
+  engine_capacity(json: 'engineCapacity') { rand( 600..2500 ) }
+end
+
+v = FM[:vehicle].build
+v.engine_capacity = 125
+```
+
+and calls to `as_json` and `to_json` will report the fieldname as `engineCapacity`.
+
+```ruby
+v.to_json
+
+=> "{\"wheels\":4,\"colour\":\"blue\",\"engineCapacity\":125}"
+```

data/docs/usage/lifecycle_hooks.md

@@ -0,0 +1,33 @@
+---
+layout: default
+title: Lifecycle Hooks
+parent: Usage
+nav_order: 8
+---
+
+# Lifecycle Hooks
+
+Faker Maker has a few hooks which can be added to the factory which are triggered when the factory builds an instance.
+
+* `before_build` the instance has been created but none of the values have been set yet
+* `after_build` the instance has been created and all of the values have been set
+
+For instance:
+
+```ruby
+FakerMaker.factory :user do 
+  before_build do
+    puts 'Building an instance of User'
+  end
+
+  name {'Patsy Stone'}
+  email {'patsy@fabulous.co.uk'}
+  admin {false}
+  
+  after_build do
+    puts "Built an instance of User (#{faker_maker_factory.instance.name})"
+  end
+end
+```
+
+Access to the factory object is through the `faker_maker_factory` method. The instance under construction is available through the `faker_maker_factory.instance` method.

data/docs/usage/omitting_fields copy.md

@@ -0,0 +1,42 @@
+---
+layout: default
+title: Omitting Fields
+parent: Usage
+nav_order: 5
+---
+
+# Omitting Fields
+
+Sometimes you want a field present, other times you don't. This is often the case when you want to skip fields which have null or empty values.
+
+```ruby
+FakerMaker.factory :user do 
+  name {'Patsy Stone'}
+  email(omit: :nil) {'patsy@fabulous.co.uk'}
+  admin {false}
+end
+
+FM[:user].build.as_json
+=> {:name=>"Patsy Stone", :email=>"patsy@fabulous.co.uk", :admin=>false}
+
+FM[:user].build(email: nil).as_json
+=> {:name=>"Patsy Stone", :admin=>false}
+```
+
+The `omit` modifier can take a single value or an array. If it is passed a value and the attribute equals this value, it will not be included in the output from `as_json` (which returns a Ruby Hash) or in `to_json` methods.
+
+There are three special modifiers:
+
+* `:nil` (symbol) to omit output when the attribute is set to nil
+* `:empty` to omit output when the value is an empty string, an empty array or an empty hash
+* `:always` to never output this attribute.
+
+These can be mixed with real values, e.g.
+
+```ruby
+FakerMaker.factory :user do 
+  name {'Patsy Stone'}
+  email(omit: [:nil, :empty, 'test@foobar.com']) {'patsy@fabulous.co.uk'}
+  admin {false}
+end
+```