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 pytest

    31

import wx

    32

import time

    33

import traceback

    34

import ddt

    35

    36

import conftest

    37

import Beremiz

    38

import PLCOpenEditor

    39

    40

    41

class UserApplicationTest(unittest.TestCase):

    42

    def InstallExceptionHandler(self):

    43

        def handle_exception(e_type, e_value, e_traceback):

    44

            # traceback.print_exception(e_type, e_value, e_traceback)

    45

            self.exc_info = [e_type, e_value, e_traceback]

    46

        self.exc_info = None

    47

        self.old_excepthook = sys.excepthook

    48

        sys.excepthook = handle_exception

    49

    50

    def StartApp(self):

    51

        self.app = None

    52

    53

    def FinishApp(self):

    54

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

    55

        self.app.MainLoop()

    56

        self.app = None

    57

    58

    def setUp(self):

    59

        self.app = None

    60

    61

    def tearDown(self):

    62

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

    63

            self.FinishApp()

    64

    65

    def RunUIActions(self, actions):

    66

        for act in actions:

    67

            wx.CallAfter(*act)

    68

            self.ProcessEvents()

    69

    70

    def CheckForErrors(self):

    71

        if self.exc_info is not None:

    72

            # reraise catched previously exception

    73

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

    74

    75

    def ProcessEvents(self):

    76

        for i in range(0, 30):

    77

            self.CheckForErrors()

    78

            wx.Yield()

    79

            time.sleep(0.01)

    80

    81

    82

@ddt.ddt

    83

class BeremizApplicationTest(UserApplicationTest):

    84

    """Test Beremiz as whole application"""

    85

    86

    def StartApp(self):

    87

        self.app = Beremiz.BeremizIDELauncher()

    88

        # disable default exception handler in Beremiz

    89

        self.app.InstallExceptionHandler = lambda: None

    90

        self.InstallExceptionHandler()

    91

        self.app.PreStart()

    92

        self.app.frame.Show()

    93

        self.ProcessEvents()

    94

        self.app.frame.ShowFullScreen(True)

    95

        self.ProcessEvents()

    96

    97

    def FinishApp(self):

    98

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

    99

        self.app.MainLoop()

   100

        time.sleep(1)

   101

        self.app = None

   102

   103

    def GetSkippedProjectTreeItems(self):

   104

        """

   105

        Returns the list of skipped items in the project tree.

   106

   107

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

   108

        """

   109

        return []

   110

   111

    def OpenAllProjectElements(self):

   112

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

   113

        self.app.frame.ProjectTree.ExpandAll()

   114

        self.ProcessEvents()

   115

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

   116

        skip = self.GetSkippedProjectTreeItems()

   117

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

   118

        while item is not None:

   119

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

   120

            self.ProcessEvents()

   121

            if item not in skip:

   122

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

   123

                    wx.lib.agw.customtreectrl.wxEVT_TREE_ITEM_ACTIVATED,

   124

                    tree_id, item)

   125

                self.app.frame.OnProjectTreeItemActivated(event)

   126

            self.ProcessEvents()

   127

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

   128

   129

    def CheckTestProject(self, project):

   130

        sys.argv = ["", project]

   131

        self.StartApp()

   132

        self.OpenAllProjectElements()

   133

        user_actions = self.GetUserActions()

   134

        self.RunUIActions(user_actions)

   135

        self.FinishApp()

   136

   137

    def GetProjectPath(self, project):

   138

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

   139

   140

    def GetUserActions(self):

   141

        """

   142

        Returns list of user actions that will be executed

   143

        on every test project by testCheckProject test.

   144

        """

   145

        user_actions = [

   146

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

   147

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

   148

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

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

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

   156

        ]

   157

        return user_actions

   158

   159

    def testStartUp(self):

   160

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

   161

        sys.argv = [""]

   162

        self.StartApp()

   163

        self.FinishApp()

   164

   165

    @ddt.data(

   166

        "first_steps",

   167

        "logging",

   168

        "svgui",

   169

        "traffic_lights",

   170

        "wxGlade",

   171

        "python",

   172

        "wiimote",

   173

        "wxHMI",

   174

    )

   175

    @pytest.mark.timeout(30)

   176

    def testCheckProject(self, name):

   177

        """

   178

        Checks that test PLC project can be open,

   179

        compiled and run on SoftPLC.

   180

        """

   181

        project = self.GetProjectPath(name)

   182

        print("Testing example " + name)

   183

        self.CheckTestProject(project)

   184

   185

   186

class PLCOpenEditorApplicationTest(BeremizApplicationTest):

   187

    """Test PLCOpenEditor as whole application"""

   188

   189

    def StartApp(self):

   190

        self.app = PLCOpenEditor.PLCOpenEditorApp()

   191

        # disable default exception handler in application

   192

        self.app.InstallExceptionHandler = lambda: None

   193

        self.InstallExceptionHandler()

   194

        self.app.Show()

   195

        self.ProcessEvents()

   196

        self.app.frame.ShowFullScreen(True)

   197

        self.ProcessEvents()

   198

   199

    def FinishApp(self):

   200

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

   201

        self.app.MainLoop()

   202

        time.sleep(1)

   203

        self.app = None

   204

   205

    def GetSkippedProjectTreeItems(self):

   206

        """

   207

        Returns the list of skipped items in the project tree.

   208

   209

        Root item opens dialog window for project settings.

   210

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

   211

        """

   212

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

   213

   214

    def GetUserActions(self):

   215

        return []

   216

   217

    def GetProjectPath(self, project):

   218

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

   219

        project_dir = BeremizApplicationTest.GetProjectPath(self, project)

   220

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

   221

   222

   223

if __name__ == '__main__':

   224

    unittest.main()