Automa Blog

Showing posts tagged with: automa, Show all

Automa 2.7.0: press_and_hold

We're happy to report that Automa 2.7.0 has just been released. Besides some small bug fixes, notable new features are the commands press_and_hold(...) and release(...). These two commands can be combined to press, hold and release keyboard keys. For example, the following snippet starts the Chrome web browser and zooms in using the mouse wheel, by pressing and holding the CTRL key:

start('Chrome')
press_and_hold(CTRL)
scroll_up()
release(CTRL)

Support for these commands was added because our users and customers requested them. If you would like to request a feature, please let us know via our contact page. (Priority is given to paying customers.)

The new version can as usual be downloaded from our download page. Happy automating!

Welcoming our latest customer: Esri Inc

Logo of Esri

We are happy to announce that after renowned companies like Intel and Samsung, we have another global specialist as one of Automa's customers: Esri specialises in GIS solutions. Esri connects governments, industry leaders, academics, and nongovernmental organizations with the analytic knowledge they need to make critical decisions that shape our planet.

If you have not tried Automa yourself yet, we encourage you to give it a go! It's so simple, everybody can do it. Simply go to our download page, fill in your details and click Download. You will receive a Windows executable which you can immediately run, without prior installation.

Happy automating!

Automa 2.6: Improvements

After a small break over the (European) summer, we're happy to report back to you with a new and improved version of Automa, 2.6 :-)

The first significant improvement in Automa 2.6 is that playing back files has become significantly easier. Previously, scripts which you had saved with a .at extension had to obey the exact same syntax rules as when you typed the file into the interpreter. For example:

notepad = start('Notepad')
if MenuItem('File').exists():
    print 'All good!'
 
kill(notepad)

Do you notice the extra, empty line after print 'All good!'? This used to be required because when you type in the above script in the Automa console, you needed to confirm with an empty line that you want to close the if block:

>>> notepad = start('Notepad')
>>> if MenuItem('File').exists():
...     print 'All good!'
...

This makes sense in the interactive interpreter (because otherwise it has no other way to know whether you are done with the if block), but for a saved .at file where the next lines are known, it was sometimes very confusing. That is why we changed it so you can now write

notepad = start('Notepad')
if MenuItem('File').exists():
    print 'All good!'
kill(notepad)

in your .at scripts.

In the process of improving Automa's playback capabilities, we also improved its error reporting. When there is an error in a script and you try to play it back using Automa, it now gives you more detailed information about where the error occurred. Another issue pointed out to us by some of our users is that when you ran a script with an error by opening it with Automa.exe, then the Automa console window used to close too quickly for you to be able to read the precise error message. We also fixed this so that the error is displayed until you explicitly close the console window.

Finally, Automa 2.6 adds support for the latest version 36 of the Google Chrome browser.

Happy automating!

Welcoming UC Berkeley as Automa's latest customer

Logo of the University of California, Berkeley

After high-profile companies like Intel and Samsung, we are very proud to announce that we now also have the highly-renowned University of California, Berkeley as one of our customers.

UC Berkeley are using Automa to automate the testing of some applications developed in-house. The fact that Automa is so lightweight and does not require installation makes it very easy to integrate into Berkeley's existing infrastructure.

For a selection of some of Automa's other customers, please visit our home page (scroll down for the selection of customers).

Taking screenshots with Automa

We're happy to announce that we just released version 2.5.5 of our next generation GUI automation tool, Automa. Besides a few small improvements, the new version features a command called save_screenshot(...). This command lets you save a screenshot of your entire screen contents to a file. This is very useful for debugging or further processing of the outcomes of a test / automation run.

The syntax of the new command is very simple. You merely pass a string identifying the path of where the screenshot should be saved. Automa saves the file as a PNG file, so we recommend the file ending .png. For instance:

save_screenshot(r'C:\screenshot.png')

Please note the leading r before the quotation mark in the example. This is always required when working with file paths as it instructs Automa's built-in Python interpreter to treat any backslashes in the string as plain-text backslashes (not, as normally, as escape characters).

After playing around with the new command ourselves, we found it surprisingly useful and fun to use. We hope you will feel the same. You can as always download the new version from our download page.

Happy automating!

Automa now supports Python 2.7.6

Python 2.7.6

After comprehensive regression testing, we are happy to announce that we just released a new version of Automa. Besides some small bug fixes and stability improvements, this release adds support for Python 2.7.6, the latest version in the Python 2.x series. You can download the Python 2.7.6 installer here and the latest version of Automa from our download page.

Happy automating! :-)

Uninstall programs automatically

Automa can be used to automate repetitve tasks such as uninstalling programs. Take a look at the script below:

import sys
assert len(sys.argv) > 2
press(LWIN + "r")
write("control.exe appwiz.cpl")
press(ENTER)
click(sys.argv[2])
click("Uninstall")
click("Yes")
uninstall.at

In order to run this script and uninstall an application run:

>Automa.exe uninstall.at "Name of the application"

Upcoming Testing Conferences

Agile Testing Days 2013 Logo EuroSTAR 2013 Logo Software Quality Days 2014 Logo

One of the things we have been busy with over the past weeks was registering for some of the most important upcoming testing conferences in Europe. They represent an ideal opportunity for us to meet our users (you!) in person, and learn first hand about their needs and requirements. The way to these conferences was not always easy, so read on for some experiences of a startup trying to get into some of the most prestigious testing events in Europe.

Agile Testing Days, October 28-31, 2013 in Potsdam / Berlin, Germany

The Agile Testing Days are one of Europe's biggest testing events, with many speakers that are prominent in the Agile Testing community. The organizers are very friendly, quick and precise in their work and were happy to cater for the needs of a startup. Their team have been extremely pleasant and helpful in our communications and we are very much looking forward to attending the conference. We will be there on October 30th. If you will be there too and would like to chat, give us a shout on our twitter page!.

EuroSTAR Software Testing Conference, November 4-7, 2013 in Gothenburg, Sweden

EuroSTAR is unquestionably the biggest software testing event in Europe. This doesn't prevent it from being leading edge: This year's conference theme is "Questioning Testing" and applies testing to Testing itself. Why do some techniques work well in some situations, and not so well in others? How can you give your clients a credible account of your (testing) work? The critical look at the field itself in this year's conference promises to be both challenging and very interesting.

Our way to EuroSTAR

It took us several attempts to get a place at EuroSTAR. As a startup, we need to monitor our expenses very tightly, so we were looking for an affordable way of attending this great testing event.

Our first attempt consisted of submitting a talk proposal to EuroSTAR. If successful, the proposal would have allowed us to attend EuroSTAR for free. Luckily, our proposal was not accepted. Why luckily? Because our proposal wasn't very good and sparked a very interesting discussion with the programme chair of this year's EuroSTAR, Michael Bolton.

When our proposal was not accepted, the programme chair Michael Bolton sent us an email asking whether we would like more detailed feedback on our submission. Of course, we said yes. Michael raised several very valid points about our proposal, and even took the time to answer more detailed follow-up questions that came up in the ensuing discussion. We were very impressed with this, because being the conference chair, Michael had to deal with literally hundreds of similarly rejected submissions.

A little bit later, we were invited to write a guest post on the EuroSTAR blog. We used this opportunity to write about the success of our unsuccessful submission to EuroSTAR. The blog post was received very well, and garnered an unusually high amount of encouraging comments. You can find it on the EuroSTAR blog, here.

The team behind EuroSTAR are very dedicated to the community and are offering several competitions in which you can win a free ticket for the conference. We took part in several of these competitions with little success, until another competition hosted by the Ministry of Testing together with EuroSTAR was announced.

The goal of the new competition was to take a selfie photo. The best three photos were to be selected by Rosie Sherry and her team at the Ministry of Testing. The winner was then to be chosen by a public vote.

We knew this was our best chance to attend EuroSTAR, so we brainstormed about what the best selfie photo would be to win. Eventually, we came up with the idea of taking a picture of one of us with a prominent figure, in Madame Tussauds in Vienna. To top it off, we decided to wear a self-printed T-shirt with the Ministry of Testing logo on it, to ensure we really made it into the final. In the end, we chose two selfie pictures as our favorites: One with the Queen and one with 007.

The picture with 007 got selected into the final. What ensued was a week of constantly asking (spamming) our friends on all possible channels to vote for us. The competition ended last Friday, and we were very happy to be notified on Sunday by Rosie Sherry that we had won. We are extremely grateful to Rosie and the Ministry of Testing for organizing this competition, and the EuroSTAR team for their dedication to the community. They are really hard at work at making this an unmissable event. We can't wait to attend.

All that's left now is to book flights and accommodation for our stay in Gothenburg. If you know of an affordable place to stay during the conference, it would be great if you could let us know in the comments below! Please, also let us know if you would like to have a chat at the conference, either in the comments below or on Twitter.

Software Quality Days, Jannuary 14-16, 2014 in Vienna, Austria

The Software Quality Days is an annual event in Vienna that has steadily been becoming more and more important in recent years. Also their organizing team are very friendly and helpful, and have been very supportive in enabling us to not only attend but exhibit. We will be presenting our next generation GUI automation tool Automa there. We can't wait to present our tool, and answer any questions from the audience there.

There is one main reason for us to go to these conferences: To meet fellow testers and our users. We are new to all of the above events and would love to catch up with anyone who would like to get to know us a little. If you do, and are at one of these conferences, please just leave a comment below, or ping us on our Twitter page.

Happy automating! And see you soon :-)

Automa 2.4: Update to Python 2.7.5

We just released a new version of our next generation GUI testing and automation tool Automa. In addition to some stability improvements, the major feature of the new version is that it is based on Python 2.7.5. Python 2.7.5 includes many bug fixes and stability improvements over version 2.7.3, which was used for previous versions of Automa.

If you use Automa as a Python library, then you need to update your Python version to 2.7.5. This is very easy: You can just download and install the correct version using this direct link. If you download the new version of Python from another location, please ensure that you are selecting the 32 bit and not the 64 bit version of Python as explained in our documentation section. Python version 2.7.5 is fully backwards-compatible with version 2.7.3, so you should not have any trouble updating.

By updating Automa to the latest version, you can now benefit from the significantly improved stability of the latest Python 2.7 release. We therefore highly recommend the update. As always, you can download the latest version of Automa by simply visiting our download page.

Happy automating! :-)

Automa 2.3: Focus on Usability

Since the last release of Automa two weeks ago, our focus has been on improving the usability of the interactive Automa console. We are extremely pleased with the results! Here are the new features:

Tab-Autocompletion

Have you ever had the need to repeatedly type a long function name such as get_name_under_mouse() in the Automa console? With the new version of Automa, you can now save a lot of typing by writing only the first few characters of the function and then pressing Tab. For instance, to enter get_name_under_mouse(), you only need to type the first two letters ge and then press Tab to have Automa automatically complete the function name for you.

When multiple completions are possible and you press Tab then you get a list of the possible completions. For example: The Automa console by default includes the commands start(...) and start_tutorial(...). If you type in st and press Tab, then the Automa console displays both commands and automatically fills in their common prefix start at the next line of input:

>>> st<TAB>
start(          start_tutorial(
>>> start

Another cool feature of the Tab completion is that it can show you the properties and methods of an object. Want to know which methods a string object has? Just append a dot . to the object and press Tab:

>>> my_string = "Hello World!"
>>> my_string.<TAB>
my_string.capitalize( my_string.islower(    my_string.rpartition(
my_string.center(     my_string.isspace(    my_string.rsplit(
my_string.count(      my_string.istitle(    my_string.rstrip(
my_string.decode(     my_string.isupper(    my_string.split(
my_string.encode(     my_string.join(       my_string.splitlines(
my_string.endswith(   my_string.ljust(      my_string.startswith(
my_string.expandtabs( my_string.lower(      my_string.strip(
my_string.find(       my_string.lstrip(     my_string.swapcase(
my_string.format(     my_string.partition(  my_string.title(
my_string.index(      my_string.replace(    my_string.translate(
my_string.isalnum(    my_string.rfind(      my_string.upper(
my_string.isalpha(    my_string.rindex(     my_string.zfill(
my_string.isdigit(    my_string.rjust(
>>> 

Finally, if you press Tab without having entered anything, then you get a quick overview of the most important commands and properties available to you:

>>> <TAB>
about(                start_tutorial(       BKSP
clear(                switch_to(            CTRL
click(                wait_until(           DEL
doubleclick(          write(                DIVIDE
drag(                 Application(          DOWN
exit(                 Button(               END
find_all(             CheckBox(             ENTER
get_name_under_mouse( ComboBox(             ESC
help(                 Config(               HOME
highlight(            GUIElement(           INS
history(              Image(                LEFT
hover(                ListItem(             LWIN
kill(                 MenuItem(             MULTIPLY
playback(             NoWorkWindowError(    PGDN
press(                Point(                PGUP
quit(                 RadioButton(          PRTSC
rightclick(           Text(                 RIGHT
save(                 TextField(            SHIFT
scroll_down(          TimeoutExpired(       SPACE
scroll_left(          TreeItem(             SUBTRACT
scroll_right(         Window(               TAB
scroll_up(            ADD                   UP
start(                ALT
>>> 

Context-sensitive help

Some mistakes in Automa are easy to make, especially for novice users. Consider the following line:

>>> press(Enter)

The problem here is that Enter is not defined: The Enter key is stored as a constant variable in Automa and the Python coding guidelines state that such variables should have all-uppercase names. The correct name of the variable in Automa is therefore ENTER.

When you type the above command, Automa now gives you a hint that you might have meant something else:

>>> press(Enter)
NameError: name 'Enter' is not defined
 
Did you maybe mean
        press(ENTER)
?
>>> 

Here are some other context-sensitive hints that were added in this release:

>>> sleep(5)
NameError: name 'sleep' is not defined
 
To wait for a specific event, you can use wait_until(...). Eg:
        wait_until(Button('Save').exists)
If you wish to wait for a number of seconds, you need to import `sleep`
from Python`s time module:
        from time import sleep
        sleep(5)
>>>
>>> enter('Hello World!')
NameError: name 'enter' is not defined
 
Did you maybe mean
        write('Hello World!')
?
>>>
>>> type('test.txt', into='File name')
TypeError: type() takes 1 or 3 arguments
 
Did you maybe mean
        write('test.txt', into='File name')
?
>>> 

Pasting via CTRL+V

Previously, it was only possible to paste into the Automa console using a right-click:

Pasting into the Automa console via rightclick

Now, this is also possible by just pressing CTRL + V.

clear()

Windows users will be familiar with the well-known command cls. This function clears the contents of a console window so you can see more clearly and not be distracted by any previously entered commands. We have implemented this functionality in Automa with the new command clear. You can simply call it as follows:

>>> clear()

Rewriting history

Consider the following commands:

>>> def f():
...     print 1
...     print 3
...
>>> 

The user has forgotten print 2 in his function definition and would like to change this. The new version of Automa makes this particularly easy: You can revoke the commands you previously entered using the Arrow Up and Down keys. So, to modify the function definition, you press Up three times and Enter to get the line

>>> def f():

Then, you press Down once and Enter to get the next line

...     print 1

Now you can enter the line that was forgotten by typing:

...     print 2

The function definition can then be completed by pressing Down again and twice confirming with Enter. With very few keystrokes, you have thus changed the function definition to:

>>> def f():
...     print 1
...     print 2
...     print 3
...
>>>

While this is a simple feature, it comes in surprisingly useful.

As always, you can download the latest version of Automa from our download page.

Happy automating! :-)