Backend interview prep

Start

Angular Service Testing

Learn Angular Service Testing with TestBed, dependency injection, HttpTestingController, mocking, spies, async testing, standalone providers, enterprise best practices, and interview questions.

Angular Services contain the application's business logic, data access logic, and communication with external systems.

Unlike Component Testing, Service Testing focuses only on business functionality without rendering any HTML.

Service Testing verifies:

  • Business logic
  • API communication
  • Dependency Injection
  • Observable behavior
  • Error handling
  • HTTP requests
  • Service interactions

Testing services thoroughly helps ensure that business rules remain correct even as the application evolves.

Table of Contents

  1. What is Service Testing?
  2. Why Service Testing?
  3. Angular Service Architecture
  4. TestBed
  5. Dependency Injection Testing
  6. Testing Business Logic
  7. Mocking Dependencies
  8. HTTP Service Testing
  9. HttpTestingController
  10. Async Service Testing
  11. Standalone Provider Testing
  12. Enterprise Banking Example
  13. Best Practices
  14. Common Mistakes
  15. Top 10 Interview Questions
  16. Interview Cheat Sheet
  17. Summary

What is Service Testing?

Service Testing verifies that an Angular service behaves correctly in isolation.

Typical responsibilities include:

  • Business calculations
  • API calls
  • Data transformation
  • Validation
  • Authentication
  • State management

Unlike Component Testing, Service Testing does not verify UI rendering.

Why Service Testing?

Benefits include:

  • Reliable business logic
  • Faster execution
  • Easy refactoring
  • Better code quality
  • Independent verification
  • High confidence during releases

Service Testing Architecture

flowchart LR

TestCase

TestCase --> TestBed

TestBed --> Service

Service --> MockDependency

MockDependency --> Assertions

Angular Testing Stack

Tool Purpose
TestBed Dependency Injection
Jasmine / Jest Test Framework
HttpTestingController Mock HTTP
Spy Objects Mock Services
RxJS Observable Testing

Sample Service

@Injectable({
  providedIn: 'root'
})
export class CalculatorService {

  add(a: number, b: number): number {

    return a + b;

  }

}

Creating a Service Test

describe('CalculatorService', () => {

  let service: CalculatorService;

  beforeEach(() => {

    TestBed.configureTestingModule({});

    service = TestBed.inject(

      CalculatorService

    );

  });

});

TestBed.inject() retrieves the service instance from Angular's dependency injection system.

Testing Business Logic

it('should add numbers', () => {

  expect(

    service.add(10, 5)

  ).toBe(15);

});

Business logic tests should be simple, deterministic, and independent.

Dependency Injection Flow

flowchart LR

TestBed

TestBed --> Injector

Injector --> Service

Service --> Dependencies

Testing Dependencies

Example

@Injectable()
export class CustomerService {

  constructor(

    private api: ApiService

  ) {}

}

Mock Dependency

const apiMock = {

  loadCustomers:

    jasmine.createSpy()

};

Provide mock

providers: [

{

provide: ApiService,

useValue: apiMock

}

]

Using Jasmine Spies

apiMock.loadCustomers

.and.returnValue([]);

Verify

expect(

apiMock.loadCustomers

)

.toHaveBeenCalled();

Spies allow tests to verify interactions without invoking real implementations.

HTTP Service Testing

Service

@Injectable({
  providedIn: 'root'
})
export class CustomerService {

  constructor(

    private http: HttpClient

  ) {}

  getCustomers() {

    return this.http.get<Customer[]>(

      '/api/customers'

    );

  }

}

Configure HTTP Testing

TestBed.configureTestingModule({

  providers: [

    provideHttpClient(),

    provideHttpClientTesting()

  ]

});

Inject

const httpMock =

TestBed.inject(

HttpTestingController

);

Testing HTTP Requests

service.getCustomers()

.subscribe(data => {

  expect(data.length)

    .toBe(2);

});

const request =

httpMock.expectOne(

'/api/customers'

);

expect(request.request.method)

.toBe('GET');

request.flush([

{

id:1,

name:'John'

},

{

id:2,

name:'Jane'

}

]);

HTTP Testing Flow

flowchart LR

Service

Service --> HttpClient

HttpClient --> HttpTestingController

HttpTestingController --> MockResponse

MockResponse --> Assertions

Verifying Outstanding Requests

afterEach(() => {

  httpMock.verify();

});

verify() ensures that no unexpected HTTP requests remain after the test completes.

Testing Errors

request.flush(

'Server Error',

{

status:500,

statusText:'Internal Server Error'

}

);

Always verify that your service handles error responses correctly.

Testing Observables

service.getCustomers()

.subscribe(result => {

  expect(result.length)

  .toBe(2);

});

Validate:

  • Returned values
  • Completion
  • Error handling

Async Service Testing

Example

it('loads data',

async () => {

  const result =

    await firstValueFrom(

      service.getCustomers()

    );

  expect(result.length)

    .toBe(2);

});

Other options include:

  • fakeAsync()
  • tick()
  • waitForAsync()

Standalone Provider Testing

Angular 17+ encourages standalone providers.

TestBed.configureTestingModule({

  providers: [

    CustomerService

  ]

});

No NgModule is required.

Enterprise Banking Example

Services

  • Authentication
  • Accounts
  • Payments
  • Loans
  • Transactions
  • Notifications

Testing Strategy

Service Test Focus
AuthService Login & Tokens
AccountService Business Rules
PaymentService Validation
LoanService Eligibility
NotificationService Messaging
CustomerService API Calls

Enterprise Service Flow

flowchart TD

Client

Client --> Service

Service --> HttpTestingController

HttpTestingController --> MockBackend

MockBackend --> Assertions

Performance Best Practices

Practice Benefit
Mock Dependencies Faster tests
Use HttpTestingController No real HTTP
Test One Behavior Better readability
Verify Requests Reliable results
Cover Error Cases Better quality
Test Async Logic Higher confidence
Keep Tests Independent Stable execution
Run in CI/CD Continuous validation

Common Mistakes

Calling Real APIs

Never call:

  • Production APIs
  • Databases
  • External systems

during unit tests.

Forgetting verify()

Always call:

httpMock.verify();

This ensures all expected HTTP requests were handled.

Ignoring Error Scenarios

Test:

  • HTTP 400
  • HTTP 401
  • HTTP 403
  • HTTP 404
  • HTTP 500
  • Network failures

Testing Multiple Behaviors

Each test should verify one behavior only.

Mocking the Service Under Test

Mock external dependencies—not the service you are trying to verify.

Service Testing Best Practices

Practice Recommendation
Test Business Logic Yes
Mock Dependencies Always
Mock HTTP Yes
Verify Requests Yes
Test Errors Yes
Independent Tests Yes
Clear Test Names Yes
Automate in CI/CD Yes

Service Testing vs Component Testing

Feature Service Testing Component Testing
Business Logic ✅ Limited
HTML Rendering ❌ ✅
DOM Testing ❌ ✅
Dependency Injection ✅ ✅
HTTP Testing ✅ Often
User Interaction ❌ ✅
Change Detection ❌ ✅

Advantages

Benefit Description
Reliable Business Logic Verifies application rules
Faster Execution No UI rendering
Better Isolation Independent testing
Easy Refactoring Detects regressions
Enterprise Ready Supports large applications
Higher Confidence Stable releases

Top 10 Service Testing Interview Questions

1. What is Service Testing?

Answer

Service Testing verifies the business logic, API communication, and dependency interactions of an Angular service in isolation.

2. Why test services separately?

Answer

Services contain reusable business logic. Testing them independently ensures correctness without involving the UI layer.

3. What is TestBed.inject()?

Answer

TestBed.inject() retrieves an instance of a service from Angular's dependency injection container during testing.

4. What is HttpTestingController?

Answer

HttpTestingController intercepts HTTP requests and allows tests to provide mock responses without making real network calls.

5. Why use mocks in Service Testing?

Answer

Mocks replace external dependencies with predictable behavior, making tests faster, isolated, and deterministic.

6. Why call httpMock.verify()?

Answer

It confirms that all expected HTTP requests were handled and that no unexpected requests remain after a test finishes.

7. How do you test Observable-based services?

Answer

Subscribe to the Observable or convert it using firstValueFrom(), then verify emitted values, completion, or errors.

8. How do you test HTTP errors?

Answer

Use HttpTestingController to flush an error response and verify that the service handles it correctly.

9. Should Service Tests call real APIs?

Answer

No. Unit tests should always mock HTTP requests and external systems.

10. What are Service Testing best practices?

Answer

  • Test one behavior per test
  • Mock dependencies
  • Mock HTTP requests
  • Verify outstanding requests
  • Test success and error scenarios
  • Keep tests independent
  • Run tests automatically in CI/CD

Interview Cheat Sheet

Requirement Recommended Tool
Service Instance TestBed.inject()
Dependency Injection TestBed
HTTP Testing HttpTestingController
Mock Dependencies Spy Objects
Observable Testing firstValueFrom() / subscribe()
HTTP Verification verify()
Async Testing fakeAsync / waitForAsync
Standalone Services Providers
Business Logic Unit Tests
Enterprise Testing Mock Everything External

Summary

Service Testing is the foundation of reliable business logic in Angular applications. By using TestBed, HttpTestingController, mocked dependencies, and focused unit tests, developers can verify calculations, API communication, Observables, and error handling without relying on external systems. A comprehensive Service Testing strategy improves maintainability, prevents regressions, and ensures that enterprise applications remain stable as they evolve.

Key Takeaways

  • ✅ Service Testing focuses on business logic rather than UI rendering.
  • ✅ TestBed.inject() retrieves services from Angular's dependency injection system.
  • ✅ Mock dependencies to isolate the service under test.
  • ✅ Use HttpTestingController for HTTP service testing.
  • ✅ Always call verify() after HTTP tests.
  • ✅ Test both success and failure scenarios.
  • ✅ Validate Observable behavior.
  • ✅ Keep tests independent and deterministic.
  • ✅ Automate Service Tests in CI/CD pipelines.
  • ✅ Service Testing is a common Angular interview topic.

Next Article

➡️ 115-HTTP-Testing-QA.md