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

    10

from sikuli import *

    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

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

    18

    """

    19

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

    20

    21

        Parameters: 

    22

            projectpath (str): path to project to open

    23

            exemple (str): path relative to exemples directory

    24

    25

        Returns:

    26

            Sikuli App class instance

    27

    """

    28

    29

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

    30

    31

    if exemple is not None:

    32

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

    33

    elif projectpath is not None:

    34

        command.append(projectpath)

    35

    36

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

    37

    # 

    38

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

    39

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

    40

    #              - pass exact window title to App class constructor

    41

    42

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

    43

    44

    # Window are macthed against process' PID

    45

    ppid = proc.pid

    46

    47

    # Timeout 5s

    48

    c = 50

    49

    while c > 0:

    50

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

    51

        try:

    52

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

    53

        except subprocess.CalledProcessError:

    54

            wlist = []

    55

    56

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

    57

        # beremiz splashcreen has no title

    58

        # wait until main window is visible

    59

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

    60

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

    61

            break

    62

    63

        wait(0.1)

    64

        c = c - 1

    65

    66

    if c == 0:

    67

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

    68

    69

    # Maximize window x and y

    70

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

    71

    72

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

    73

    return proc, switchApp(wtitle)

    74

    75

class KBDShortcut:

    76

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

    77

          Stop   

    78

          Run    

    79

          Transfer

    80

          Connect

    81

          Clean  

    82

          Build  

    83

    84

    example:

    85

        k = KBDShortcut(app)

    86

        k.Clean()

    87

    """

    88

    89

    fkeys = {"Stop":     Key.F4,

    90

             "Run":      Key.F5,

    91

             "Transfer": Key.F6,

    92

             "Connect":  Key.F7,

    93

             "Clean":    Key.F9,

    98

    99

    def __init__(self, app):

   100

        self.app = app

   101

   102

    def __getattr__(self, name):

   103

        fkey = self.fkeys[name]

   106

        app = self.app

   107

   108

        def PressShortCut():

   109

            app.focus()

   111

   112

        return PressShortCut

   113

   114

   115

class IDEIdleObserver:

   116

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

   117

   118

    def __init__(self, app):

   119

        """

   120

        Parameters: 

   121

            app (class App): Sikuli app given by StartBeremizApp

   122

        """

   123

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

   124

   125

        self.idechanged = False

   126

   127

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

   128

        # FIXME : remove blinking cursor in console

   129

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

   130

        self.r.observeInBackground()

   131

   132

    def __del__(self):

   133

        self.r.stopObserver()

   134

   135

    def _OnIDEWindowChange(self, event):

   136

        self.idechanged = True

   137

   138

    def Wait(self, period, timeout):

   139

        """

   140

        Wait for IDE to stop changing

   141

        Parameters: 

   142

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

   143

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

   144

        """

   145

        c = timeout/period

   146

        while c > 0:

   147

            self.idechanged = False

   148

            wait(period)

   149

            if not self.idechanged:

   150

                break

   151

            c = c - 1

   152

   153

        if c == 0:

   154

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

   155

   156

   157

class stdoutIdleObserver:

   158

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

   159

   160

    def __init__(self, proc):

   161

        """

   162

        Parameters: 

   163

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

   164

        """

   165

        self.proc = proc

   166

        self.stdoutchanged = False

   167

   168

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

   169

   171

        while True:

   172

            a = self.proc.stdout.read(1)

   173

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

   174

                break

   175

            sys.stdout.write(a)

   176

            self.idechanged = True

   177

   178

    def Wait(self, period, timeout):

   179

        """

   180

        Wait for IDE'stdout to stop changing

   181

        Parameters: 

   182

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

   183

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

   184

        """

   185

        c = timeout/period

   186

        while c > 0:

   187

            self.idechanged = False

   188

            wait(period)

   189

            if not self.idechanged:

   190

                break

   191

            c = c - 1

   192

   193

        if c == 0:

   194

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

   195

   196

   197

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

   198

   199

    success_event = Event()

   200

   201

    def waitPatternInStdoutProc():

   202

        found = 0

   203

        while True:

   204

            a = proc.stdout.readline()

   205

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

   206

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

   207

            sys.stdout.write(a)

   208

            if a.find(pattern) >= 0:

   209

                found = found + 1

   210

                if found >= count:

   211

                    success_event.set()

   212

                    break

   213

   214

   215

    Thread(target = waitPatternInStdoutProc).start()

   216

   217

    if not success_event.wait(timeout):

   218

        # test timed out

   219

        return False

   220

    else:

   221

        return True

   222

   223

   224