Ruby on Rails 2.2 Release Notes

===============================

Ruby on Rails 2.3 Release Notes

===============================

Ruby on Rails 3.0 Release Notes

===============================

Ruby on Rails 3.1 Release Notes

===============================

Ruby on Rails 3.2 Release Notes

===============================

Ruby on Rails 4.0 Release Notes

===============================

Ruby on Rails 4.1 Release Notes

===============================

Ruby on Rails 4.2 Release Notes

===============================

Highlights in Rails 4.2:

* Active Job

* Adequate Record

* Web Console

* Foreign key support

to their respective adapters. Active Job comes pre-configured with an inline

runner that executes jobs right away.

object references as URIs (uniform resource identifiers) instead of marshaling

the object itself. The new [Global ID](https://github.com/rails/globalid)

library builds URIs and looks up the objects they reference. Passing Active

See the [Active Job Basics](active_job_basics.html) guide for more

information.

calls. For more details, please refer to [Aaron Patterson's blog

post](http://tenderlovemaking.com/2014/02/19/adequaterecord-pro-like-activerecord.html).

supported operations without any user involvement or code changes. Here are

```ruby

Post.find(1) # First call generates and cache the prepared statement

```

It's important to highlight that, as the examples above suggest, the prepared

have placeholders for them.

- The model has a default scope

- The model uses single table inheritance

### Web Console

### Foreign Key Support

### `render` with a String Argument

Previously, calling `render "foo/bar"` in a controller action was equivalent to

`respond_with` and the corresponding class-level `respond_to` have been moved

to the [responders](https://github.com/plataformatec/responders) gem. Add

Due to a [change in Rack](https://github.com/rack/rack/commit/28b014484a8ac0bbb388e7eaeeef159598ec64fc),

`rails server` now listens on `localhost` instead of `0.0.0.0` by default. This

However, with this change you will no longer be able to access the Rails

server from a different machine, for example if your development environment

[Nokogiri](https://github.com/sparklemotion/nokogiri). The new sanitizer is

more secure and its sanitization is more powerful and flexible.

If you have a particular need for the exact output of the old sanitizer, you

can add the [rails-deprecated_sanitizer](https://github.com/kaspth/rails-deprecated_sanitizer)

non-alphanumeric characters.

```

```

* DOMs built from HTML source containing invalid HTML with improperly

serving assets from your Rails server in production.

([Pull Request](https://github.com/rails/rails/pull/16466))

Action View

-----------

`Relation` for performing queries and updates is the preferred API.

([Commit](https://github.com/rails/rails/commit/d5902c9e))

* Deprecated `Reflection#source_macro` without replacement as it is no longer

needed in Active Record.

([Pull Request](https://github.com/rails/rails/pull/16373))

### Notable changes

* Added a `:required` option to singular associations, which defines a

presence validation on the association.

([Pull Request](https://github.com/rails/rails/pull/16056))

current environment.

([Commit](https://github.com/rails/rails/commit/e2f232aba15937a4b9d14bd91e0392c6d55be58d))

([Pull Request](https://github.com/rails/rails/pull/8639))

* Introduced `validate` as an alias for `valid?`.

`SELECT`s.

([Pull Request](https://github.com/rails/rails/pull/15866))

* The `references` method in migrations now supports a `type` option for

specifying the type of the foreign key (e.g. `:uuid`).

`module Foo; extend ActiveSupport::Concern; end` boilerplate.

([Commit](https://github.com/rails/rails/commit/b16c36e688970df2f96f793a759365b248b582ad))

Credits

-------

</p>

<% else %>

<p>

These guides are designed to make you immediately productive with Rails, and to help you understand how all of the pieces fit together.

</p>

<% end %>

<p>

</p>

Action Controller Overview

==========================

The value of `params[:ids]` will now be `["1", "2", "3"]`. Note that parameter values are always strings; Rails makes no attempt to guess or cast the type.

for more information.

To send a hash you include the key name inside the brackets:

you to create a persistent connection with a browser. Using this module, you will

be able to send arbitrary data to the browser at specific points in time.

#### Incorporating Live Streaming

Including `ActionController::Live` inside of your controller class will provide

end

```

NOTE: Certain exceptions are only rescuable from the `ApplicationController` class, as they are raised before the controller gets initialized and the action gets executed. See Pratik Naik's [article](http://m.onkey.org/2008/7/20/rescue-from-dispatching) on the subject for more information.

Force HTTPS protocol

--------------------

Action Mailer Basics

====================

```ruby

# app/mailers/application_mailer.rb

class ApplicationMailer < ActionMailer::Base

layout 'mailer'

end

#### generating URLs with `url_for`

If you did not configure the `:host` option globally make sure to pass it to

`url_for`.

action: 'greeting') %>

```

#### generating URLs with named routes

Email clients have no web context and so paths have no base URL to form complete

`config/initializers/sandbox_email_interceptor.rb`

```ruby

```

NOTE: The example above uses a custom environment called "staging" for a

Action View Overview

====================

Active Job Basics

=================

# environment

```

`config.active_job.queue_name_delimiter` in `application.rb`:

```ruby

Callbacks

---------

### Available callbacks

Active Model Basics

===================

Active Record Basics

====================

t.string :publisher_type

t.boolean :single_issue

end

add_index :publications, :publication_type_id

end

Active Record Callbacks

=======================

Active Record Migrations

========================

t.string :name

t.text :description

end

end

end

t.string :name

t.text :description

end

end

end

are using a dynamic value (such as a date), the default will only be calculated

the first time (i.e. on the date the migration is applied).

* `index` Adds an index for the column.

Some adapters may support additional options; see the adapter specific API docs

for further information.

create_table :products do |t|

t.string :name

t.text :description

end

end

Active Record and PostgreSQL

============================

* [type definition](http://www.postgresql.org/docs/9.3/static/hstore.html)

```ruby

# db/migrate/20131009135255_create_profiles.rb

ActiveRecord::Schema.define do

create_table :profiles do |t|

t.hstore 'settings'

end

Active Record Query Interface

=============================

* How to specify the order, retrieved attributes, grouping, and other properties of the found records.

* How to use eager loading to reduce the number of database queries needed for data retrieval.

* How to use dynamic finders methods.

* How to check for the existence of particular records.

* How to perform various calculations on Active Record models.

* How to run EXPLAIN on relations.

If you want to find both by name and locked, you can chain these finders together by simply typing "`and`" between the fields. For example, `Client.find_by_first_name_and_locked("Ryan", true)`.

Find or Build a New Object

--------------------------

It's common that you need to find a record or create it if it doesn't exist. You can do that with the `find_or_create_by` and `find_or_create_by!` methods.

### `find_or_create_by`

Active Record Validations

=========================

* `:even` - Specifies the value must be an even number if set to true. The

default error message for this option is _"must be even"_.

The default error message is _"is not a number"_.

### `presence`

Active Support Core Extensions

==============================

"hello".from(0) # => "hello"

"hello".from(2) # => "llo"

"hello".from(-2) # => "lo"

```

NOTE: Defined in `active_support/core_ext/string/access.rb`.

(4.months + 5.years).from_now

```

### Formatting

Enables the formatting of numbers in a variety of ways.

Active Support Instrumentation

==============================

API Documentation Guidelines

============================

The Asset Pipeline

==================

Assets can still be placed in the `public` hierarchy. Any assets under `public`

will be served as static files by the application or web server when

In production, Rails precompiles these files to `public/assets` by default. The

precompiled copies are then served as static assets by the web server. The files

file (or CoffeeScript file if the `coffee-rails` gem is in the `Gemfile`) and a

Cascading Style Sheet file (or SCSS file if `sass-rails` is in the `Gemfile`)

for that controller. Additionally, when generating a scaffold, Rails generates

`Gemfile`.)

For example, if you generate a `ProjectsController`, Rails will also add a new

to use by your application immediately using the `require_tree` directive. See

[Manifest Files and Directives](#manifest-files-and-directives) for more details

on require_tree.

scope of the application or those libraries which are shared across applications.

* `vendor/assets` is for assets that are owned by outside entities, such as

WARNING: If you are upgrading from Rails 3, please take into account that assets

under `lib/assets` or `vendor/assets` are available for inclusion via the

This writes the path to the particular asset being referenced.

Similarly, you can use the `asset_path` helper in CoffeeScript files with `erb`

```js

$('#logo').attr src: "<%= asset_path('logo.png') %>"

When a controller or a scaffold is generated with the default Rails gemset, a

CoffeeScript file and a SCSS file are generated in place of a regular JavaScript

and CSS file. The example used before was a controller called "projects", which

In development mode, or if the asset pipeline is disabled, when these files are

requested they are processed by the processors provided by the `coffee-script`

Additional layers of preprocessing can be requested by adding other extensions,

where each extension is processed in a right-to-left manner. These should be

used in the order the processing should be applied. For example, a stylesheet

then SCSS, and finally served as CSS. The same applies to a JavaScript file -

CoffeeScript, and served as JavaScript.

Keep in mind the order of these preprocessors is important. For example, if

then it would be processed with the CoffeeScript interpreter first, which

wouldn't understand ERB and therefore you would run into problems.

Active Record Associations

==========================

def change

create_table :customers do |t|

t.string :name

end

create_table :orders do |t|

t.belongs_to :customer, index: true

t.datetime :order_date

end

end

end

def change

create_table :suppliers do |t|

t.string :name

end

create_table :accounts do |t|

t.belongs_to :supplier, index: true

t.string :account_number

end

end

end

def change

create_table :customers do |t|

t.string :name

end

create_table :orders do |t|

t.belongs_to :customer, index:true

t.datetime :order_date

end

end

end

def change

create_table :physicians do |t|

t.string :name

end

create_table :patients do |t|

t.string :name

end

create_table :appointments do |t|

t.belongs_to :physician, index: true

t.belongs_to :patient, index: true

t.datetime :appointment_date

end

end

end

def change

create_table :suppliers do |t|

t.string :name

end

create_table :accounts do |t|

t.belongs_to :supplier, index: true

t.string :account_number

end

create_table :account_histories do |t|

t.belongs_to :account, index: true

t.integer :credit_rating

end

end

end

def change

create_table :assemblies do |t|

t.string :name

end

create_table :parts do |t|

t.string :part_number

end

create_table :assemblies_parts, id: false do |t|

def change

create_table :suppliers do |t|

t.string :name

end

create_table :accounts do |t|

t.integer :supplier_id

t.string :account_number

end

add_index :accounts, :supplier_id

t.string :name

t.integer :imageable_id

t.string :imageable_type

end

add_index :pictures, :imageable_id

create_table :pictures do |t|

t.string :name

t.references :imageable, polymorphic: true, index: true

end

end

end

def change

create_table :employees do |t|

t.references :manager, index: true

end

end

end

belongs_to :customer, counter_cache: :count_of_orders

end

class Customer < ActiveRecord::Base

end

```

Counter cache columns are added to the containing model's list of read-only attributes through `attr_readonly`.

##### `:dependent`

* `:as`

* `:autosave`

* `:class_name`

* `:dependent`

* `:foreign_key`

* `:inverse_of`

end

```

##### `:dependent`

Controls what happens to the associated objects when their owner is destroyed:

Caching with Rails: An overview

===============================

<% end %>

```

```erb

<% cache_if (condition, cache_key_for_products) do %>

The Rails Command Line

======================

* `rails dbconsole`

* `rails new app_name`

Let's create a simple Rails application to step through each of these commands in context.

$ cd commandsapp

$ bin/rails server

=> Booting WEBrick

=> Call with -d to detach

=> Ctrl-C to shutdown server

[2013-08-07 02:00:01] INFO WEBrick 1.3.1

create app/helpers/greetings_helper.rb

invoke assets

invoke coffee

invoke scss

```

What all did this generate? It made sure a bunch of directories were in our application, and created a controller file, a view file, a functional test file, a helper for the view, a JavaScript file and a stylesheet file.

create app/views/high_scores/show.json.jbuilder

invoke assets

invoke coffee

invoke scss

invoke scss

```

The generator checks that there exist the directories for models, controllers, helpers, layouts, functional and unit tests, stylesheets, creates the views, controller, model and database migration for HighScore (creating the `high_scores` table and fields), takes care of the route for the **resource**, and new tests for everything.

```bash

$ bin/rails console --sandbox

Any modifications you make will be rolled back on exit

irb(main):001:0>

```

You can get a list of Rake tasks available to you, which will often depend on your current directory, by typing `rake --tasks`. Each task has a description, and should help you find the thing you need.

```bash

$ bin/rake --tasks

rake tmp:clear # Clear session, cache, and socket files from tmp/ (narrow w/ tmp:sessions:clear, tmp:cache:clear, tmp:sockets:clear)

rake tmp:create # Creates tmp directories for sessions, cache, sockets, and pids

```

### `about`

```bash

$ bin/rake about

About your application's environment

JavaScript Runtime Node.js (V8)

Middleware Rack::Sendfile, ActionDispatch::Static, Rack::Lock, #<ActiveSupport::Cache::Strategy::LocalCache::Middleware:0x007ffd131a7c88>, Rack::Runtime, Rack::MethodOverride, ActionDispatch::RequestId, Rails::Rack::Logger, ActionDispatch::ShowExceptions, ActionDispatch::DebugExceptions, ActionDispatch::RemoteIp, ActionDispatch::Reloader, ActionDispatch::Callbacks, ActiveRecord::Migration::CheckPending, ActiveRecord::ConnectionAdapters::ConnectionManagement, ActiveRecord::QueryCache, ActionDispatch::Cookies, ActionDispatch::Session::CookieStore, ActionDispatch::Flash, ActionDispatch::ParamsParser, Rack::Head, Rack::ConditionalGet, Rack::ETag

Application root /home/foobar/commandsapp

Configuring Rails Applications

==============================

* `secrets.secret_key_base` is used for specifying a key which allows sessions for the application to be verified against a known secure key to prevent tampering. Applications get `secrets.secret_key_base` initialized to a random key present in `config/secrets.yml`.

* `config.session_store` is usually set up in `config/initializers/session_store.rb` and specifies what class to use to store the session. Possible values are `:cookie_store` which is the default, `:mem_cache_store`, and `:disabled`. The last one tells Rails not to deal with sessions. Custom session stores can also be specified:

Every Rails application comes with a standard set of middleware which it uses in this order in the development environment:

* `ActionDispatch::SSL` forces every request to be under HTTPS protocol. Will be available if `config.force_ssl` is set to `true`. Options passed to this can be configured by using `config.ssl_options`.

* `Rack::Lock` wraps the app in mutex so it can only be called by a single thread at a time. Only enabled when `config.cache_classes` is `false`.

* `ActiveSupport::Cache::Strategy::LocalCache` serves as a basic memory backed cache. This cache is not thread safe and is intended only for serving as a temporary memory cache for a single thread.

* `Rack::Runtime` sets an `X-Runtime` header, containing the time (in seconds) taken to execute the request.

* `config.action_controller.default_charset` specifies the default character set for all renders. The default is "utf-8".

* `config.action_controller.logger` accepts a logger conforming to the interface of Log4r or the default Ruby Logger class, which is then used to log information from Action Controller. Set to `nil` to disable logging.

* `config.action_controller.request_forgery_protection_token` sets the token parameter name for RequestForgery. Calling `protect_from_forgery` sets it to `:authenticity_token` by default.

Contributing to Ruby on Rails

=============================

### Creating a Bug Report

Your issue report should contain a title and a clear description of the issue at the bare minimum. You should include as much relevant information as possible and should at least post a code sample that demonstrates the issue. It would be even better if you could include a unit test that shows how the expected behavior is not occurring. Your goal should be to make it easy for yourself - and others - to replicate the bug and figure out a fix.

* Use Ruby >= 1.9 syntax for hashes. Prefer `{ a: :b }` over `{ :a => :b }`.

* Prefer `&&`/`||` over `and`/`or`.

* Prefer class << self over self.method for class methods.

* Use `a = b` and not `a=b`.

* Use assert_not methods instead of refute.

* Prefer `method { do_stuff }` instead of `method{do_stuff}` for single-line blocks.

The `-n` option allows you to run a single method instead of the whole

file.

This is how you run the Active Record test suite only for SQLite3:

Debugging Rails Applications

============================

```bash

=> Booting WEBrick

=> Run `rails server -h` for more startup options

=> Notice: server is listening on all interfaces (0.0.0.0). Consider using 127.0.0.1 (--binding option)

=> Ctrl-C to shutdown server

--> #0 ArticlesController.index

at /PathTo/project/test_app/app/controllers/articles_controller.rb:8

#1 ActionController::ImplicitRender.send_action(method#String, *args#Array)

#2 AbstractController::Base.process_action(action#NilClass, *args#Array)

#3 ActionController::Rendering.process_action(action#NilClass, *args#NilClass)

...

```

```

(byebug) frame 2

184: # is the intended way to override action dispatching.

185: #

186: # Notice that the first argument is the method to be dispatched

```

(byebug) step

50: ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])

51: end

52: alias :day :days

Development Dependencies Install

================================

-

name: Testing Rails Applications

url: testing.html

-

name: Securing Rails Applications

url: security.html

url: working_with_javascript_in_rails.html

description: This guide covers the built-in Ajax/JavaScript functionality of Rails.

-

name: The Rails Initialization Process

work_in_progress: true

url: initialization.html

description: This guide explains the internals of the Rails initialization process as of Rails 4

-

name: Extending Rails

documents:

name: Creating and Customizing Rails Generators

url: generators.html

description: This guide covers the process of adding a brand new generator to your extension or providing an alternative to an element of a built-in Rails generator (such as providing alternative test stubs for the scaffold generator).

-

name: Contributing to Ruby on Rails

documents:

Getting Started with Engines

============================

Form Helpers

============

Creating and Customizing Rails Generators & Templates

=====================================================

create app/views/users/show.json.jbuilder

invoke assets

invoke coffee

invoke scss

invoke scss

```

Looking at this output, it's easy to understand how generators work in Rails 3.0 and above. The scaffold generator doesn't actually generate anything, it just invokes others to do the work. This allows us to add/replace/remove any of those invocations. For instance, the scaffold generator invokes the scaffold_controller generator, which invokes erb, test_unit and helper generators. Since each generator has a single responsibility, they are easy to reuse, avoiding code duplication.

create app/views/comments/show.json.jbuilder

invoke assets

invoke coffee

invoke scss

```

Getting Started with Rails

==========================

TIP: A number of tools exist to help you quickly install Ruby and Ruby

on Rails on your system. Windows users can use [Rails Installer](http://railsinstaller.org),

while Mac OS X users can use [Tokaido](https://github.com/tokaido/tokaidoapp).

```bash

$ ruby -v

ruby 2.0.0p353

```

Verify that it is correctly installed and in your PATH:

```bash

$ rails --version

```

### Creating the Blog Application

create app/helpers/welcome_helper.rb

invoke assets

invoke coffee

invoke scss

```

Most important of these are of course the controller, located at

# ...

```

controllers and actions. This file contains many sample routes on commented

lines, and one of them actually shows you how to connect the root of your site

to a specific controller and action. Find the line beginning with `root` and

This error indicates that Rails cannot find the `new` action inside the

`ArticlesController` that you just generated. This is because when controllers

are generated in Rails they are empty by default, unless you tell it

To manually define an action inside a controller, all you need to do is to

define a new method inside the controller. Open

`app/controllers/articles_controller.rb` and inside the `ArticlesController`

```ruby

class ArticlesController < ApplicationController

You're getting this error now because Rails expects plain actions like this one

to have views associated with them to display their information. With no view

In the above image, the bottom line has been truncated. Let's see what the full

>Missing template articles/new, application/new with {locale:[:en], formats:[:html], handlers:[:erb, :builder, :coffee]}. Searched in: * "/path/to/blog/app/views"

That's quite a lot of text! Let's quickly go through and understand what each

`articles/new` template. Rails will first look for this template. If not found,

then it will attempt to load a template called `application/new`. It looks for

one here because the `ArticlesController` inherits from `ApplicationController`.

The next part of the message contains a hash. The `:locale` key in this hash

this is the English - or "en" - template. The next key, `:formats` specifies the

format of template to be served in response. The default format is `:html`, and

so Rails is looking for an HTML template. The final key, `:handlers`, is telling

location, but in more complex applications it could be many different paths.

The simplest template that would work in this case would be one located at

Go ahead now and create a new file at `app/views/articles/new.html.erb` and

write this content in it:

it's been applied to your database. Migration filenames include a timestamp to

ensure that they're processed in the order that they were created.

```ruby

class CreateArticles < ActiveRecord::Migration

t.string :title

t.text :text

end

end

end

`@article.save` is responsible for saving the model in the database. Finally,

we redirect the user to the `show` action, which we'll define later.

TIP: As we'll see later, `@article.save` returns a boolean indicating whether

the article was saved or not.

# this line adds an integer column called `article_id`.

t.references :article, index: true

end

end

end

```

== CreateComments: migrating =================================================

-- create_table(:comments)

-> 0.0115s

== CreateComments: migrated (0.0119s) ========================================

```

| app/views/comments/ | Views of the controller are stored here |

| test/controllers/comments_controller_test.rb | The test for the controller |

| app/helpers/comments_helper.rb | A view helper file |

Like with any blog, our readers will create their comments directly after

reading the article, and once they have added their comment, will be sent back

------------

Now that you've seen your first Rails application, you should feel free to

* The [Ruby on Rails Guides](index.html)

* The [Ruby on Rails Tutorial](http://railstutorial.org/book)

in your web browser to explore the API documentation.

TIP: To be able to generate the Rails Guides locally with the `doc:guides` rake

`bundle install` and you're ready to go.

Configuration Gotchas

Rails Internationalization (I18n) API

=====================================

I.e. the translation denoted as `:one` is regarded as singular, the other is used as plural (including the count being zero).

### Setting and Passing a Locale

The Rails Initialization Process

================================

Layouts and Rendering in Rails

==============================

| | 510 | :not_extended |

| | 511 | :network_authentication_required |

#### Finding Layouts

To find the current layout, Rails first looks for a file in `app/views/layouts` with the same base name as the controller. For example, rendering actions from the `PhotosController` class will use `app/views/layouts/photos.html.erb` (or `app/views/layouts/photos.builder`). If there is no such controller-specific layout, Rails will use `app/views/layouts/application.html.erb` or `app/views/layouts/application.builder`. If there is no `.erb` layout, Rails will use a `.builder` layout if one exists. Rails also provides several ways to more precisely assign specific layouts to individual controllers and actions.

This will produce:

```erb

```

#### Linking to Audio Files with the `audio_tag`

Here, the `_ad_banner.html.erb` and `_footer.html.erb` partials could contain content that is shared among many pages in your application. You don't need to see the details of these sections when you're concentrating on a particular page.

TIP: For content that is shared among all pages in your application, you can use partials directly from layouts.

#### Partial Layouts

Maintenance Policy for Ruby on Rails

====================================

Rails Nested Model Forms

========================

The Basics of Creating Rails Plugins

====================================

Once your comments are good to go, navigate to your plugin directory and run:

```bash

```

### References

Rails Application Templates

===========================

Rails on Rack

=============

**`ActionDispatch::Static`**

**`Rack::Lock`**

Rails Routing from the Outside In

=================================

Ruby on Rails Guides Guidelines

===============================

Ruby on Rails Security Guide

============================

<img src="http://www.harmless.com/img" width="400" height="400" onmouseover="..." />

```

To protect against all other forged requests, we introduce a _required security token_ that our site knows but other sites don't know. We include the security token in requests and verify it on the server. This is a one-liner in your application controller, and is the default for newly created rails applications:

This will automatically include a security token in all forms and Ajax requests generated by Rails. If the security token doesn't match what was expected, an exception will be thrown.

It is common to use persistent cookies to store user information, with `cookies.permanent` for example. In this case, the cookies will not be cleared and the out of the box CSRF protection will not be effective. If you are using a different cookie store than the session for this information, you must handle what to do with it yourself:

```ruby

end

```

`['foo', nil]` it will bypass the test for `nil`, but `IS NULL` or

`IN ('foo', NULL)` where clauses still will be added to the SQL query.

| JSON | Parameters |

|-----------------------------------|--------------------------|

| `{ "person": null }` | `{ :person => nil }` |

| `{ "person": ["foo", null] }` | `{ :person => ["foo"] }` |

It is possible to return to old behaviour and disable `deep_munge` configuring

A Guide to Testing Rails Applications

=====================================

By default, every Rails application has three environments: development, test, and production. The database for each one of them is configured in `config/database.yml`.

### Rails Sets up for Testing from the Word Go

```bash

$ ls -F test

fixtures/ integration/ models/

```

The `test_helper.rb` file holds the default configuration for your tests.

For good tests, you'll need to give some thought to setting up test data.

In Rails, you can handle this by defining and customizing fixtures.

#### What Are Fixtures?

#### YAML

Here's a sample YAML fixture file:

profession: guy with keyboard

```

If you are working with [associations](/association_basics.html), you can simply

define a reference node between two different fixtures. Here's an example with

category: about

```

#### ERB'in It Up

#### Fixtures in Action

* Remove any existing data from the table corresponding to the fixture

* Load the fixture data into the table

#### Fixtures are Active Record objects

```ruby

# this will return the User object for the fixture named david

email(david.girlfriend.email, david.location_tonight)

```

Unit Testing your Models

------------------------

```bash

$ bin/rails generate scaffold article title:string body:text

require 'test_helper'

```

```ruby

class ArticleTest < ActiveSupport::TestCase

```

Any method defined within a class inherited from `Minitest::Test`

```ruby

test "the truth" do

end

```

```ruby

def test_the_truth

end

```

```ruby

assert true

```

* does this value = that value?

* is this object nil?

* does this line of code throw an exception?

* is the user's password greater than 5 characters?

### Maintaining the test database schema

### Running Tests

1 tests, 1 assertions, 0 failures, 0 errors, 0 skips

```

The `.` (dot) above indicates a passing test. When a test fails you see an `F`; when a test throws an error you see an `E` in its place. The last line of the output is the summary.

To see how a test failure is reported, you can add a failing test to the `article_test.rb` test case.

```ruby

Now, if you noticed, we first wrote a test which fails for a desired functionality, then we wrote some code which adds the functionality and finally we ensured that our test passes. This approach to software development is referred to as _Test-Driven Development_ (TDD).

To see how an error gets reported, here's a test containing an error:

$ BACKTRACE=1 bin/rake test test/models/article_test.rb

```

### Available Assertions

By now you've caught a glimpse of some of the assertions that are available. Assertions are the worker bees of testing. They are the ones that actually perform the checks to ensure that things are going as planned.

Because of the modular nature of the testing framework, it is possible to create your own assertions. In fact, that's exactly what Rails does. It includes some specialized assertions to make your life easier.

You'll see the usage of some of these assertions in the next chapter.

Functional Tests for Your Controllers

-------------------------------------

### What to Include in your Functional Tests

* `head`

* `delete`

### The Four Hashes of the Apocalypse

* `assigns` - Any objects that are stored as instance variables in actions for use in views.

* `cookies` - Any cookies that are set.

You also have access to three instance variables in your functional tests:

* `@controller` - The controller processing the request

### Setting Headers and CGI variables

### Testing Templates and Layouts

If you want to make sure that the response rendered the correct template and layout, you can use the `assert_template`

method:

get :index

assert_template :index

assert_template layout: "layouts/application"

end

```

Otherwise, assertion will fail.

```ruby

test "new should render correct layout" do

end

```

```ruby

test "should create article" do

assert_difference('Article.count') do

end

assert_redirected_to article_path(assigns(:article))

assert_equal 'Article was successfully created.', flash[:notice]

end

```

There are two forms of `assert_select`:

assert_select 'title', "Welcome to Rails Testing Guide"

```

```ruby

assert_select 'ul.navigation' do

end

```

```ruby

assert_select "ol" do |elements|

end

```

#### Additional View-Based Assertions

end

```

Integration Testing

-------------------

```bash

$ bin/rails generate integration_test user_flows

end

```

### Helpers Available for Integration Tests

```

```ruby

require 'test_helper'

end

end

```

```ruby

end

```

```ruby

```

Testing Your Mailers

--------------------

end

```

Testing Jobs

------------

### Custom Assertions And Testing Jobs Inside Other Components

It's a good practice to ensure that your jobs correctly get enqueued or performed

wherever you invoke them (e.g. inside your controllers). This is precisely where

A Guide for Upgrading Ruby on Rails

===================================

Rails generally stays close to the latest released Ruby version when it's released:

* Rails 4 prefers Ruby 2.0 and requires 1.9.3 or newer.

TIP: Ruby 1.8.7 p248 and p249 have marshaling bugs that crash Rails. Ruby Enterprise Edition has these fixed since the release of 1.8.7-2010.02. On the 1.9 front, Ruby 1.9.1 is not usable because it outright segfaults, so if you want to use 1.9.x, jump straight to 1.9.3 for smooth sailing.

Don't forget to review the difference, to see if there were any unexpected changes.

Upgrading from Rails 4.1 to Rails 4.2

-------------------------------------

```

### Rails DOM Testing

The [`TagAssertions` module](http://api.rubyonrails.org/classes/ActionDispatch/Assertions/TagAssertions.html) (containing methods such as `assert_tag`), [has been deprecated](https://github.com/rails/rails/blob/6061472b8c310158a2a2e8e9a6b81a1aef6b60fe/actionpack/lib/action_dispatch/testing/assertions/dom.rb) in favor of the `assert_select` methods from the `SelectorAssertions` module, which has been extracted into the [rails-dom-testing gem](https://github.com/rails/rails-dom-testing).

### Masked Authenticity Tokens

In order to mitigate SSL attacks, `form_authenticity_token` is now masked so that it varies with each request. Thus, tokens are validated by unmasking and then decrypting. As a result, any strategies for verifying requests from non-rails forms that relied on a static session CSRF token have to take this into account.

Upgrading from Rails 4.0 to Rails 4.1

-------------------------------------

```ruby

# Require the gems listed in Gemfile, including any gems

# you've limited to :test, :development, or :production.

```

### vendor/plugins

Make the following changes to your `Gemfile`.

```ruby

group :assets do

gem 'sass-rails', '~> 3.2.6'

```ruby

# Configure static asset server for tests with Cache-Control for performance

config.static_cache_control = 'public, max-age=3600'

```

Working with JavaScript in Rails

================================