describe('My Test', function() {
  // THIS RUNS IMMEDIATELY (Parsing Phase)
  const db = connectToDatabase(); 
  
  it('should query', function() {
    // This runs later. DB connection might not be ready!
  });
});

const testCases = [1, 2, 3, 4];

describe('Math', function() {
  testCases.forEach(function(num) {
    it(`should square ${num} correctly`, function() {
      expect(num * num).to.equal(Math.pow(num, 2));
    });
  });
});

const objA = { a: 1 };
const objB = { a: 1 };

// PASS: checks content -- are the values the same? (like comparing photocopies)
expect(objA).to.deep.equal(objB); 

// FAIL: checks reference -- are these the exact same object in memory? (like asking "is this the same piece of paper?")
expect(objA).to.equal(objB);

expect(user)
  .to.be.an('object')
  .that.has.property('email')
  .that.is.not.empty;

const spy = sinon.spy(console, 'log'); // Wrap the real console.log
myFunction(); // Call the code under test -- console.log still works normally
expect(spy.calledWith('Hello')).to.be.true; // But now we can check what was logged
spy.restore(); // CRITICAL: Remove the spy, or it leaks into other tests!

const stub = sinon.stub(database, 'query');

// Scenario 1: Force a specific return value (happy path testing)
stub.returns({ id: 1 });

// Scenario 2: Force an error (test your error handling!)
stub.throws(new Error('Connection Failed'));

// Scenario 3: Simulate changing behavior across calls
// Useful for testing retry logic or pagination
stub.onCall(0).returns(true);   // First call succeeds
stub.onCall(1).returns(false);  // Second call fails

stub.restore(); // Always restore -- stubs are permanent until you undo them

const mock = sinon.mock(database);
mock.expects('save').once().withArgs({ id: 1 });

saveUser({ id: 1 });

mock.verify(); // Fails if expectation not met
mock.restore();

describe('User Service', function() {
  let sandbox;
  
  beforeEach(() => {
    sandbox = sinon.createSandbox();
  });
  
  afterEach(() => {
    sandbox.restore(); // Restores EVERYTHING created by sandbox
  });
  
  it('test', () => {
    // Created on sandbox, auto-cleaned later
    const stub = sandbox.stub(api, 'get'); 
  });
});

let clock;
before(() => { clock = sinon.useFakeTimers(); });
after(() => { clock.restore(); });

it('should timeout', () => {
  startTimer();
  clock.tick(5000); // Fast-forward 5000ms instantly
  expect(timeoutHappened).to.be.true;
});

// Mocha Root Hook Plugin pattern
exports.mochaHooks = {
  async beforeAll() {
    console.log('Global Setup: Starting Server');
    await server.start();
  },
  async afterAll() {
    console.log('Global Teardown: Stopping Server');
    await server.stop();
  }
};

// package.json
"nyc": {
  "check-coverage": true,
  "lines": 80,
  "functions": 80
}

module.exports = {
  exclude: [
    "**/*.test.js",
    "coverage/**",
    "docs/**"
  ]
};

const jsdom = require('jsdom-global');
before(function() {
  this.cleanup = jsdom();
});
after(function() {
  this.cleanup();
});

it('uses document', () => {
  const div = document.createElement('div'); // Works!
});

/* Structure */
describe('User', function() {
  before(function() { /* run once */ });
  after(function() { /* run once */ });
  beforeEach(function() { /* run before each */ });
  afterEach(function() { /* run after each */ });

  it('should save', function() {
    // Test Body
  });
});

/* Assertions (Chai) */
expect(foo).to.be.a('string');
expect(foo).to.equal('bar');
expect(foo).to.have.lengthOf(3);
expect(foo).to.have.property('tea').with.lengthOf(3);

/* Mocks (Sinon) */
const spy = sinon.spy(object, 'method');
const stub = sinon.stub(object, 'method').returns(42);
const mock = sinon.mock(object);

/* Execution Control */
describe.only('Focus', ...); // Run ONLY this
describe.skip('Ignore', ...); // Skip this
this.retries(3); // Retry flaky test
this.timeout(5000); // 5s timeout