Example #1
0
    def tes1t_loadCsvCase(self):
        from Parser import caseParser
        setup = []
        run = []
        teardown = []
        duts = {'winTel': baseS}
        mode = 'full'
        cs = caseParser('testParser', mode, './log/ut_parser')
        arg = []
        gvars = [
            'gv1',
            'gv2',
            'gv3',
        ]

        resp = cs.load('./case2-novar.csv', gvars)
        dutname, varlist, setup, run, tear = resp
        print(dutname)
        print(varlist)
        print(setup)
        print(run)
        print(tear)

        resp = cs.load('./case1.csv', gvars)
        dutname, varlist, setup, run, tear = resp
        print(dutname)
        print(varlist)
        print(setup)
        print(run)
        print(tear)
Example #2
0
    def tes1t_loadCsvCase(self):
        from Parser import  caseParser
        setup =[]
        run =[]
        teardown=[]
        duts = {'winTel': baseS}
        mode = 'full'
        cs = caseParser('testParser',  mode, './log/ut_parser' )
        arg =[]
        gvars =['gv1', 'gv2', 'gv3',]

        resp =cs.load('./case2-novar.csv',gvars )
        dutname, varlist,setup, run, tear = resp
        print(dutname)
        print(varlist)
        print(setup)
        print(run)
        print(tear)


        resp =cs.load('./case1.csv',gvars )
        dutname, varlist,setup, run, tear = resp
        print(dutname)
        print(varlist)
        print(setup)
        print(run)
        print(tear)
Example #3
0
    def test_case_runner_init_dut_failed(self):
        from runner import case_runner, initDUT, createLogDir
        logpath ='./log'
        if not os.path.exists(logpath):
            os.mkdir(logpath)
        logpath+='/ut_runner'
        logger = createLogger('runner_logger', logpath)
        casename = 'test_case_runner_2_duts'
        casefolder = createLogDir(casename,logpath)

        from common import bench2dict
        benchfile = './bench.csv'
        benchfile= './home.csv'
        bench =bench2dict(benchfile)


        from Parser import  caseParser
        mode = 'full'
        cs = caseParser(casename, mode, casefolder)
        casefile = './runner_case.csv'
        sdut, lvar, lsetup, lrun, ltear =cs.load(casefile)
        ldut = list(sdut)
        ldut[0]='N1wrong'
        errormessage =[]
        #duts= initDUT(errormessage,bench,ldut,logger, casefolder)#['lnx1', 'lnx2']
        self.assertRaises(Exception, initDUT,errormessage,bench, ldut,logger, casefolder)
Example #4
0
    def test_case_runner_init_dut_failed(self):
        from runner import case_runner, initDUT, createLogDir
        logpath = './log'
        if not os.path.exists(logpath):
            os.mkdir(logpath)
        logpath += '/ut_runner'
        logger = createLogger('runner_logger', logpath)
        casename = 'test_case_runner_2_duts'
        casefolder = createLogDir(casename, logpath)

        from common import bench2dict
        benchfile = './bench.csv'
        benchfile = './home.csv'
        bench = bench2dict(benchfile)

        from Parser import caseParser
        mode = 'full'
        cs = caseParser(casename, mode, casefolder)
        casefile = './runner_case.csv'
        sdut, lvar, lsetup, lrun, ltear = cs.load(casefile)
        ldut = list(sdut)
        ldut[0] = 'N1wrong'
        errormessage = []
        #duts= initDUT(errormessage,bench,ldut,logger, casefolder)#['lnx1', 'lnx2']
        self.assertRaises(Exception, initDUT, errormessage, bench, ldut,
                          logger, casefolder)
Example #5
0
    def test_execute2(self):
        from winTelnet import winTelnet
        name= 'e7-20'

        cmd = 'telnet cdc-dash'
        if where =='home':
            cmd = 'telnet 192.168.1.113'
        attr={'TIMEOUT':180,'LOGIN': '******','CMD':cmd, 'LINEEND':'\r\n', 'EXP':'name:' }
        logger=None
        logpath='./log/ut_parser'

        import shutil
        if not os.path.exists(logpath):
            os.mkdir(logpath)

        import logging
        logfile = logpath+os.sep+"execute2tc.log"
        logging.basicConfig( level = logging.DEBUG)
        #from common import CLogger
        #self.logger = CLogger(self.Name)
        logger = logging.Logger(name,logging.DEBUG)
        hdrlog = logging.FileHandler(logfile)
        logger.setLevel(logging.DEBUG)
        hdrlog .setFormatter(logging.Formatter('%(asctime)s -%(levelname)s:    %(message)s'))
        logger.addHandler(hdrlog )

        baseS = winTelnet(name,attr,logger , logpath)
        baseS.find('ogin:', 30)
        baseS.send('syu')
        baseS.find('assword', 30)
        baseS.send('yxw123')
        baseS.find('~', 30)
        from Parser import caseParser
        setup =[]
        run =[]
        teardown=[]
        duts = {'winTel': baseS}
        mode = 'full'
        cs = caseParser('execute2', mode, './tmp1' )
        arg =[]
        gvars =['winTel', 'whoami', 'ls','pwd']
        resp =cs.load('./case3.csv',gvars )
        dutname, varlist,setup, run, tear = resp
        #baseS.send('ls')
        #baseS.find('git', 30)

        #ref = cs.duts['winTel']
        #ref.send('ping localhost')
        #ref.send('pwd')
        #ref.find('syu', 10)
        #ref.send('ping localhost')
        #ref.send('c', Ctrl=True)
        #cs.execute('full')
        print(dutname)
        print(varlist)
        print(setup)
        print(run)
        print(tear)
        baseS.SessionAlive =False
Example #6
0
 def tes1t_Init(self):
     from Parser import  caseParser
     setup =[]
     run =[]
     teardown=[]
     duts = {'winTel': baseS}
     mode = 'full'
     global cs
     cs = caseParser('testcase',  mode, './log/ut_parser' )
Example #7
0
 def tes1t_Init(self):
     from Parser import caseParser
     setup = []
     run = []
     teardown = []
     duts = {'winTel': baseS}
     mode = 'full'
     global cs
     cs = caseParser('testcase', mode, './log/ut_parser')
Example #8
0
 def tes1t_execute(self):
     from Parser import  caseParser
     setup =[]
     run =[]
     teardown=[]
     duts = {'winTel': baseS}
     mode = 'full'
     cs = caseParser('testcase', mode, './log/ut_parser' )
     #cs.myrunner(cs.runcase, [mode])
     rsp = self.assertRaises(Exception, cs.execute, 'xxx')
     rsp = cs.execute('s')
     rsp = cs.execute('r')
     rsp = cs.execute('t')
Example #9
0
 def tes1t_execute(self):
     from Parser import caseParser
     setup = []
     run = []
     teardown = []
     duts = {'winTel': baseS}
     mode = 'full'
     cs = caseParser('testcase', mode, './log/ut_parser')
     #cs.myrunner(cs.runcase, [mode])
     rsp = self.assertRaises(Exception, cs.execute, 'xxx')
     rsp = cs.execute('s')
     rsp = cs.execute('r')
     rsp = cs.execute('t')
Example #10
0
def run_case_in_suite(casename, currentBenchfile, currentBenchinfo,logger, stop_at_fail,logdir, cmd, dry_run):

    patDash  = re.compile('\s*(python |python[\d.]+ |python.exe |)\s* cr.py\s+(.+)\s*', re.DOTALL|re.IGNORECASE)
    m =  re.match(patDash, cmd)
    returncode = 0
    if m:
        argstring = m.group(2)
        import shlex
        lstArg = shlex.split(argstring)
        #0-case.csv, 1-bench, 2-mode, 4...-2- args
        casefile = lstArg[0]
        benchfile = lstArg[1]
        mode       = lstArg[2]
        args= lstArg[3:]
        newBenchInfo =None
        if currentBenchfile!=benchfile:
           # from common import bench2dict
            bench =bench2dict(benchfile)
            releaseDUTs()
        else:
            bench = currentBenchinfo
        from Parser import  caseParser

        cs = caseParser(casename, mode, logdir, logger)
        sdut, lvar, lsetup, lrun, ltear =cs.load(casefile)
        ldut = list(sdut)
        errormessage =[]

        duts= initDUT(errormessage,bench,ldut,logger, logdir, dry_run)
        seq = [cs.seqSetup, cs.seqRun, cs.seqTeardown]
        returncode, caseErrorMessage= case_runner(casename,duts,seq, mode)
    else:
        import subprocess
        pp =None
        if cmd.startswith('\w+.py') :
            exe_cmd ='python '+ cmd+" "+logdir
            pp = subprocess.Popen(args = exe_cmd ,shell =True)

        import time
        ChildRuning = True
        first =True
        while ChildRuning:
            if pp.poll() is None:
                interval = 1
                if first:
                    first=False
                time.sleep(interval)
            else:
                ChildRuning = False

        returncode = pp.returncode
Example #11
0
    def test_PowerShell(self):
        from runner import case_runner, initDUT, createLogDir, createLogger
        logpath ='./log'
        if not os.path.exists(logpath):
            os.mkdir(logpath)
        logpath+='/PowerShell'
        logger = createLogger('PowerShell', logpath)
        casename = 'PowerShell_1'
        casefolder = createLogDir(casename,logpath)

        from common import bench2dict
        where= 'nohome'
        benchfile = './bench.csv'
        casefile = './powershell.csv'
        if where=='home':
            benchfile= './home.csv'
            casefile = './home_case.csv'

        bench =bench2dict(benchfile)


        from Parser import  caseParser
        mode = 'full'
        cs = caseParser(casename, mode, casefolder)

        sdut, lvar, lsetup, lrun, ltear =cs.load(casefile)
        ldut = list(sdut)
        errormessage =[]
        duts= initDUT(errormessage,bench,ldut,logger, casefolder)#['lnx1', 'lnx2']
        seq = [cs.seqSetup, cs.seqRun, cs.seqTeardown]
        case= case_runner(casename,duts,seq, mode)


        print(duts)
        for name in duts.keys():
            dut = duts[name]
            if dut :
                dut.SessionAlive=False
Example #12
0
    def test_PowerShell(self):
        from runner import case_runner, initDUT, createLogDir, createLogger
        logpath = './log'
        if not os.path.exists(logpath):
            os.mkdir(logpath)
        logpath += '/PowerShell'
        logger = createLogger('PowerShell', logpath)
        casename = 'PowerShell_1'
        casefolder = createLogDir(casename, logpath)

        from common import bench2dict
        where = 'nohome'
        benchfile = './bench.csv'
        casefile = './powershell.csv'
        if where == 'home':
            benchfile = './home.csv'
            casefile = './home_case.csv'

        bench = bench2dict(benchfile)

        from Parser import caseParser
        mode = 'full'
        cs = caseParser(casename, mode, casefolder)

        sdut, lvar, lsetup, lrun, ltear = cs.load(casefile)
        ldut = list(sdut)
        errormessage = []
        duts = initDUT(errormessage, bench, ldut, logger,
                       casefolder)  #['lnx1', 'lnx2']
        seq = [cs.seqSetup, cs.seqRun, cs.seqTeardown]
        case = case_runner(casename, duts, seq, mode)

        print(duts)
        for name in duts.keys():
            dut = duts[name]
            if dut:
                dut.SessionAlive = False
Example #13
0
            os.mkdir(defaultlogdir)
        defaultlogdir=sys.argv[-1]
        basename_casename = os.path.basename(sys.argv[1])
        casefolder = createLogDir(basename_casename,defaultlogdir)
        logger = createLogger(basename_casename, casefolder)


        from common import bench2dict
        benchfile = sys.argv[2]
        bench =bench2dict(benchfile)


        from Parser import  caseParser
        mode = sys.argv[3]
        case_file_name =os.path.abspath(sys.argv[1])
        cs = caseParser(case_file_name, mode, casefolder)
        casefile = case_file_name
        sdut, lvar, lsetup, lrun, ltear =cs.load(casefile, sys.argv)
        ldut = list(sdut)
        errormessage =[]
        sharedata ={}
        #duts= initDUT(errormessage,bench,ldut,logger, casefolder)#['lnx1', 'lnx2']
        duts= initDUT(errormessage,bench, ldut,logger, casefolder, sharedata)
        seq = [cs.seqSetup, cs.seqRun, cs.seqTeardown]

        caseFail, CaseErrorMessage= case_runner(case_file_name,duts,seq, mode, logger,sharedata)

        from runner import releaseDUTs
        releaseDUTs(duts, logger)
        if caseFail:
            with open('%s/case_error.txt'%casefolder, 'a+') as ef:
Example #14
0
    def test_execute2(self):
        from winTelnet import winTelnet
        name = 'e7-20'

        cmd = 'telnet cdc-dash'
        if where == 'home':
            cmd = 'telnet 192.168.1.113'
        attr = {
            'TIMEOUT': 180,
            'LOGIN': '******',
            'CMD': cmd,
            'LINEEND': '\r\n',
            'EXP': 'name:'
        }
        logger = None
        logpath = './log/ut_parser'

        import shutil
        if not os.path.exists(logpath):
            os.mkdir(logpath)

        import logging
        logfile = logpath + os.sep + "execute2tc.log"
        logging.basicConfig(level=logging.DEBUG)
        #from common import CLogger
        #self.logger = CLogger(self.Name)
        logger = logging.Logger(name, logging.DEBUG)
        hdrlog = logging.FileHandler(logfile)
        logger.setLevel(logging.DEBUG)
        hdrlog.setFormatter(
            logging.Formatter('%(asctime)s -%(levelname)s:    %(message)s'))
        logger.addHandler(hdrlog)

        baseS = winTelnet(name, attr, logger, logpath)
        baseS.find('ogin:', 30)
        baseS.send('syu')
        baseS.find('assword', 30)
        baseS.send('yxw123')
        baseS.find('~', 30)
        from Parser import caseParser
        setup = []
        run = []
        teardown = []
        duts = {'winTel': baseS}
        mode = 'full'
        cs = caseParser('execute2', mode, './tmp1')
        arg = []
        gvars = ['winTel', 'whoami', 'ls', 'pwd']
        resp = cs.load('./case3.csv', gvars)
        dutname, varlist, setup, run, tear = resp
        #baseS.send('ls')
        #baseS.find('git', 30)

        #ref = cs.duts['winTel']
        #ref.send('ping localhost')
        #ref.send('pwd')
        #ref.find('syu', 10)
        #ref.send('ping localhost')
        #ref.send('c', Ctrl=True)
        #cs.execute('full')
        print(dutname)
        print(varlist)
        print(setup)
        print(run)
        print(tear)
        baseS.SessionAlive = False
Example #15
0
def run1case(casename, cmd,benchfile, benchinfo, dut_pool, logdir, logger, sharedata, dry_run =False):
    errormessage = ''
    caselogger = createLogger('caselog.txt', logdir)
    bench = benchinfo
    try:
        for dut_name in dut_pool:
            try:
                dut_pool[dut_name].logger = caselogger
                dut_pool[dut_name].openLogfile(logdir)
                dut_pool[dut_name].FailFlag    =False # the flag means in Session's perspective view, case failed
                dut_pool[dut_name].ErrorMessage=None # to store the error message
                dut_pool[dut_name].info(dut_pool[dut_name].name, 'session info reseted')
            except Exception as e:
                caselogger.error('failed to update logger for dut:%s'%dut_name)

        patDash  = re.compile('\s*(python |python[\d.]+ |python.exe |)\s*(cr.py|cr.exe)\s+(.+)\s*', re.DOTALL|re.IGNORECASE)
        m =  re.match(patDash, cmd)
        returncode = 1
        if m:

            argstring = m.group(3)
            import shlex
            if os.name =='nt':
                posix =False
            else:
                posix =True
            lstArg = shlex.split(argstring, posix=posix)
            #0-case.csv, 1-bench, 2-mode, 4...-2- args
            casefile = lstArg[0]
            case_benchfile = lstArg[1]
            case_mode       = lstArg[2]
            case_args= lstArg
            case_args.insert(0,'cr.py')


            if case_benchfile!=benchfile:
                #from common import bench2dict
                caselogger.info('loading a new bench:%s'%case_benchfile)
                global gPathLocker
                gPathLocker.acquire()
                bench =bench2dict(case_benchfile)
                gPathLocker.release()
                benchfile = case_benchfile
                caselogger.info('releasing duts in old dut_pool')
                releaseDUTs(dut_pool, caselogger)
                dut_pool ={}
            from Parser import  caseParser
            caselogger.info('loading case: %s'% casename)
            cs = caseParser(casename, case_mode, logdir, caselogger)
            sdut, lvar, lsetup, lrun, ltear =cs.load(casefile, case_args)
            ldut = list(sdut)
            newduts= []
            oldduts = []
            for nd in ldut:
                if dut_pool.has_key(nd):
                    oldduts.append(nd)
                    dut_pool[nd].FailFlag    =False # the flag means in Session's perspective view, case failed
                    dut_pool[nd].ErrorMessage=None # to store the error message
                    caselogger.info(dut_pool[nd].name+ ' cleared FailFlag and ErrorMessage')
                else:
                    newduts.append(nd)
            if dry_run is not True:
                for od in oldduts :
                    dut_pool[od].FailFlag    =False # the flag means in Session's perspective view, case failed
                    dut_pool[od].ErrorMessage=None
                    if dut_pool[od].isAlive() :
                        dut_pool[od].logger = caselogger
                        dut_pool[od].openLogfile(logdir)
                    else:
                        dut_pool[od].closeSession()
                        dut_pool.pop(od)
                        newduts.append(od)
            errormessage =[]
            duts= initDUT(errormessage,bench,newduts,caselogger, logdir,sharedata, dry_run=dry_run)


            #duts['cfa84'].isAlive()
            #duts['sba94'].isAlive()
            #print('initedduts')
            for k in duts.keys():
                dut_pool[k]=duts[k]
            #print('initedduts 2')
            for key in duts.keys():
                dut_pool[key]= duts[key]
            #print('initedduts 3 ' )
            seq = [cs.seqSetup, cs.seqRun, cs.seqTeardown]
            caselogger.info('starting to run case: %s'%cmd)
            returncode, STRerrormessage= case_runner(casename,dut_pool,seq, case_mode, caselogger)

            if returncode:
                import pprint
                STRerrormessage = pprint.pformat(STRerrormessage)
                caselogger.error('Case Failed:')
                for line in STRerrormessage.replace('\\r', '\r').replace('\\n', '\n').replace('\r\n', '\n').split('\n'):
                    caselogger.error(line)
                errormessage.append(STRerrormessage)

            else:
                caselogger.info('Case PASS')

        else:
            import subprocess
            pp =None

            patPython = re.compile(r'\s*(python\s+|python.exe\s+|)(.*[./\w_-]+.py)', re.IGNORECASE|re.DOTALL)
            m=re.match(patPython, cmd)
            if m :
                newcmd =m.group(2)
                if os.path.exists('y.exe'):
                    exe_cmd ='python -O '+ cmd+" -l "+logdir
                else:
                    exe_cmd ='python '+ cmd+" -l "+logdir
                caselogger.info('running case: %s'%exe_cmd)
                pp = subprocess.Popen(args = exe_cmd ,shell =True,stderr=subprocess.PIPE)
                import time
                ChildRuning = True
                first =True
                while ChildRuning:
                    if pp.poll() is None:
                        interval = 1
                        if first:
                            first=False
                        time.sleep(interval)
                    else:
                        ChildRuning = False

                returncode = pp.returncode
            if returncode:
                try:
                    stdout, stderr =pp.communicate()
                    try:
                        with open('%s/case_error.txt'%logdir,'r') as f:
                            errormessage +='\n'.join(f.readlines()[:10])
                    except Exception as e:
                        pass

                        if stderr!='':
                            errormessage +=stderr
                        else:
                            errormessage = stderr
                        with open('%s/case_error.txt'%logdir,'a+') as f:
                            f.write(stderr)

                except Exception as e:
                    print(e)
    except KeyboardInterrupt :
        sys.exit(1)
    except Exception as e:

        if returncode ==0:
            returncode =1

        #import traceback
        errormessage = '%s\n%s'%(e.__str__(),traceback.format_exc())
        caselogger.error('Case FAIL')
        for line in errormessage.split('\n'):
            caselogger.error(line)
    return  returncode, errormessage, benchfile,bench, dut_pool
Example #16
0
            sys.argv.append(defaultlogdir)
        if not os.path.exists(defaultlogdir):
            os.mkdir(defaultlogdir)
        defaultlogdir = sys.argv[-1]
        basename_casename = os.path.basename(sys.argv[1])
        casefolder = createLogDir(basename_casename, defaultlogdir)
        logger = createLogger(basename_casename, casefolder)

        from common import bench2dict
        benchfile = sys.argv[2]
        bench = bench2dict(benchfile)

        from Parser import caseParser
        mode = sys.argv[3]
        case_file_name = os.path.abspath(sys.argv[1])
        cs = caseParser(case_file_name, mode, casefolder)
        casefile = case_file_name
        sdut, lvar, lsetup, lrun, ltear = cs.load(casefile, sys.argv)
        ldut = list(sdut)
        errormessage = []
        sharedata = {}
        #duts= initDUT(errormessage,bench,ldut,logger, casefolder)#['lnx1', 'lnx2']
        duts = initDUT(errormessage, bench, ldut, logger, casefolder,
                       sharedata)
        seq = [cs.seqSetup, cs.seqRun, cs.seqTeardown]

        caseFail, CaseErrorMessage = case_runner(case_file_name, duts, seq,
                                                 mode, logger, sharedata)

        from runner import releaseDUTs
        releaseDUTs(duts, logger)