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 print_function

    27

import os

    28

import sys

    29

import unittest

    30

import time

    31

import traceback

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

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

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

    93

        self.app.frame.Show()

    94

        self.ProcessEvents()

    95

        self.app.frame.ShowFullScreen(True)

    96

        self.ProcessEvents()

    97

    98

    def FinishApp(self):

    99

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

   100

        self.app.MainLoop()

   101

        time.sleep(1)

   102

        self.app = None

   103

   104

    def GetSkippedProjectTreeItems(self):

   105

        """

   106

        Returns the list of skipped items in the project tree.

   107

   108

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

   109

        """

   110

        return []

   111

   112

    def OpenAllProjectElements(self):

   113

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

   114

        self.app.frame.ProjectTree.ExpandAll()

   115

        self.ProcessEvents()

   116

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

   117

        skip = self.GetSkippedProjectTreeItems()

   118

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

   119

        while item is not None:

   120

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

   121

            self.ProcessEvents()

   122

            if item not in skip:

   123

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

   124

                    wx.lib.agw.customtreectrl.wxEVT_TREE_ITEM_ACTIVATED,

   125

                    tree_id, item)

   126

                self.app.frame.OnProjectTreeItemActivated(event)

   127

            self.ProcessEvents()

   128

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

   129

   130

    def CheckTestProject(self, project):

   131

        sys.argv = ["", project]

   132

        self.StartApp()

   133

        self.OpenAllProjectElements()

   134

        user_actions = self.GetUserActions()

   135

        self.RunUIActions(user_actions)

   136

        self.FinishApp()

   137

   138

    def GetProjectPath(self, project):

   139

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

   140

   141

    def GetUserActions(self):

   142

        """

   143

        Returns list of user actions that will be executed

   144

        on every test project by testCheckProject test.

   145

        """

   146

        user_actions = [

   147

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

   148

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

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

        ]

   158

        return user_actions

   159

   160

    def testStartUp(self):

   161

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

   162

        sys.argv = [""]

   163

        self.StartApp()

   164

        self.FinishApp()

   165

   166

    @ddt.data(

   167

        "first_steps",

   168

        "logging",

   169

        "svgui",

   170

        "traffic_lights",

   171

        "wxGlade",

   172

        "python",

   173

        "wiimote",

   174

        "wxHMI",

   175

    )

   176

    @pytest.mark.timeout(30)

   177

    def testCheckProject(self, name):

   178

        """

   179

        Checks that test PLC project can be open,

   180

        compiled and run on SoftPLC.

   181

        """

   182

        project = self.GetProjectPath(name)

   183

        print("Testing example " + name)

   184

        self.CheckTestProject(project)

   185

   186

   187

class PLCOpenEditorApplicationTest(BeremizApplicationTest):

   188

    """Test PLCOpenEditor as whole application"""

   189

   190

    def StartApp(self):

   191

        self.app = PLCOpenEditor.PLCOpenEditorApp()

   192

        # disable default exception handler in application

   193

        self.app.InstallExceptionHandler = lambda: None

   194

        self.InstallExceptionHandler()

   195

        self.app.Show()

   196

        self.ProcessEvents()

   197

        self.app.frame.ShowFullScreen(True)

   198

        self.ProcessEvents()

   199

   200

    def FinishApp(self):

   201

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

   202

        self.app.MainLoop()

   203

        time.sleep(1)

   204

        self.app = None

   205

   206

    def GetSkippedProjectTreeItems(self):

   207

        """

   208

        Returns the list of skipped items in the project tree.

   209

   210

        Root item opens dialog window for project settings.

   211

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

   212

        """

   213

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

   214

   215

    def GetUserActions(self):

   216

        return []

   217

   218

    def GetProjectPath(self, project):

   219

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

   220

        project_dir = BeremizApplicationTest.GetProjectPath(self, project)

   221

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

   222

   223

   224

if __name__ == '__main__':

   225

    unittest.main()