import {
  Dependency_Mock, dependency_mock_DataParams, Dependent_Mock, dependent_mock_DataParams
} from './data-model.mock';

describe('| Dependency_Mock', () => {
  it('| should create an instance with default values', () => {
    const instance = new Dependency_Mock();

    expect(instance).toBeTruthy();
    expect(instance.string).toBeUndefined();
    expect(instance.number).toBeUndefined();
    expect(instance.date).toBeUndefined();
    expect(instance.boolean).toBeUndefined();
    expect(instance.array).toBeUndefined();
    expect(instance.object).toBeUndefined();
    expect(instance.objectArray).toBeUndefined();
    expect(instance.objectArrayArray).toBeUndefined();
  });

  it('| should create an instance with provided values', () => {
    const mockData: Dependency_Mock = {
      string: 'test',
      number: 42,
      date: new Date(),
      boolean: true,
      array: [ 'a', 'b' ],
      object: { key: 'value' },
      objectArray: [{ key: 'value' }],
      objectArrayArray: [[{ key: 'value' }]],
    };
    const instance = new Dependency_Mock(mockData);

    expect(instance).toEqual(jasmine.objectContaining(mockData));
  });
});

describe('| DyFM_DataModel_Params for Dependency_Mock', () => {
  it('| should have correct dataName and properties', () => {
    expect(dependency_mock_DataParams.dataName).toBe('dependency_mock');
    // Check that required properties exist with correct type
    expect(dependency_mock_DataParams.properties.string).toBeDefined();
    expect(dependency_mock_DataParams.properties.string.type).toBe('string');
    expect(dependency_mock_DataParams.properties.number).toBeDefined();
    expect(dependency_mock_DataParams.properties.number.type).toBe('number');
    expect(dependency_mock_DataParams.properties.date).toBeDefined();
    // DyFM_DataModel_Params normalizes type to lowercase 'date'
    expect(dependency_mock_DataParams.properties.date.type).toBe('date');
    expect(dependency_mock_DataParams.properties.boolean).toBeDefined();
    expect(dependency_mock_DataParams.properties.boolean.type).toBe('boolean');
  });
});

describe('| Dependent_Mock', () => {
  it('| should create an instance with default values', () => {
    const instance = new Dependent_Mock();

    expect(instance).toBeTruthy();
    expect(instance.dependencyId).toBeUndefined();
    expect(instance.string).toBeUndefined();
    expect(instance.number).toBeUndefined();
    expect(instance.date).toBeUndefined();
    expect(instance.boolean).toBeUndefined();
    expect(instance.array).toBeUndefined();
    expect(instance.object).toBeUndefined();
    expect(instance.objectArray).toBeUndefined();
    expect(instance.objectArrayArray).toBeUndefined();
  });

  it('| should create an instance with provided values', () => {
    const mockData: Dependent_Mock = {
      dependencyId: 'dep123',
      string: 'test',
      number: 42,
      date: new Date(),
      boolean: true,
      array: [ 'a', 'b' ],
      object: { key: 'value' },
      objectArray: [{ key: 'value' }],
      objectArrayArray: [[{ key: 'value' }]],
    };
    const instance = new Dependent_Mock(mockData);

    expect(instance).toEqual(jasmine.objectContaining(mockData));
  });
});

describe('| DyFM_DataModel_Params for Dependent_Mock', () => {
  it('| should have correct dataName and properties', () => {
    expect(dependent_mock_DataParams.dataName).toBe('dependent_mock');
    // Use jasmine.objectContaining to allow for additional properties from base class
    // Note: DyFM_DataModel_Params normalizes array types to 'array' and object types to 'object'
    expect(dependent_mock_DataParams.properties).toEqual(jasmine.objectContaining({
      dependencyId: jasmine.objectContaining({
        type: 'string',
        unique: true,
        required: true,
        dependencyDataName: dependency_mock_DataParams.dataName,
      }),
      string: jasmine.objectContaining({ type: 'string' }),
      number: jasmine.objectContaining({ type: 'number' }),
      // DyFM_DataModel_Params normalizes type to lowercase 'date'
      date: jasmine.objectContaining({ type: 'date' }),
      boolean: jasmine.objectContaining({ type: 'boolean' }),
      array: jasmine.objectContaining({ type: 'array' }),
      object: jasmine.objectContaining({ type: 'object' }),
      objectArray: jasmine.objectContaining({ type: 'array' }),
      objectArrayArray: jasmine.objectContaining({ type: 'array' }),
    }));
  });
});