AutoIT Page/Window Object Model

I would like to ask if we can also achieved a Page/Window Object Model in AutoIT? Majority of my project assignment was on Web Automation and I'm using Selenium Webdriver with Framework uses Page Object Model. Currently, I'm assigned to a project for GUI automation. I like to implement this kind of approach also in AutoIT if feasible so that I can reuse the objects to other classes. We are planning to use AutoIT standalone. I noticed that most of the example available in the internet was the object created on each class/script.

Your insights are highly appreciated.

Thanks!

General:

That common approach of using the Page Object Model (POM) Design Pattern isn't quit good feasible with AutoIt. Of course you can create a object structure with AutoIt too, but it was not intended for the language. Anyway, some of the goals of POM can be achieved with the following example suggestion of a test structure.

Please notice:

Since you don't provide enough information about your application under test (AUT), I explain a basic structure. The implementation depends on your application (SWING/RCP, WinForm etc.). It's also important which tool support do you need for your page object recognition. Besides WinForm that could be controled by ControlCommand functions in AutoIt, it's a proper way to use UIASpy or au3_uiautomation as helper tools.

• UIASpy - UI Automation Spy Tool
  
• au3_uiautomation

It's an advantage to know the POM structure in context with Selenium. I usually include a test case description with behavior driven development BDD (Gherkin syntax with Cucumber or SpecFlow), but this will not be a part of that example here.

Example structure:

The structure consists of two applications under test Calc and VlcPlayer. Both follow the common structure PageObjects and Tests. You should try to devide your page objects (files) in many subfolders to keep an overview. This substructure should be similar for the Tests folder/subfolders.

In the Tests area you could include several test stages or test categories depending on your test goals (Acceptance/UI tests, just functional smoke tests and so on). It's also a good idea to control the execution order by an separat wrapper file, TestCaseExecutionOrder.au3. This should exist for all test categories to avoid a mixing of them.

This wrapper au3 file contains the function calls, it's the processing start/control.

Approach description:

• TestCaseExecutionOrder.au3

  • Calls the functions which are the test cases in the subfolders (Menu, PlaylistContentArea, SideNavigation).

  • Test case NiceName consists of some test steps.

    • These test steps have to be included into that script/file by:

      #include-once ; this line is optional
      #include "Menu\OpenFolder.au3"
      

    • Test step OpenFolder.au3 (which is a part of a test case) contains the function(s) to do the folder loading and there content.

      • In that functions the PageObject MenuItemMedia.au3 will be loaded/included into the script/file by:

        #include-once ; this line is optional
        #include "..\..\..\PageObjects\Menu\MenuItemMedia.au3" 
        

        • File MenuItemMedia.au3 should only contain the recognition mechanism for that area and actions.

          • This could be find menu item Media (as a function).

          • or find open folder menu item (as a function) and so on.

            Func _findMenuItemMedia()
                ; do the recognition action
                ; ...
            
                Return $oMenuItem
            EndFunc
            

    • In the test step OpenFolder.au3 which calls _findMenuItemMedia() like:

      Global $oMedia = _findMenuItemMedia()
      

      can a .click executed or something like .getText etc.

The test cases should only #include the files which are necessary (test steps). The test steps should also only #include the necessary files (page objects) and so on. So it's possible to adjust the recognition functions once and it can be used in the corresponding test steps.

Conclusion:

Of course it's hard to explain it in this way, but with this approach you can do a similar way like in Selenium for web testing. Please notice that you properbly have to use Global variables often. You have to be ensure the correct includings and don't lose the overview of your test, which is in OOP test based approaches much easier.

I recommend the usage of VS Code, because you can jump from file to file at the #include statements. That's pretty handy.

I hope this will help you.