Mocha and Chai Assertions Knowledge Check Quiz

Challenge your understanding of using assertion libraries with testing frameworks by answering these questions about Mocha and Chai assertions. This quiz targets core concepts, assertion methods, and best practices within the tools ecosystem of JavaScript testing.

1. Choosing an Assertion Library

   In a JavaScript testing project using Mocha, which option correctly describes the role of Chai when writing tests?

   1. Chai provides assertion functions to check test outcomes.
   2. Chai acts as the test runner that executes test files.
   3. Chai is used for configuring test reporters in Mocha.
   4. Chai manages test file discovery and inclusion.

   Explanation: Chai is used as an assertion library, offering a set of functions to compare actual results against expected outcomes in your tests. Mocha, not Chai, serves as the test runner and manages execution of test files. Setting up reporters and handling file discovery are tasks handled by Mocha, not by Chai. Hence, only the first option accurately describes Chai's main function.

2. Strict Equality with Assertions

   If you want to verify that a variable 'score' is exactly 100 using Chai's strict equality, which assertion should you use?

   1. expect(score).to.equal(100);
   2. expect(score).to.be.equalTo(100);
   3. expect(score).to.equals(100);
   4. expect(score).is(100);

   Explanation: The correct way to assert strict equality in Chai is using 'to.equal'. Other options either use incorrect methods (like 'equalTo', 'equals', or 'is') that do not exist or are not supported in Chai's assertion syntax. Therefore, only the first option is valid for strict equality.

3. Deep Object Comparisons

   Given two different objects with identical keys and values, which Chai assertion checks for deep equality between them?

   1. expect(obj1).to.deep.equal(obj2);
   2. expect(obj1).to.be.strictly.equal(obj2);
   3. expect(obj1).equals(obj2);
   4. expect(obj1).to.deepEquals(obj2);

   Explanation: Chai's 'to.deep.equal' assertion compares two objects based on their properties and values, not just references. The 'strictly.equal' and 'equals' methods would check for reference (identity), which would fail for separate but identical objects. 'deepEquals' is not a valid assertion in Chai. Only the first choice correctly does a deep comparison.

4. Using Negation in Assertions

   Suppose you want to check that a string variable 'greeting' does NOT equal 'hello' using Chai, which of the following is correct?

   1. expect(greeting).to.not.equal('hello');
   2. expect(greeting).not.equals('hello');
   3. expect(greeting).is.notEqual('hello');
   4. expect.not(greeting).equals('hello');

   Explanation: The correct negation syntax in Chai uses 'to.not.equal'. The other options incorrectly structure the assertion or use methods not recognized by the library ('not.equals', 'is.notEqual', 'expect.not'). Only the first statement accurately negates the equality check.

5. Assertions Involving Arrays

   To verify that an array 'ids' contains the value 42 using Chai, which assertion is most appropriate?

   1. expect(ids).to.include(42);
   2. expect(ids).has(42);
   3. expect(ids).should.contain(42);
   4. expect(ids).containItem(42);

   Explanation: The 'to.include' assertion checks for the presence of a value within arrays or strings, making it the correct choice for this scenario. 'has', 'should.contain', and 'containItem' are either not valid assertion methods in Chai or use incorrect syntax. As a result, only the first option will work as intended.