ChaiJS Should: How to Test for Empty Strings – Fixing 'empty' is not a function Error

Table of Contents#

1. What is ChaiJS and the Should Interface?
2. Setting Up ChaiJS Should in Your Project
3. Understanding Chai’s empty Assertion
4. Testing Empty Strings with Chai Should: The Right Way
5. Fixing the 'empty' is not a function Error
   • Cause 1: Forgetting to Initialize the Should Interface
   • Cause 2: Asserting on Undefined/Null Values
   • Cause 3: Outdated Chai Version
   • Cause 4: Typos in Assertion Syntax
6. Troubleshooting Common Scenarios
   • Testing Null vs. Empty Strings
   • Testing Whitespace Strings
7. Best Practices for Using empty with Chai Should
8. Conclusion
9. References

What is ChaiJS and the Should Interface?#

ChaiJS is a BDD/TDD assertion library for Node.js and the browser, designed to work with testing frameworks like Mocha, Jest, or Jasmine. It provides three assertion styles:

• Assert: Classic TDD style (e.g., assert.equal(foo, 'bar')).
• Expect: BDD style with a chainable API (e.g., expect(foo).to.equal('bar')).
• Should: Extends Object.prototype to add a should property, enabling even more natural language assertions (e.g., foo.should.equal('bar')).

The Should interface is beloved for its readability, but it requires explicit initialization (unlike Expect) because it modifies Object.prototype. This initialization step is often the root cause of the 'empty is not a function' error.

Setting Up ChaiJS Should in Your Project#

Before diving into testing empty strings, let’s set up ChaiJS with the Should interface. We’ll use Mocha as our test runner (a common pairing), but the setup is similar for other frameworks.

Step 1: Install Dependencies#

First, install Chai and Mocha as dev dependencies:

npm install chai mocha --save-dev

Step 2: Initialize the Should Interface#

In your test file (e.g., string.test.js), require Chai and initialize the Should interface. This step is critical—omitting it will cause errors like 'empty is not a function':

// Import Chai
const chai = require('chai');
 
// Initialize Should interface (modifies Object.prototype)
chai.should();
 
// Now you can use `should` assertions!

Step 3: Write a Basic Test#

With setup complete, write a simple test to verify Chai is working:

describe('Basic Chai Should Test', () => {
  it('should assert that "hello" equals "hello"', () => {
    const str = 'hello';
    str.should.equal('hello'); // ✅ Works if setup is correct
  });
});

Run the test with Mocha:

npx mocha string.test.js

If the test passes, you’re ready to test empty strings!

Understanding Chai’s empty Assertion#

Chai’s empty assertion checks if a value is "empty." Its behavior varies by type:

For strings, empty explicitly checks if the string’s length is 0. This means:

• '' (empty string) → empty ✅
• ' ' (single space) → Not empty (length 1) ❌
• 'hello' (non-empty) → Not empty ❌

Testing Empty Strings with Chai Should: The Right Way#

Let’s write tests for empty strings using Chai’s Should interface. We’ll cover both positive cases (string is empty) and negative cases (string is not empty).

Example 1: Assert a String is Empty#

Suppose we have a function getUserInput() that returns an empty string when no input is provided. We want to test this:

// string.test.js
const chai = require('chai');
chai.should(); // Initialize Should!
 
// Function to test (could be imported from another file)
const getUserInput = () => ''; // Returns empty string
 
describe('getUserInput', () => {
  it('should return an empty string when no input is provided', () => {
    const result = getUserInput();
    result.should.be.a('string'); // Verify it's a string first (optional but safe)
    result.should.be.empty; // ✅ Assert it's empty
  });
});

Why this works:

• result is a string (''), so result.should is valid.
• be.empty checks if result.length === 0, which is true for ''.

Example 2: Assert a String is NOT Empty#

Now test the inverse: a function that returns a non-empty string:

const getGreeting = () => 'Hello, World!';
 
describe('getGreeting', () => {
  it('should return a non-empty string', () => {
    const greeting = getGreeting();
    greeting.should.not.be.empty; // ✅ Assert it's NOT empty
  });
});

Fixing the 'empty' is not a function Error#

If you see TypeError: Cannot read property 'empty' of undefined or 'empty' is not a function, one of these issues is likely the cause.

Cause 1: Forgetting to Initialize the Should Interface#

Problem: The should property is added to Object.prototype only after calling chai.should(). If you skip this step, result.should will be undefined, leading to errors.

Example of the Error:

// ❌ Missing chai.should()!
const chai = require('chai');
 
describe('Test', () => {
  it('will fail', () => {
    const str = '';
    str.should.be.empty; // Error: Cannot read property 'be' of undefined
  });
});

Fix: Always initialize the Should interface with chai.should() at the top of your test file:

const chai = require('chai');
chai.should(); // ✅ Add this line!
 
// Now assertions work:
str.should.be.empty; // No error

Cause 2: Asserting on Undefined/Null Values#

Problem: If the value you’re testing is undefined or null, value.should will throw an error because undefined/null have no should property.

Example of the Error:

chai.should();
 
describe('Test', () => {
  it('will fail', () => {
    const str = undefined; // or null
    str.should.be.empty; // Error: Cannot read property 'should' of undefined
  });
});

Fix: Check if the value is defined first, or use Chai’s expect interface (which handles null/undefined more gracefully). For Should, explicitly guard against undefined/null:

// Option 1: Check if defined first
const str = undefined;
if (str !== undefined && str !== null) {
  str.should.be.empty;
} else {
  // Handle undefined/null case (e.g., assert it's undefined)
  str.should.be.undefined;
}
 
// Option 2: Use expect for null/undefined (if preferred)
const expect = chai.expect;
expect(str).to.be.undefined; // Works even for undefined/null

Cause 3: Outdated Chai Version#

Problem: Older versions of Chai (pre-v1.0.0) had bugs or different behavior for empty. If you’re using an ancient version, empty might not work as expected.

Fix: Upgrade Chai to the latest version:

npm install chai@latest --save-dev

Cause 4: Typos in Assertion Syntax#

Problem: A simple typo like be.emptry (misspelled "empty") will throw 'emptry' is not a function.

Example of the Error:

chai.should();
 
describe('Test', () => {
  it('will fail', () => {
    const str = '';
    str.should.be.emptry; // ❌ Typo: "emptry" instead of "empty"
  });
});

Fix: Double-check spelling! Chai’s assertions are case-sensitive and require exact matches (e.g., be.empty, not be.Empty or be.emptry).

Troubleshooting Common Scenarios#

Testing Null vs. Empty Strings#

A common pitfall is confusing null with empty strings. Chai’s empty assertion treats null as not empty, and trying to assert null.should.be.empty will throw an error (since null has no should property).

Example:

chai.should();
 
describe('Null vs. Empty String', () => {
  it('null is not empty', () => {
    const str = null;
    // ❌ This will throw: Cannot read property 'should' of null
    // str.should.be.empty;
 
    // ✅ Correct: Explicitly check for null
    str.should.be.null;
  });
 
  it('empty string is empty', () => {
    const str = '';
    str.should.be.empty; // ✅ Works
  });
});

Testing Whitespace Strings#

A string with whitespace (e.g., ' ', '\t', '\n') is not empty because its length is greater than 0. If you need to test for "blank" strings (whitespace only), use .equal('') for empty strings or a regex for whitespace:

chai.should();
 
describe('Whitespace Strings', () => {
  it('" " is not empty', () => {
    const str = ' '; // Single space
    str.should.not.be.empty; // ✅ True (length 1)
  });
 
  it('"  " (two spaces) is not empty', () => {
    const str = '  ';
    str.should.not.be.empty; // ✅ True (length 2)
  });
 
  it('test for blank (whitespace-only) string', () => {
    const str = '  \t\n'; // Whitespace
    str.should.match(/^\s*$/); // ✅ Matches whitespace-only (optional)
  });
});

Best Practices for Using empty with Chai Should#

To avoid errors and write maintainable tests, follow these best practices:

1. Initialize Should Once Per Test Suite#

Initialize chai.should() once at the top of your test file (or in a setup file like test/setup.js) to avoid redundant code.

2. Use be.empty for Clarity#

While should.empty works, should.be.empty is more readable and aligns with Chai’s recommended style (e.g., should.be.a('string'), should.be.true).

3. Combine with Type Checks#

Explicitly verify the type of the value before asserting empty to catch unexpected undefined/null values:

const str = '';
str.should.be.a('string').and.be.empty; // ✅ Fails fast if str is not a string

4. Test Edge Cases#

Always test edge cases like undefined, null, and non-string types (e.g., numbers, arrays) to ensure your code handles them:

// Test non-string types
[].should.be.empty; // ✅ Empty array
({}).should.be.empty; // ✅ Empty object
'hello'.should.not.be.empty; // ✅ Non-empty string

Conclusion#

Testing empty strings with Chai’s Should interface is powerful and readable, but it requires careful setup. The 'empty is not a function' error is almost always due to:

• Forgetting to initialize chai.should().
• Asserting on undefined/null values.
• Typos or outdated Chai versions.

By following the steps in this guide—initializing Should, validating values before assertion, and avoiding common pitfalls—you’ll write robust tests for empty strings. Remember to combine be.empty with type checks (e.g., be.a('string')) for clarity and reliability.

References#

• ChaiJS Official Documentation
• Chai Should Interface Guide
• Chai empty Assertion Docs
• Mocha Test Runner