Mastering Geo-Blocked Feature Testing in Microservices with TypeScript

Introduction

In modern microservices architectures, implementing region-specific or geo-restricted features presents unique testing challenges. Developers often encounter the need to simulate geolocation-based responses, especially when working with third-party APIs or feature toggles that are region-dependent. This post explores a systematic approach to testing geo-blocked features efficiently, leveraging TypeScript's capabilities within a microservices ecosystem.

The Challenge of Testing Geo-Blocked Features

Geo-restrictions typically involve checking the user's IP address, locale, or user profile attributes to determine access. During testing, it's impractical to manipulate actual network conditions or geolocation data. Instead, we need a way to mock or simulate these conditions reliably.

In a microservices context, where multiple services might handle authentication, user profiles, and feature flags, the complexity multiplies. Ensuring consistent, isolated, and reproducible tests requires a layered approach.

Strategy Overview

• Abstract Geolocation Logic: Encapsulate geo-determination logic into an injectable service.
• Use Dependency Injection: To swap real geo-detection with mocks during testing.
• Implement Feature Flags: Store geo-specific feature toggles in a centralized store or config service.
• Create Mocked Data Providers: For simulating different geolocation scenarios.
• Leverage TypeScript's Type System: To enforce correct usage and prevent regressions.

Example Implementation

Let’s consider a microservice responsible for serving personalized content based on the user's region.

Geo-Detection Service

// geolocationService.ts
export interface GeoLocation {
  country: string;
  region?: string;
}

export interface GeoDetection {
  getUserGeo(ipAddress: string): Promise<GeoLocation>;
}

export class RealGeoDetection implements GeoDetection {
  async getUserGeo(ipAddress: string): Promise<GeoLocation> {
    // Integration with third-party GeoIP service
    const response = await fetch(`https://geoip-service.com/ip/${ipAddress}`);
    const data = await response.json();
    return { country: data.country, region: data.region };
  }
}

Feature Toggle with Geo Region

// featureToggle.ts
export interface FeatureFlags {
  isFeatureEnabled(featureName: string, geo: GeoLocation): boolean;
}

export class RegionalFeatureFlags implements FeatureFlags {
  private flags: Record<string, Record<string, boolean>>;

  constructor() {
    // Example: featureName -> countryCode -> enabled
    this.flags = {
      "newDashboard": {"US": true, "DE": false},
      "regionalBanner": {"US": true, "FR": false}
    };
  }

  isFeatureEnabled(featureName: string, geo: GeoLocation): boolean {
    const featureRegions = this.flags[featureName];
    if (!featureRegions) return false;
    return featureRegions[geo.country] || false;
  }
}

Testing with Mocks

// geoMock.ts
import { GeoDetection, GeoLocation } from './geolocationService';

export class MockGeoDetection implements GeoDetection {
  private mockGeo: GeoLocation;

  constructor(mockGeo: GeoLocation) {
    this.mockGeo = mockGeo;
  }

  async getUserGeo(ipAddress: string): Promise<GeoLocation> {
    return Promise.resolve(this.mockGeo);
  }
}

Test Example

import { MockGeoDetection } from './geoMock';
import { RegionalFeatureFlags } from './featureToggle';

async function testFeatureAvailability(ip: string, geo: GeoLocation) {
  const geoService = new MockGeoDetection(geo);
  const featureFlags = new RegionalFeatureFlags();

  const userGeo = await geoService.getUserGeo(ip);
  console.log(`User geo: ${userGeo.country}`);

  const isEnabled = featureFlags.isFeatureEnabled(
    "newDashboard",
    userGeo
  );
  console.log(`Is new dashboard enabled? ${isEnabled}`);
}

// Example test
testFeatureAvailability('127.0.0.1', { country: 'DE' });

Best Practices for Geo-Blocked Feature Testing

• Injectability: Always design geo-detection as an injectable dependency.
• Isolation: Use mocks to isolate tests from network dependencies.
• Reproducibility: Parameterize mocks for different geolocation scenarios.
• Automation: Integrate mocked geolocation tests into CI pipelines.
• Scaling: Use a centralized configuration for geo features to easily update or add regions.

Conclusion

By encapsulating geolocation logic, leveraging dependency injection, and employing mocks during testing, organizations can reliably test geo-blocked features within microservices architectures. TypeScript's static typing enhances safety and clarity, ensuring developers can confidently iterate over region-specific features without risking regressions or flaky tests.

This approach leads to robust, maintainable, and scalable testing strategies that accommodate the dynamic nature of geo-based features and regional compliance requirements.

---

🛠️ QA Tip

I rely on TempoMail USA to keep my test environments clean.