Intermediate Ruby test (Intermediate)

Sample questions

5 sample questions from the Intermediate Ruby test, with the answers. Samples are taken out of the live test, so you will not meet these when you sit it.

1. A Rails application is encountering a routing error when trying to access a specific controller action. Which of the following is the most likely cause of this issue?

   1. The controller action is not defined with the correct HTTP verb (e.g., get, post, etc.).
   2. The controller action is not using the correct helper method.
   3. The controller action is using an incorrect model association.
   4. The controller action is rendering the wrong view template.

   Answer: A. The controller action is not defined with the correct HTTP verb (e.g., get, post, etc.).

   In Rails, controller actions are mapped to specific HTTP verbs using routes. If the action is not defined with the correct verb, the request will not be handled properly, leading to a 404 or other routing error. The other options describe unrelated issues, such as incorrect view rendering, incorrect model associations, or incorrect use of helpers, which do not directly relate to the HTTP verb mismatch in the controller action.

2. What is the behavior of the RSpec describe block when it is executed?

   1. It runs the block for each example in the spec suite.
   2. It returns the number of examples defined in the block.
   3. It returns an empty object and does not execute the block.
   4. It runs the block once and returns the result of the last expression in the block.

   Answer: D. It runs the block once and returns the result of the last expression in the block.

   In RSpec, the describe block is used to group related tests. It runs the block once and returns the result of the last expression in the block, which is typically the result of the tests defined within it. The other options are incorrect because they describe behaviors of other constructs such as it blocks, before/after hooks, or the outcome of test execution, not the describe block itself.

3. Which of the following is the correct RSpec syntax to check that a User object has a name attribute with the value 'Ria'?

   1. expect(User.new).to eq(name: 'Ria')
   2. expect(User.new).to be_truthy(name: 'Ria')
   3. expect(User.new).to have_attributes(name: 'Ria')
   4. expect(User.new).to be(name: 'Ria')

   Answer: C. expect(User.new).to have_attributes(name: 'Ria')

   In RSpec, the correct syntax to check attributes of an object is to use have_attributes with a hash of expected values. Option A is incorrect because it uses be instead of have_attributes. Option C is incorrect because it uses eq, which is for direct equality, not attribute matching. Option D is incorrect because it uses be_truthy, which checks for truthiness, not attribute values.

4. Which of the following is the correct approach when deciding between using `where` and `find_by` in ActiveRecord query methods?

   1. Use `where` when you need a single record and don't need to chain further methods and `find_by` when you need to chain additional query methods.
   2. Use `where` when you need to chain additional query methods and `find_by` when you need a single record and don't need to chain further methods.
   3. Use `where` and `find_by` interchangeably because they both return the same type of object.
   4. Use `where` when you need to chain additional query methods and `find_by` when you need to chain additional query methods.

   Answer: B. Use `where` when you need to chain additional query methods and `find_by` when you need a single record and don't need to chain further methods.

   The `where` method returns an ActiveRecord::Relation object, which allows for further query method chaining. On the other hand, `find_by` returns a single record (or nil) and is not chainable. Therefore, the correct choice is to use `where` when chaining is needed and `find_by` for single record retrieval without further chaining.

5. What is the difference between a lambda and a proc in Ruby when it comes to returning control?

   1. A lambda returns from the enclosing method, while a proc returns immediately from the proc.
   2. A lambda returns immediately from the lambda, while a proc returns from the enclosing method.
   3. A lambda and a proc behave identically when it comes to returning control.
   4. A lambda is a type of proc, and they both return from the enclosing method.

   Answer: B. A lambda returns immediately from the lambda, while a proc returns from the enclosing method.

   Lambdas and procs both capture blocks of code, but they differ in how they handle returns. A lambda behaves like a method, returning control to the caller of the lambda. A proc, on the other hand, returns from the enclosing method, which can lead to unexpected behavior if not handled carefully.