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 sikuli import *

     8

     9

home = os.environ["HOME"]

    10

beremiz_path = os.environ["BEREMIZPATH"]

    11

    12

opj = os.path.join

    13

    14

    15

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

    16

    """

    17

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

    18

    19

        Parameters: 

    20

            projectpath (str): path to project to open

    21

            exemple (str): path relative to exemples directory

    22

    23

        Returns:

    24

            Sikuli App class instance

    25

    """

    26

    27

    command = ["%s/beremizenv/bin/python"%home, opj(beremiz_path,"Beremiz.py"), "--log=/dev/stdout"]

    28

    29

    if exemple is not None:

    30

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

    31

    elif projectpath is not None:

    32

        command.append(projectpath)

    33

    34

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

    35

    # 

    36

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

    37

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

    38

    #              - pass exact window title to App class constructor

    39

    40

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

    41

    42

    # Window are macthed against process' PID

    43

    ppid = proc.pid

    44

    45

    # Timeout 5s

    46

    c = 50

    47

    while c > 0:

    48

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

    49

        try:

    50

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

    51

        except subprocess.CalledProcessError:

    52

            wlist = []

    53

    54

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

    55

        # beremiz splashcreen has no title

    56

        # we wity until main window is visible

    57

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

    58

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

    59

            break

    60

    61

        wait(0.1)

    62

        c = c - 1

    63

    64

    if c == 0:

    65

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

    66

    67

    # Maximize window x and y

    68

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

    69

    70

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

    71

    return proc, switchApp(wtitle)

    72

    73

class KBDShortcut:

    74

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

    75

          Stop   

    76

          Run    

    77

          Transfer

    78

          Connect

    79

          Clean  

    80

          Build  

    81

    82

    example:

    83

        k = KBDShortcut(app)

    84

        k.Clean()

    85

    """

    86

    87

    fkeys = {"Stop":     Key.F4,

    88

             "Run":      Key.F5,

    89

             "Transfer": Key.F6,

    90

             "Connect":  Key.F7,

    91

             "Clean":    Key.F9,

    92

             "Build":    Key.F11}

    93

    94

    def __init__(self, app):

    95

        self.app = app

    96

    97

    def __getattr__(self, name):

    98

        fkey = self.fkeys[name]

    99

        app = self.app

   100

   101

        def PressShortCut():

   102

            app.focus()

   103

            type(fkey)

   104

   105

        return PressShortCut

   106

   107

   108

class IDEIdleObserver:

   109

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

   110

   111

    def __init__(self, app):

   112

        """

   113

        Parameters: 

   114

            app (class App): Sikuli app given by StartBeremizApp

   115

        """

   116

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

   117

   118

        self.idechanged = False

   119

   120

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

   121

        # FIXME : remove blinking cursor in console

   122

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

   123

        self.r.observeInBackground()

   124

   125

    def __del__(self):

   126

        self.r.stopObserver()

   127

   128

    def _OnIDEWindowChange(self, event):

   129

        print event

   130

        self.idechanged = True

   131

   132

    def Wait(self, period, timeout):

   133

        """

   134

        Wait for IDE to stop changing

   135

        Parameters: 

   136

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

   137

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

   138

        """

   139

        c = timeout/period

   140

        while c > 0:

   141

            self.idechanged = False

   142

            wait(period)

   143

            if not self.idechanged:

   144

                break

   145

            c = c - 1

   146

   147

        if c == 0:

   148

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

   149

   150

   151

class stdoutIdleObserver:

   152

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

   153

   154

    def __init__(self, proc):

   155

        """

   156

        Parameters: 

   157

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

   158

        """

   159

        self.proc = proc

   160

        self.stdoutchanged = False

   161

   162

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

   163

   164

    def _waitStdoutProc():

   165

        while True:

   166

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

   167

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

   168

                break

   169

            sys.stdout.write(a)

   170

            self.idechanged = True

   171

   172

    def Wait(self, period, timeout):

   173

        """

   174

        Wait for IDE'stdout to stop changing

   175

        Parameters: 

   176

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

   177

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

   178

        """

   179

        c = timeout/period

   180

        while c > 0:

   181

            self.idechanged = False

   182

            wait(period)

   183

            if not self.idechanged:

   184

                break

   185

            c = c - 1

   186

   187

        if c == 0:

   188

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

   189

   190

   191

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

   192

   193

    success_event = Event()

   194

   195

    def waitPatternInStdoutProc():

   196

        found = 0

   197

        while True:

   198

            a = proc.stdout.readline()

   199

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

   200

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

   201

            sys.stdout.write(a)

   202

            if a.find(pattern) >= 0:

   203

                found = found + 1

   204

                if found >= count:

   205

                    success_event.set()

   206

                    break

   207

   208

   209

    Thread(target = waitPatternInStdoutProc).start()

   210

   211

    if not success_event.wait(timeout):

   212

        # test timed out

   213

        return False

   214

    else:

   215

        return True

   216

   217

   218