RSpecZ

RSpecZ is a powerful extension for RSpec with strong and straightforward syntaxes. With RSpecZ you can handle different contexts with only a single line of code. RSpecZ also provides a number of aliases to improve the readability of RSpec code.

Add this line to your application's Gemfile:

Use github syntax until release Version 1.0.

gem 'rspecz', github: 'RSpecZ/RSpecZ'

This is one of the most powerful features in RSpecZ. RSpecZ has a number of context-related methods that can automatically generate context descriptions for you. You can also use methods like set_values to assign different values to a variable without writing multiple lines of code in your test.

RSpecZ provides variable assignment methods like create_params and strings, which allows you to create complex variables in only one line of code.

RSpecZ also provides subject-related methods to simplify your code when you test subjects.

To improve the readability of your test code, RSpecZ provides aliases such as make and behave. These aliases can help to greatly simplify your code and make them easier to review.

You can use with to set value to a variable, and execute the specified block:

with(name, value).so { my_block }

This will automatically create context description for you based on the name and value you specified, like this:

context "when #{name} is #{value}" do
  let(name) { value }
  my_block
end

In the example above, value is assigned to name and the specified block will be executed.

You can also specify your own description:

with(name, value).desc('my_context_description').so { my_block }

with allows you to assign multiple values to a variable in only one line of code, it also creates context for each value, for example:

with(:age, 20, 30).so { my_block }

This is equals to:

context "when age is 20" do
  let(:age) { 20 }
  my_block
end

context "when age is 30" do
  let(:age) { 30 }
  my_block
end

Using multiple values don't allow you to set your own context description.

If you want to set description, you should write with(name, value) multiple times.

with also allow you to assign block value to a variable.

You can use dynamic values like FactoryBot.

with(:person) { create(:person) }.so { my_block }

This is equals to:

context "when person is create(:person)" do
  let(:person) { create(:person) }
   my_block
end

with with block produce description from your block source, so you can know what kind of context it is.

Each with method can chain and method.

If you want to set another variable for spec, you can set additional variable with and method.

with(:name, 'test').and(:age) { 10 }.so { my_block }

This is equals to:

context 'when name is test and age is 10' do
  let(:name) { 'test' }
  let(:age) { 10 }
  my_block
end

with_nil is a specific method to set nil to variables.

with_nil(:name, :age, :phone_number).so { my_block }

This is equals to:

%i[name age phone_number].each do |variable|
  context "when #{variable} is nil" do
    let(variable) { nil }
    my_block
  end
end

with method doesn't provide any information about what kind of spec it is.

RSpecZ has with_valid , with_invalid , with_missing provide spec information by method name.

You can use these method to make specs review easy.

RSpec's super in let cannot be used in RSpecZ.

RSpecZ has _super method for this.

You can use _super like this.

let(:name) { 'test' }

with(:name) { _super + '10' }.so { my_block }

set_context will include the specified shared context and generate a proper context description, for example:

set_context(shared_context) { my_block }

will act like this:

context "when include context(#{name})" do
  include_context name
  my_block
end

create_params helps to create hash in just one line.

Suppose you have some variables like this:

let(:name) { 'Alan' }
let(:age) { 20 }

Generally, to create a hash with these variables, you need to write:

let(:params) {{
  name: name,
  age: age
}}

While in RSpecZ, you just use create_params and it will automatically create a hash with proper keys and values:

create_params(:name, :age)

string is useful when you are trying to create a number of strings, it will create strings using the variable name with the prefix test-.

For example:

string(name, address)

This equals to:

let(:name) { 'test-name' }
let(:address) { 'test-address' }

Some times the code needs to be tested under a specified time. In RSpec, you will write code like this:

let(:now) { Time.zone.now }
subject do
  travel_to(now) do
    my_block
  end
end

However, RSpecZ provides a simpler way to do this:

let(:now) { Time.zone.now }
subject_freezed { my_block }

let and let! are so confusing for rubyists when writing specs, for example:

let(:user)    { create(:user) }
let!(:post)   { create(:post, user: user) } # eager evaluation
let(:like)    { create(:like, user: user, post: post) }
let(:comment) { create(:comment, user: user, post: post) }

In RSpecZ, you can use make instead of let!, which provides better identification and readability.

let(:user)    { create(:user) }
make(:post)   { create(:post, user: user) } # eager evaluation
let(:like)    { create(:like, user: user, post: post) }
let(:comment) { create(:comment, user: user, post: post) }

RSpecZ also provides a short version of it_behaves_like when you use shared_examples, just use the keyword behave:

behave 'my_shared_examples'

# equals to:
# it_behaves_like 'my_shared_examples'

Bug reports and pull requests are welcome on GitHub.

The gem is available as open source under the terms of the MIT License.