validai/dist/__tests__/providers/GeminiProvider.test.js

AI-powered text validation for slang and gibberish detection

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const gemini_1 = require("../../providers/gemini");
const generative_ai_1 = require("@google/generative-ai");
// Mock the GoogleGenerativeAI
jest.mock('@google/generative-ai', () => {
    return {
        GoogleGenerativeAI: jest.fn().mockImplementation(() => ({
            getGenerativeModel: jest.fn().mockImplementation(() => ({
                generateContent: jest.fn().mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
                    return ({
                        response: {
                            text: jest.fn().mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
                                return `{
                            "text1": {
                                "Restricted": false,
                                "RestrictedReason": "",
                                "gibbrish": false,
                                "gibbrishReason": ""
                            },
                            "text2": {
                                "Restricted": true,
                                "RestrictedReason": "Contains offensive words",
                                "gibbrish": false,
                                "gibbrishReason": ""
                            }
                        }`;
                            }))
                        }
                    });
                }))
            }))
        }))
    };
});
describe('GeminiProvider', () => {
    let provider;
    let mockGenerateContent;
    beforeEach(() => {
        // Reset mocks
        jest.clearAllMocks();
        mockGenerateContent = jest.fn();
        generative_ai_1.GoogleGenerativeAI.mockImplementation(() => ({
            getGenerativeModel: jest.fn().mockReturnValue({
                generateContent: mockGenerateContent
            })
        }));
        provider = new gemini_1.GeminiProvider('fake-api-key', 'gemini-model');
    });
    describe('constructor', () => {
        it('should create instance with API key and model', () => {
            expect(provider).toBeInstanceOf(gemini_1.GeminiProvider);
            expect(generative_ai_1.GoogleGenerativeAI).toHaveBeenCalledWith('fake-api-key');
        });
    });
    describe('validate', () => {
        it('should call Gemini API and parse response correctly', () => __awaiter(void 0, void 0, void 0, function* () {
            mockGenerateContent.mockResolvedValueOnce({
                response: {
                    text: () => __awaiter(void 0, void 0, void 0, function* () {
                        return `{
                        "text1": {
                            "slang": false,
                            "slangReason": "",
                            "gibbrish": false,
                            "gibbrishReason": ""
                        },
                        "text2": {
                            "slang": true,
                            "slangReason": "Contains slang words",
                            "gibbrish": false,
                            "gibbrishReason": ""
                        }
                    }`;
                    })
                }
            });
            const texts = {
                text1: 'Hello world',
                text2: 'lol what up'
            };
            const result = yield provider.validate(texts);
            expect(result).toHaveProperty('text1');
            expect(result).toHaveProperty('text2');
            expect(result.text1.slang).toBe(false);
            expect(result.text2.slang).toBe(true);
        }));
        it('should handle API errors', () => __awaiter(void 0, void 0, void 0, function* () {
            mockGenerateContent.mockRejectedValueOnce(new Error('API Error'));
            const texts = {
                text: 'Hello world'
            };
            yield expect(provider.validate(texts)).rejects.toThrow('API Error');
        }));
        it('should handle malformed API responses', () => __awaiter(void 0, void 0, void 0, function* () {
            mockGenerateContent.mockResolvedValueOnce({
                response: {
                    text: () => __awaiter(void 0, void 0, void 0, function* () { return 'invalid json'; })
                }
            });
            const texts = {
                text: 'Hello world'
            };
            yield expect(provider.validate(texts)).rejects.toThrow(SyntaxError);
        }));
    });
});