Ruby 2.4 – redpanthers.co

Make unit tests great again – Integrate Jasmine into Rails

alan — Tue, 22 Aug 2017 07:28:43 +0000

Install Jasmine To make Jasmine available to your Rails app, you just have to place the jasmine-gem (link) in your Gemfile. That will do the magic. Just make sure you have it under Development and Test group in the Gemfile as follows:

group :development, :test do
  gem "jasmine"
end

Then run this to install the gem:

bundle install

After all the gems are installed, run this code to generate necessary files for Jasmine to run:

rails generate jasmine:install

This will create the jasmine helper file and the yml file where you configure how it should run the tests.

Run tests

You can use Jasmine right after it’s installed. It can be run in several ways, the most important ones being,

In your browser
Continuous Integration Mode (CI)

The CI mode is usually used when you have to integrate it into your build system.

Browser Mode

You have to start the Jasmine server to run it in a browser. This server runs all the tests and serves the results to a webpage. Run this to start the Jasmine Server:

rake jasmine

With the default settings, you can view the output in:

http://localhost:8888/

But this page would be pretty empty since you don’t have any tests written for your Javascript code. There is a method provided to generate sample tests. Try running this:

rails generate jasmine:examples

Now refresh the webpage and you can see something similar to this:

Configurable Settings

Clicking on the options button in the top right corner will display a list of options that change how Jasmine runs the tests. Let’s get into each one of them:

Raise Exceptions

This option disables the error catching mechanism of Jasmine in the JavaScript source code and in the test file. The default setting is to wrap all the errors in a catch block.

Stop Spec on Expectation Failure

With this option turned on, Jasmine will stop the test at the first occurrence of an error. The default setting is to run the full test suit and then display all the tests which fail.

Run Tests in Random Order

This option enables the test to be run in a random sequence every time the test runs. The benefit of enabling this option is to reveal dependencies between tests, therefore, you can reduce test dependencies and each test will have good isolation.

Continous Integration Mode

A headless browser is used to integrate Jasmine into your continuous integration workflow. To make our lives easier, this gem that we are using supports integration with a headless browser out of the box. The default headless browser is Phantom JS. So it will download automatically if not installed when you try to run in CI mode. Run this code to run in CI mode:

rake jasmine:ci

By default, Jasmine will attempt to find a random open port. To set a default port manually, just add this to the jasmine_helper.rb

Jasmine.configure do |config|
   config.ci_port = 1234
end

Configuration

The two files which you should be looking into, if you need to alter the behavior of tests are:

jasmine.yml
jasmine_helper.rb

Jasmine reads the jasmine.yml first and then overrides it with the settings mentioned in jasmine_helper.rb

Sample configuration:

# spec/javascripts/support/jasmine.yml
random: true
show_console_log: false
stop_spec_on_expectation_failure: true

# spec/javascripts/support/jasmine_helper.rb
Jasmine.configure do |config|
  config.random = false
  config.show_console_log = false
  config.stop_spec_on_expectation_failure: false
  config.show_full_stack_trace = false
  config.prevent_phantom_js_auto_install = false
end

Testing

Writing tests for Javascript in a Rails app should be fairly straightforward as it uses same standards as Jasmine in general. But there are things that need to be considered specific to a Jasmine installation in Rails.

Testing JavaScript

Test files for JavaScript in a rails application reside in the spec/javascripts folder. For each javascript file, you need to put the test file in the same path as the file. For example, if you have the following javascript file in your app: app/assets/javascripts/jasmine_examples/Calculator.js You place the spec file in the following path: spec/javascripts/jasmine_examples/CalculatorSpec.js Jasmine will include the test on the next test run. There is no configuration to have your test run.

Plugins worth considering

Jasmine-Jquery – this plugin provides a lot of jquery related matchers. Download it here
Jasmine-Matchers – a tool to provide additional matchers. Download it here
Jasmine-Fixture – a plugin that provides DOM creation using CSS selectors, therefore you can interact with the DOM much easier. Download it here

Write Beautiful Unit tests

95% of the developers I know write unit tests in order to prevent defects from being deployed to production. But the essential ingredients to a great unit test is unknown to most of them. There have been countless times that I’ve seen a test fails, only to investigate and discover that I have no idea what feature the developer was trying to test, let alone how it went wrong or why it matters.

Importance of Test Discipline

Your tests are the best set of weapons to defend your code from bugs. They are more important that linting and static analysis. A few reasons why tests are your secret weapon:

Writing tests first gives you a clearer perspective on the ideal API design.
Does the developer understand the problem enough to articulate in code all critical component requirements?
Manual QA is error-prone. In my experience, it’s impossible for a developer to remember all features that need testing after making a change to refactor, add new features, or remove features.
Continous Integration prevents failed builds from getting deployed to production.

Bug Report vs plain Unit Test

The test fail report comes to save your life when a test fails. So you better make it loud and clear. I came up with a list of must-have info in your bug report.

What are you trying to test?
What should it do?
What is the real-time output (actual behavior)?
What is the expected output (expected behavior)?

Here is a sample test with all of these info:

describe("CalculatorAddMethod", function() {
  var calculator = new Calculator();
  it("should return number", function() {
    const actual = typeof Calculator.add(5,10);
    const expected = 'number'
    expect(actual).toEqual(expected);
  });
});

This test suit answers all the questions above. Let’s go through each one of them.

What are you trying to test?
- -> Go for the test description. It is testing for the return type of the add method of Calculator().
What should it do?
- -> Again, look at the test description. It clearly says that it is testing for the return type of add method.
What is the actual output?
- -> There is a dedicated variable which holds the actual result and how you got the actual result. TWO FOR ONE!
What is the expected output?
- -> Again, there is a dedicated variable which holds the actual result. Straight as a ruler!

Make your tests even better

This is from my experiences and the knowledge I gained from good articles. This worked for me in the long run even if I find it a little difficult to implement when I started. Write every single test using toEqual(). Don’t worry about the quality impact on your test suit. It will get better with exercise.

Easter Egg

This method I suggested would answer one more question, which is by far the most important question I guess. How can you reproduce the test? The const actual holds the answer to this question. Please go take a look at the variable in my sample test suit above and get delighted.

Conclusion

Integrating Jasmine into your Rails app is done by the jasmine-gem. This gem gives you the ability to run tests in a browser or as Continous Integration mode. The usage of right plugins will improve your productivity and helps you write tests faster and better. Next time you write a test, remember to see if your test answers the following questions:

What are you trying to test?
What should it do?
What is the real-time output (actual behavior)?
What is the expected output (expected behavior)?
How can be the test reproduced?

]]>

Behind the scenes of hash table performance in ruby 2.4

aboobacker — Tue, 31 Jan 2017 07:32:26 +0000

Ruby 2.4 got released this Christmas with a lot of exciting features. One of the most underrated features in ruby 2.4 is hash table improvements. Before going into details about implementation, let’s first check the benchmark to know how this change gonna affect your ruby application. Some benchmarks are:

Getting keys and values of a hash

h = {}
10000.times do |i|
  h[i] = nil
end
# Get all hash values
Benchmark.measure { 50000.times { h.values } }
# Get all hash keys
Benchmark.measure { 50000.times { h.keys } }

Output Ruby 2.3.3

 => #
#

ruby 2.4.0

#
#

Yeah, the above two operations executed ~ 3 times faster on my laptop. Though these numbers can vary with your machine and processor, the performance improvements will be significant on all modern processors. Not all operations became 3 times faster , average perfomence improvement is more than 50% If you are a ruby developer and excited to know what are the new features in ruby 2.4, then this feature gonna make your application faster and you don’t have to change anything in the code for that. Because these changes are backward compatible. If you are curious to know what happened behind the scenes of this performance boost, then continue reading.

Hash Table

In computing, hash table (hash map) is a data structure that is used to implement an associative array, a structure that can map keys to values. Hash table uses a hash function to compute an index into an array of buckets or slots, from which the desired value can be found. Wikipedia

In other words, it is a data structure that allows you to store key value pair and helps to fetch specific data using the key in an efficient way. Unlike arrays, you don’t have to iterate through all elements to find a given element in the hash. If you are new to this data structure, check this cs50 video for a better understanding.

hash = {key1: value1, key2: value2}

That is cool right! Now, let’s see how this is made possible in ruby.

Pre 2.4

Let’s first check how ruby implemented Hash in pre 2.4 Ruby internally uses a structure called st_table to represent hash. st_table contains type, the number of bins, the number of entries and pointers to bin array. Bin array is an array with 11 default size and can grow when required. Let’s take an example of hash and see how it will be represented using above diagram.

sample_hash = {a: 10, b: 20, c: 30, d: 40, e: 50}

Let’s take keys :c and :d Step 1: First thing ruby does is it will take the hash of the key using the internal hash function.

2.3.1 :075 > :c.hash
=> 2782
2.3.1 :076 > :d.hash
=> 2432

Step 2: After getting the hash value, result ?it takes modulo of 11 to get figure in which bin ruby can store the given pair

2.3.1 :073 > :c.hash % 11
=> 10
2.3.1 :074 > :d.hash % 11
=> 1

This means we can put :c => 30 in 10’th bin and :d in 1st bin Step 3 What if there are multiple modulo operations that give the result? This is called hash collision. To resolve this, ruby uses a separate chaining approach i.e, it will make a doubly linked list and add it to the existing value in the bin. Step 4 What if the hash is too large ?? Linked list will start growing and will make the hash slower. So, ruby will allocate more bins and do an operation called Rehashing to utilise newly added bins. Improvements in 2.0 In ruby 2.0, Ruby eliminated the need for extra data structures for smaller hashes and uses linear search for better performance. Improvements in 2.2 In 2.2.0, Ruby has used bin array sizes that correspond to powers of two (16, 32, 64, 128, …).

Changes in 2.4

[caption id="attachment_1629" align="aligncenter" width="300"] Source: https://github.com/ruby/ruby/blob/trunk/st.c[/caption] In ruby 2.4, Hash table is moved to open addressing model i.e, we no longer have the separate doubly linked list for collision resolution. Here, we will be storing records in the entries array itself i.e, there is no need of pointer chasing and data will be stored in the adjacent memory location (Data locality). The hash table has two arrays called bins and entries. Entry array contains hash entries in the order of insertion and the bin array provides access to entry the by their keys. The key hash is mapped to a bin containing the index of the corresponding entry in the entry array. Inserting entries in Hash Step 1: Ruby will insert an entry to entries array in sequential order. Step 2: Ruby will identify the bin from which the entry is to be mapped. Ruby uses first few bits of the hash as the bin index, Explaining the whole process is beyond the scope of this article. You can check the logic in MRI source code here Accessing element by key Let’s examine it with a sample hash **

sample_hash = {a: 10, b: 20, c: 30, d: 40, e: 50}

Here, ruby will create two internal arrays, entries and bins as shown below

entries = [[2297,a,10], [451,b,20], [2782,c,30], [2432,d,40],[1896,e,50]]

each record in entries array will contain a hash, key, and value respectively Default bin size in ruby is 16 so Bins array for the above hash will be somewhat like this

bins = [
3,
nil,
nil,
nil,
1,
nil,
nil,
nil,
5,
0,
nil,
nil,
nil,
nil,
2,
nil
]

Now what if we want to fetch an element from hash, say ‘c’

sample_hash[:c]

Step 1: Find the hash using ruby’s internal hash function

:c.hash
2782

Step 2 Find the location in bin array by using find bin method

find_bin(2782)

Step 3 Find the location entries array using bin array

bins[14] => 2

Step 4. Find the entry using the key we got

entries[2] => [2782,c,30]

Now we have value for the key ‘c’ without iterating through all the records

Deleting an item

If the item to be deleted is first one, then ruby will change the index of ‘current first entry ‘, otherwise ruby will mark the item as reserved using a reserved hash value. In the ruby source code, DELETED is marked using 0 and EMPTY is marked using 1. To summarise this approach made hash implementation in ruby faster because the new bins array stores much smaller reference to the entries instead of storing entries themselves. Hence, it can take advantage of the modern processor caching levels ** Small hashes will use the linear search to find entries from ruby 2.0 onwards to avoid extra overhead and improve performance. Given example is just for reference only. References

]]>

New binding.irb introduced in ruby 2.4

coderhs — Tue, 22 Nov 2016 05:23:21 +0000

IRB, which stands for Interactive Ruby, is the standard REPL which is bundled along with ruby. Pry is a popular alternative for IRB, which has many developer-friendly features like tab compilation and syntax highlighting. One of the most heavily used features of pry is the ability to introduce a REPL session in between your code execution for better debugging. Instead of using p or puts to print the result and various variables, this helps us try out various codes and fixes in between the code to find the right solution. [caption id="" align="aligncenter" width="625"] binding.pry being used.[/caption] To use binding.irb in your code, you need to require the IRB library to your code and call binding.irb where you want to introduce the REPL.

require 'irb'
# all the codes before the binding
binding.irb
# all the codes after the binding

and you will see a REPL like below. ]]>