/* eslint camelcase: 0 */
const AJV = require('ajv');
const assert = require('assert');
const deploymentConfigSchema = require('../deployment/config');

const ajv = new AJV({allErrors: true});

exports.test_unknown_keys = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		foo: 1,
		bar: 2
	});
	assert.equal(isValid, false);
	assert.equal(ajv.errors.length, 2);
	['foo', 'bar'].forEach((prop, i) => {
		const error = ajv.errors[i];
		assert.equal(error.keyword, 'additionalProperties');
		assert.equal(error.params.additionalProperty, prop);
	});
};

exports.test_features_object = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		features: {
			foo: 'v2',
			bar: 2
		}
	});
	assert.equal(isValid, true);
};

exports.test_slot_key = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		features: {
			cloud: 'v2'
		},
		slot: 'c.125-m512'
	});
	assert.equal(isValid, true);
};

exports.test_staging_slot_key = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		features: {
			cloud: 'v2'
		},
		slot: 'staging-c.5-t1-w-m1024'
	});
	assert.equal(isValid, true);
};

exports.test_invalid_slot_key = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		features: {
			cloud: 'v2'
		},
		slot: 'invalid-key'
	});
	assert.equal(isValid, false);
};

exports.test_slot_key_without_cloud_v2 = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		slot: 'c.125-m512'
	});
	assert.equal(isValid, false);
};

exports.test_invalid_features_object = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		features: {
			foo: []
		}
	});
	assert.equal(isValid, false);
};

exports.test_features_object = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		limits: {
			duration: 60000,
			maxConcurrentReqs: 2,
			timeout: 60000 * 2
		}
	});
	assert.equal(isValid, true);
};

exports.test_invalid_limits_object = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		limits: {
			foo: []
		}
	});
	assert.equal(!isValid, true);
};

exports.test_valid_env_types = () => {
	let isValid = ajv.validate(deploymentConfigSchema, {
		env: {
			VALID: '1'
		}
	});
	assert.equal(isValid, true);

	isValid = ajv.validate(deploymentConfigSchema, {
		env: [
			'VALID'
		]
	});
	assert.equal(isValid, true);
};

exports.test_invalid_env_types = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		env: {
			INVALID: true
		}
	});
	assert.equal(!isValid, true);
};

exports.test_valid_build_env_types = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		build: {
			env: {
				VALID: '1'
			}
		}
	});
	assert.equal(isValid, true);
};

exports.test_invalid_build_env_types = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		build: {
			env: {
				INVALID: true
			}
		}
	});
	assert.equal(!isValid, true);
};

exports.test_invalid_static_object = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		'static': {
			foo: []
		}
	});
	assert.equal(isValid, false);
};

exports.test_valid_static_headers_object = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		'static': {
			headers: [
				{
					source: '/_next/webpack/chunks/*',
					headers: [{
						key: 'Cache-Control',
						value: 'adssds'
					}]
				},
				{
					source: '/_next/static/commons/**',
					headers: [{
						key: 'Cache-Control',
						value: 'public, max-age=31536000, immutable'
					}]
				},
				{
					source: '/_next/*/page/**/*.js',
					headers: [{
						key: 'Cache-Control',
						value: 'public, max-age=31536000, immutable'
					}]
				}
			]
		}
	});

	assert.equal(isValid, true);
};

exports.test_invalid_static_headers_object = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		'static': {
			headers: [
				{
					source: '/_next/webpack/chunks/*',
					headers: [{
						key: ':alternate-protocol',
						value: 'foo\x00bar'
					}]
				},
				{
					source: '/_next/static/commons/**',
					headers: [{
						key: 'Cache-Control',
						value: 'public, max-age=31536000, immutable'
					}]
				}
			]
		}
	});

	assert.equal(isValid, false);
};

exports.test_valid_static_object_trailing_slash = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		'static': {
			trailingSlash: true
		}
	});
	assert.equal(isValid, true);
};

exports.test_valid_static_object_invalid_prop = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		'static': {
			trailingSlash: []
		}
	});
	assert.equal(isValid, false);
};

exports.test_github_enabled = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		github: {
			enabled: false
		}
	});
	assert.equal(isValid, true);
};

exports.test_github_aliasing = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		github: {
			aliasing: false
		}
	});
	assert.equal(isValid, true);
};

exports.test_github_auto_alias = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		github: {
			autoAlias: false
		}
	});
	assert.equal(isValid, true);
};

exports.test_github_additional_field = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		github: {
			abc: 'bbc'
		}
	});
	assert.equal(isValid, false);
};

exports.test_scale_sfo1 = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		scale: {
			sfo1: {
				min: 0,
				max: 1
			}
		}
	});
	assert.equal(isValid, true);
};

exports.test_scale_all = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		scale: {
			all: {
				min: 0,
				max: 'auto'
			}
		}
	});
	assert.equal(isValid, true);
};

exports.test_scale_invalid = () => {
	const isValid = ajv.validate(deploymentConfigSchema, {
		scale: {
			foo: {
				min: -1,
				max: 'auto'
			}
		}
	});
	assert.equal(isValid, false);
};