1

"Commons definitions for sikuli based beremiz IDE GUI tests"

     2

     3

import os

     4

import sys

     5

import subprocess

     6

from threading import Thread, Event

     7

from time import time as timesec

     8

     9

typeof=type

    10

    11

from sikuli import *

    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

def StartBeremizApp(projectpath=None, exemple=None):

    19

    """

    20

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

    21

    22

        Parameters: 

    23

            projectpath (str): path to project to open

    24

            exemple (str): path relative to exemples directory

    25

    26

        Returns:

    27

            Sikuli App class instance

    28

    """

    29

    30

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

    31

    32

    if exemple is not None:

    33

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

    34

    elif projectpath is not None:

    35

        command.append(projectpath)

    36

    37

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

    38

    # 

    39

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

    40

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

    41

    #              - pass exact window title to App class constructor

    42

    43

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

    44

    45

    # Window are macthed against process' PID

    46

    ppid = proc.pid

    47

    48

    # Timeout 5s

    49

    c = 50

    50

    while c > 0:

    51

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

    52

        try:

    53

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

    54

        except subprocess.CalledProcessError:

    55

            wlist = []

    56

    57

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

    58

        # beremiz splashcreen has no title

    59

        # wait until main window is visible

    60

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

    61

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

    62

            break

    63

    64

        wait(0.1)

    65

        c = c - 1

    66

    67

    if c == 0:

    68

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

    69

    70

    # Maximize window x and y

    71

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

    72

    73

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

    74

    return proc, switchApp(wtitle)

    75

    76

class KBDShortcut:

    77

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

    78

          Stop   

    79

          Run    

    80

          Transfer

    81

          Connect

    82

          Clean  

    83

          Build  

    84

    85

    example:

    86

        k = KBDShortcut(app)

    87

        k.Clean()

    88

    """

    89

    90

    fkeys = {"Stop":     Key.F4,

    91

             "Run":      Key.F5,

    92

             "Transfer": Key.F6,

    93

             "Connect":  Key.F7,

    94

             "Clean":    Key.F9,

    95

             "Build":    Key.F11,

    96

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

    97

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

    98

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

    99

   100

    def __init__(self, app):

   101

        self.app = app

   102

   103

    def __getattr__(self, name):

   104

        fkey = self.fkeys[name]

   105

        if typeof(fkey) != tuple:

   106

            fkey = (fkey,)

   107

        app = self.app

   108

   109

        def PressShortCut():

   110

            app.focus()

   111

            type(*fkey)

   112

   113

        return PressShortCut

   114

   115

   116

class IDEIdleObserver:

   117

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

   118

   119

    def __init__(self, app):

   120

        """

   121

        Parameters: 

   122

            app (class App): Sikuli app given by StartBeremizApp

   123

        """

   124

        self.r = Region(app.window())

   125

   126

        self.idechanged = False

   127

   128

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

   129

        # FIXME : remove blinking cursor in console

   130

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

   131

        self.r.observeInBackground()

   132

   133

    def __del__(self):

   134

        self.r.stopObserver()

   135

   136

    def _OnIDEWindowChange(self, event):

   137

        self.idechanged = True

   138

   139

    def Wait(self, period, timeout):

   140

        """

   141

        Wait for IDE to stop changing

   142

        Parameters: 

   143

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

   144

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

   145

        """

   146

        c = max(timeout/period,1)

   147

        while c > 0:

   148

            self.idechanged = False

   149

            wait(period)

   150

            if not self.idechanged:

   151

                break

   152

            c = c - 1

   153

   154

        if c == 0:

   155

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

   156

   157

   158

class stdoutIdleObserver:

   159

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

   160

   161

    def __init__(self, proc):

   162

        """

   163

        Parameters: 

   164

            proc (subprocess.Popen): Beremiz process, given by StartBeremizApp

   165

        """

   166

        self.proc = proc

   167

        self.stdoutchanged = False

   168

   169

        self.changes = 0

   170

        self.last_change_count = 0

   171

   172

        self.event = Event()

   173

   174

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

   175

   176

    def _waitStdoutProc(self):

   177

        while True:

   178

            a = self.proc.stdout.readline()

   179

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

   180

                break

   181

            # sys.stdout.write(a)

   182

            self.changes = self.changes + 1

   183

            self.event.set()

   184

   185

    def WaitForChangeAndIdle(self, period, timeout):

   186

        """

   187

        Wait for IDE'stdout to start changing

   188

        Parameters: 

   189

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

   190

        """

   191

        start_time = timesec()

   192

        if self.changes == self.last_change_count:

   193

            if self.event.wait(timeout):

   194

                self.event.clear()

   195

                self.last_change_count = self.changes

   196

            else:

   197

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

   198

   199

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

   200

   201

    def Wait(self, period, timeout):

   202

        """

   203

        Wait for IDE'stdout to stop changing

   204

        Parameters: 

   205

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

   206

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

   207

        """

   208

        c = max(timeout/period, 1)

   209

        while c > 0:

   210

            changes = self.changes

   211

            wait(period)

   212

            if self.changes == changes:

   213

                self.last_change_count = self.changes

   214

                break

   215

            c = c - 1

   216

   217

        if c == 0:

   218

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

   219

   220

   221

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

   222

   223

    success_event = Event()

   224

   225

    def waitPatternInStdoutProc():

   226

        found = 0

   227

        while True:

   228

            a = proc.stdout.readline()

   229

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

   230

                raise Exception("App finished before producing expected stdout pattern")

   231

            # sys.stdout.write(a)

   232

            if a.find(pattern) >= 0:

   233

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

   234

                found = found + 1

   235

                if found >= count:

   236

                    success_event.set()

   237

                    break

   238

   239

   240

    Thread(target = waitPatternInStdoutProc).start()

   241

   242

    if not success_event.wait(timeout):

   243

        # test timed out

   244

        return False

   245

    else:

   246

        return True

   247

   248

   249