1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2017: Andrey Skvortsov

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

from __future__ import absolute_import

    27

from __future__ import print_function

    28

import os

    29

import sys

    30

import unittest

    31

import time

    32

    33

import pytest

    34

import wx

    35

import ddt

    36

    37

import conftest

    38

import Beremiz

    39

import PLCOpenEditor

    40

    41

    42

class UserApplicationTest(unittest.TestCase):

    43

    def InstallExceptionHandler(self):

    44

        def handle_exception(e_type, e_value, e_traceback, exit=False):

    45

            # traceback.print_exception(e_type, e_value, e_traceback)

    46

            self.exc_info = [e_type, e_value, e_traceback]

    47

        self.exc_info = None

    48

        self.old_excepthook = sys.excepthook

    49

        sys.excepthook = handle_exception

    50

    51

    def StartApp(self):

    52

        self.app = None

    53

    54

    def FinishApp(self):

    55

        wx.CallAfter(self.app.frame.Close)

    56

        self.app.MainLoop()

    57

        self.app = None

    58

    59

    def setUp(self):

    60

        self.app = None

    61

    62

    def tearDown(self):

    63

        if self.app is not None and self.app.frame is not None:

    64

            self.FinishApp()

    65

    66

    def RunUIActions(self, actions):

    67

        for act in actions:

    68

            wx.CallAfter(*act)

    69

            self.ProcessEvents()

    70

    71

    def CheckForErrors(self):

    72

        if self.exc_info is not None:

    73

            # reraise catched previously exception

    74

            raise self.exc_info[0], self.exc_info[1], self.exc_info[2]

    75

    76

    def ProcessEvents(self):

    77

        for dummy in range(0, 30):

    78

            self.CheckForErrors()

    79

            wx.Yield()

    80

            time.sleep(0.01)

    81

    82

    83

@ddt.ddt

    84

class BeremizApplicationTest(UserApplicationTest):

    85

    """Test Beremiz as whole application"""

    86

    87

    def StartApp(self):

    88

        self.app = Beremiz.BeremizIDELauncher()

    89

        # disable default exception handler in Beremiz

    90

        self.app.InstallExceptionHandler = lambda: None

    91

        self.InstallExceptionHandler()

    92

        self.app.handle_exception = sys.excepthook

    93

        self.app.PreStart()

    94

        self.ProcessEvents()

    95

        self.app.frame.Show()

    96

        self.ProcessEvents()

    97

        self.app.frame.ShowFullScreen(True)

    98

        self.ProcessEvents()

    99

   100

    def FinishApp(self):

   101

        wx.CallAfter(self.app.frame.Close)

   102

        self.app.MainLoop()

   103

        time.sleep(1)

   104

        self.app = None

   105

   106

    def GetSkippedProjectTreeItems(self):

   107

        """

   108

        Returns the list of skipped items in the project tree.

   109

   110

        Beremiz test don't need to skip any elemnts in the project tree.

   111

        """

   112

        return []

   113

   114

    def OpenAllProjectElements(self):

   115

        """Open editor for every object in the project tree"""

   116

        self.app.frame.ProjectTree.ExpandAll()

   117

        self.ProcessEvents()

   118

        item = self.app.frame.ProjectTree.GetRootItem()

   119

        skip = self.GetSkippedProjectTreeItems()

   120

        tree_id = self.app.frame.ProjectTree.GetId()

   121

        while item is not None:

   122

            self.app.frame.ProjectTree.SelectItem(item, True)

   123

            self.ProcessEvents()

   124

            if item not in skip:

   125

                event = wx.lib.agw.customtreectrl.TreeEvent(

   126

                    wx.lib.agw.customtreectrl.wxEVT_TREE_ITEM_ACTIVATED,

   127

                    tree_id, item)

   128

                self.app.frame.OnProjectTreeItemActivated(event)

   129

            self.ProcessEvents()

   130

            item = self.app.frame.ProjectTree.GetNextVisible(item)

   131

   132

    def CheckTestProject(self, project):

   133

        sys.argv = ["", project]

   134

        self.StartApp()

   135

        self.OpenAllProjectElements()

   136

        user_actions = self.GetUserActions()

   137

        self.RunUIActions(user_actions)

   138

        self.FinishApp()

   139

   140

    def GetProjectPath(self, project):

   141

        return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", project))

   142

   143

    def GetUserActions(self):

   144

        """

   145

        Returns list of user actions that will be executed

   146

        on every test project by testCheckProject test.

   147

        """

   148

        user_actions = [

   149

            [self.app.frame.SwitchFullScrMode, None],

   150

            [self.app.frame.SwitchFullScrMode, None],

   151

            [self.app.frame.CTR._Clean],

   152

            [self.app.frame.CTR._Build],

   153

            [self.app.frame.CTR._Connect],

   154

            [self.app.frame.CTR._Transfer],

   155

            [self.app.frame.CTR._Run],

   156

            [self.app.frame.CTR._Stop],

   157

            [self.app.frame.CTR._Disconnect],

   158

            [self.app.frame.CTR._Clean],

   159

        ]

   160

        return user_actions

   161

   162

    def testStartUp(self):

   163

        """Checks whether the app starts and finishes correctly"""

   164

        sys.argv = [""]

   165

        self.StartApp()

   166

        self.FinishApp()

   167

   168

    @ddt.data(

   169

        "first_steps",

   170

        "logging",

   171

        "svgui",

   172

        "traffic_lights",

   173

        "wxGlade",

   174

        "python",

   175

        "wiimote",

   176

        "wxHMI",

   177

    )

   178

    @pytest.mark.timeout(30)

   179

    def testCheckProject(self, name):

   180

        """

   181

        Checks that test PLC project can be open,

   182

        compiled and run on SoftPLC.

   183

        """

   184

        project = self.GetProjectPath(name)

   185

        print("Testing example " + name)

   186

        self.CheckTestProject(project)

   187

   188

   189

class PLCOpenEditorApplicationTest(BeremizApplicationTest):

   190

    """Test PLCOpenEditor as whole application"""

   191

   192

    def StartApp(self):

   193

        self.app = PLCOpenEditor.PLCOpenEditorApp()

   194

        # disable default exception handler in application

   195

        self.app.InstallExceptionHandler = lambda: None

   196

        self.InstallExceptionHandler()

   197

        self.app.Show()

   198

        self.ProcessEvents()

   199

        self.app.frame.ShowFullScreen(True)

   200

        self.ProcessEvents()

   201

   202

    def FinishApp(self):

   203

        wx.CallAfter(self.app.frame.Close)

   204

        self.app.MainLoop()

   205

        time.sleep(1)

   206

        self.app = None

   207

   208

    def GetSkippedProjectTreeItems(self):

   209

        """

   210

        Returns the list of skipped items in the project tree.

   211

   212

        Root item opens dialog window for project settings.

   213

        To avoid code that handles closing dialog windows just skip this item.

   214

        """

   215

        return [self.app.frame.ProjectTree.GetRootItem()]

   216

   217

    def GetUserActions(self):

   218

        return []

   219

   220

    def GetProjectPath(self, project):

   221

        """Open PLC program in every Beremiz test project"""

   222

        project_dir = BeremizApplicationTest.GetProjectPath(self, project)

   223

        return os.path.join(project_dir, "plc.xml")

   224

   225

   226

if __name__ == '__main__':

   227

    conftest.init_environment()

   228

    unittest.main()