.cache/opencode/node_modules/json-schema-ref-resolver/test/collisions.test.js

'use strict'

const assert = require('node:assert/strict')
const { test } = require('node:test')
const { RefResolver } = require('../index.js')

test('should not throw if there is a same schema with a same id', () => {
  const refResolver = new RefResolver()

  const schemaId = 'schemaId'
  const schema = {
    $id: schemaId,
    type: 'object',
    properties: {
      foo: { type: 'string' }
    }
  }

  refResolver.addSchema(schema)
  refResolver.addSchema(schema)

  const resolvedSchema = refResolver.getSchema(schemaId)
  assert.deepStrictEqual(resolvedSchema, schema)
})

test('should throw if there is a same schema with a same id (allowEqualDuplicates === false)', () => {
  const refResolver = new RefResolver({
    allowEqualDuplicates: false
  })

  const schemaId = 'schemaId'
  const schema = {
    $id: schemaId,
    type: 'object',
    properties: {
      foo: { type: 'string' }
    }
  }

  refResolver.addSchema(schema)

  try {
    refResolver.addSchema(schema)
    assert.fail('should throw')
  } catch (err) {
    assert.equal(err.message, `There is already another schema with id "${schemaId}".`)
  }
})

test('should throw if there is another schema with a same id', () => {
  const refResolver = new RefResolver()

  const schemaId = 'schemaId'

  const schema1 = {
    $id: schemaId,
    type: 'object',
    properties: {
      foo: { type: 'string' }
    }
  }

  const schema2 = {
    $id: schemaId,
    type: 'object',
    properties: {
      bar: { type: 'string' }
    }
  }

  refResolver.addSchema(schema1)

  try {
    refResolver.addSchema(schema2)
    assert.fail('should throw')
  } catch (err) {
    assert.equal(err.message, `There is already another schema with id "${schemaId}".`)
  }

  const resolvedSchema = refResolver.getSchema(schemaId)
  assert.deepStrictEqual(resolvedSchema, schema1)
})

test('should not throw if there is a same sub schema with a same id', () => {
  const refResolver = new RefResolver()

  const subSchemaId = 'subSchemaId'

  const schema1 = {
    $id: 'schemaId1',
    definitions: {
      subSchema: {
        $id: subSchemaId,
        type: 'object',
        properties: {
          foo: { type: 'string' }
        }
      }
    }
  }

  const schema2 = {
    $id: 'schemaId2',
    definitions: {
      subSchema: {
        $id: subSchemaId,
        type: 'object',
        properties: {
          foo: { type: 'string' }
        }
      }
    }
  }

  refResolver.addSchema(schema1)
  refResolver.addSchema(schema2)

  const resolvedSchema = refResolver.getSchema(subSchemaId)
  assert.deepStrictEqual(resolvedSchema, schema1.definitions.subSchema)
  assert.deepStrictEqual(resolvedSchema, schema2.definitions.subSchema)
})

test('should throw if there is another different sub schema with a same id', () => {
  const refResolver = new RefResolver()

  const subSchemaId = 'subSchemaId'

  const schema1 = {
    $id: 'schemaId1',
    definitions: {
      subSchema: {
        $id: subSchemaId,
        type: 'object',
        properties: {
          foo: { type: 'string' }
        }
      }
    }
  }

  const schema2 = {
    $id: 'schemaId2',
    definitions: {
      subSchema: {
        $id: subSchemaId,
        type: 'object',
        properties: {
          bar: { type: 'string' }
        }
      }
    }
  }

  refResolver.addSchema(schema1)

  try {
    refResolver.addSchema(schema2)
    assert.fail('should throw')
  } catch (err) {
    assert.equal(err.message, `There is already another schema with id "${subSchemaId}".`)
  }

  const resolvedSchema = refResolver.getSchema(subSchemaId)
  assert.deepStrictEqual(resolvedSchema, schema1.definitions.subSchema)
  assert.notDeepStrictEqual(resolvedSchema, schema2.definitions.subSchema)
})

test('should throw if there is the same anchor in the same schema', () => {
  const refResolver = new RefResolver()

  const subSchemaAnchor = '#subSchemaId'

  const schema = {
    $id: 'schemaId1',
    definitions: {
      subSchema1: {
        $id: subSchemaAnchor,
        type: 'object',
        properties: {
          foo: { type: 'string' }
        }
      },
      subSchema2: {
        $id: subSchemaAnchor,
        type: 'object',
        properties: {
          bar: { type: 'string' }
        }
      }
    }
  }

  try {
    refResolver.addSchema(schema)
    assert.fail('should throw')
  } catch (err) {
    assert.equal(err.message, 'There is already another anchor "#subSchemaId" in schema "schemaId1".')
  }
})