100% coverage tests

tests/asKey.test.ts

@@ -4,7 +4,7 @@ import { getAsKey } from '../src/ISOToLanguage'
 describe('getAsKey', () => {
     describe('getAsKey', () => {
         it('should return an object with languages as keys', () => {
-            const result = getAsKey('languages')
+            const result = getAsKey('language')
             const expectedKeys = Object.keys(result)
 
             expect(expectedKeys.length).toBeGreaterThan(10)
@@ -14,14 +14,59 @@ describe('getAsKey', () => {
             const result = getAsKey('name')
             const expectedKeys = Object.keys(result)
 
-            expect(expectedKeys).toEqual(expect.arrayContaining(['Andorra', 'United Arab Emirates', 'Afghanistan']))
+            expect(expectedKeys).toEqual(
+                expect.arrayContaining(['Andorra', 'United Arab Emirates', 'Afghanistan'])
+            )
+        })
+
+        it('should return an object with locale as keys', () => {
+            const result = getAsKey('locale')
+            const expectedKeys = Object.keys(result)
+
+            expect(expectedKeys).toEqual(
+                expect.arrayContaining([
+                    'ca_AD',
+                    'ar_AE',
+                    'ps_AF',
+                    'uz_AF',
+                    'tk_AF',
+                    'en_AG',
+                    'en_AI',
+                ])
+            )
+        })
+
+        it('should return an object with language-code as keys', () => {
+            const result = getAsKey('language-code')
+            const expectedKeys = Object.keys(result)
+
+            expect(expectedKeys).toEqual(
+                expect.arrayContaining([
+                    'ca-AD',
+                    'uz-AF',
+                    'tk-AF',
+                    'en-AG',
+                    'en-AI',
+                    'sq-AL',
+                    'hy-AM',
+                ])
+            )
         })
 
         it('should return an object with original data as keys', () => {
             const result = getAsKey('original')
             const expectedKeys = Object.keys(result)
 
-            expect(expectedKeys).toEqual(expect.arrayContaining(["Andorra", "دولة الإمارات العربية المتحدة", "افغانستان", "Antigua and Barbuda", "Anguilla", "Shqipëria"]))
+            expect(expectedKeys).toEqual(
+                expect.arrayContaining([
+                    'Andorra',
+                    'دولة الإمارات العربية المتحدة',
+                    'افغانستان',
+                    'Antigua and Barbuda',
+                    'Anguilla',
+                    'Shqipëria',
+                ])
+            )
         })
     })
 })

tests/format.test.ts

@@ -1,4 +1,4 @@
-import { format, getCountriesByLanguage } from '../src/ISOToLanguage'
+import { format } from '../src/ISOToLanguage'
 
 describe('format', () => {
     it('should format the language and country into a single string with default options', () => {
@@ -11,6 +11,26 @@ describe('format', () => {
         expect(formattedString).toBe('en_US') // assuming en_US is the default country for en
     })
 
+    it('should return null if the language is not found', () => {
+        const formattedString = format('hh')
+        expect(formattedString).toBeNull()
+    })
+
+    it('should return null if the language is not provided', () => {
+        const formattedString = format(undefined as unknown as string)
+        expect(formattedString).toBeNull()
+    })
+
+    it('Should return null if the language is passed at the place of the country', () => {
+        const formattedString = format('us')
+        expect(formattedString).toBeNull()
+    })
+
+    it('Should fallback to the language if the country is not provided', () => {
+        const formattedString = format('id')
+        expect(formattedString).toBe('id_ID')
+    })
+
     it('should fallback to the language if the country is not provided and isValidIso returns false', () => {
         const formattedString = format('EN')
         expect(formattedString).toBe('en_US')

tests/getAll.test.ts

@@ -1,10 +1,8 @@
 import { describe, expect } from '@jest/globals'
-import {getAll} from '../src/ISOToLanguage'
+import { getAll } from '../src/ISOToLanguage'
 import { isoList } from '../src/iso'
 
 describe('getAll', () => {
-
-
     describe('getAll', () => {
         it('should return all ISO codes when type is "iso"', () => {
             const result = getAll('iso')
@@ -22,5 +20,76 @@ describe('getAll', () => {
             const result = getAll('invalidType' as unknown as 'iso')
             expect(result).toEqual(isoList)
         })
+
+        describe('getAll', () => {
+            test.each([
+                ['iso', Object.keys(isoList)],
+                ['countries', { AD: {}, AE: {} }],
+                ['language', ['ar', 'en', 'en', 'en', 'en', 'sq', 'en']],
+                [
+                    'name',
+                    [
+                        'Armenia',
+                        'Angola',
+                        'Antarctica',
+                        'Argentina',
+                        'American Samoa',
+                        'Austria',
+                        'Australia',
+                    ],
+                ],
+                [
+                    'original',
+                    [
+                        'دولة الإمارات العربية المتحدة',
+                        'افغانستان',
+                        'Antigua and Barbuda',
+                        'Anguilla',
+                        'Shqipëria',
+                    ],
+                ],
+                [
+                    'language-code',
+                    [
+                        'ca-AD',
+                        'ar-AE',
+                        'ps-AF',
+                        'uz-AF',
+                        'tk-AF',
+                        'en-AG',
+                        'en-AI',
+                        'sq-AL',
+                        'hy-AM',
+                        'ru-AM',
+                    ],
+                ],
+                [
+                    'locale',
+                    [
+                        'ca_AD',
+                        'ar_AE',
+                        'ps_AF',
+                        'uz_AF',
+                        'tk_AF',
+                        'en_AG',
+                        'en_AI',
+                        'sq_AL',
+                        'hy_AM',
+                        'ru_AM',
+                    ],
+                ],
+            ])('should return correct result for type "%s"', (type, expected) => {
+                // Run the test
+                const result = getAll(type)
+
+                if (type !== 'countries') {
+                    // Test only a part of the result array
+                    expect(result).toEqual(expect.arrayContaining(expected))
+                } else {
+                    // For other types, test objects
+                    expect(result).toMatchObject(expected)
+                }
+            })
+        })
     })
 })

tests/getAllLanguageCodesByISO.test.ts

@@ -1,17 +1,13 @@
 import { describe, expect } from '@jest/globals'
-import {getAllLanguagesByISO} from '../src/ISOToLanguage'
+import { getAllLanguagesByISO } from '../src/ISOToLanguage'
 import { isoList } from '../src/iso'
 
 describe('getAllLanguagesByISO', () => {
-
-
     it('should return all languages associated with the given ISO codes', () => {
         const isoCodes = ['AD', 'AE', 'AF']
         const result = getAllLanguagesByISO(isoCodes)
         const expectedLanguages = Array.from(
-            new Set(
-                isoCodes.flatMap((isoCode) => isoList[isoCode].languages)
-            )
+            new Set(isoCodes.flatMap((isoCode) => isoList[isoCode].languages))
         )
 
         expect(result).toEqual(expectedLanguages)

tests/getAllLanguagesByISO.test.ts

@@ -3,17 +3,13 @@ import { getAllLanguageCodesByISO } from '../src/ISOToLanguage'
 import { isoList } from '../src/iso'
 
 describe('getAllLanguageCodesByISO', () => {
-
-
     it('should return all language codes associated with the given ISO codes', () => {
         const isoCodes = ['AD', 'AE', 'AF']
         const result = getAllLanguageCodesByISO(isoCodes)
         const expectedLanguageCodes = Array.from(
             new Set(
                 isoCodes.flatMap((isoCode) => {
-                    return isoList[isoCode].languages.map(
-                        (language) => `${language}-${isoCode}`
-                    )
+                    return isoList[isoCode].languages.map((language) => `${language}-${isoCode}`)
                 })
             )
         )
@@ -27,9 +23,7 @@ describe('getAllLanguageCodesByISO', () => {
         const expectedLanguageCodes = Array.from(
             new Set(
                 isoCodes.flatMap((isoCode) => {
-                    return isoList[isoCode].languages.map(
-                        (language) => `${language}_${isoCode}`
-                    )
+                    return isoList[isoCode].languages.map((language) => `${language}_${isoCode}`)
                 })
             )
         )

tests/getCountriesByLanguage.test.ts

@@ -1,4 +1,4 @@
-import {getCountriesByLanguage} from '../src/ISOToLanguage'
+import { getCountriesByLanguage } from '../src/ISOToLanguage'
 
 describe('getCountriesByLanguage', () => {
     it('should return an array of countries that speak the given languages', () => {
@@ -7,13 +7,15 @@ describe('getCountriesByLanguage', () => {
 
         // Add your expectations based on the isoList data
         // For demonstration purposes we assume that isoList contains specific data
-        expect(result).toEqual(expect.objectContaining({
-            AG: {
-                languages: ['en'],
-                name: 'Antigua and Barbuda',
-                original: 'Antigua and Barbuda',
-            },
-        } ))
+        expect(result).toEqual(
+            expect.objectContaining({
+                AG: {
+                    languages: ['en'],
+                    name: 'Antigua and Barbuda',
+                    original: 'Antigua and Barbuda',
+                },
+            })
+        )
     })
 
     it('should handle an empty array of languages', () => {

tests/getCountry.test.ts

@@ -11,9 +11,7 @@ describe('ISOToLanguage', () => {
                 name: 'Andorra',
                 original: 'Andorra',
             }
-            const resultByOriginal = getCountry(
-                'دولة الإمارات العربية المتحدة'
-            )
+            const resultByOriginal = getCountry('دولة الإمارات العربية المتحدة')
             const expectedDataAE = {
                 code: 'AE',
                 languages: ['ar'],
@@ -23,9 +21,7 @@ describe('ISOToLanguage', () => {
 
             expect(resultByName).toEqual(expectedDataAD)
             expect(resultByOriginal).not.toBeNull()
-            expect(resultByOriginal).toEqual(
-                expect.objectContaining(expectedDataAE)
-            )
+            expect(resultByOriginal).toEqual(expect.objectContaining(expectedDataAE))
         })
 
         it('should return null for an invalid country name', () => {

tests/getCountryData.test.ts

@@ -2,7 +2,6 @@ import { describe, expect } from '@jest/globals'
 import { getCountryData } from '../src/ISOToLanguage'
 
 describe('ISOToLanguage', () => {
-
     it('should return the country data for a valid language code', () => {
         const result = getCountryData('tk_AF')
         const expectedData = {
@@ -19,7 +18,6 @@ describe('ISOToLanguage', () => {
         expect(result).toBeFalsy()
     })
 
-
     it('should return the country data for a valid language code', () => {
         const result = getCountryData('AF_tk')
         const expectedData = {
@@ -31,6 +29,17 @@ describe('ISOToLanguage', () => {
         expect(result).not.toEqual(expectedData)
     })
 
+    it('should return the country data for a valid language code', () => {
+        const result = getCountryData('IT')
+        const expectedData = {
+            languages: ['it'],
+            name: 'Italy',
+            original: 'Italia',
+        }
+
+        expect(result).toEqual(expectedData)
+    })
+
     it('should return null for an invalid language code', () => {
         const result = getCountryData(false as unknown as string)
 

tests/getCountryIso.test.ts

@@ -2,7 +2,6 @@ import { describe, expect } from '@jest/globals'
 import { getCountriesByISO } from '../src/ISOToLanguage'
 
 describe('getCountriesByISO', () => {
-
     it('should return an object of country data for valid ISO codes', () => {
         const result = getCountriesByISO(['AD', 'AE', 'AF'])
         const expectedData = {
@@ -27,10 +26,7 @@ describe('getCountriesByISO', () => {
     })
 
     it('should return an empty object for an array of invalid ISO codes', () => {
-        const result = getCountriesByISO([
-            'Invalid1',
-            'Invalid2',
-        ])
+        const result = getCountriesByISO(['Invalid1', 'Invalid2'])
 
         expect(result).toEqual({})
     })

tests/getKeyValue .test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, test } from '@jest/globals';
+import { getKeyValue } from '../src/ISOToLanguage';
+import { IsoDataType } from '../src/type'
+
+describe('getKeyValue', () => {
+    test.each([
+        ['iso', 'name', [{ value: 'AD', label: 'Andorra' }, /* ... */]],
+        ['language', 'original', [{ value: 'nl', label: 'Nederland' }, /* ... */]],
+    ])('should return the expected array for key "%s" and value "%s"', (key, value, expected) => {
+        const result = getKeyValue(key as IsoDataType, value as IsoDataType);
+        expect(result).toEqual(expect.arrayContaining(expected))
+    });
+});

tests/isValid.test.ts

@@ -2,8 +2,6 @@ import { describe, expect } from '@jest/globals'
 import { isValidIso } from '../src/ISOToLanguage'
 
 describe('ISOToLanguage', () => {
-
-
     describe('isValidISO', () => {
         it('should return true for a valid ISO code', () => {
             const result = isValidIso('AD')