Target by specific countries and/or country group

src/server/tests/epics/epicSelection.test.ts

@@ -282,6 +282,10 @@ describe('matchesCountryGroups filter', () => {
         const test = {
             ...testDefault,
             locations: [],
+            targetedCountries: {
+                locations: [],
+                countries: [],
+            },
         };
 
         const got = matchesCountryGroups.test(test, targetingDefault);
@@ -293,6 +297,10 @@ describe('matchesCountryGroups filter', () => {
         const test: EpicTest = {
             ...testDefault,
             locations: ['GBPCountries'],
+            targetedCountries: {
+                locations: ['GBPCountries'],
+                countries: [],
+            },
         };
         const targeting = {
             ...targetingDefault,
@@ -308,6 +316,10 @@ describe('matchesCountryGroups filter', () => {
         const test: EpicTest = {
             ...testDefault,
             locations: ['EURCountries'],
+            targetedCountries: {
+                locations: ['EURCountries'],
+                countries: [],
+            },
         };
         const targeting: EpicTargeting = {
             ...targetingDefault,
@@ -323,6 +335,86 @@ describe('matchesCountryGroups filter', () => {
         const test: EpicTest = {
             ...testDefault,
             locations: ['EURCountries'],
+            targetedCountries: {
+                locations: ['EURCountries'],
+                countries: [],
+            },
+        };
+        const targeting: EpicTargeting = {
+            ...targetingDefault,
+            countryCode: 'GB',
+        };
+
+        const got = matchesCountryGroups.test(test, targeting);
+
+        expect(got).toBe(false);
+    });
+
+    it('should pass if user is in country group or targeted country', () => {
+        const test: EpicTest = {
+            ...testDefault,
+            locations: ['EURCountries'],
+            targetedCountries: {
+                locations: ['EURCountries'],
+                countries: ['Canada'],
+            },
+        };
+        const targeting: EpicTargeting = {
+            ...targetingDefault,
+            countryCode: 'DE',
+        };
+
+        const got = matchesCountryGroups.test(test, targeting);
+
+        expect(got).toBe(true);
+    });
+
+    it('should pass if user is in targeted country', () => {
+        const test: EpicTest = {
+            ...testDefault,
+            locations: [],
+            targetedCountries: {
+                locations: [],
+                countries: ['Germany'],
+            },
+        };
+        const targeting: EpicTargeting = {
+            ...targetingDefault,
+            countryCode: 'DE',
+        };
+
+        const got = matchesCountryGroups.test(test, targeting);
+
+        expect(got).toBe(true);
+    });
+
+    it('should pass if user is in both country group or targeted country', () => {
+        const test: EpicTest = {
+            ...testDefault,
+            locations: ['EURCountries'],
+            targetedCountries: {
+                locations: ['EURCountries'],
+                countries: ['Germany'],
+            },
+        };
+        const targeting: EpicTargeting = {
+            ...targetingDefault,
+            countryCode: 'DE',
+        };
+
+        const got = matchesCountryGroups.test(test, targeting);
+
+        expect(got).toBe(true);
+    });
+
+    it('should fail if user is not in country group or targeted country', () => {
+        const test: EpicTest = {
+            ...testDefault,
+            locations: ['EURCountries'],
+            targetedCountries: {
+                locations: ['EURCountries'],
+                countries: ['New Zealand'],
+            },
         };
         const targeting: EpicTargeting = {
             ...targetingDefault,

src/server/tests/epics/epicSelection.ts

@@ -74,7 +74,19 @@ export const hasCountryCode: Filter = {
 
 export const matchesCountryGroups: Filter = {
     id: 'matchesCountryGroups',
-    test: (test, targeting): boolean => inCountryGroups(targeting.countryCode, test.locations),
+    test: (test, targeting): boolean => {
+        const targetedCountries = test.targetedCountries
+            ? [
+                  ...(test.targetedCountries.locations || []),
+                  ...(test.targetedCountries.countries || []),
+              ]
+            : [];
+        return inCountryGroups(
+            targeting.countryCode,
+            test.locations, // Country groups/region
+            targetedCountries, // Individual country names
+        );
+    },
 };
 
 export const withinMaxViews = (log: EpicViewLog, now: Date = new Date()): Filter => ({

src/shared/lib/geolocation.test.ts

@@ -1,4 +1,9 @@
-import { getCountryName, getLocalCurrencySymbol, addRegionIdToSupportUrl } from './geolocation';
+import {
+    getCountryName,
+    getLocalCurrencySymbol,
+    addRegionIdToSupportUrl,
+    getCountryCodeFromName,
+} from './geolocation';
 
 describe('getLocalCurrencySymbol', () => {
     const currencySymbolTests = [
@@ -83,3 +88,18 @@ describe('addRegionIdToSupportUrl', () => {
         expect(modifiedUrl).toEqual(nonconformingUrl);
     });
 });
+
+describe('get Country Code from name', () => {
+    const testCases = [
+        { input: 'the UK', expected: 'GB' },
+        { input: 'the Czech Republic', expected: 'CZ' },
+        { input: 'France', expected: 'FR' },
+        { input: 'Nonexistent Country', expected: undefined },
+    ];
+
+    testCases.forEach(({ input, expected }) => {
+        it(`returns ${expected} for country name ${input}`, () => {
+            expect(getCountryCodeFromName(input)).toEqual(expected);
+        });
+    });
+});

src/shared/lib/geolocation.ts

@@ -14,6 +14,13 @@ export type CountryGroupId = (typeof CountryGroupId)[number];
 
 export const countryGroupIdSchema = z.enum(CountryGroupId);
 
+export const targetedCountriesSchema = z
+    .object({
+        locations: z.array(countryGroupIdSchema),
+        countries: z.array(z.string()).optional(),
+    })
+    .optional();
+
 // Used to internationalise 'Support the Guardian' links
 export type SupportRegionId = 'UK' | 'US' | 'AU' | 'EU' | 'INT' | 'NZ' | 'CA';
 
@@ -560,25 +567,37 @@ export const countryCodeToCountryGroupId = (countryCode?: string): CountryGroupI
     const foundCountryGroupId = availableCountryGroupIds.find((countryGroupId) =>
         countryGroups[countryGroupId].countries.includes(countryCode ?? ''),
     );
-
     return foundCountryGroupId || 'International';
 };
 
 export const inCountryGroups = (
     countryCode?: string,
     countryGroups: CountryGroupId[] = [],
+    countryNames: string[] = [], // Accepts country names
 ): boolean => {
-    // Always True if no locations set for the test
-    if (countryGroups.length === 0) {
+    // Always True if no locations or targeted countries set for the test (so always displays epic)
+    if (countryGroups.length === 0 && countryNames.length === 0) {
         return true;
     }
-
-    // Always False if user location unknown but test has locations set
+    // Always false if user location unknown but test has locations set (so never displays epic unless in country)
     if (!countryCode) {
         return false;
     }
 
-    return countryGroups.includes(countryCodeToCountryGroupId(countryCode.toUpperCase()));
+    // Check if the country belongs to the specified country groups
+    if (countryGroups.includes(countryCodeToCountryGroupId(countryCode.toUpperCase()))) {
+        return true;
+    }
+
+    // Check if the country is in the targeted countries by name
+    for (const name of countryNames) {
+        const code = getCountryCodeFromName(name);
+        if (code && code.toUpperCase() === countryCode.toUpperCase()) {
+            return true;
+        }
+    }
+
+    return false;
 };
 
 const defaultCurrencySymbol = '£';
@@ -623,3 +642,13 @@ export const addRegionIdToSupportUrl = (originalUrl: string, countryCode?: strin
 
     return originalUrl;
 };
+
+const countryNameToCodeMap: Record<string, string> = {};
+for (const [code, name] of Object.entries(countryNames)) {
+    countryNameToCodeMap[name] = code;
+}
+
+// Function to get country code from country name
+export const getCountryCodeFromName = (countryName: string): string | undefined => {
+    return countryNameToCodeMap[countryName];
+};

src/shared/types/abTests/epic.ts

@@ -1,4 +1,4 @@
-import { CountryGroupId, countryGroupIdSchema } from '../../lib';
+import { CountryGroupId, countryGroupIdSchema, targetedCountriesSchema } from '../../lib';
 import {
     articlesViewedSettingsSchema,
     testSchema,
@@ -112,7 +112,8 @@ export interface EpicTest extends EpicTestFromTool {
 export const epicTestFromToolSchema = testSchema.extend({
     name: z.string(),
     status: testStatusSchema,
-    locations: z.array(countryGroupIdSchema),
+    locations: z.array(countryGroupIdSchema), //deprecated
+    targetedCountries: targetedCountriesSchema.optional(),
     tagIds: z.array(z.string()),
     sections: z.array(z.string()),
     excludedTagIds: z.array(z.string()),