Apa iku unit testing?

Question

Accepted Answer

**Unit testing** verifies individual **units** saka code (functions, methods, classes) ing **isolation** — checking yen saben small piece works correctly dhewe. Unit tests iku fast, focused, lan form the foundation saka good testing strategy.

## Apa iku unit test

```text
A UNIT test verifies the smallest testable piece (a function/method) in ISOLATION:
  → test ONE thing; give inputs, check the output/behavior
  → ISOLATED from dependencies (database, network, other units) — mock/stub those
  → FAST (no real I/O), focused, deterministic
```

## Example

```js
// the function under test
function add(a, b) { return a + b; }

// a unit test (Jest)
test('add returns the sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);          // input → expected output
  expect(add(-1, 1)).toBe(0);         // test cases, including edge cases
});

// test logic/behavior of a single unit
test('Cart.total sums item prices', () => {
  const cart = new Cart();
  cart.add({ price: 10 });
  cart.add({ price: 5 });
  expect(cart.total).toBe(15);
});
```

## Characteristics saka good unit tests

```text
✓ FAST — run in milliseconds (so you run many, often)
✓ ISOLATED — test one unit; mock external dependencies; independent of other tests
✓ DETERMINISTIC — same result every time (no flakiness)
✓ Test BEHAVIOR/outcomes (not implementation details); clear and readable
✓ Cover normal cases, EDGE CASES, and error conditions
```

## Ngapa iki penting

Paham unit testing iku fundamental karena **unit tests iku foundation saka good testing strategy** — the base saka test pyramid — mula essential, must-know knowledge.

A unit test verifies the **smallest testable piece saka code (a function or method) ing isolation**, checking yen work correctly dhewe karo given inputs producing expected outputs.

Paham iki — testing one thing at a time, isolated saka dependencies (mocking external systems kaya databases lan networks), fast lan deterministic — iku core saka unit testing.

Unit tests iku valuable karena iku **fast** (running ing milliseconds, mula you can run many frequently untuk quick feedback), **focused** (pinpointing exactly apa broken when they fail), lan form the **foundation** yen most saka test suite should consist of.

Paham the **characteristics saka good unit tests** — fast, isolated (mocking dependencies, independent saka other tests), deterministic (no flakiness), testing behavior lan outcomes (not implementation details, mula tests don't break on refactoring), lan covering normal cases, edge cases, lan error conditions — iku important untuk write effective tests yen provide real value rather than brittle or low-value ones.

Unit testing iku most common lan foundational form saka testing, central to TDD, CI/CD, lan confident development.

Since unit tests iku foundation saka testing (the base saka pyramid, the most numerous lan frequently-run tests) lan paham apa iku lan how to write good ones (isolated, fast, focused, testing behavior) iku essential untuk any testing strategy, paham unit testing iku essential, foundational knowledge — the cornerstone saka software testing yen every developer should paham lan practice, fundamental to verifying code correctness lan enabling the confident, safe development yen good testing provides.