Gain insights into good testing practices in Ruby on Rails. Learn the testing mindset, convert requirements into user stories, and master feature, request, and unit tests for comprehensive coverage.

bullet3.tar.gz

foo-copy

second

challenge1

requests

unit

requestChallenge

featureChallenge

unitChallenge

PassingT1

This course aims to teach you how to write better Rails applications by applying good testing practices. You’ll learn about the reasoning behind testing and the process of applying good testing practices. 

In the first half of the course, you’ll learn about the testing mindset and understand its importance. Next, you’ll learn to turn business requirements into user stories. These user stories will become the basis of the code and tests you’ll write.

Once you understand the reasoning and process, you’ll proceed to write the actual tests. You’ll test what is most important to the end user first. So, the first set of tests you’ll learn to write will be feature tests. Finally, you’ll learn to write request tests and unit tests ensuring end-to-end coverage of our application.

Bulletproof Ruby on Rails Applications

# Catching bugs
It should be clear at this point that there’s a bug in the code.


import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js


If we look at the `test.log` file more closely, we’ll see a warning just under the parameters line. It says `"Unpermitted parameter: :name"`.

```bash
Parameters: {"utf8"=>"✓", "user"=>{"email"=>"jdoe@example.com", "name"=>"jdoe", "password"=>"[FILTERED]", "password_confirmation"=>"[FILTERED]"}, "commit"=>"Sign up"}
Unpermitted parameter: :name
```

That means that the test is passing, but it's not behaving exactly as we expect it to. It simply ignores the `name` attribute when creating the user.

# Behavior-driven development
These types of occurrences are easy to miss. Don’t stress about these kinds of things, because they happen to all of us. Some things slip through the cracks, and bugs can still show up even if we write our tests first.

This style of development, also called **Behavior-Driven Development (BDD)**,  cann’t guarantee that we’ll never have bugs in our application. It will guarantee that we’ll have a much more stable system, and we can be a lot more confident in the code we write.


Let's get back to the problem at hand.

To ensure that the name attribute is taken into consideration, we make use of it in the UI. Namely, we display a `"Hi <name>"` message on the page after the user has logged in.
# Fixing app behavior
Let’s add one more step to the feature file.


Let’s learn to catch and fix bugs in our tests.


There's a Bug

Let’s learn to catch and fix bugs in our tests.

Before We Start

The Why Behind Testing

The How Behind Testing

Planning

The Feature Layer

The Request Layer

The Unit Layer

Create a Bill Split Application Using Ruby on Rails

Conclusion

There's a Bug

Catching bugs