1

"Commons definitions for sikuli based beremiz IDE GUI tests"

     2

     3

import os

     4

import sys

     5

import subprocess

     6

import traceback

     7

import signal

     8

from threading import Thread, Event, Lock

     9

from time import time as timesec

    10

    11

import sikuli

    12

    13

beremiz_path = os.environ["BEREMIZPATH"]

    14

python_bin = os.environ.get("BEREMIZPYTHONPATH", "/usr/bin/python")

    15

    16

opj = os.path.join

    17

    18

    19

class KBDShortcut:

    20

    """Send shortut to app by calling corresponding methods.

    21

    22

    example:

    23

        k = KBDShortcut()

    24

        k.Clean()

    25

    """

    26

    27

    fkeys = {"Stop":     sikuli.Key.F4,

    28

             "Run":      sikuli.Key.F5,

    29

             "Transfer": sikuli.Key.F6,

    30

             "Connect":  sikuli.Key.F7,

    31

             "Clean":    sikuli.Key.F9,

    32

             "Build":    sikuli.Key.F11,

    33

             "Save":     ("s",sikuli.Key.CTRL),

    34

             "New":      ("n",sikuli.Key.CTRL),

    35

             "Address":  ("l",sikuli.Key.CTRL)}  # to reach address bar in GTK's file selector

    36

    37

    def __init__(self, app):

    38

        self.app = app

    39

    40

    def __getattr__(self, name):

    41

        fkey = self.fkeys[name]

    42

        if type(fkey) != tuple:

    43

            fkey = (fkey,)

    44

    45

        def PressShortCut():

    46

            self.app.sikuliapp.focus()

    47

            sikuli.type(*fkey)

    48

            self.app.ReportText("Sending " + name + " shortcut")

    49

    50

        return PressShortCut

    51

    52

    53

class IDEIdleObserver:

    54

    "Detects when IDE is idle. This is particularly handy when staring an operation and witing for the en of it."

    55

    56

    def __init__(self):

    57

        """

    58

        Parameters: 

    59

            app (class BeremizApp)

    60

        """

    61

        self.r = sikuli.Region(self.sikuliapp.window())

    62

    63

        self.idechanged = False

    64

    65

        # 200 was selected because default 50 was still catching cursor blinking in console

    66

        # FIXME : remove blinking cursor in console

    67

        self.r.onChange(200,self._OnIDEWindowChange)

    68

        self.r.observeInBackground()

    69

    70

    def __del__(self):

    71

        self.r.stopObserver()

    72

    73

    def _OnIDEWindowChange(self, event):

    74

        self.idechanged = True

    75

    76

    def WaitIdleUI(self, period=1, timeout=15):

    77

        """

    78

        Wait for IDE to stop changing

    79

        Parameters: 

    80

            period (int): how many seconds with no change to consider idle

    81

            timeout (int): how long to wait for idle, in seconds

    82

        """

    83

        c = max(timeout/period,1)

    84

        while c > 0:

    85

            self.idechanged = False

    86

            sikuli.wait(period)

    87

            if not self.idechanged:

    88

                break

    89

            c = c - 1

    90

    91

        self.ReportScreenShot("UI is idle" if c != 0 else "UI is not idle")

    92

    93

        if c == 0:

    94

            raise Exception("Window did not idle before timeout")

    95

    96

    97

class stdoutIdleObserver:

    98

    "Detects when IDE's stdout is idle. Can be more reliable than pixel based version (false changes ?)"

    99

   100

    def __init__(self):

   101

        """

   102

        Parameters: 

   103

            app (class BeremizApp)

   104

        """

   105

        self.stdoutchanged = False

   106

   107

        self.event = Event()

   108

   109

        self.pattern = None

   110

        self.success_event = Event()

   111

   112

        if self.proc is not None:

   113

            self.thread = Thread(target = self._waitStdoutProc).start()

   114

   115

    def __del__(self):

   116

        pass  # self.thread.join() ?

   117

   118

    def _waitStdoutProc(self):

   119

        while True:

   120

            a = self.proc.stdout.readline()

   121

            if len(a) == 0 or a is None: 

   122

                break

   123

            self.ReportOutput(a)

   124

            self.event.set()

   125

            if self.pattern is not None and a.find(self.pattern) >= 0:

   126

                sys.stdout.write("found pattern in '" + a +"'")

   127

                self.success_event.set()

   128

   129

    def waitForChangeAndIdleStdout(self, period=2, timeout=15):

   130

        """

   131

        Wait for IDE'stdout to start changing

   132

        Parameters: 

   133

            timeout (int): how long to wait for change, in seconds

   134

        """

   135

        start_time = timesec()

   136

   137

        wait_result = self.event.wait(timeout)

   138

   139

        self.ReportScreenShot("stdout changed" if wait_result else "stdout didn't change")

   140

   141

        if wait_result:

   142

            self.event.clear()

   143

        else:

   144

            raise Exception("Stdout didn't become active before timeout")

   145

   146

        self.waitIdleStdout(period, timeout - (timesec() - start_time))

   147

   148

    def waitIdleStdout(self, period=2, timeout=15):

   149

        """

   150

        Wait for IDE'stdout to stop changing

   151

        Parameters: 

   152

            period (int): how many seconds with no change to consider idle

   153

            timeout (int): how long to wait for idle, in seconds

   154

        """

   155

        end_time = timesec() + timeout

   156

        self.event.clear()

   157

        while timesec() < end_time:

   158

            if self.event.wait(period):

   159

                # no timeout -> got event -> not idle -> loop again

   160

                self.event.clear()

   161

            else:

   162

                # timeout -> no event -> idle -> exit

   163

                self.ReportScreenShot("stdout is idle")

   164

                return True

   165

   166

        self.ReportScreenShot("stdout did not idle")

   167

   168

        raise Exception("Stdout did not idle before timeout")

   169

   170

    def waitPatternInStdout(self, pattern, timeout, count=1):

   171

        found = 0

   172

        self.pattern = pattern

   173

        end_time = timesec() + timeout

   174

        while True:

   175

            remain = end_time - timesec()

   176

            if remain <= 0 :

   177

                res = False

   178

                break

   179

   180

            res = self.success_event.wait(remain)

   181

            if res:

   182

                self.success_event.clear()

   183

                found = found + 1

   184

                if found >= count:

   185

                    break

   186

        self.pattern = None

   187

        self.ReportScreenShot("found pattern" if res else "pattern not found")

   188

        return res

   189

   190

class BeremizApp(IDEIdleObserver, stdoutIdleObserver):

   191

    def __init__(self, projectpath=None, exemple=None, testproject=None):

   192

        """

   193

        Starts Beremiz IDE, waits for main window to appear, maximize it.

   194

   195

            Parameters: 

   196

                projectpath (str): path to project to open

   197

                exemple (str): path relative to exemples directory

   198

   199

            Returns:

   200

                Sikuli App class instance

   201

        """

   202

   203

        sikuli.OCR.Options().smallFont()

   204

   205

        self.screenshotnum = 0

   206

        self.starttime = timesec()

   207

        self.screen = sikuli.Screen()

   208

   209

        self.report = open("report.html", "w")

   210

        self.report.write("""<!doctype html>

   211

<html>

   212

  <head>

   213

    <meta charset="utf-8">

   214

    <meta name="color-scheme" content="light dark">

   215

    <title>Test report</title>

   216

  </head>

   217

  <body>

   218

""")

   219

   220

        command = [python_bin, opj(beremiz_path,"Beremiz.py"), "--log=/dev/stdout"]

   221

   222

        if exemple is not None:

   223

            command.append(opj(beremiz_path,"exemples",exemple))

   224

        elif projectpath is not None:

   225

            command.append(projectpath)

   226

        elif testproject is not None:

   227

            command.append(opj(beremiz_path,"tests","projects",testproject))

   228

   229

   230

        # App class is broken in Sikuli 2.0.5: can't start process with arguments.

   231

        # 

   232

        # Workaround : - use subprocess module to spawn IDE process,

   233

        #              - use wmctrl to find IDE window details and maximize it

   234

        #              - pass exact window title to App class constructor

   235

   236

        self.ReportText("Launching " + repr(command))

   237

   238

        self.proc = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=0)

   239

   240

        # Window are macthed against process' PID

   241

        ppid = self.proc.pid

   242

   243

        # Timeout 5s

   244

        c = 50

   245

        while c > 0:

   246

            # equiv to "wmctrl -l -p | grep $pid"

   247

            try:

   248

                wlist = filter(lambda l:(len(l)>2 and l[2]==str(ppid)), map(lambda s:s.split(None,4), subprocess.check_output(["wmctrl", "-l", "-p"]).splitlines()))

   249

            except subprocess.CalledProcessError:

   250

                wlist = []

   251

   252

            # window with no title only has 4 fields do describe it

   253

            # beremiz splashcreen has no title

   254

            # wait until main window is visible

   255

            if len(wlist) == 1 and len(wlist[0]) == 5:

   256

                windowID,_zero,wpid,_XID,wtitle = wlist[0] 

   257

                break

   258

   259

            sikuli.wait(0.1)

   260

            c = c - 1

   261

   262

        if c == 0:

   263

            raise Exception("Couldn't find Beremiz window")

   264

   265

        # Maximize window x and y

   266

        subprocess.check_call(["wmctrl", "-i", "-r", windowID, "-b", "add,maximized_vert,maximized_horz"])

   267

   268

        # switchApp creates an App object by finding window by title, is not supposed to spawn a process

   269

        self.sikuliapp = sikuli.switchApp(wtitle)

   270

        self.k = KBDShortcut(self)

   271

   272

        IDEIdleObserver.__init__(self)

   273

        stdoutIdleObserver.__init__(self)

   274

   275

        # stubs for common sikuli calls to allow adding hooks later

   276

        for name in ["click","doubleClick","type","rightClick","wait"]:

   277

            def makeMyMeth(n):

   278

                def myMeth(*args, **kwargs):

   279

                    self.ReportScreenShot("Begin: " + n + "(" + repr(args) + "," + repr(kwargs) + ")")

   280

                    try:

   281

                        getattr(sikuli, n)(*args, **kwargs)

   282

                    finally:

   283

                        self.ReportScreenShot("end: " + n + "(" + repr(args) + "," + repr(kwargs) + ")")

   284

                return myMeth

   285

            setattr(self, name, makeMyMeth(name))

   286

   287

    def dragNdrop(self, src, dst):

   288

        sikuli.drag(src)

   289

        sikuli.mouseMove(5,0)

   290

        sikuli.dropAt(dst)

   291

   292

    def close(self):

   293

        self.sikuliapp.close()

   294

        self.sikuliapp = None

   295

        self.report.write("""

   296

  </body>

   297

</html>""")

   298

        self.report.close()

   299

   300

    def __del__(self):

   301

        if self.sikuliapp is not None:

   302

            self.sikuliapp.close()

   303

        IDEIdleObserver.__del__(self)

   304

        stdoutIdleObserver.__del__(self)

   305

   306

    def ReportScreenShot(self, msg):

   307

        elapsed = "%.3fs: "%(timesec() - self.starttime)

   308

        fname = "capture"+str(self.screenshotnum)+".png"

   309

        cap = self.screen.capture(self.r)

   310

        cap.save(".", fname)

   311

        self.screenshotnum = self.screenshotnum + 1

   312

        self.report.write( "<p>" + elapsed + msg + "<br/><img src=\""+ fname + "\">" + "</p>")

   313

   314

    def ReportText(self, text):

   315

        elapsed = "%.3fs: "%(timesec() - self.starttime)

   316

        self.report.write("<p>" + elapsed + text + "</p>")

   317

   318

    def ReportOutput(self, text):

   319

        elapsed = "%.3fs: "%(timesec() - self.starttime)

   320

        sys.stdout.write(elapsed + text)

   321

        self.report.write("<pre>" + elapsed + text + "</pre>")

   322

   323

   324

class AuxiliaryProcess(stdoutIdleObserver):

   325

    def __init__(self, beremiz_app, command):

   326

        self.app = beremiz_app

   327

        self.app.ReportText("Launching process " + repr(command))

   328

        self.proc = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=0)

   329

        self.app.ReportText("Launched process " + repr(command) + " PID: " + str(self.proc.pid))

   330

        stdoutIdleObserver.__init__(self)

   331

   332

    def close(self):

   333

        if self.proc is not None:

   334

            proc = self.proc

   335

            self.proc = None

   336

            # self.proc.stdout.close()

   337

            self.app.ReportText("Kill process PID: " + str(proc.pid))

   338

            try:

   339

                os.kill(proc.pid, signal.SIGTERM)

   340

            except OSError:

   341

                pass

   342

            proc.wait()

   343

            # self.thread.join()

   344

   345

    def ReportOutput(self, text):

   346

        self.app.ReportOutput("Aux: "+text)

   347

   348

    def ReportScreenShot(self, msg):

   349

        self.app.ReportOutput("Aux: "+msg)

   350

   351

    def __del__(self):

   352

        self.close()

   353

   354

def run_test(func, *args, **kwargs):

   355

    app = BeremizApp(*args, **kwargs)

   356

    try:

   357

        success = func(app)

   358

    except:

   359

        # sadly, sys.excepthook is broken in sikuli/jython 

   360

        # purpose of this run_test function is to work around it.

   361

        # and catch exception cleanly anyhow

   362

        e_type, e_value, e_traceback = sys.exc_info()

   363

        err_msg = "\n".join(traceback.format_exception(e_type, e_value, e_traceback))

   364

        app.ReportOutput(err_msg)

   365

        success = False

   366

   367

    app.close()

   368

   369

    if success:

   370

        sikuli.exit(0)

   371

    else:

   372

        sikuli.exit(1)

   373

   374

   375