@lableb/javascript-sdk/src/request/search-by-id/search-by-id.request.test.ts

Lableb cloud search client for javascript

import { v4 as generateUUID } from 'uuid';
import { generate } from "randomstring";
import { LablebRequestBuilder } from '../main/main.request';
import { MESSAGES } from '../../config/messages';
import { GlobalRequestOptions, LablebRequestBuilderType } from '../main/main.request.type';
import { SearchByIdRequestParams } from './search-by-id.request.type';
import { createAndTestSearchByIdURL } from '../../utils/test.utils/test.utils';


describe('Missing required fields', () => {

    test('missing api key', async () => {

        try {

            const options: SearchByIdRequestParams = {
                id: generate(),
                platformName: generate(),
            }

            const lablebRequest = LablebRequestBuilder();
            await lablebRequest.searchById(options);

            throw new Error('unexpected error');

        } catch (error) {
            expect([
                MESSAGES.API_KEY_IS_REQUIRED,
            ]).toContain(error.message);
        }
    });



    test('missing id', async () => {

        try {

            const options: SearchByIdRequestParams = {
                APIKey: generateUUID(),
                id: '',
                platformName: generate(),
            }

            const lablebRequest = LablebRequestBuilder();
            await lablebRequest.searchById(options);

            throw new Error('unexpected error');

        } catch (error) {
            expect(error.message).toEqual(MESSAGES.DOCUMENT_ID_IS_REQUIRED)
        }
    });


    test('missing platform name', async () => {

        try {

            const options: SearchByIdRequestParams = {
                APIKey: generateUUID(),
                id: generate(),
                platformName: '',
            }

            const lablebRequest = LablebRequestBuilder();
            await lablebRequest.searchById(options);

            throw new Error('unexpected error');

        } catch (error) {
            expect(error.message).toEqual(MESSAGES.PLATFORM_NAME_IS_REQUIRED)
        }
    });

});


describe('Pass required fields and compare', () => {



    test('passing all required fields', async () => {

        const searchOptions: SearchByIdRequestParams = {
            APIKey: generateUUID(),
            id: generate(),
            platformName: generate(),
        }

        const lablebRequest = LablebRequestBuilder();
        const { params } = await lablebRequest.searchById(searchOptions);


        const expectedURL = `${process.env.API_BASE_URL}/projects/${searchOptions.platformName}/indices/${process.env.GLOBAL_DEFAULT_INDEX_NAME}/documents/${searchOptions.id}`;

        await createAndTestSearchByIdURL({
            expectedURL,
            globalOptions: {},
            searchOptions
        });

        expect(params.apikey).toEqual(searchOptions.APIKey);

    });

});




describe('Pass optional fields and compare', () => {


    test('passing all optional fields', async () => {

        const searchOptions: SearchByIdRequestParams = {
            APIKey: generateUUID(),
            id: generate(),
            platformName: generate(),

            indexName: generate(),


            userCountry: generate(2).toUpperCase(),
            sessionId: generate(7),
            userId: '24',
            userIp: '172.110.64.4',
        }


        const lablebRequest = LablebRequestBuilder();
        const { params } = await lablebRequest.searchById(searchOptions);

        const expectedURL = `${process.env.API_BASE_URL}/projects/${searchOptions.platformName}/indices/${searchOptions.indexName}/documents/${searchOptions.id}`;

        await createAndTestSearchByIdURL({
            expectedURL,
            globalOptions: {},
            searchOptions
        });


        expect(params.apikey).toEqual(searchOptions.APIKey);

        expect(params.userCountry).toEqual(searchOptions.userCountry);
        expect(params.sessionId).toEqual(searchOptions.sessionId);
        expect(params.userId).toEqual(searchOptions.userId);
        expect(params.userIp).toEqual(searchOptions.userIp);
    });


    test('passing all optional fields with facets', async () => {

        const searchOptions: SearchByIdRequestParams = {
            APIKey: generateUUID(),
            id: generate(),
            platformName: generate(),

            indexName: generate(),


            userCountry: generate(2).toUpperCase(),
            sessionId: generate(7),
            userId: '24',
            userIp: '172.110.64.4',

        }


        const lablebRequest = LablebRequestBuilder();
        const { params } = await lablebRequest.searchById(searchOptions);

        const expectedURL = `${process.env.API_BASE_URL}/projects/${searchOptions.platformName}/indices/${searchOptions.indexName}/documents/${searchOptions.id}`;

        await createAndTestSearchByIdURL({
            expectedURL,
            globalOptions: {},
            searchOptions
        });


        expect(params.apikey).toEqual(searchOptions.APIKey);

        expect(params.userCountry).toEqual(searchOptions.userCountry);
        expect(params.sessionId).toEqual(searchOptions.sessionId);
        expect(params.userId).toEqual(searchOptions.userId);
        expect(params.userIp).toEqual(searchOptions.userIp);
    });

});


describe('Test global/private options', () => {

    const globalOptions: GlobalRequestOptions = {
        platformName: generate(),
        indexName: generate(),
        APIKey: generateUUID(),
        searchHandler: generate(),
    }

    let lablebRequest: LablebRequestBuilderType;

    beforeAll(async () => {
        lablebRequest = LablebRequestBuilder(globalOptions);;
    });


    test('using global platform name', async () => {

        const searchOptions: SearchByIdRequestParams = {
            id: generate(),
            indexName: generate(),
        }

        const expectedURL = `${process.env.API_BASE_URL}/projects/${globalOptions.platformName}/indices/${searchOptions.indexName}/documents/${searchOptions.id}`;

        await createAndTestSearchByIdURL({
            expectedURL,
            globalOptions,
            searchOptions
        });
    });


    test('using private platform name', async () => {

        const searchOptions: SearchByIdRequestParams = {
            id: generate(),
            indexName: generate(),
            platformName: generate()
        }


        const expectedURL = `${process.env.API_BASE_URL}/projects/${searchOptions.platformName}/indices/${searchOptions.indexName}/documents/${searchOptions.id}`;

        await createAndTestSearchByIdURL({
            expectedURL,
            globalOptions,
            searchOptions
        });
    });






    test('using global api key', async () => {

        const searchOptions: SearchByIdRequestParams = {
            id: generate(),
            indexName: generate(),
            platformName: generate(),
        }

        const { params } = await lablebRequest.searchById(searchOptions);

        expect(params.apikey).toEqual(globalOptions.APIKey);
    });


    test('using private api key', async () => {

        const searchOptions: SearchByIdRequestParams = {
            id: generate(),
            indexName: generate(),
            platformName: generate(),
            APIKey: generateUUID(),
        }

        const { params } = await lablebRequest.searchById(searchOptions);
        expect(params.apikey).toEqual(searchOptions.APIKey);
    });


});



describe('Validate bad inputs', () => {


    test('validate id', async () => {
        try {
            const searchOptions: SearchByIdRequestParams = {
                id: '',
                platformName: generate(),
                APIKey: generateUUID()
            }

            const lablebRequest = LablebRequestBuilder();
            await lablebRequest.searchById(searchOptions);
        } catch (error) {
            expect(error.message).toEqual(MESSAGES.DOCUMENT_ID_IS_REQUIRED)
        }
    });




    test('validate user country 1', async () => {
        try {
            const searchOptions: SearchByIdRequestParams = {
                APIKey: generate(),
                id: generate(),
                indexName: generate(),
                platformName: generate(),
                userCountry: '',
            }

            const lablebRequest = LablebRequestBuilder();
            await lablebRequest.searchById(searchOptions);

        } catch (error) {
            expect(error.message).toEqual(MESSAGES.COUNTRY_NAME_LENGTH_IS_INVALID)
        }
    });


    test('validate user country 2', async () => {
        try {
            const searchOptions: SearchByIdRequestParams = {
                id: generate(),
                indexName: generate(),
                platformName: generate(),
                userCountry: 'FAV',
            }

            const lablebRequest = LablebRequestBuilder();
            await lablebRequest.searchById(searchOptions);

        } catch (error) {
            expect(error.message).toEqual(MESSAGES.COUNTRY_NAME_LENGTH_IS_INVALID)
        }
    });


    test('validate user ip', async () => {
        try {
            const searchOptions: SearchByIdRequestParams = {
                id: generate(),
                indexName: generate(),
                platformName: generate(),
                userIp: '366.125.21.21',
            }

            const lablebRequest = LablebRequestBuilder();
            await lablebRequest.searchById(searchOptions);

        } catch (error) {
            expect(error.message).toEqual(MESSAGES.INVALID_IP_ADDRESS)
        }
    });



    

    
});