#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

# Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.

#

import os

import shutil

import tempfile

import unittest

import lxml.etree as etree

import solaris_install.js2ai as js2ai

from solaris_install.js2ai.common import ARCH_GENERIC, ARCH_SPARC, ARCH_X86

from solaris_install.js2ai.common import ConversionReport

from solaris_install.js2ai.common import KeyValues

from solaris_install.js2ai.common import DEFAULT_AI_FILENAME

from solaris_install.js2ai.common import DEFAULT_AI_DTD_FILENAME

from solaris_install.js2ai.common import fetch_xpath_node

from solaris_install.js2ai.common import pretty_print

from solaris_install.js2ai.common import write_xml_data

from solaris_install.js2ai.common import validate

from solaris_install.js2ai.conv import XMLProfileData

from solaris_install.js2ai.conv import XMLRuleData

from solaris_install.js2ai.default_xml import XMLDefaultData

from test_js2ai import failure_report

TEST_PROFILE_NAME = "profile.xml"

class Test_Profile(unittest.TestCase):

    """Test Profile code"""

    default_xml = None

    def setUp(self):

        """Setup test run"""

        # Create a directory to work in

        self.working_dir = tempfile.mkdtemp()

        self.log_file = os.path.join(self.working_dir, js2ai.LOGFILE)

        # Test to see if the default xml file is present

        # on the system.  It isn't guaranteed to be present unless

        # the package pkg:/system/install/auto-install/auto-install-common

        # is installed.   If it is present use it.  If not we'll create

        # a barebones xml file

        if os.path.isfile(DEFAULT_AI_FILENAME):

            default_xml_filename = DEFAULT_AI_FILENAME

        else:

            default_xml_filename = None

        self.default_xml = XMLDefaultData(default_xml_filename)

        js2ai.logger_setup(self.working_dir)

    def tearDown(self):

        """Clean up test run"""

        # Delete everything when we are done

        shutil.rmtree(self.working_dir)

    def get_xml_contents(self, filename):

        """Read in the xml file and return it's contents"""

        name = os.path.join(self.working_dir, filename)

        x = etree.parse(name)

        return etree.tostring(x, pretty_print=True)

    def validate_xml_output(self, xml_data):

        """Outputs the xml data to a file and then performs a validation test

           on the resulting file

        """

        self.assertNotEquals(xml_data.tree, None)

        report = ConversionReport()

        if xml_data.architecture is None:

            tree = xml_data.fetch_tree(ARCH_X86)

        else:

            tree = xml_data.tree

        write_xml_data(tree, self.working_dir, TEST_PROFILE_NAME)

        result = validate(TEST_PROFILE_NAME, self.working_dir,

                          TEST_PROFILE_NAME, DEFAULT_AI_DTD_FILENAME,

                          report, False)

        self.assertTrue(result, "Validation of xml failed:\n\n" +

                        self.get_xml_contents(TEST_PROFILE_NAME))

    def profile_failure_report(self, xml_profile_data, report):

        """Generate profile failure report"""

        rbuffer = "\nResulting XML Tree: "

        if xml_profile_data.tree is None:

            rbuffer += "No data available"

        else:

            rbuffer += "\n\n" + pretty_print(xml_profile_data.tree)

        rbuffer += "\n\n\n" + failure_report(report, self.log_file)

        return rbuffer

    def test_arch_conflict(self):

        """Test for conversion error when x86 and sparc ops mixed"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2t0d0s1"], 2)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("fdisk", ["c3t0d0", "solaris", "all"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report, xml_data.conversion_report)

        self.assertEquals(report.has_errors(), True)

        self.assertEquals(report.process_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_arch_sparc(self):

        """Make sure arch type for profile is SPARC when sparc op used"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2t0d0s1"], 2)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report, xml_data.conversion_report)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(ARCH_SPARC, xml_data.architecture)

        self.validate_xml_output(xml_data)

    def test_arch_x86(self):

        """Make sure arch type for profile is X86 when x86 op used"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2t0d0"], 2)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report, xml_data.conversion_report)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(ARCH_X86, xml_data.architecture)

        self.validate_xml_output(xml_data)

    def test_arch_generic(self):

        """Ensure arch type for prof is generic when no sparc/x86 is op used"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("pool",

                              ["newpool", "auto", "auto", "auto", "any"], 2)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report, xml_data.conversion_report)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(ARCH_GENERIC, xml_data.architecture)

        self.validate_xml_output(xml_data)

    def test_arch_none(self):

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("partitioning", ["default"], 2)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("filesys", ["c0t0d0s0", "40", "/"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report, xml_data.conversion_report)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(None, xml_data.architecture)

        # Fetch x86 and sparc versions of the manifest xml tree

        x86_tree = xml_data.fetch_tree(ARCH_X86)

        sparc_tree = xml_data.fetch_tree(ARCH_SPARC)

        # Test to make sure that the <partition> node exists in the x86

        # tree but not in the sparc tree

        xpath = "/auto_install/ai_instance/target/disk/partition"

        partition = fetch_xpath_node(x86_tree, xpath)

        self.assertNotEquals(None, partition,

                             "<partition> not found in x86 tree")

        partition = fetch_xpath_node(sparc_tree, xpath)

        self.assertEquals(None, partition,

                          "<partition> found in sparc tree")

        self.validate_xml_output(xml_data)

    def test_boot_device_entry1(self):

        """Tests boot_device <device> where device is a disk"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2t0d0"], 5)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report, xml_data.conversion_report)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry2(self):

        """Tests boot_device <device> where device is a slice"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2d0s0"], 4)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        report = xml_data.conversion_report

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry3(self):

        """Tests boot_device <device> where device = any"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["any"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry4(self):

        """Tests boot_device <device> where device = existing"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["existing"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), True)

        self.assertEquals(report.process_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry5(self):

        """Tests boot_device <device> <eprom> where eprom = preserve"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2t0d0s0", "preserve"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry6(self):

        """Tests boot_device <device> <eprom> where eeprom = update"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2t0d0s0", "update"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), True)

        self.assertEquals(report.process_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry7(self):

        """Tests boot_device <device> where device is a /dev/dsk"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2d0s0"], 4)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        report = xml_data.conversion_report

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry8(self):

        """Tests boot_device <device> where too many args specified"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2d0s0", "1", "2"], 4)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        report = xml_data.conversion_report

        self.assertEquals(report.has_errors(), True)

        self.assertEquals(report.process_errors, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry9(self):

        """Tests boot_device <device> <eprom> where eeprom = bogus"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c2t0d0s0", "bogus"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), True, str(report))

        self.assertEquals(report.process_errors, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry10(self):

        """Tests boot_device with previous set root_device """

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("root_device", ["c2t0d0"], 2)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c0t0d0s0"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), True, str(report))

        self.assertEquals(report.process_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_boot_device_entry11(self):

        """Tests boot_device with bad device name """

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("boot_device", ["c0txx0s0"], 3)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), True, str(report))

        self.assertEquals(report.process_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_fdisk_entry1(self):

        """Tests fdisk <diskname> where diskname is rootdisk"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("fdisk", ["rootdisk", "solaris", "all"], 4)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), True)

        self.assertEquals(report.process_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

        self.validate_xml_output(xml_data)

    def test_fdisk_entry2(self):

        """Tests fdisk <diskname> where diskname is all"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("fdisk", ["all", "solaris", "all"], 5)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), True)

        self.assertEquals(report.process_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.conversion_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.unsupported_items, 1,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.validation_errors, 0,

                          self.profile_failure_report(xml_data, report))

        self.assertEquals(report.warnings, 0,

                          self.profile_failure_report(xml_data, report))

    def test_fdisk_entry3(self):

        """Tests fdisk <diskname> where diskname is a valid disk"""

        kv_dict = {}

        key_value = KeyValues("install_type", ["initial_install"], 1)

        kv_dict[key_value.line_num] = key_value

        key_value = KeyValues("fdisk", ["c2t0d0", "solaris", "all"], 5)

        kv_dict[key_value.line_num] = key_value

        report = ConversionReport()

        xml_data = XMLProfileData("test", kv_dict, report,

                                  self.default_xml, True, None)

        self.assertEquals(report.has_errors(), False,

                          self.profile_failure_report(xml_data, report))