#============================================================================ 
#Name        : test_filter_metadatalog.py 
#Part of     : Helium 

#Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
#All rights reserved.
#This component and the accompanying materials are made available
#under the terms of the License "Eclipse Public License v1.0"
#which accompanies this distribution, and is available
#at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
#Initial Contributors:
#Nokia Corporation - initial contribution.
#
#Contributors:
#
#Description:
#===============================================================================

""" Test cases for filter meta data logs.

"""

# pylint: disable-msg=E1101

import logging
import os
import sys
import time
import mocker
import re
import tempfile
import shutil

_logger = logging.getLogger('test.test_filter_metadatalog')
logging.basicConfig(level=logging.DEBUG)

TEMP_PATH = tempfile.mkdtemp()
#NOTE: THE COMMENTED OUT CODE IS REQUIRED WHEN RUNNING THIS TEST USING THE PT TARGET
#WITH THE COMMENTED OUT CODE IT DOES NOT WORK IN THE FULL UNITTEST TARGET DUE TO RAPTOR.PY
#FILE BEING CALLED WITHOUT ALL THE ENVIRONMENT VARIABLES SET WHEN RUN SINGLY AND THEY ARE SET WHEN
#RUN AS PART OF THE UNITTEST TARGET.

PYTHON_FILE_NAME = os.path.join(TEMP_PATH, 'raptor.py')
FILTER_FILE_NAME = os.path.join(TEMP_PATH, 'filter_interface.py')

sys.path = [TEMP_PATH] + sys.path

def setup_module():
    """ Setup for test_filter_metadata """
    #in order to allow the filter_metadata.py file to compile we need to create a dummy 
    #raptor.py file as this is part of SBS and not present here, the classes and objects 
    #it uses from raptor.py file are created in this file, the same goes for the file filter_interface.py
    #does not exist so create empty python.py file
    f_handle = open(PYTHON_FILE_NAME, "w")
    f_handle.write("class testRaptor():\n")
    f_handle.write("    def testRaptorFunc(self):\n")
    f_handle.write("        return True \n")
    f_handle.close()
    #does not exist so create empty python.py file
    f_handle = open(FILTER_FILE_NAME, "w")
    f_handle.write("class Filter():\n")
    f_handle.write("    def testFilterFunc(self):\n")
    f_handle.write("        return True \n")
    f_handle.close()


def teardown_module():
    """ Teardown test_filter_metadata. """
    print("teardown called")
    if os.path.exists(TEMP_PATH):
        shutil.rmtree(TEMP_PATH)

# regex for "bare" drive letters  
DRIVERE = re.compile('^[A-Za-z]:$')

# are we on windows, and if so what is the current drive letter
ISWIN = sys.platform.lower().startswith("win")
if ISWIN:
    DRIVE = re.match('^([A-Za-z]:)', os.getcwd()).group(0)

# Base class
class Path(object):
    """This class represents a file path.                                      
                                                                               
    A generic path object supports operations without needing to know          
    about Windows and Linux differences. The standard str() function can       
    obtain a string version of the path in Local format for use by             
    platform-specific functions (file opening for example).                    
                                                                               
    We use forward slashes as path separators (even on Windows).               
                                                                               
    For example,                                                               
                                                                               
      path1 = generic_path.Path("/foo")                                        
      path2 = generic_path.Path("bar", "bing.bang")                            
                                                                               
      print str(path1.Append(path2))                                           
                                                                               
    Prints /foo/bar/bing.bang   on Linux                                       
    Prints c:/foo/bar/bing.bang   on Windows (if c is the current drive)       
    """                                                                        

    def __init__(self, *arguments):
        """construct a path from a list of path elements"""
        
        if len(arguments) == 0:
            self.path = ""
            return
        
        list = []
        for i, arg in enumerate(arguments):
            if ISWIN:
                if i == 0:
                    # If the first element starts with \ or / then we will
                    # add the current drive letter to make a fully absolute path
                    if arg.startswith("\\\\"):
                        list.append(arg) # A UNC path - don't mess with it
                    elif arg.startswith("\\") or arg.startswith("/"):
                        list.append(DRIVE + arg)
                    # If the first element is a bare drive then dress it with a \
                    # temporarily otherwise "join" will not work properly.
                    elif DRIVERE.match(arg):
                        list.append(arg + "\\")
                    # nothing special about the first element
                    else:
                        list.append(arg)
                else:
                    if arg.startswith("\\\\"):
                        raise ValueError("non-initial path components must not start with \\\\ : %s" % arg)
                    else:
                        list.append(arg)
                if ";" in arg:
                    raise ValueError("An individual windows Path may not contain ';' : %s" % arg)
            else:
                list.append(arg)
      
        self.path = os.path.join(*list)
        
        # normalise to avoid nastiness with dots and multiple separators
        # but do not normalise "" as it will become "."
        if self.path != "":
            self.path = os.path.normpath(self.path)
        
        # always use forward slashes as separators
        self.path = self.path.replace("\\", "/")
        
        # remove trailing slashes unless we are just /
        if self.path != "/":
            self.path = self.path.rstrip("/")

    def Dir(self):
        "return an object for the directory part of this path"
        if DRIVERE.match(self.path):
            return Path(self.path)
        else:
            return Path(os.path.dirname(self.path))
    def __str__(self):
        return self.path


class Raptor(object):
    """An instance of a running Raptor program.

    When operated from the command-line there is a single Raptor object
    created by the Main function. When operated by an IDE several Raptor
    objects may be created and operated at the same time."""

    def defaultSetUp(self):
        """ setup some variables for use by the unit under test """
        self.logFile = None #self.mocker.proxy(generic_path.Join)
        self.summary = True
        # things to initialise
        self.starttime = time.time()
        self.timestring = time.strftime("%Y-%m-%d-%H-%M-%S")
        self.logFileName = Path(os.path.join(TEMP_PATH, 'makefile_2009-11-12-12-32-34.log'))

class FilterMetaDataLogTest(mocker.MockerTestCase):
    """ Tests the filter_metadataLog wrapper to the SBS plugin. 
    The plugin uses the SBS API of open, write, summary and close. """

#    def test_a_setupOK(self):       #need to call it this to get it executed in the right order (alphabetical)
#        """test_a_setupOK: tests that we have imported the correct files and that they are present 
#        before importing the file to be tested and having it fail due to missing files"""
#        print("got to test-a-setup ")
#        import filter_metadatalog
#        print("got passed import filter file to test-a-setup ")
#        #setup an instance of the class and test it exists OK
#        obj = filter_metadatalog.raptor.testRaptor()
#        result = obj.testRaptorFunc()
#        assert result == True
#        obj = filter_metadatalog.filter_interface.Filter()
#        result = obj.testFilterFunc()
#        assert result == True

    def test_openWriteSummaryCloseInvalidData(self):
        """test_openWriteSummaryCloseInvalidData: test the opening writing, summary and 
        closing of the log file with invalid data."""
        import filter_metadatalog
        obj = self.mocker.patch(filter_metadatalog.SBSScanlogMetadata)
        obj.initialize(mocker.ANY)
        self.mocker.result(False)
        self.mocker.replay()
        
        raptor_instance = Raptor()
        raptor_instance.defaultSetUp()
        raptor_instance.logFileName = Path("..")
        filter_mLog = filter_metadatalog.FilterMetadataLog()
        result = filter_mLog.open(raptor_instance)
        assert result == False
        result = filter_mLog.close()
        assert result == False

    def test_openValidData_default(self):
        """test_openValidData_default: test the opening of the log file with valid data."""
        import filter_metadatalog
        obj = self.mocker.patch(filter_metadatalog.SBSScanlogMetadata)
        obj.initialize(mocker.ANY)
        self.mocker.result(True)
        self.mocker.replay()
        
        raptor_instance = Raptor()
        raptor_instance.defaultSetUp()
        filter_mLog = filter_metadatalog.FilterMetadataLog()
        result = filter_mLog.open(raptor_instance)
        assert result == True

    def test_openValidData_empty(self):
        """test_openValidData_empty: test the opening of the log file with valid data."""
        import filter_metadatalog
        obj = self.mocker.patch(filter_metadatalog.SBSScanlogMetadata)
        obj.initialize(mocker.ANY)
        self.mocker.result(True)
        self.mocker.replay()
        
        raptor_instance = Raptor()
        raptor_instance.defaultSetUp()
        raptor_instance.logFileName = Path("")
        filter_mLog = filter_metadatalog.FilterMetadataLog()
        result = filter_mLog.open(raptor_instance)
        assert result == True

    def test_openValidData_stdout(self):
        """test_openValidData_stdout: test the opening of the log file with valid data."""
        import filter_metadatalog
        obj = self.mocker.patch(filter_metadatalog.SBSScanlogMetadata)
        obj.initialize(mocker.ANY)
        self.mocker.count(0, 0)
        self.mocker.replay()
        
        raptor_instance = Raptor()
        raptor_instance.defaultSetUp()
        raptor_instance.logFileName = None
        filter_mLog = filter_metadatalog.FilterMetadataLog()
        result = filter_mLog.open(raptor_instance)
        assert result == True