1

"Commons definitions for sikuli based beremiz IDE GUI tests"

     2

     3

import os

     4

import sys

     5

import subprocess

     6

import traceback

     7

from threading import Thread, Event, Lock

     8

from time import time as timesec

     9

    10

import sikuli

    11

    12

beremiz_path = os.environ["BEREMIZPATH"]

    13

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

    14

    15

opj = os.path.join

    16

    17

    18

class KBDShortcut:

    19

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

    20

    21

    example:

    22

        k = KBDShortcut()

    23

        k.Clean()

    24

    """

    25

    26

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

    27

             "Run":      sikuli.Key.F5,

    28

             "Transfer": sikuli.Key.F6,

    29

             "Connect":  sikuli.Key.F7,

    30

             "Clean":    sikuli.Key.F9,

    31

             "Build":    sikuli.Key.F11,

    32

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

    33

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

    34

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

    35

    36

    def __init__(self, app):

    37

        self.app = app

    38

    39

    def __getattr__(self, name):

    40

        fkey = self.fkeys[name]

    41

        if type(fkey) != tuple:

    42

            fkey = (fkey,)

    43

    44

        def PressShortCut():

    45

            self.app.sikuliapp.focus()

    46

            sikuli.type(*fkey)

    47

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

    48

    49

        return PressShortCut

    50

    51

    52

class IDEIdleObserver:

    53

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

    54

    55

    def __init__(self):

    56

        """

    57

        Parameters: 

    58

            app (class BeremizApp)

    59

        """

    60

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

    61

    62

        self.idechanged = False

    63

    64

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

    65

        # FIXME : remove blinking cursor in console

    66

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

    67

        self.r.observeInBackground()

    68

    69

    def __del__(self):

    70

        self.r.stopObserver()

    71

    72

    def _OnIDEWindowChange(self, event):

    73

        self.idechanged = True

    74

    75

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

    76

        """

    77

        Wait for IDE to stop changing

    78

        Parameters: 

    79

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

    80

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

    81

        """

    82

        c = max(timeout/period,1)

    83

        while c > 0:

    84

            self.idechanged = False

    85

            sikuli.wait(period)

    86

            if not self.idechanged:

    87

                break

    88

            c = c - 1

    89

    90

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

    91

    92

        if c == 0:

    93

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

    94

    95

    96

class stdoutIdleObserver:

    97

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

    98

    99

    def __init__(self):

   100

        """

   101

        Parameters: 

   102

            app (class BeremizApp)

   103

        """

   104

        self.stdoutchanged = False

   105

   106

        self.event = Event()

   107

   108

        self.pattern = None

   109

        self.success_event = Event()

   110

   111

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

   112

   113

    def _waitStdoutProc(self):

   114

        while True:

   115

            a = self.proc.stdout.readline()

   116

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

   117

                break

   118

            sys.stdout.write(a)

   119

            self.ReportOutput(a)

   120

            self.event.set()

   121

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

   122

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

   123

                self.success_event.set()

   124

   125

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

   126

        """

   127

        Wait for IDE'stdout to start changing

   128

        Parameters: 

   129

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

   130

        """

   131

        start_time = timesec()

   132

   133

        wait_result = self.event.wait(timeout)

   134

   135

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

   136

   137

        if wait_result:

   138

            self.event.clear()

   139

        else:

   140

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

   141

   142

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

   143

   144

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

   145

        """

   146

        Wait for IDE'stdout to stop changing

   147

        Parameters: 

   148

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

   149

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

   150

        """

   151

        end_time = timesec() + timeout

   152

        self.event.clear()

   153

        while timesec() < end_time:

   154

            if self.event.wait(period):

   155

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

   156

                self.event.clear()

   157

            else:

   158

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

   159

                self.ReportScreenShot("stdout is idle")

   160

                return True

   161

   162

        self.ReportScreenShot("stdout did not idle")

   163

   164

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

   165

   166

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

   167

        found = 0

   168

        self.pattern = pattern

   169

        end_time = timesec() + timeout

   170

        self.event.clear()

   171

        while True:

   172

            remain = end_time - timesec()

   173

            if remain <= 0 :

   174

                res = False

   175

                break

   176

   177

            res = self.success_event.wait(remain)

   178

            if res:

   179

                self.success_event.clear()

   180

                found = found + 1

   181

                if found >= count:

   182

                    break

   183

        self.pattern = None

   184

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

   185

        return res

   186

   187

class BeremizApp(IDEIdleObserver, stdoutIdleObserver):

   188

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

   189

        """

   190

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

   191

   192

            Parameters: 

   193

                projectpath (str): path to project to open

   194

                exemple (str): path relative to exemples directory

   195

   196

            Returns:

   197

                Sikuli App class instance

   198

        """

   199

   200

        self.screenshotnum = 0

   201

        self.starttime = timesec()

   202

        self.screen = sikuli.Screen()

   203

   204

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

   205

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

   206

<html>

   207

  <head>

   208

    <meta charset="utf-8">

   209

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

   210

    <title>Test report</title>

   211

  </head>

   212

  <body>

   213

""")

   214

   215

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

   216

   217

        if exemple is not None:

   218

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

   219

        elif projectpath is not None:

   220

            command.append(projectpath)

   221

   222

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

   223

        # 

   224

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

   225

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

   226

        #              - pass exact window title to App class constructor

   227

   228

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

   229

   230

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

   231

   232

        # Window are macthed against process' PID

   233

        ppid = self.proc.pid

   234

   235

        # Timeout 5s

   236

        c = 50

   237

        while c > 0:

   238

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

   239

            try:

   240

                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()))

   241

            except subprocess.CalledProcessError:

   242

                wlist = []

   243

   244

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

   245

            # beremiz splashcreen has no title

   246

            # wait until main window is visible

   247

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

   248

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

   249

                break

   250

   251

            sikuli.wait(0.1)

   252

            c = c - 1

   253

   254

        if c == 0:

   255

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

   256

   257

        # Maximize window x and y

   258

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

   259

   260

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

   261

        self.sikuliapp = sikuli.switchApp(wtitle)

   262

        self.k = KBDShortcut(self)

   263

   264

        IDEIdleObserver.__init__(self)

   265

        stdoutIdleObserver.__init__(self)

   266

   267

        # stubs for common sikuli calls to allow adding hooks later

   268

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

   269

            def makeMyMeth(n):

   270

                def myMeth(*args, **kwargs):

   271

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

   272

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

   273

                return myMeth

   274

            setattr(self, name, makeMyMeth(name))

   275

   276

    def close(self):

   277

        self.sikuliapp.close()

   278

        self.sikuliapp = None

   279

        self.report.write("""

   280

  </body>

   281

</html>""")

   282

        self.report.close()

   283

   284

    def __del__(self):

   285

        if self.sikuliapp is not None:

   286

            self.sikuliapp.close()

   287

        IDEIdleObserver.__del__(self)

   288

        stdoutIdleObserver.__del__(self)

   289

   290

    def ReportScreenShot(self, msg):

   291

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

   292

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

   293

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

   294

        cap.save(".", fname)

   295

        self.screenshotnum = self.screenshotnum + 1

   296

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

   297

   298

    def ReportText(self, text):

   299

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

   300

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

   301

   302

    def ReportOutput(self, text):

   303

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

   304

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

   305

   306

   307

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

   308

    app = BeremizApp(*args, **kwargs)

   309

    try:

   310

        success = func(app)

   311

    except:

   312

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

   313

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

   314

        # and catch exception cleanly anyhow

   315

        e_type, e_value, e_traceback = sys.exc_info()

   316

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

   317

        sys.stdout.write(err_msg)

   318

        app.ReportOutput(err_msg)

   319

        success = False

   320

   321

    app.close()

   322

   323

    if success:

   324

        sikuli.exit(0)

   325

    else:

   326

        sikuli.exit(1)

   327

   328

   329