📘Cisco DevNet Associate (200-901 DEVASC)

1. What is Test-Driven Development (TDD)?

Test-Driven Development (TDD) is a software development method where:

You write automated tests before writing the actual code.

Instead of writing the program first, developers:

Write a test.
Run the test (it fails).
Write the code to pass the test.
Improve (refactor) the code.

TDD focuses on small, testable changes and continuous validation.

2. Why TDD is Important in DevNet

Cisco DevNet focuses heavily on:

APIs
Automation scripts
Network programmability
CI/CD pipelines
DevOps practices

TDD helps ensure:

API responses are correct
Automation scripts work as expected
Configuration changes do not break production
Code remains stable after updates

In modern IT environments (cloud, network automation, microservices), reliability is critical. TDD helps maintain that reliability.

3. The TDD Cycle (Red → Green → Refactor)

This is the most important concept for the exam.

TDD follows a repeating cycle:

1️⃣ Red Phase – Write a Failing Test

Write a test for a new function or feature.
The test fails because the feature does not exist yet.

Example in an IT context:

You are developing a REST API.
You write a test to check if /devices returns HTTP 200.
Since the endpoint is not implemented, the test fails.

Failing is expected here.

2️⃣ Green Phase – Write Code to Pass the Test

Write the minimum amount of code needed to make the test pass.
Do not add extra features.

Example:

Implement the /devices API endpoint.
Return a simple valid response.
Run the test → it passes.

3️⃣ Refactor Phase – Improve the Code

Clean up the code.
Remove duplication.
Improve structure.
Ensure tests still pass.

Important:

Refactoring does NOT change functionality.
Tests must continue to pass.

This cycle repeats for every new feature or change.

4. Key Concepts You Must Know for DEVASC

4.1 Unit Testing

TDD is strongly connected to unit testing.

A unit test:

Tests a small part of the program.
Usually tests a single function or method.

In network automation:

A function that formats JSON payload.
A function that validates an IP address.
A function that parses API responses.

Each of these can have its own test.

4.2 Automated Testing

TDD requires automated testing tools.

Common tools in Python (important for DevNet):

unittest
pytest

In CI/CD environments:

Tests run automatically whenever code is pushed.

Automation ensures:

No manual testing required.
Faster development.
Immediate feedback.

4.3 Assertions

Tests use assertions.

An assertion checks if something is true.

Example:

Check if HTTP status code == 200
Check if JSON contains expected key
Check if function returns correct value

If assertion fails → test fails.

4.4 Test Coverage

Test coverage measures:

How much of the code is tested.

Higher coverage:

More reliability
Fewer hidden bugs

However:

100% coverage does NOT guarantee no bugs.
Quality of tests matters more than quantity.

4.5 Mocking (Very Important for DevNet)

In network automation and API development, you often:

Cannot access real devices
Cannot call real production APIs
Do not want to depend on external systems

Mocking allows you to:

Simulate API responses
Simulate device responses
Simulate database calls

Example:

Instead of calling a real network controller,
You mock the controller response.

This makes tests:

Faster
Safer
More reliable

Mocking is commonly tested in DevNet context.

5. Benefits of TDD

You should understand WHY organizations use TDD.

1️⃣ Fewer Bugs

Tests catch issues early.

2️⃣ Better Code Design

Writing tests first forces:

Smaller functions
Clear responsibilities
Modular code

3️⃣ Safe Refactoring

When updating code:

Tests verify nothing is broken.

4️⃣ Faster Debugging

If something fails:

You immediately know which part broke.

5️⃣ CI/CD Friendly

TDD fits perfectly into:

Continuous Integration
Automated pipelines

6. TDD in API Development (DevNet-Relevant Example)

Suppose you are building an API for managing network devices.

Using TDD:

Write a test that:
- Sends GET request to /devices
- Expects status 200
- Expects JSON list
Run test → fails.
Implement minimal API endpoint.
Run test → passes.
Refactor code.
Add new test:
- POST /devices
- Validate device format
- Expect correct response

Repeat process.

This ensures:

Every endpoint works.
Changes do not break existing endpoints.

7. TDD and DevOps / CI/CD

TDD supports DevOps principles:

Continuous Integration
Continuous Testing
Continuous Deployment

In CI pipelines:

Developer pushes code.
Pipeline runs:
- Unit tests
- Integration tests
If tests fail → deployment stops.
If tests pass → deployment continues.

Without automated tests:

Broken code may reach production.

For DevNet exam, understand:

TDD = foundation of automated CI/CD validation.

8. TDD vs Traditional Development

Traditional Approach:

Write code first.
Test later.
Fix bugs afterward.

TDD Approach:

Write test first.
Write code to pass test.
Continuously verify.

TDD reduces:

Late-stage defects
Large debugging efforts

9. TDD vs Integration Testing

Know the difference:

Unit Testing (TDD focus)

Tests small pieces of code.
Fast.
Independent.

Integration Testing

Tests interaction between components.
Example:
- API + Database
- Script + Network controller

TDD mainly focuses on unit tests, but integration tests are also important.

10. Common Misconceptions (Exam-Relevant)

❌ TDD means no need for manual testing
→ False. Manual testing is still needed.

❌ TDD guarantees bug-free software
→ False. It reduces bugs, does not eliminate them.

❌ TDD slows development
→ Initially maybe, but long term it speeds up maintenance and reduces production issues.

11. When TDD is Especially Useful in DevNet Context

API development
Network automation scripts
Configuration management tools
Data validation modules
Microservices
Infrastructure-as-Code (IaC)

For example:

Validating JSON schema before sending API call
Verifying automation script behavior
Checking response parsing logic

12. Best Practices for TDD

For exam understanding, remember:

✔ Write small tests
✔ Test one behavior at a time
✔ Keep tests independent
✔ Use mocking for external systems
✔ Run tests frequently
✔ Refactor only when tests pass

13. Challenges of TDD

Understand limitations:

Requires discipline
Learning curve for writing good tests
Can be difficult with legacy code
Requires good test design skills

14. Key Exam Takeaways (Very Important)

For Cisco DevNet Associate, remember:

TDD = Write tests before writing code.
Follows Red → Green → Refactor cycle.
Uses automated unit testing.
Relies on assertions.
Works well with CI/CD.
Improves code quality and reliability.
Often uses mocking for APIs and devices.
Critical in API and automation development.

If you remember these clearly, you can confidently answer TDD-related questions in the exam.

Final Summary (Simple Version)

Test-Driven Development is a method where:

Write a failing test.
Write minimal code to pass it.
Improve the code safely.
Repeat.

It ensures:

Reliable APIs
Stable automation scripts
Safe code changes
Better DevOps integration

For the DEVASC exam, focus on:

The TDD cycle
Unit testing
Automation
CI/CD integration
Mocking
Benefits and limitations