Friday, April 3, 2009

Blog moving to

Few days ago we launched our new website at

The website is a single sign-on that integrates our blogs, forums, downloads and all ArtOfTest, Inc users under one profile.

We are moving this blog to our site blog here:

If you have an RSS feed for this blog, please update your feed to:

We will soon be adding more blogs on our main site discussing our products and features.

ArtOfTest, Inc.

Thursday, March 12, 2009

Automation Design Canvas 1.1 Released!

We are happy to announce the availability of Automation Design Canvas Version 1.1! This release incorporates tons of customer feedback that we have gathered since 1.0. We want to thank all our customers that have helped us refine our feature set and make 1.1 a robust testing platform for modern application.

Automation Design Canvas is not your average testing tool. It has many innovations specifically designed for testing rich internet applications and handle the dynamic nature and complexities of these applications. Automation Design Canvas which is built on top of our popular WebAii Automation Framework is not only a tool but also a testing platform for anyone to build on top of!

This release also signals a new era of innovations in automated testing with the release of Telerik’s WebUI Test Studio which is powered by Automation Design Canvas and WebAii Framework. Our partnership with Telerik highlights our commitment to customizable and contemporary testing solutions that are not only geared to help end users but also development vendors! It is one step forward in our mission of making software testing easier.
If you have not given Automation Design Canvas a good look then this is the time to do so. Here are some of the key features that Automation Design Canvas can offer:

1. Simple point and click recording. The designer offers an integrated overlay surface that intelligently detects HTML page elements and offers common verification and action tags. There is no code to write or external tools to use. To update your tests, simply select a step and update its properties.

2. Integrated in Visual Studio. If you are developing a .NET application, you are most probably using VS. Why not have your QA team also work in the same environment? Eradicate the need for managing different tools and eliminate the silos between your development and QA teams. Integrating both teams in one environment is one of the most effective ways to enhance your team’s productivity and cut your cost. Not to mention, Automation Design Canvas offers a very compelling price point.

3. Sentence Verification Builder. Your test is a good as its verification! Without solid verification in each test, an automation test is useless. With Automation Design Canvas we offer an integrated and innovative designer that helps you build verification just like writing a sentence.

4. Code Generation. For those of you that want full control of your test case or simply want to customize a test using code, no problem! Automation Design Canvas allows you to generate code at a test or step level and add any set of custom steps using your favorite .NET language.

So what’s next?

Well… many things. This year we hope to fully cover the web application matrix for testing by
1. Adding support for Silverlight. WebAii 2.0 will feature our runtime support and future Automation Design Canvas releases will feature our record/playback support.
2. Expanding our browser support matrix to include Chrome and Safari.
3. New website. This will be unveiled in the next few weeks.
4. Updated documentation and samples
Download Automation Design Canvas today!

ArtOfTest, Inc. Team.

Monday, February 16, 2009

ArtOfTest forges a strategic alliance with Telerik, Inc.

Austin, TX – February 2, 2009 – ArtOfTest, Inc. the experts in software quality assurance technologies and automated software testing has forged a strategic alliance with Telerik, Inc., the leading vendor of developer tools and UI components for .NET. This alliance is a first of its kind and reinforces ArtOfTest’s position as a thought leader and innovator in the software testing tools market.

Telerik’s WebUI Test Studio™ announced today is the first tangible result of this alliance. Telerik’s WebUI Test Studio™ is an automated testing solution featuring the innovative ArtOfTest Automation Design Canvas™ and WebAii™Automation Framework and is specifically tailored for Telerik RadControls™ for ASP.NET AJAX; thanks to the integrated control translators which leverage ArtOfTest’s patented extensibility architecture of Automation Design Canvas.

“We are very excited about partnering with Telerik and offering a specialized version of Automation Design Canvas™ to their customers,” said Faris Sweis & Christopher Eyhorn, Co-Founders of ArtOfTest. “This partnership and its offerings is a first of its kind between a UI component vendor and a testing tools company. We believe it is time to bring a new generation of cutting-edge technologies and innovative processes to software testing that will assist software quality professionals in building better software easier.”

“With the new WebUI Test Studio, we are happy to present a new era in automated web testing,” said Svetozar Georgiev, Telerik Co-CEO. “Historically, testing tools have been complex and expensive, and as a result—out of reach for most small and medium-sized companies. We believe WebUI Test Studio will bring automated testing to the masses, finally making superior and cost-effective testing possible and facilitating team collaboration between developers and QAs. And there is an added value to Telerik customers—thanks to the integrated control translators, they can easily build tests against Telerik controls without having to understand their structure.”

About Telerik
Telerik is a leading vendor of development tools and components for Microsoft .NET. Developers from most of the Fortune 2000 companies, many of the world’s leading educational and non-profit organizations and thousands of consultants rely on Telerik products to build applications with unparalleled richness, responsiveness and interactivity. For more info on Telerik and its products, please visit .

About ArtOfTest
ArtOfTest, Inc. is building the next generation of software testing tools. Their mission is to evolve the software quality assurance industry through the advancement of cutting-edge technologies used in software testing and software quality assurance. For more info on ArtOfTest and its products, please visit .

Sunday, February 1, 2009

WebAii Automation Design Canvas 1.1 Preview now available

ArtOfTest is happy to announce the availability of Automation Design Canvas 1.1 - Preview! The most productive and innovative tool for testing Web 2.0 applications! The official release of 1.1 will be available at the end of this month.

WebAii Automation Design Canvas 1.1 incorporates tons of customer feedback that we have gathered over the last 6 months from customers using our 1.0 version. The 1.1 version includes vast enhancements in the following areas:

1. Simplified Project Model: Your tests are now self-contained and have no dependency on other files in the solution. No more .WebAiiElements file or WebAiiProj files. Makes deployment scenarios a breeze and allows for tests to be easily portable across machines, users and projects. Simply copy, paste and include in any test project.

2. Strongly-typed Project Elements: As you record tests, strongly typed elements are being generated on the fly and are automatically accessible from your NUnit or VS Unit tests or any other unit testing framework that you like. If you are one of those customers that wants to simply use our design canvas to quickly generate code, then this feature is for you! Other key benefits to this feature is the ability to discover project element changes at compile time vs. execution time which is a huge time saver!

3. Record directly from Internet Explorer: You are no longer limited to our hosted browser instance inside Visual Studio. Launch IE in record mode and get the entire recording functionality including our Automation Overlay Surface and DOM Explorer attached to your IE instance. This setup is ideal for multi-monitor environments since you can have an IE instance on one screen to record from and Visual Studio on the second screen to manage the tests and execute them.

4. Test case Reusability: This has been a constant customer request. If you have repetitive test steps that you need to execute in multiple tests (i.e. login), then record them as one test and then add that test as a step to whatever test that requires it.

5. Enhanced Test Maintenance Support: Have your storyboard images gone out of date due to the churn in your application? With a simple click of a button, you can update these storyboard images automatically as your test is executing. You can even choose the browser type you want the images to be captured from.

6. Tons of performance and reliability fixes.

For more details, please check out our expanded How-To Videos here, which expand on our existing feature set and cover the new 1.1 features.


ArtOfTest, Inc. Team.

Saturday, January 10, 2009

WebAii 2.0 – Automate more than you expect!

In the last few months, we've been working really hard on refining our WebAii 2.0 feature set and polishing our first beta that we hope to release in Q1 of 2009. The goal for WebAii 2.0 is to enable a broader list of automation scenarios that were not possible in previous versions, address customer pain-points and expand our support to span the latest advancements in web development technologies. This has always been our promise to our customers and we believe WebAii 2.0 will delight our existing customers and will spur many to give WebAii a serious look. Let me outline some of our major features that we hope to preview in WebAii 2.0 beta:

  1. Safari/Chrome support: Yes, I have said it. WebAii 2.0 will support Safari (on Windows) and Google Chrome browsers. Our Beta support most probably will only contain the Safari support but future updates will incorporate Chrome support too. The great thing about this support is that you don't need to make any changes to your existing testcases if you are already using WebAii. Simply change the BrowserType setting to Safari or Chrome and watch your existing tests execute against that browser. WebAii's browser abstraction architecture is the key enabler to seamless browser integration. By adding this support we are enabling existing customers to expand their browser /compatibility testing.

  2. Silverlight Automation Support: WebAii 2.0 will incorporate our Silverlight Extension that we have been previewing in the last few months. Whether you are automating HTML or Silverlight or both, you will have a one-stop-shop library that enables you to automate any of these technologies

  3. Exposing the HTTP stack: In WebAii 2.0 in addition to having access to the browser DOM and the ability to manipulate it, we will also enable you to access/intercept and change the raw http requests between the browser and your web server. The HTTP stack will be wrapped in a clean object model that will enable you to intercept requests, modify requests/responses and measure raw http data for your test automation. This support will enable you to automate web scenarios within your test bed that were not possible before. You will be able to build synchronization points against specific http requests, test your page sizes for performance regression testing and potentially do some security testing by doing request/response tampering.

  4. Enhanced JavaScript support. We are taking JavaScript support in WebAii to new levels unheard of before J. Our HtmlControl suite will expand to contain a highly advanced architecture for JavaScript access. You will be able to access strongly typed JavaScript objects from your testcases, attach to native JavaScript events from .NET, pass JavaScript eventargs and map HtmlControls to pure JavaScript object instances. With such support, you should be able to fully automate and control your JavaScript with a clean object model.

In addition to the above features WebAii 2.0 will contain tons of feature requests that customers have been asking for in addition to tons of bug fixes. Our goal is to also release a 1.1 update by end of Feb 09 that will service many of the bug reported by customers directly or on the forums.


Monday, November 3, 2008

WebAii Silverlight Extension CTP2 Released!

We are happy to announce the release of CTP2. You can download it from our downloads pages .

This CTP is tested against Microsoft's official Silverlight 2 Release. CTP2 fixes all issues reported in CTP1. The dowload entry description contains all the major fixes. I will list them again in this post:

1. Connecting to Silverlight Apps. If you were using CTP1, you might have noticed that our extension stopped being able to connect to Silverlight apps once Microsoft released RC0. In RC0 Microsoft disabled one feature that we were relying on to plug into the app (Security reasons). Instead of trying to hack around this, we simple leverged our built-in http proxy (a new WebAii 2.0 feature that will be fully exposed using an OM but currently marked internal in this release) to connect to the app. This made our execution much cleaner and faster. No more reloading of the app or anything. It should be seamless. The only limitation we have right now is HTTPS.

>> NOTE: In CTP2 there is a new Setting.EnableSilverlight flag that needs to be set to enable WebAii to connect to Silverlight applications. By default this setting is not on. Setting this flag will activate the built-in proxy that we use to detect Silverlight applications.

2. Silverlight UI Controls. All our Silverlight controls that we ship in the box are now extensible. We removed the sealing of these classes. So anyone that wanted to extend them to build their own classes can do so.

3. Silverlight Test Template. As part of the installation, you now have a Silverlight test template that you can use to get you started. The template has one sample test that automates a simple silverlight app.

4. Bug Fixes/Additional Features worth noting:

  1. Finding child elements bug:
  2. Application duplication:
  3. Ability to move the mouse in a certain path:

This is going to be the last standalone CTP2 for silverlight and the silverlight automation functionality you see in thie extension will be rolled into WebAii 2.0 next many other cool new features. Keep an eye on our blogs in the next few weeks where we will preview the roadmap for WebAii 2.0.

Have fun automating.....

Friday, August 8, 2008

Automated Testing of Silverlight Applications – PART II – WebAii’s Support Preview

It's been over a year now since we outlined our vision for supporting Silverlight test automation. We have looked into Silverlight automation from every angle and considered all approaches including UIAutomation. Our automation support for Silverlight doesn't really rely on UIAutomation but at the same time doesn't exclude it 100%. We will probably dedicate a full blog post about this topic and discuss how we are integrating UIAutomation and our reasoning for not relying on it 100%. But for now, let's just dig into our first preview release that will include Silverlight Test Automation support. Officially we are calling this release : WebAii's Silverlight Extension (CTP1) and the release will be available early next week. We are hoping this will be the first extension in a series of WebAii extensions that customers can pick and choose from that cater to specialized technology areas. (i.e. extensions for WebServices, WCF, Data …etc).

Getting started with Silverlight Automation in WebAii

To get started, let's first use a simple application and demo some basic automation scenarios like button click and set text. We will then expand into more advanced topics and scenarios.

Let's take the following simple Silverlight application that contains a button and a text box. When you click the button, it simply displays hello in a textblock on the canvas. The application looks like this:

To automate the application above to set the text, click the button and then verify the hello text in WebAii, we can simply write the following code using WebAii's Silverlight Extension (which currently resides under ArtOfTest.WebAii.Silverlight). Eventually we will be moving this into its own dll/extension:

Let's take a closer look at the code above line by line:

Line 319-323

This is basic WebAii code that launches the browser and navigates to a specific page.

Line 326

As soon as you include the Silverlight extension namespace in your test, (ArtOfTest.WebAii.Silverlight), the 'SilverlightApps()' extension method is added to the ActiveBrowser. The extension method offers you a list of all Silverlight applications found on that page. The extension method returns a list that has two accessors. An index accessor that takes an int (as shown above) and an string accessor that takes a hostid [The id of the html element that contains the <object> tag for the plug-in]. You can pick and choose what works for you. In this sample, given that we only have one Silverlight plugin on the page, we simply accessed the first and only one.

Line 329

As soon as you have an instance of a SilverlightApp, you now have full access to the application including the entire VisualTree. The app offers a short-cut method 'FindName', that can be used to search the application using an element name. In the above sample, given that the TextBox has a name associated with it, we can use FindName to locate it. The SilverlightApp object offers two versions of 'FindName': The first is a generic method that can return a strongly-typed object of the element (As shown above , i.e. a Button, a TextBox, a Grid…etc). The second is simpler and returns the base FrameworkElement object. We will discuss the strongly-typed object model offered in WebAii Silverlight Extension later in this post.

To go back to the line above, we are simply accessing the TextBox that has a name 'myName' and then setting its Text property to "ArtOfTest". Note that given we are accessing a property on the element, this is analogous to SetText on a DOM element in web automation. You are not really typing the text in the textbox but rather setting the Text property inside the application to that text. Our extension enables you to access and set properties directly against any FrameworkElement. If we wanted to simulate real typing of the text we would have written code like this:

app.FindName<TextBox>("myName").User.TypeText("ArtOfTest", 50);

Line 332

Same as above in terms of accessing the button. The difference here is that we are using the 'User' object to click the button. The User object is presented off all elements that inherit from FrameworkElement and offers real user interactions with Silverlight elements. So a Click off 'User' will actually move the mouse over that button an click it. That is exactly what this line does.

Line 335

Now that the button is clicked, we need to verify that the message is correct. The difference here is that we can't really use FindName to locate the TextBlock because the TextBlock doesn't really have a name. The SilverlightApp object offers extensive search support within the VisualTree beyond FindName() by utilizing similar approach to the Find object off the ActiveBrowser (that is used for HTML DOM searches) but adapted to specific XAML search scenarios.

In our code above, we are searching for a TextBlock (All Find.xxText() routines return TextBlocks) that partially contains 'Hello', hence 'p:Hello' (Similar to Find.ByContent in HTML search). Once we find the TextBlock, we then verify that the Text of that label is actually 'Hello ArtOfTest' using the Assert.IsTrue.

Now that we understand this sample, let's dig into some of the key objects available in WebAii's Silverlight Extension.

The SilverlightApp object

The SilverlightApp object is the main object you interact with when automating a silverlight plugin and is the entry point into the silverlight plugin. Below are some of the key properties/methods offered by the SilverlightApp object:


Returns a Rectangle object that is the actual screen coordinates of this Silverlight-plugin.


Exposes the properties found on plugin.content. (i.e. ActualHeight/ActualWidth/FullScreen)


Note: All properties are currently read-only.


Exposes the properties found on plugin.settings. (i.e. Background/EnableHtmlAccess/EnableFramerateCounter…etc)


Note: All properties are currently read-only.


The entire VisualTree of this application. The VisualTree can be navigated up and down and the root element can be accessed using VisualTree.Root. The elements accessed from the VisualTree are FrameworkElement objects.


Returns an HtmlControl object that represents the actual HTML object tag of the plugin.


Returns an HtmlControl object that represents the actual html tag that the plugin object tag is contained in. Typically this is a Div tag if you are using Visual Studio's Silverlight designer.


Exposes a Find object used to search the VisualTree for FrameworkElements. This property is a shortcut to the VisualTree.Find object.


A shortcut to the Find.ByName & Find.ByName<> methods used to find an element using its xaml set name.


The VisualTree

The VisualTree object exposed by the SilverlightApp is a hierarchal representation of the actual VisualTree of the Silverlight application at a specific point in time. If your Silverlight application changes, you can always refresh this tree by calling VisualTree.Refresh(). The VisualTree also exposes the VisualTree.Root property which is a FrameworkElement that represents the root element of the VisualTree of the app.

Note: To help eliminate any synchronization issues between the VisualTree available to the test client and the actual app running in the browser, every time the Find object attempts to find an element in the tree, it will always refresh before starting the search to ensure that the tree is up-to-date with the application.

Locating elements

For complex applications, locating elements is probably going to be one of the more time consuming areas where testers need to spend time understanding how to reliably find an element. Real Silverlight applications that we studied that rely heavily on control templates and databinding produce quite complex visual trees that contain elements that are not easily searchable by FindName() given the different namescopes created and the duplication of names within these templates. For example, check out the following application built by Telerik ( ) , the VisualTree for this application is quite complex.

The SilverlightApp.Find (Same object as VisualTree.Find) offers a rich set of search methods that enable you to not only find elements using their names but also by their text or type. Combined with type filtering, LINQ, FrameworkElement navigation (discussed below) and the Find.Allxxx routines, you get a pretty rich set of routines that enables you to find any framework element in the tree. That being said, this area is probably the area where we would really like lots of feedback in terms of additional search routines customers would like to see and scenarios that we need to support better or make easier. Here is a quick listing of the search routines available in this release:


Find all elements that have a specific name. Allows filtering on a specific control type.


Find all TextBlocks that contain a specific text. Use p:text to search for partial text


Find all elements of certain type. i.e Button, Grid..etc. Filtering on type is inherit here.


Same as FindName(). Search using a specific name.


Returns the first TextBlock that matches the text provided.


Note: All the generic find methods also have a none generic companion for cases where you are working with control types that are not available in the ArtOfTest.WebAii.Silverlight.UI namespace.


Unlike the ActiveBrowser.Find, the SilverlightApp.Find allows you to configure the FindStrategy that you wish to use when locating elements. By default we use the AlwaysWaitForElementsVisible which provides the most reliable approach to locating elements and eliminates any timing issues between the application and the test. So by default when we locate an element we will try to find it, if we don't find it, we keep trying until the element is available up to Find.WaitOnElementsTimeout. You can change this strategy at any point in time. Your options are:

FrameworkElement object

The FrameworkElement available in WebAii's Silverlight Extension is analogous to the FrameworkElement in Silverlight and is the base object that all visual elements and controls inherit from in the ArtOfTest.WebAii.Silverlight.UI namespace (discussed later below). For customers interested in our extensibility model, WebAii's Silverlight Extension does not expose a UIElement and therefore, our FrameworkElement can be viewed as the combination of Silverlight's UIElement + FrameworkElement.

The FrameworkElement and all objects that inherit from it get the following infrastructure methods and services:

  1. VisualTree navigation: All FrameworkElements enable you to navigate the visual tree up or down. The object exposes methods and properties like Parent, Children, NextSibling, PreviousSibling, AnySibling<T>. The navigation also supports control sensitive navigation. For example, if you would like to find the parent 'Grid' that a certain text is contained in you do the following:


    Grid containerGrid = app.Find.ByText("SomeText").Parent<Grid>();


    If you are working with a custom control that doesn't have a strongly-typed object under ArtOfTest.WebAii.Silverlight.UI, the navigation methods all offer a non-generic version that can be used to search for a certain type. For example, let's say you are trying to find the custom control "Bar" that contains some text, then you can do the following:

    FrameworkElement barElement = app.Find.ByText("SomeText").Parent("Bar");

    Parent, NextSibling, PreviousSibling & AnySibling all offer a non-generic versions in addition to the generic one.

  2. User Interaction object:
    The FrameworkElement object exposes a user interaction object. The object is exposed as a property named 'User'. User then exposes all the real automation methods like moving the mouse to click an element, type a text, mouseenter, mouseleave…etc. Here is a listing of all the methods exposed in this preview release

    Note: One of the reasons why we moved these methods into their own object under '' is to help users differentiate between automation that is done by setting/getting properties vs real automation that does use the mouse or keyboard to invoke an action. That is one feedback we got on our design for the HtmlControls suite where customers didn't know which method actually used the real mouse vs direct DOM interaction.


  3. Element coordinates: All FrameworkElements offer the ability to get both the relative coordinates of the element within the silverlight application and the actual coordinates in screen coordinates. The two methods are GetRectangle()
    and GetScreenRectangle().


    Note: Given that WPF/Silverlight applications allow for rich transforms for visual elements (i.e rotate, zoom….etc) and some elements like ellipses don't really conform to a rectangle per-say, our coordinate calculations will always return the largest rectangle that contains the actual element with its center right at the center of the element. For example, a GetRectangle on an ellipse will return this:

    [Note the highlighting above is using the FrameworkElement.Highlight() method]


  4. Scoped search within an element visual children.
    Every single FrameworkElement also has a Find object associated with it that searches only this element's child visual elements. This object will prove very useful when getting into more complex application automation scenarios.


    Example: Find the first StackPanel in the application that contains a specific text:

    StackPanel panel = app.Find.AllByType<StackPanel>().Where(sp => sp.Find.AllByText("SomeText").Count > 0).First();

  5. Visual Synchronization:
    Silverlight applications and the richness they offer to developers in terms of scenario building, accentuate
    the need for rich synchronization support within an automated testing framework. Any testing framework that wants to be considered as a serious and dependable test automation solution within the enterprise for Silverlight needs to offer rich support for synchronization between the application under test and the test being executed. For that reason, all FrameworkElement objects also expose a Wait object that is used to syncronize that element against specific check points. Currently our support is limited to Visible, VisibleNot. Future support is planned for event waiting, animation synchronization and much more. Again feedback on this feature from customers would be of great help.


  6. Xml Representation:
    Every FrameworkElement has a ToXml() method on it that returns the VisualTree of that element as an XML formatted string. This is very useful when trying to understand the visual tree at a certain state. [Hint: You can get the entire visual tree of an app by calling app.VisualTree.Root.ToXml()]


ArtOfTest.WebAii.Silverlight.UI namespace

The UI namespace includes all the strongly-typed controls like Button, TextBox…etc including their properties/methods and enums. The namespace also includes types used by these properties like Brush, SolidBrush…etc. In this preview we are only claiming support for simple primitive property setting/getting and enums. Later on, we will be supporting the ability to retrieve and set complex types like setting a SolidBrush on a Background or retrieving a specific Transform properties from an object. Although setting/getting these types of properties might seem outside the scope of test automation but these properties are going to be much needed to help with test case synchronization with that application and will make it much easier to craft verification points within an automated test. [i.e. Enabling scenarios where a test will need to wait until a specific storyboard has finished a specific animation or waiting/verifying that a specific trigger has been triggered or a certain DependencyProperty has changed…etc.]

Current limitations with this release:

  1. On Vista, if you are automating an external website, then make sure to add the url to your Trusted WebSites list in IE.
  2. Our automation targets Silverlight 2.0 (Beta2) and doesn't support any previous versions.
  3. The automation supports only .XAP deployment method.
  4. EnableHtmlAccess needs to be set to 'True' on your application.
  5. ArtOfTest.WebAii.Silverlight.UI does not contain controls in the System.Windows.Controls.Extended namespace. This will be available in future releases.
  6. There are known issues with Silverlight applications that attempt to perform webservice calls within the application. This issue will be resolved in future versions.
  7. This release does not support side-by-side installation with any previous versions of WebAii or Design Canvas.
  8. The application needs to be running off http:// not C:\...
  9. VS Debugging. Currently the experience of inspecting objects while broken in the debugger is a bit rough. You get lots of timeouts. This will be resolve in future versions.

What's next?

This is our first CTP preview for Silverlight automation. One of the goals of this release is to gather feedback from customers on our design and get specific feature requests that customers want to see implemented. That being said, we still have a set of features that will be implemented in future previews and beta releases of this extension to WebAii, specifically:

  1. More synchronization support within the Wait object for animation and events.
  2. Ability to trigger specific events on an element.
  3. Extended support for setting/getting complex types.
  4. Rich support for interacting with custom Scriptable objects.
  5. Debugging and Tracing support.

That's pretty much it for now. We are very excited about this release and look forward to your feedback. Feel free to send feedback directly to us:

You can download CTP1 build from here.


ArtOfTest Team