import avsc from 'avsc';
import { readFileSync } from 'fs';
import path from 'path';

const getValidator = (schemaName: string) => (payload: any) => {
    const schema = JSON.parse(readFileSync(path.join(__dirname, 'schema', `${schemaName}.avsc`), 'utf-8'));
    const avroType = avsc.Type.forSchema(schema);

    const errors: string[] = [];
    const isValid = avroType.isValid(payload, {
        errorHook: (_path, any, type) => {
            errors.push(`Invalid at ${_path}: ${any} (type: ${type})`);
        }
    });
    return { isValid, errors };
};

describe('avroSchema', () => {
    describe('ContactTask_update', () => {
        let validator: (payload: any) => { isValid: boolean; errors: string[] };
        beforeAll(() => {
            validator = getValidator('ContactTask_update');
        });

        describe('context: desired params', () => {
            it('should pass', () => {
                const payload = {
                    cmdDate: 123456789,
                    processedBy: { username: 'name' },
                    correlationId: 'correlationId',
                    status: 'Closed_NotProcessed',
                    sourceSystemId: 'sourceSystemId',
                    sourceSystemRecordId: 'sourceSystemRecordId',
                };

                const { isValid, errors } = validator(payload);
                expect(errors).toEqual([]);
                expect(isValid).toBe(true);
            });
        });

        describe('context: required params', () => {
            it('should pass', () => {
                const payload = {
                    cmdDate: 123456789,
                    correlationId: 'correlationId',
                    sourceSystemId: 'sourceSystemId',
                    sourceSystemRecordId: 'sourceSystemRecordId',
                };

                const { isValid, errors } = validator(payload);
                expect(errors).toEqual([]);
                expect(isValid).toBe(true);
            });
        });

        describe('context: missing params', () => {
            it('should fail', () => {
                const payload = {
                    aaa: 'aaa',
                };

                const { isValid, errors } = validator(payload);
                expect(errors).toEqual(
                    [
                        'Invalid at cmdDate: undefined (type: "long")',
                        'Invalid at correlationId: undefined (type: "string")',
                        'Invalid at sourceSystemId: undefined (type: "string")',
                        'Invalid at sourceSystemRecordId: undefined (type: "string")',
                    ]
                );
                expect(isValid).toBe(false);
            });
        });
    });
});