Assertions

test("validate nested object structure", function() {
  const data = res.getBody();
  
  expect(data).to.have.nested.property('user.profile.email');
  expect(data).to.have.nested.property('settings.notifications.email', true);
  
  // Deep equality
  expect(data.user).to.deep.include({
    id: 123,
    role: 'admin'
  });
  
  // Validate entire structure
  expect(data).to.deep.equal({
    success: true,
    user: {
      id: 123,
      name: 'John Doe',
      email: 'john@example.com'
    },
    metadata: {
      timestamp: data.metadata.timestamp // dynamic value
    }
  });
});

test("validate array contents", function() {
  const data = res.getBody();
  
  // Array length
  expect(data.items).to.have.lengthOf(10);
  expect(data.items).to.have.length.above(0);
  
  // Array membership
  expect(data.tags).to.include('javascript');
  expect(data.tags).to.include.members(['node', 'api']);
  expect(data.tags).to.have.members(['node', 'api', 'rest']);
  
  // Array of objects
  expect(data.users).to.be.an('array').that.is.not.empty;
  expect(data.users[0]).to.have.property('id');
  
  // Every item matches condition
  data.items.forEach(item => {
    expect(item).to.have.property('id');
    expect(item.id).to.be.a('number');
  });
});

test("response time is acceptable", function() {
  const responseTime = res.getResponseTime();
  
  expect(responseTime).to.be.below(2000);
  expect(responseTime).to.be.within(0, 5000);
});

test("response size is reasonable", function() {
  const size = res.getSize();
  
  expect(size.total).to.be.below(1024 * 1024); // < 1MB
  expect(size.body).to.be.above(0);
});

test("validate response headers", function() {
  const headers = res.getHeaders();
  
  expect(headers).to.have.property('content-type');
  expect(headers['content-type']).to.include('application/json');
  
  expect(res.getHeader('x-rate-limit-remaining')).to.be.a('string');
  
  const rateLimit = parseInt(res.getHeader('x-rate-limit-remaining'));
  expect(rateLimit).to.be.at.least(0);
});

test("validate JSON schema", function() {
  const tv4 = require('tv4');
  const data = res.getBody();
  
  const schema = {
    type: 'object',
    required: ['id', 'name', 'email'],
    properties: {
      id: { type: 'number' },
      name: { type: 'string', minLength: 1 },
      email: { type: 'string', format: 'email' },
      age: { type: 'number', minimum: 0 },
      roles: {
        type: 'array',
        items: { type: 'string' }
      }
    }
  };
  
  const valid = tv4.validate(data, schema);
  expect(valid).to.be.true;
  
  if (!valid) {
    console.error('Schema validation error:', tv4.error);
  }
});

test("validate JWT token", function() {
  const jwt = require('jsonwebtoken');
  const token = res.getBody().token;
  
  // Decode without verification
  const decoded = jwt.decode(token);
  expect(decoded).to.have.property('exp');
  expect(decoded.exp).to.be.greaterThan(Date.now() / 1000);
  
  // Validate claims
  expect(decoded.userId).to.equal(bru.getVar('expectedUserId'));
  expect(decoded.role).to.be.oneOf(['user', 'admin']);
  
  // Store for later use
  bru.setVar('authToken', token);
});