######################################################################
# Copyright 2015 The Kubernetes Authors All rights reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#     http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
######################################################################

import os
import unittest
import schema_validation
import yaml

INVALID_PROPERTIES = "Invalid properties for 'template.py'"


def GetFilePath():
  """Find our source and data files."""
  return  os.path.dirname(os.path.abspath(__file__))


def ReadTestFile(filename):
  """Returns contents of a file from the testdata/ directory."""

  full_path = os.path.join(GetFilePath(), '..', 'test', 'schemas', filename)
  return open(full_path, 'r').read()


def RawValidate(raw_properties, schema_name, raw_schema):
  return ImportsRawValidate(raw_properties, schema_name,
                            {schema_name: raw_schema})


def ImportsRawValidate(raw_properties, schema_name, import_map):
  """Takes raw properties, calls validate and returns yaml properties."""
  properties = yaml.safe_load(raw_properties)
  return schema_validation.Validate(properties, schema_name, 'template.py',
                                    import_map)


class SchemaValidationTest(unittest.TestCase):
  """Tests of the schema portion of the template expansion library."""
  
  def testDefaults(self):
    schema_name = 'defaults.jinja.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''
    expected_properties = """
      alpha: alpha
      one: 1
    """
    self.assertEqual(yaml.safe_load(expected_properties),
                     RawValidate(empty_properties, schema_name, schema))

  def testNestedDefaults(self):
    schema_name = 'nested_defaults.py.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      zone: us-central1-a
      disks:
        - name: backup       # diskType and sizeGb set by default
        - name: cache        # sizeGb set by default
          diskType: pd-ssd
        - name: data         # Nothing set by default
          diskType: pd-ssd
          sizeGb: 150
        - name: swap         # diskType set by default
          sizeGb: 200
    """
    expected_properties = """
      zone: us-central1-a
      disks:
        - sizeGb: 100
          diskType: pd-standard
          name: backup
        - sizeGb: 100
          diskType: pd-ssd
          name: cache
        - sizeGb: 150
          diskType: pd-ssd
          name: data
        - sizeGb: 200
          diskType: pd-standard
          name: swap
    """
    self.assertEqual(yaml.safe_load(expected_properties),
                     RawValidate(properties, schema_name, schema))

  def testNestedRefDefaults(self):
    schema_name = 'ref_nested_defaults.py.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      zone: us-central1-a
      disks:
        - name: backup       # diskType and sizeGb set by default
        - name: cache        # sizeGb set by default
          diskType: pd-ssd
        - name: data         # Nothing set by default
          diskType: pd-ssd
          sizeGb: 150
        - name: swap         # diskType set by default
          sizeGb: 200
    """
    expected_properties = """
      zone: us-central1-a
      disks:
        - sizeGb: 100
          diskType: pd-standard
          name: backup
        - sizeGb: 100
          diskType: pd-ssd
          name: cache
        - sizeGb: 150
          diskType: pd-ssd
          name: data
        - sizeGb: 200
          diskType: pd-standard
          name: swap
    """
    self.assertEqual(yaml.safe_load(expected_properties),
                     RawValidate(properties, schema_name, schema))

  def testInvalidDefault(self):
    schema_name = 'invalid_default.jinja.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''
    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn(INVALID_PROPERTIES, e.message)
      self.assertIn("'string' is not of type 'integer' at ['number']",
                    e.message)

  def testRequiredDefault(self):
    schema_name = 'required_default.jinja.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''
    expected_properties = """
      name: my_name
    """
    self.assertEqual(yaml.safe_load(expected_properties),
                     RawValidate(empty_properties, schema_name, schema))

  def testRequiredDefaultReference(self):
    schema_name = 'req_default_ref.py.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''

    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn(INVALID_PROPERTIES, e.message)
      self.assertIn("'my_name' is not of type 'integer' at ['number']",
                    e.message)

  def testDefaultReference(self):
    schema_name = 'default_ref.jinja.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''
    expected_properties = 'number: 1'

    self.assertEqual(yaml.safe_load(expected_properties),
                     RawValidate(empty_properties, schema_name, schema))

  def testMissingQuoteInReference(self):
    schema_name = 'missing_quote.py.schema'
    schema = ReadTestFile(schema_name)
    properties = 'number: 1'

    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(2, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn("type 'NoneType' is not iterable", e.message)
      self.assertIn('around your reference', e.message)

  def testRequiredPropertyMissing(self):
    schema_name = 'required.jinja.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''
    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn(INVALID_PROPERTIES, e.message)
      self.assertIn("'name' is a required property", e.errors[0].message)

  def testRequiredPropertyValid(self):
    schema_name = 'required.jinja.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      name: my-name
    """
    self.assertEqual(yaml.safe_load(properties),
                     RawValidate(properties, schema_name, schema))

  def testMultipleErrors(self):
    schema_name = 'defaults.py.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      one: not a number
      alpha: 12345
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(2, len(e.errors))
      self.assertIn(INVALID_PROPERTIES, e.message)
      self.assertIn("'not a number' is not of type 'integer' at ['one']",
                    e.message)
      self.assertIn("12345 is not of type 'string' at ['alpha']", e.message)

  def testNumbersValid(self):
    schema_name = 'numbers.py.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      minimum0: 0
      exclusiveMin0: 1
      maximum10: 10
      exclusiveMax10: 9
      even: 20
      odd: 21
    """
    self.assertEquals(yaml.safe_load(properties),
                      RawValidate(properties, schema_name, schema))

  def testNumbersInvalid(self):
    schema_name = 'numbers.py.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      minimum0: -1
      exclusiveMin0: 0
      maximum10: 11
      exclusiveMax10: 10
      even: 21
      odd: 20
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(6, len(e.errors))
      self.assertIn(INVALID_PROPERTIES, e.message)
      self.assertIn("-1 is less than the minimum of 0 at ['minimum0']",
                    e.message)
      self.assertIn(('0 is less than or equal to the minimum of 0'
                     " at ['exclusiveMin0']"), e.message)
      self.assertIn("11 is greater than the maximum of 10 at ['maximum10']",
                    e.message)
      self.assertIn(('10 is greater than or equal to the maximum of 10'
                     " at ['exclusiveMax10']"), e.message)
      self.assertIn("21 is not a multiple of 2 at ['even']", e.message)
      self.assertIn("{'multipleOf': 2} is not allowed for 20 at ['odd']",
                    e.message)

  def testReference(self):
    schema_name = 'reference.jinja.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      odd: 6
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn('even', e.message)
      self.assertIn('is not allowed for 6', e.message)

  def testBadSchema(self):
    schema_name = 'bad.jinja.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''
    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(2, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn("u'minimum' is a dependency of u'exclusiveMinimum'",
                    e.message)
      self.assertIn("0 is not of type u'boolean'", e.message)

  def testInvalidReference(self):
    schema_name = 'invalid_reference.py.schema'
    schema = ReadTestFile(schema_name)
    properties = 'odd: 1'
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn('Unresolvable JSON pointer', e.message)

  def testInvalidReferenceInSchema(self):
    schema_name = 'invalid_reference_schema.py.schema'
    schema = ReadTestFile(schema_name)
    empty_properties = ''
    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn('Unresolvable JSON pointer', e.message)

  def testMetadata(self):
    schema_name = 'metadata.py.schema'
    schema = ReadTestFile(schema_name)
    properties = """
      one: 2
      alpha: beta
    """
    self.assertEquals(yaml.safe_load(properties),
                      RawValidate(properties, schema_name, schema))

  def testInvalidInput(self):
    schema_name = 'schema'
    schema = """
      info:
        title: Invalid Input
      properties: invalid
    """
    properties = """
      one: 2
      alpha: beta
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn("'invalid' is not of type u'object'", e.message)

  def testPattern(self):
    schema_name = 'schema'
    schema = r"""
      properties:
        bad-zone:
          pattern: \w+-\w+-\w+
        zone:
          pattern: \w+-\w+-\w+
    """
    properties = """
      bad-zone: abc
      zone: us-central1-a
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn('Invalid properties', e.message)
      self.assertIn("'abc' does not match", e.message)
      self.assertIn('bad-zone', e.message)

  def testUniqueItems(self):
    schema_name = 'schema'
    schema = """
      properties:
        bad-list:
          type: array
          uniqueItems: true
        list:
          type: array
          uniqueItems: true
    """
    properties = """
      bad-list:
      - a
      - b
      - a
      list:
      - a
      - b
      - c
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn('Invalid properties', e.message)
      self.assertIn('has non-unique elements', e.message)
      self.assertIn('bad-list', e.message)

  def testUniqueItemsOnString(self):
    schema_name = 'schema'
    schema = """
      properties:
        ok-string:
          type: string
          uniqueItems: true
        string:
          type: string
          uniqueItems: true
    """
    properties = """
      ok-string: aaa
      string: abc
    """
    self.assertEquals(yaml.safe_load(properties),
                      RawValidate(properties, schema_name, schema))

  def testRequiredTopLevel(self):
    schema_name = 'schema'
    schema = """
      info:
        title: Invalid Input
      required:
        - name
    """
    properties = """
      one: 2
      alpha: beta
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn(INVALID_PROPERTIES, e.message)
      self.assertIn("'name' is a required property", e.message)

  def testEmptySchemaProperties(self):
    schema_name = 'schema'
    schema = """
      info:
        title: Empty Input
      properties:
    """
    properties = """
      one: 2
      alpha: beta
    """
    try:
      RawValidate(properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn("None is not of type u'object' at [u'properties']",
                    e.message)

  def testNoInput(self):
    schema = """
      info:
        title: No other sections
    """
    properties = """
      one: 2
      alpha: beta
    """
    self.assertEquals(yaml.safe_load(properties),
                      RawValidate(properties, 'schema', schema))

  def testEmptySchema(self):
    schema = ''
    properties = """
      one: 2
      alpha: beta
    """
    self.assertEquals(yaml.safe_load(properties),
                      RawValidate(properties, 'schema', schema))

  def testImportPathSchema(self):
    schema = """
      imports:
        - path: a
        - path: path/to/b
          name: b
    """
    properties = """
      one: 2
      alpha: beta
    """

    import_map = {'schema': schema,
                  'a': '',
                  'b': ''}

    self.assertEquals(yaml.safe_load(properties),
                      ImportsRawValidate(properties, 'schema', import_map))

  def testImportSchemaMissing(self):
    schema = ''
    empty_properties = ''

    try:
      properties = yaml.safe_load(empty_properties)
      schema_validation.Validate(properties, 'schema', 'template',
                                 {'wrong_name': schema})
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Could not find schema file 'schema'", e.message)

  def testImportsMalformedNotAList(self):
    schema_name = 'schema'
    schema = """
      imports: not-a-list
      """
    empty_properties = ''

    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn("is not of type 'array' at ['imports']", e.message)

  def testImportsMalformedMissingPath(self):
    schema_name = 'schema'
    schema = """
      imports:
        - name: no_path.yaml
      """
    empty_properties = ''

    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn("'path' is a required property", e.message)

  def testImportsMalformedNonunique(self):
    schema_name = 'schema'
    schema = """
      imports:
        - path: a.yaml
          name: a
        - path: a.yaml
          name: a
      """
    empty_properties = ''

    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn('non-unique elements', e.message)

  def testImportsMalformedAdditionalProperties(self):
    schema_name = 'schema'
    schema = """
      imports:
        - path: a.yaml
          gnome: a
      """
    empty_properties = ''

    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(1, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn('Additional properties are not allowed'
                    " ('gnome' was unexpected)", e.message)

  def testImportAndInputErrors(self):
    schema = """
      imports:
        - path: file
      required:
        - name
      """
    empty_properties = ''

    try:
      RawValidate(empty_properties, 'schema', schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(2, len(e.errors))
      self.assertIn("'file' requested in schema 'schema'", e.message)
      self.assertIn("'name' is a required property", e.message)

  def testImportAndInputSchemaErrors(self):
    schema_name = 'schema'
    schema = """
      imports: not-a-list
      required: not-a-list
      """
    empty_properties = ''

    try:
      RawValidate(empty_properties, schema_name, schema)
      self.fail('Validation should fail')
    except schema_validation.ValidationErrors as e:
      self.assertEqual(2, len(e.errors))
      self.assertIn("Invalid schema '%s'" % schema_name, e.message)
      self.assertIn("is not of type 'array' at ['imports']", e.message)
      self.assertIn("is not of type u'array' at [u'required']", e.message)

if __name__ == '__main__':
  unittest.main()