View source for Bogus (Ruby)


'''Bogus''' is a [[Ruby (programming language)|Ruby]] [[Application programming interface|API]] library used for minimizing risks involved in isolated [[Unit testing|unit testing]]. It was initially released in July 2012 by rubygems.org.<ref>{{cite web|url=https://rubygems.org/|title=RubyGems.org - your community gem host|website=rubygems.org}}</ref> Through Bogus, a piece of code can be tested in a fast and safe manner, without any actual integration with external programs. Bogus cannot mock or stub methods not present in the required external environment.

{{Infobox programming language
| name =       Bogus
| logo =       
| logo caption = 
| screenshot = <!-- (filename) -->
| screenshot caption = 
| paradigm =   
| family =  
| released =   30 July 2012
| designer =   Adam Pohorecki, Paweł Pierzchała, Piotr Szotkowski, Marek Nowak
| developer =  <!-- or: | developers = -->
| discontinued =
| latest release version =0.1.6 
| latest release date = 2 January 2015
| latest preview version = 
| latest preview date = <!-- {{Start date and age|YYYY|MM|DD|df=yes/no}} -->
| typing = 
| scope = 
| implementations = 
| dialects = 
| influenced by = 
| influenced = 
| programming language =Ruby 
| platform = 
| operating system = 
| license =The MIT License (MIT)
Copyright (c) 2012-2013 Adam Pohorecki 
| website =     https://rubygems.org/gems/bogus
| file ext = 
| file format = <!-- or: | file formats = -->
}}

== Features ==
Ruby provides various features to achieve the required testing framework.

=== Fakes ===
Fakes are lightweight objects that mock actual objects' interface. In order to test a class in isolation, usually some [[Test double|test double]]s or anonymous objects are used in place of integrated classes with required methods stubbed in it. But there is a problem with this approach, If the class is changed in between, those changes are not reflected in mock objects and tests run without any integration exceptions. Fakes resolve this problem as they will have exact interface of real collaborator and will raise an exception whenever the actual class is modified.

Fakes can be implemented using the following methodologies.

==== Faking existing classes ====
A fake is created by calling fake method:

Syntax:

<code>fake(fake_name, options) { ClassToCopy }</code>

"fake_name" is the name of the created fake and can be used to identify the fake while using contract tests. if it is omitted then an anonymous fake is created. A fake provides options to return an instance or a copy of class depending on the requirement. Fakes can be applied to stub methods as well.

==== Global configuration ====
Fakes avoid the need of stubbing and eliminate much of configuration things like (<code>as: :class</code> / <code>as: :instance</code><ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/fakes/global-fake-configuration|title=Global fake configuration - Fakes - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-13}}</ref>).  Regardless, this type of configuration should be added to fake definitions, and the more collaborators one has, there will be more duplication. Bogus deals with this problem by introducing DSL <ref>{{Cite web|url=https://www.infoq.com/news/2007/06/dsl-or-not|title=What's a Ruby DSL and what isn't?|website=InfoQ|access-date=2017-02-10}}</ref> to configure fakes in a single place, thus unifying its use in all the tests. Stubbed methods can be overridden using fake macros or fake helper functions.

==== Nameless test doubles ====
Anonymous test doubles can be used as intermediate steps while migrating objects from another testing library. They help in observing methods without mocking them. Methods can be stubbed: 
* with any number of arguments 
* in an initialize method 
* inline  
* to invoke arbitrary methods

==== Replacing classes  ====
Usually dependency injections are used to make the composition of classes easy and make the code more modular. Replacement of classes with fakes avoids this requirement. Different fake names can be given to created fake classes.

==== Duck type faking ====
A system may have multiple classes implementing a single function. This complicates the selection of an implementation for that particular scenario. Bogus solves this problem by creating a [[Duck typing|duck type]] for classes.

Syntax to create a duck type:

<code>make_duck(Class 1, Class 2, Class 3)</code>

Bogus simplifies it further by creating duck types automatically when more than one class are returned from fake. Indeed, it does it in global configuration as well.

=== Contract tests ===
In order to verify that [[Exception handling|exception handling]] is done as expected in the fake stub, a sample test should be written for the mock object. This test is not written by Bogus, but it reminds the developer to do so.

verify_contract<ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/contract-tests|title=Contract Tests - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-13}}</ref>(object) method records all the interceptions made with the real class, and fails the test if any scenario recorded on a fake object that has been forgotten to be tested.

Whenever an object is mocked, stubbed or spied, a contract is specified on input/output parameters. Bogus automatically verifies whether the contract is satisfied or not.  They fail when mocked or stubbed methods are not called on real objects. Contract tests not only check whether correct number of parameters are passed but also makes sure that the object is tested with right arguments.

Contract verification can be identified correctly only when passed block of code or arguments are idempotent<ref>{{Cite web|url=http://restcookbook.com/HTTP%20Methods/idempotency/|title=What are idempotent and/or safe methods? - The RESTful cookbook|website=restcookbook.com|access-date=2017-02-13}}</ref> and without any side effects.

=== Stubbing ===
In addition to fakes, bogus allows [[Method stub|stubs]] in the cases where the [[Inversion of control|inversion of control]] principle is not used. They follow two conditions:
# The method that is being stubbed should exist.
# The passing parameters need to be consistent. It retains the method signature. 
The syntax is similar to that of ruby stubbing:<ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/safe-stubbing|title=Safe Stubbing - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-11}}</ref><source lang="ruby">
# RR syntax
stub(object).method_name { return_value }

# Bogus syntax
stub(object).method_name(any_args) { return_value }
</source> The main difference between fakes and stubbing is that in fakes, method call can be verified before stubbing. But in stubbing, to verify that a method call has occurred, stubbing beforehand is necessary.

==== Safe mocking ====
Mocks are used to test an object in isolation. These help to find out if there is proper communication between the object and its collaborators. Mocks are like stubs in the way that the object and the method being mocked need to exist.

Syntax:<ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/safe-stubbing/safe-mocking|title=Safe mocking - Safe Stubbing - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-11}}</ref><source lang="ruby">
mock(object).method_name(*args) { return_value }
</source>

==== Spies ====
When the code is being tested, the message transmission and reception is a vital part. This is verified using spies. They are used to specify what needs to happen in the ideal case. Spies verify that a method is called before stubbing it.

==== Argument matchers ====
Argument matchers are helpful when the details of the passing arguments are not as important as knowing if the method is being called or not. Instead of the actual arguments, some matchers like [[Wildcard character|wildcard entries]] or [[Regular expression|regular expression]]s can be used.<ref>{{Cite web|title=Bogus: A Brief Introduction|url=http://bogus-wrug-2013-07.herokuapp.com|language=en}}</ref><ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/safe-stubbing/argument-matchers|title=Argument matchers - Safe Stubbing - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-12}}</ref>

=== Configuration options ===
Bogus configuration syntax:<ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/configuration|title=Configuration Options - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-11}}</ref><source lang="ruby" line="1">
Bogus.configure do |c|
  c.search_modules = [Object]
  c.fake_ar_attributes = true
end
</source>

==== Search_modules ====
By default, Bogus does not maintain a namespace. Therefore, during the search for a particular class(to resolve a class name), the search is performed on all of the identifiers. In order to  narrow down the search space, Search_modules can be customized to include a particular module of classes. For example:<ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/configuration/search-modules|title=search_modules - Configuration Options - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-11}}</ref><source lang="ruby">
Bogus.configure do |c|
  c.search_modules << Bar
end
</source>Here, 'Bar' is a module which contains a set of classes where the search has to be performed.

==== Fake_ar_modules ====
This feature deals with the ActiveRecord::Base<ref>{{cite web|url=http://www.rubydoc.info/docs/rails/3.1.1/ActiveRecord/Base|title=Class: ActiveRecord::Base — Documentation for rails (3.1.1)|website=www.rubydoc.info}}</ref> class. Here, the [[Active record pattern|Active Record]] is a module and Base is one of its classes. Active Record's attributes are not explicit. Their modification is done in the database directly. The Base class is a special class that has methods it responds to but doesn't explicitly mention as its own methods. Therefore, when such a method is faked, it raises an error because the method does not exist for the class. For example,<ref>{{Cite web|url=https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/configuration/fake-ar-attributes|title=fake_ar_attributes - Configuration Options - Bogus - bogus - Relish|website=www.relishapp.com|access-date=2017-02-11}}</ref><source lang="ruby">
class BlogPost < ActiveRecord::Base
end
blog_post = BlogPost.new
blog_post.respond_to?(:name) # => true
blog_post.method(:name) # raises NameError
</source>To avoid this problem, fake_ar_modules is set to true. Then fakes can be created with no error.

== RSpec Mocks vs Bogus ==
Bogus isolates objects while unit testing i.e., it does not require any information of classes or objects involved in testing object method, whereas Rspec Mocks require additional information regarding objects used in testing object. One major advantage of using bogus over Rspec Mocks is that Bogus provides safe stubbing.

== Version history ==
{| class="wikitable"
!Version
!Highlights
|-
|0.1.6
|Cleared tests on Rubinius, RSpec 3 usage
|-
|0.1.5
|Matchers were added, refined features 
|-
|0.1.4
|Reorganised code, improved fakes, minitest contract support
|-
|0.1.3
|Minitest support
|-
|0.1.2
|Removed [[Software:RSpec|RSpec]] warning
|-
|0.1.1
|Support for [[Software:Rubinius|Rubinius]] and [[Software:JRuby|JRuby]]
|-
|0.1.0
|Supports Ruby 2.0, stubbing on fakes, improved spying
|-
|0.0.4
|Improved mocks 
|-
|0.0.3
|Global fakes, improved stub syntax
|-
|0.0.2
|Anonymous fakes, improved stub method calls
|-
|0.0.1
|Fakes, stubs, mocks, spies
|}

== References ==
{{Reflist}}

===Sources===
* https://www.relishapp.com/bogus/bogus/v/0-1-6/docs/getting-started
* https://github.com/psyho/bogus
* https://github.com/groyoh/bogus
* https://www.ruby-toolbox.com/projects/bogus
* https://packages.debian.org/sid/ruby/ruby-bogus
* http://gunpowderlabs.com/blog/write-safer-tests-with-bogus/
* https://coderwall.com/p/d1dksg/safe-stubbing-with-bogus
* http://bogus-wrug-2013-07.herokuapp.com/#59

== External links ==
* [https://rubygems.org/gems/mocha/versions/1.2.1 Mocha] 
* [https://github.com/rspec/rspec-mocks/wiki Rspec-mocks] 
* [http://www.rubydoc.info/github/stympy/faker/frames Faker] 
* [https://test-unit.github.io/ Test-Unit] 
* [https://jasmine.github.io/ Jasmine]

[[Category:Ruby (programming language)]]

{{Sourceattribution|Bogus (Ruby)}}