ArtOfTest Blogs

Design Canvas 2.0 Released

ArtOfTest — Thu, 10 Dec 2009 08:30:00 GMT

It is official! WebAii 2.0 and Design Canvas 2.0 are released. Since Beta in early November we have fixed over 122 issues reported from our internal testing, our partners and end users. Design Canvas 2.0 and WebAii 2.0 are packed with new features and most importantly first class support for Silverlight record/playback automation.

Download WebAii 2.0 / Design Canvas 2.0 from here.

We are also conducting a joined (free) webinar with Telerik today Dec 10th @ 11:00AM-12:00PM EST, to introduce the new features in Design Canvas 2.0. We will also be giving out a free license to one of the attendees. So sign-up today!

To get familiar with Design Canvas 2.0 new features, please check out our beta post here. Since the beta we have enhanced and added several features to help make recording and playback much more reliable. Some of the key enhancements since the beta:

�Silverlight Automation:

Custom Control Support: When DC2.0 detects a custom control on the surface, it now instead of showing the generic list of quick tasks for that control, it will automatically detect the base class that the control inherits from and show the quick tasks for that base control. So for example, if you have MyButton control that inherits from Button, we will automatically show the quick tasks for Button on the surface and codegen against Button instead of FrameworkElement. This is gives customers that have applications that heavily utilize custom controls a richer out-of-box experience.
Playback Reliability: On playback, our execution engine not only waits for an element to be visible, it also waits for the item to stop its animations (Wait.ForNoMotion) which is common in Silverlight as buttons and other UI widgets you are trying to automation fly-in, scroll up or expand (which drive testers crazy!). Further more, if the element is contained in ScrollViewer, we will automatically detected if the element is scrolled into view, and if not, scroll it. Only then, we perform the action.�
Smarter ScrollToVisible: This was something we enhanced as per the requirement of #2 above. The ScrollToVisible on FrameworkElement now can detect ScrollViewers and intelligently scroll the item within them to view - including scrolling the browser content if needed.�
New Sentence Editor UI: We skinned the sentence editor to match the new 3D View

Expanded property verification for Silverlight objects: You can now verify almost all public properties on your Silverlight control. We will be expand this support to include ALL properties including attached properties in the next update:

Better recording performance in the external browser: In beta the overlay surface was a bit sluggish when run against Silverlight applications. Now, it should be on par with the hosted browser.
Better support for multi-Silverlight app scenarios and app in frames. In beta, we had few issue when an application hosted several Silverlight application islands on the same page or when a Silverlight application was hosted in a sub frame. All these issues are now resolved.
SilverligthApp Connect timeout setting. You now can customize the connect timeout for your Silverlight application depending on its size and time it takes to load. The default settings should work for most applications but if the application take much longer to load then you utilize this settings to extend it.

LockOnSurface: From the DOM Explorer you can now target Silverlight elements and lock them on the browser surface and show the element menu for them. This feature is very useful when try to do validation against an element that is hard to highlight using the mouse on the surface.

�General Enhancements

Better text typing recording: In addition to enhanced typing recording, we now record other keys beyond alpha numeric keys.

�

jQuery selector syntax support: This was a customer feature request and we plan to blog more about it in the near future, but in case you are a jQuery junkie, you can now search the DOM similar to how you would do it in jQuery with a strongly-typed object model in WebAii. Here is a quick example (make sure to import the ArtOfTest.WebAii.jQuery namespace first):

�

WebAii's HTTP Proxy Request Cookie fixes. We no longer combines cookies into a single header line.
Download dialog handling support fixes�

�

Enjoy!

ArtOfTest, Inc.

�

Design Canvas 2.0 Beta Released!

ArtOfTest — Wed, 04 Nov 2009 15:07:00 GMT

We are happy to announce the availability of Design Canvas 2.0 Beta! Design Canvas 2.0 is a major update to our flagship Design Canvas product line and is packed with new features and updates.

Silverlight recording and playback is now fully supported in Design Canvas!!!

Design Canvas 2.0 Beta can be downloaded from here.

We are planning the final release the beginning of December this year. We really want to hear your feedback so we encourage you to share it at our Design Canvas 2.0 forum here.

Watch Getting Started Video here

What's New in 2.0?

As mentioned, Design Canvas is a major upgrade and contains tons of new features and enhancements. Let's start by talking about the biggest new feature in Design Canvas 2.0 which is support for Silverlight Automation.

Silverlight Automation:

We've spent over a� year studying and understanding the usage scenarios for Silverlight automation and the distinct challenges it poses. We tried to address many of these challenges in Design Canvas 2.0 and we know we still have many more that we are actively working on addressing before the final release in December. Here are some of the features that are worth mentioning when it comes to Silverlight automation:

Object Based Recording: All elements that are targets of a specific action/verification or wait operation are abstracted for you and organized under the proper Page/SilverlightApp in the Elements Explorer. Each action is performed against a target and the target has specific find logic that gets generated to be used on playback.

�

"On Spot" Silverlight Control Detection: Silverlight applications - especially real enterprise applications - have large, complex and deep visual trees. In fact, we found that some Silverlight applications have bigger visual trees than complex Ajax applications. For example, a simply HTML button can be represented as one tag in HTML <input type="submit" /> but in Silverlight a Button is made out of many mini controls like Paths/Rectangles/TextBlocks.etc. That by itself makes identifying the correct UI control to build validation against a bit more tedious and complex. Design Canvas 2.0 offers UI cues using what we call "fans" that allow you to visually identify what element you have under the mouse and what logical controls this element is part of in order or containment.

�

Integrated Visual Tree Explorer: The DOM Explorer can now show both your HTML page DOM and your Silverlight application Visual Tree. Furthermore, you can set the root of the DOM Explorer to be the Silverlight application if you do not care about the HTML portion of the page. That is probably the case for customers building 100% Silverlight LOB applications. The DOM Explorer is also hooked to the highlighting surface and vice-versa.

�

Built-in translators for all out-of-box Silverlight controls: We have custom translators built for all the built-in controls (common & complex) that Microsoft ships out of box for Silverlight development. The translators offer tailored recording experience for each control. We also have future plans (post 2.0) to support the Silverlight Control Toolkit that Microsoft ships too.

�

These are just a few of the main highlights of our Silverlight recording support.

NEW Interactive HIGHLIGHTING SURFACE

The new highlighting surface in Design Canvas 2.0 is designed to allow for a more intuitive and richer user experience right on top of the target application you testing.

- Drag elements directly from the page to locate in the DOM or add to the project elements:

- New simple and easy to use "Element Menu"

- Rich Drag & Drop recording experience:

New 3D Element View

Accessed through the verifications menu, this new feature allows users to dissect the DOM hierarchy and target a specific element using a new 3D visualizer. This feature is extremely important when building Silverlight or HTML automation in real-world applications that have complex DOM or Visual Trees. Furthermore, the UI allows you to build all sorts of verifications against the targeted element with just few clicks.

�

New Slick Storyboard

A new storyboard experience.The storyboard is also now hooked to the Test Explorer and vice-versa so you can visual identify each step easily.

�

And MUCH many more

Test Explorer Enhancements: Do/Undo/Copy/Paste/Record at a certain step.
Support for XUnit & MBUnit
New find logic editor to modify how elements are found.
New tasks: Clear Cookies , WaitForUrl for redirects and Inspection Points.
Set a BaseUrl for your entire project.
Control Translators for all of Telerik's Silverlight RadControls.

Telerik also released their WebUI Test Studio (Beta) as part of their Q3 release which is based on our Design Canvas 2.0 Beta.

Enjoy and do let us know what you think!!!

ArtOfTest

CI with WebAii for Silverlight

ArtOfTest — Wed, 21 Oct 2009 04:46:00 GMT

Continuous integration is a topic of great interest to many.. I wanted to point everyone to a code library project that one of Telerik's customers has posted on their Code Library.�

The project shows how to integrate WebAii for Silverlight testing with NUnit + CruiseControl.NET

Check out the full blog post here:

We also have full documentation on how to use WebAii with different integration servers on our documentation site.

�Overview of WebAii with Continuous Integration.

�WebAii + TFS Server Builds

�WebAii + CruiseControl.NET

�WebAii + TeamCity

�

Hope that helps.

Updated WebAii 2.0 Beta Released

ArtOfTest — Tue, 06 Oct 2009 03:05:00 GMT

We are making available a new update for the WebAii 2.0 Beta. This Beta is version 2.0.4. This should be the last beta release of the WebAii 2.0 framework. The next release should be the final release! Expect the final release sometime in November this year.

Download WebAii 2.0 Beta (2.0.4) from here.

Many customers have already moved to the WebAii 2.0 release and the feedback has been tremendous. We know the 2.0 final release is going to be one of our best releases given the large amount of adoption and dogfooding in the community! This release contains over 300 fixes since 2.0.2. Some that are worth noting and that customers have run into:

TypeText reliability issues.
Added Custom control mappings collection and global override support.
New FrameworkElement.GetProperties() method returns a list of all public properties on the live FrameworkElement and their types.
Scan entire visual tree when UID not found at expected node. Fixes Drag & Drop cases. Add new ElementNotFound exception.
Fixed crash in Window.CutBitmap().
Added Support for Focus() on the HtmlControl + Keyboard support.
Added KeyBoard Processing Events.
Use UID for validating elements as we walk down the visual tree to act on an element. If UID does not match at any specific level, enumerate all the child nodes at that level looking for a match. Sometimes the path changes out from under us between the find and the operation.
Reset _isProxy when the real element is found and being created.
Fix setting cookie. Was creating cookies like Name=Name=Value.
Exposed WindowMoved event on the GenericWindow.
Expanded events fired from Generic window.
New HtmlControl.IsActiveElement property returns true if the HTML element has the keyboard focus.
Added Support for Attribute Exists/Missing.
Fix for testing using ASP.NET local development server on x64 machine.
Fixed issue when calling Wait.For() with a lambda expression as the assert condition
Fixed GetBitmap to truncate the rectangle rather than throw an exception.
Added Find.AllByCustom method.
Added new XMultiMgr setting. When set to true, we use the WebAii 1.1 connection method, which supports multiple processes doing testing.
Change how we wait for the SL extension to be loaded.
Fix launching IE-8 regression.

�

In addition to the WebAii 2.0 framework, we have been busy with Design Canvas 2.0 which is going to leverage all the Silverlight work we have done in framework to offer a rich Silverlight recording experience. In addition to Silverlight support, Design Canvas 2.0 is packed with rich features including a new automation overlay surface entirely built using WPF that offers an intuitive interface and rich interaction with the live page. Stay tuned for more details..

�

Telerik RadControl Test Wrappers

ArtOfTest — Mon, 06 Jul 2009 09:00:00 GMT

I'm happy to announce Telerik's Q2 2009 release now includes the WebAii Framework as part of their RadControls for AJAX and Silverlight bundles. The release is based on WebAii 2.0 Beta2 that was released last week.

In addition to the full WebAii Framework, this release also includes Telerik's RadControl test wrappers for both Ajax and Silverlight. Telerik used WebAii's framework architecture and extensibility model to build abstract test wrappers for all their controls that ship in the box. The wrappers give customers a rich and powerful object model to work with for their controls so they don't have to worry about internal specifics of how the control works. The wrappers also ensure backward compatibility for UI tests built against websites using RadControls. So if you use Telerik RadControls, you can now simply use these wrappers in addition to the full power of WebAii to code your unit UI tests easily!

Check out this video that demonstrates some of the richness of WebAii and Telerik's RadControl Test Wrappers.

This product is another result of the technology partnership that Telerik has with ArtOfTest! Enjoy..

WebAii 2.0 Beta2 Released!

ArtOfTest — Mon, 29 Jun 2009 11:18:00 GMT

We are happy to announce the release of the highly anticipated WebAii Beta2 to the public. Beta2 contains lots of enhancements in terms of bug fixes and feature requests. Beta2 also contains some of the refactoring work that we have been working on for a while now. If you have not used WebAii 2.0 yet, check out the general feature set it contains here.

DOWNLOAD BETA2

(Make sure to uninstall beta1 before installing beta2)

As for Beta2, here are some of the highlights that are worth noting:

1. Silverlight Automation: We have spent a substantial amount of time to enhance and fix any issues reported by customers on the forums to make Silverlight automation experience as rich and seamless as possible including support for Silverlight 3. Here are some of the key advancements in Beta2:

No Proxy needed in IE: When running Silverlight automation in Internet Explorer, we no longer require the HttpProxy to be set. So, no more issues with LocalHost, WCF web services or streaming media. Silverlight automation in IE should be seamless. You though still need the EnableSilverlight flag to be set in the settings. We are working on getting rid of this dependency for Firefox too. This enhancement should resolve many of the http proxy related issues that customers reported.

Performance Enhancements: For complex automation and complex visual tree searches, you should see a considerable performance boost.
InvokeMethod Support: You can now invoke methods on Silverlight controls in addition to accessing their complex properties. For example:
 1: // Invoke the ScrollToVerticalOffset method
 2: searchScroll.InvokeMethod("ScrollToVerticalOffset",2000);
Wait.For Support: All FrameworkElement objects, now have a generic Wait.For that can take a predicate. This is a key piece in making test automation easier to synchronize with Silverlight animations. For example, you can wait on a Transform to finish or reach a certain point:
 1: // The Grid uses a TranslateTransform to hide/show the top bit
 2: app.FindName<Grid>("navBarGrid").Wait.For(
 3:     r => (r.RenderTransform as TranslateTransform).Y == -50);
We also added a Wait.ForNoMotion() call on the FrameworkElement that uses the element's position and waits until that element has stopped moving or resizing.

Find.ByType<T>(): Added the Find.ByType<T>() which allows you to find the first occurrence of a specific type

Silverlight 3 Support. In case you already started using Silverlight 3!

Many other bug fixes: (Added AbsoluteSiblingTagIndex and AbsoluteTagIndex to FrameworkElement), IsChecked tri-state issue, Bitmap.UriSource access. Localization issue for GetRectangle().
If you are new to Silverlight automation in WebAii we encourage you to take a look at the following blog posts that should introduce you to it:

Introduction to Silverlight Automation using WebAii.

Automation Real World Silverlight Applications using WebAii.

WebAii Silverlight Automation In Action

Note: The above sample is now included in the QuickStart Samples that ship with the product.

2. Safari 4 Support: In addition to our existing Safari 3.x support on Windows, WebAii 2.0 Beta2 now supports Safari 4 on windows. We also worked on the Safari automation support to address the following issues:

Performance: Safari automation should be faster in Beta2 than in Beta1. We made several optimizations in the synchronization code.

Frames Issues: We no longer load the main page in our own frameset which means that we no longer mess with how a page's frameset is accessed within the application. There was at least one customer that reported issues with how their application accessed frames in Safari.

Reliability: We made few enhancements in how we wait for the browser to be ready which was causing random timeouts in Beta1.

WebAii running same test in IE, Firefox and Safari

�

3. MbUnit & XUnit Integration + Templates:� If you use MbUnit or xUnit as your unit testing framework,� we now have built-in templates that get installed for you to use. Right-Click, Add New Item and you should be able to pick from 4 installed templates (NUnit, VSUnit, MbUnit or XUnit). You now have no more excuses not to use WebAii :).

�

4. Browser Recycling: Although the ability to use the same browser instance across tests have been enabled in 1.1, we now made browser recycling very easy to setup within our templates. All the testing templates + our base test class have been updated for this. Using the latest templates you will notice an additional overload for the Initialize() method that takes in a boolean flag on whether you want recycling on or off. By default it is off. All you need to turn recycling on, is to set that flag to true, no more SharedManager Templates (We actually got rid of those templates).
 1: // Pass in 'true' to recycle the browser between test methods
 2: Initialize(false, this.TestContext.TestLogsDir, 
 3: new TestContextWriteLine(this.TestContext.WriteLine));

�

BREAKING CHANGES IN BETA2

With Beta2, we had to make few breaking changes as we refactored some of our namespaces. Here are the key breaking changes that customers might hit.

In addition to the ArtOfTest.WebAii.dll, you also now need to reference the ArtOfTest.Common.dll. Both dlls should be available in the Bin\ folder under ArtOfTest or from the Add-References / .NET tab
�BaseNUnitTestSharedManager & BaseVsUnitTestSharedManager base classes are gone. These classes are no longer needed. We are unifying our base classes into one single base class for all frameworks and scenarios. Simply replace these classes wit the new BaseTest class that exists under TestTemplates and make sure to use the new Initialize() method for browser recycling as described in #4 above. The templates associated with these two classes are also removed.
Wait.For() class has been refactored to simplify the overloads, leverage generics and make it consistent. No more ElementCondition or ControlCondition delegates are needed. The Wait.For<>() now can take a predicate or a function with two parameters. So you can pass in a control and other properties that you want to check or wait for. Example:

�

  1: Wait.For<HtmlTable>(   2:          table => table.BaseElement.GetAttributeValueOrEmpty("align") != string.Empty,   3:          myTableInstance,false, 5000); 

�

IN OTHER NEWS:

Keep an eye on our partners (Telerik) Q2 release. There is some exciting work done on top of WebAii framework that they are going to release sometime this week. For both their Silverlight and Ajax RadControls. Once they release, we will dedicate some blog posts to describe how you can achieve the level of productivity they have achieved for their RadControls for your own testing projects!

�

Also as a reminder, make sure to sign-up for the FREE�Webinar conducted by our consulting partners Falafel, Inc. The webinar will be using our latest WebAii 2.0 Beta2!

�

Thanks for all the feedback and support! Keep the feedback coming and let us know what you think of our Beta2 release!

ArtOfTest, Inc. Team.

Free Webinar July 1st

ArtOfTest — Tue, 26 May 2009 11:00:00 GMT

Our friends at Falafel, Inc. are conducting a new Webinar on July 1st. This time the Webinar is FREE!!

Click on this link to register today!

Topics for this Webinar include:

Browser Support
Test Regions
Silverlight automation
Ajax Testing
Best practices

�

These topics touch on areas of the product that we know customers are very interested in and we feel will be of great help to anyone doing test automation using WebAii or Design Canvas. Whether you are just starting or are an advanced user, this webinar will be of added value to you. We encourage everyone to attend! If you are interested, please sign-up soon before we run out of seats.

ArtOfTest Team

Automating Real World Silverlight Apps.

ArtOfTest — Thu, 14 May 2009 13:44:00 GMT

As promised I will dedicate this post to talk more about Silverlight automation using WebAii in more depth. To help illustrate the power of WebAii, I decided to pick a real world application rather than a "Hello World"/"Calculator" type of application. This will hopefully make this post more relevant to what testers might face as more application developers adopt Silverlight.

The application I chose is a Health Care application built by Microsoft's Health Common User Interface (CUI). The application is live and can be viewed here. The application shows off the capabilities of Silverlight and gives us a glimpse into what we might expect from the next generation of web applications built using Silverlight.�

Let's start by dissecting some aspects of that application that a tester might be interested in testing. I will then demonstrate how some of these areas can be automated using WebAii.

As a tester I might be interested in testing the following areas of the application:

Note: I picked these areas for the purpose of this post. It does not mean only these areas need to be tested for such an application. The goal for this post is to demonstrate WebAii's capabilities rather than actually fully testing this application.�

1. Test the Guidance UI. [Show/Hide Guidance] and validate its data:

2. Validate the search functionality of the application

3. Test the data zoom-in/zoom-out of the search results

UI manipulation/positioning which will include:

4. Scrolling - Manipulate ScrollViewers and querying scroll positions.

5. Drag/Drop of UI elements and re-positioning them + validation.

6. Sync tests with UI elements in motion.

Now that we have a better idea of what we plan to test, let's build some automation.

�Note: If you are new to WebAii's Silverlight automation, I encourage you to read our last blog post which introduces you to it using a simple application.

Also, some of the feature we are using are not in the current 2.0 beta. We plan to publish a Beta2 for 2.0 soon which will include everything we will show in this post.

Initialization

All our tests need to do the same initialization: Launch a browser, navigate to the page and initialize an instance of SilverlightApp object.

  1: // Launch browser   2: Manager.LaunchNewBrowser(BrowserType.InternetExplorer);   3:�    4: // Navigate to our app   5: ActiveBrowser.NavigateTo("http://www.mscui.net/PatientJourneyDemonstrator/PrimaryCareAdmin.htm");   6:�    7: // Get an instance of the running Silverlight Application.   8: SilverlightApp app = ActiveBrowser.SilverlightApps()[0]; 

Task #1: Validate that clicking on the "Show Guide" button shows the guide and validate that it shows 15 guidance tooltips. Click the button again, and validate that it hides the guide.

  1: //   2: // Verify Show/Hide of the Guide works   3: //   4:�    5: // Click the ShowGuide button.   6: app.FindName("guideButton").User.Click();   7:�    8: //   9: // Wait for the guidance to be fully visible.   10: //   11: // In this application they use the Opacity of the   12: // "GuidanceCanvas" to show/hide the guidance.   13: Canvas guidanceCanvas = app.FindName<Canvas>("GuidanceCanvas");   14: guidanceCanvas.Wait.For(canvas => canvas.Opacity == 1);   15:�    16: guidanceCanvas.Refresh();   17:�    18: // Make sure we got the correct # of guidance popups   19: // The application pops 15 overlays on top   20: IList<FrameworkElement> guidanceOverlays = guidanceCanvas.Find.AllByType("GuidanceOverlay");   21: Assert.IsTrue(guidanceOverlays.Count == 15);   22:�    23: // Now hide the guidance   24: app.FindName("guideButton").User.Click();   25: guidanceCanvas.Wait.For(canvas => canvas.Opacity == 0); 

Notes:

Line #14: The Framework.Wait.For() is a great utility that allows you to wait on any property on the FrameworkElement object.
Line #20: Scoped searches. Every FrameworkElement, has a Find object associated with it an is scope to only search within that element's children in the Visual Tree. This can help you avoid any name conflicts (Which is very common in these rich applications) and makes your test automation much less prone to breaking and much easier to debug for failures.
Line #21, you can perform more verification for each popup in the guidanceOverlays list. You can verify the text, size or any other information.

Task #2:� Perform a search to test the search functionality. Input text in the search box, validate the number of search results you expect.�

  1: //   2: // Let's test the search functionality   3: //    4:�    5: app.VisualTree.Refresh();   6:�    7: // Find the Patient Search TextBox   8: TextBox searchText = app.FindName<TextBox>("searchText");   9:�    10: // Move the mouse over the search box until we have an IBeam.   11: searchText.User.DetectHotSpot(100, System.Windows.Forms.Cursors.IBeam);   12:�    13: // Make sure the navigation bar is hidden before trying to type.   14: // Currently it hides half the text box.    15:�    16: // The Grid uses a TranslateTransform to hide/shotthe top bit   17: app.FindName<Grid>("navBarGrid").Wait.For(   18:     r => (r.RenderTransform as TranslateTransform).Y == -50);   19:�    20: // Now we can start typing.   21: searchText.User.TypeText("A", 100); 

Notes:

Line #11: Not how we are able to move the mouse to the location exactly just like they user. The DetectHotSpot function allows you to search a certain radius from the center point of the FrameworkElement in a spiral motion until a certain hot spot is detected. A hot spot is detected when the mouse cursor changes from its current state or when the defined state by the function is detected. In this case we want to detect the IBeam cursor for the TextBox. Other application for this could be a certain resize handle for a window or a dynamic Thumb that you want to lock on and you can't easily find using absolute or even relative X/Y coordinates.
Line #17: This is very powerful. Given that we have access to even complex properties of the FrameworkElement, we are able to perform wait on things like RenderTransform objects. In this case we are waiting for the "TranslateTransform" for this element to move -50 in Y direction. This is very important when trying to sync your tests with certain animation points of the application.

Now that we have typed "A" in the search box. Let's validate the list of search results:

  1: ///   2: /// Validate the search results.   3: ///   4:�    5: // Get the search lists.    6: ItemsControl searchList = app.FindName<ItemsControl>("patientSearchList");   7:�    8: // Get the number of results in the search.    9: //    10: // OBSERVER: WebAii can search custom types too not available   11: // in ArtOfTest.WebAii.Silverlight.UI namespace. All the Find.xx methods have a non-generic   12: // overload too that takes in a control type name.   13: //   14: IList<FrameworkElement> foundPatients =    15:     searchList.Find.AllByType("patientsearchitem").Where(   16:     fx => fx.Visibility == Visibility.Visible).ToList();   17:�    18: // Validate the search   19: Assert.IsTrue(foundPatients.Count == 95); 

�Notes:

Line #14. The health care application we are using utilizes some custom controls not defined in our Silverlight.UI namespace. All our Find.By/Find.AllBy routines have a none generic companion method for every generic method which allows users to also perform searches against certain control types. In this case, we are searching for the "patientsearchitem" control.
Line #19: Again, you can look through each item in the "foundPatients" list and validate more data about each found patient. We will actually demonstrate some of how to do that in our next part.

Task #3: With the search results open, validate that details zoom-in/zoom-out shows more/less data about each patient.�

  1: ///   2: /// Verify the zoom in/zoom out functionality.   3: ///   4: FrameworkElement zoomBox = app.FindName("zoomBox");   5:�    6: // Inside of it, find the plus part   7: Button plusButton = zoomBox.Find.ByName<Button>("~PlusButton");   8:�    9: // Let's grab one of the patients to verify the zoom functionality on.   10: FrameworkElement patientSearchItem = foundPatients.First();   11: FrameworkElement patientAddress = patientSearchItem.Find.ByName("Address");   12: FrameworkElement patientContactIcons = patientSearchItem.Find.ByName("ContactDetailsIcons");   13: FrameworkElement patientAdditionalInfo = patientSearchItem.Find.ByName("ContactDetailsIcons");   14:�    15:�    16: // Level 0 - Address & ContactDetails are not visible   17: Assert.IsTrue(patientAddress.Visibility == Visibility.Collapsed);   18: Assert.IsTrue(patientContactIcons.Visibility == Visibility.Collapsed);   19: Assert.IsTrue(patientAdditionalInfo.Visibility == Visibility.Collapsed);   20:�    21: // Zoom level #1   22: plusButton.User.Click();   23:�    24: // Level 0 - Address & ContactDetails is visible. Additional info is not visible.   25: Assert.IsTrue(patientAddress.Visibility == Visibility.Visible);   26: Assert.IsTrue(patientContactIcons.Visibility == Visibility.Visible);   27: Assert.IsTrue(patientAdditionalInfo.Visibility == Visibility.Collapsed);   28:�    29: // Zoom level #2   30: plusButton.User.Click();   31:�    32: // Level 0 - Address + additional info is visible only.   33: Assert.IsTrue(patientAddress.Visibility == Visibility.Visible);   34: Assert.IsTrue(patientContactIcons.Visibility == Visibility.Collapsed);   35: Assert.IsTrue(patientAdditionalInfo.Visibility == Visibility.Visible); 

Notes:�

In this scenario here we opted to simply use FrameworkElement and not any strongly typed object since most of our validations are against the Visibility property which is on the base FrameworkElement.

Task #4. Scroll a certain container and validate the scroll position.

  1: //   2: // Scroll the search results   3: //   4:�    5: // Find the scroll viewer   6: ScrollViewer searchScroll = app.FindName("patientSearchScroller").Find.ByType<ScrollViewer>();   7:�    8: AutomationMethod scrollVert = new AutomationMethod("ScrollToVerticalOffset", null);   9: searchScroll.Invoke(scrollVert, 2000);   10:�    11: // Assert scrolling position.   12: Assert.IsTrue(searchScroll.VerticalOffset == 2000);   13:�    14: //   15: // Close search results   16: //   17: app.FindName("clearSearch").User.Click(); 

Notes:

This scenario is more to demonstrate how you can manipulate scrolling/scrollviewers with WebAii.

Line #8: Note how we are able to invoke any method + params on any object. If you have custom control, you can easily use this methodology to invoke any method on them you might have defined.

Task #5: Perform UI element drag/drop and validate the correct positioning after the moves.

  1: //   2: // Re-arrange admins UI   3: //   4: Grid adminsPanels = app.FindName<Grid>("adminPanels");   5:�    6: IList<FrameworkElement> admins = adminsPanels.Find.AllByName("~adminDockPanel");   7:�    8: FrameworkElement admin1 = admins.Where(adm => adm.Name.Equals("adminDockPanel1")).First();   9: FrameworkElement admin2 = admins.Where(adm => adm.Name.Equals("adminDockPanel2")).First();   10: FrameworkElement admin3 = admins.Where(adm => adm.Name.Equals("adminDockPanel3")).First();   11:�    12: // Get locations before the move   13: System.Drawing.Rectangle admin1Loc = admin1.GetScreenRectangle();   14: System.Drawing.Rectangle admin2Loc = admin2.GetScreenRectangle();   15: System.Drawing.Rectangle admin3Loc = admin3.GetScreenRectangle();   16:�    17: // Now perform the drag/drop   18: admin1.Find.ByType("Thumb").User.DragTo(admin2.Find.ByType("Thumb"));   19: admin2.Find.ByType("Thumb").User.DragTo(admin3.Find.ByType("Thumb"));   20:�    21: // Validate the new locations.   22: adminsPanels.Refresh();   23: adminsPanels.Find.ByName(admin1.Name).GetScreenRectangle().Equals(admin1Loc); 

Notes:

Line #18: We basically find the "Thumb" object inside the admin1 UI and move it to the center point in the admin2 UI. the User.DragTo() method by default will calculate the center point of the FrameworkElement it is on and perform a drag and drop to the center point of the FrameworkElement passed in. DragTo also supports other overloads that can be used to do offset dropping.

Task #6: Perform a UI action that triggers some animation and wait until the animation is complete

We kind of touched on this in Task #2 where we used the Framework.Wait.For() to wait on a certain property of the element including its RenderTransform but I wanted to also demonstrate another feature that customers can use to detect when animation is complete.

  1: //   2: // Expand Admin1 information   3: //   4:�    5: admin1.Find.ByName("maximiseButton").User.Click();   6: admin1.Wait.ForNoMotion(100); // Wait until the animation is complete. 

Notes:

Line #6 : Some customers might find this useful. The Wait.ForNoMotion() allows you to wait until a certain framework element is fixed. Meaning its location within the application is no longer changing. You can customize the period to use to deem a certain element if done moving. This function is very handy when you are trying to sync your test with a certain animation if you don't want to mess with RenderTransforms.

That's about it. I do hope this example was useful in helping you perform some of the automation tasks that you might be faced with in Silverlight.

If there are specific topics you would like to see covered in future blog posts, feel free to email us at contact _at_ artoftest.com or write us a tweet at http://twitter.com/artoftest.

Here is a recorded demo of this test in action. We will post the code of this test as part of the release of WebAii Beta2.

Enjoy

ArtOfTest, Inc.

Intro to Silverlight Automation

ArtOfTest — Mon, 11 May 2009 12:00:00 GMT

Silverlight automation has been our main focus since the release of Automation Design Canvas 1.1 earlier this year. Lots of customers ask us when Design Canvas will support Silverlight recording and I want to assure everyone that we are actively working on it. It is our #1 priority here at ArtOfTest. We do hope to preview our recording for Silverlight (which I'm sure is going to impress many) soon. Silverlight recording will be part of Automation Design Canvas 2.0 when its released.

As for this blog post, I'm going to dedicate it to talk more about WebAii 2.0 framework and its impressive support for automating Silverlight applications. WebAii 2.0 is going to be the framework on top of which Automation Design Canvas 2.0 and Silverlight recording/execution will be built.

In this post, I would like to discuss the following:

Why WebAii 2.0 sticks out as the clear choice when looking for Silverlight automation solutions.
Go over a simple example that is geared towards users that are new or just getting started.

Next post I will go over:

Talk a bit about some of the rich and advanced features for Silverlight automation in WebAii 2.0.
Demonstrate a more complex automation scenario that shows-off some of these advanced capabilities.

So, let's get started....

Why choose WebAii for Silverlight automation?

Well, there are tons of reasons why. I'm going to try to summarize them in the following points.

WebAii plugs-in directly into Silverlight applications it automates. It has access to every single element/object in the entire Silverlight application. This allows us to expose a rich feature set with very little limitations.
WebAii is NOT limited to what UIAutomation interfaces expose on each object. Beside the ability to perform basic automation actions like clicking, moving and setting text, WebAii gives you access to all properties including complex properties on UI elements such as brushes, borders and even transform matrices..etc. It allows you to get and set most of these properties which is very critical when it comes to test verifications and test synchronizations. For example, you can wait until a certain animation in Silverlight has changed a certain brush to a certain color.
WebAii has a complete UI object model under ArtOfTest.WebAii.Silverlight.UI namespace that mimics the complete list of UI XAML elements that Silverlight ships with including the extended controls that ship with Silverlight. This allows you to access everything in your application as if you are sitting inside the Silverlight application and using the same object model.
WebAii comes with an extensibility model that allows you to extend its current support. You want to access a custom property on a custom control? No problem, with few lines of code, you can achieve that. The best part�is that the application being tested (the production application) does not need to be touched at all. There are no extra UIAutomation interfaces to implement or objects to add. Less code churn is always a good thing especially�for production applications.
A one stop shop for everything Web. WebAii 2.0 includes rich support for Html/Ajax automation along side Silverlight automation: One framework and�one�consistent API that�allows you to automate all your web application needs regardless of the technology you are using!
WebAii enables real user simulation with the User.<action> methods in addition to direct API access. These methods move the mouse just like the user, type just like the user and even offer hotspot detection just like a user would do. This real user simulation is critical when rich UI scenarios are needed for automation like hover overs, drags..etc.

�

Getting Started with a simple example

First, make sure to download and install WebAii 2.0 Beta from our website here: http://www.artoftest.com/products/downloads.aspx. If you already have WebAii 1.1 or Automation Design Canvas 1.1 on your machine, no worries. WebAii 2.0 runs Side by Side with 1.1. There is only one known issue currently using Firefox. You need to disable the 1.1 extension in Firefox's add-on dialog (Tools->Add-ons) to allow the 2.0 extension to work. You can later on re-enable it when you want to switch back to 1.1.

Now that you have the framework installed, you will notice that it comes with a sample VS Solution that contains several samples that demos the 2.0 feature set including a Silverlight sample test. The installer should have placed a short-cut in your start menu. Click Start->All Programs->ArtOfTest Inc.->WebAii 2.0 Beta and then click on "Open WebAii 2." which should launch Visual Studio and load the sample solution.

The sample Silverlight test simply automates a simple application located here:

�

The test basically performs the following actions:

1. Launch the browser and�Navigate to the URL above.

2. Connect to the Silverlight application on that page.

3. Set the text in the textbox to: ArtOfTest.

4. Select a date.

5. Click the 'OK' button.

6. Validate the message "Hi ArtOfTest".

�So let's automate the above scenario using WebAii.

1. Launch a new browser instance and navigate to the URL above. This is basic WebAii stuff.

  1: // Launch a new browser instance.   2: Manager.LaunchNewBrowser();   3:�    4: // Navigate to the page.   5: ActiveBrowser.NavigateTo("http://www.artoftest.com/samples/SampleApplication.html"); 

2.� Connect to the Silverlight application on the page.

  1: SilverlightApp app = ActiveBrowser.SilverlightApps()[0];   2: Assert.IsNotNull(app); 

Few things to note here:

a. As soon as you include the ArtOfTest.WebAii.Silverlight namespace. An extension method "SilverlightApps" is added to the Browser object. This method allows you to access all Silverlight applications on the page.

b. WebAii allows you to access and automate any of your Silverlight apps/islands that are on your page simultaneously.

c. The accessor on the SilverlightApps collection method, internally calls SilverlightApp.Connect which basically activates a connection between that SilverlightApp instance and the live instance in your browser.

At this point we have access to all of the UI element in the Silverlight application.

3. Set the text for the Name to ArtOfTest.

  1: TextBox name1 = app.Find.ByName<TextBox>("name1");   2: Assert.IsNotNull(name1);   3: name1.Text = "ArtOfTest"; 

As you can see, this is where the power of WebAii starts to show. You will notice that there is a "Find" object� on the app that supports all the common ways customers might want to find an element inside the Silverlight application. In this case we are using the Find.ByName. Other supported search routines include: Find.ByText, Find.ByAutomationId, Find.ByType.

The object returned from the Find call is a strongly-typed TextBox object�that resembles the System.Windows.Controls.TextBox object in Silverlight. It contains a similar object model which enables you to manipulate it directly. For example, line three above sets the text to "ArtOfTest".

4. Select a date from the calendar.

You might think that this is going to be a pretty complex operation to implement. But it is not given the fact that WebAii supports all the native rich controls that come out of the box with Silverlight. Here is the code to select a date:

  1: Calendar cal1 = app.Find.ByName<Calendar>("cal1");   2: Assert.IsNotNull(cal1);   3: cal1.SelectedDate = DateTime.Now; 

That is it. Using the rich object model provided you are able to access a strongly-typed Calendar object and set the date on it. The code is concise, intuitive and easy to read.

5. Click the OK button.

Again, this is pretty simply.

  1: Button ok = app.Find.ByName<Button>("okButton");   2: Assert.IsNotNull(ok);   3: ok.User.Click(); 

Note, here the "User.Click()". When using any method off the User.xx class, you are really simulating real user interaction with the application. Inside that call, WebAii has determined exactly where the center of that button is on the screen, moved the mouse to it and clicked the button.

6. Now, let's validate that the button was clicked and that the text is exactly how we want it.

  1: TextBlock message1 = app.Find.ByName<TextBlock>("message1");   2: Assert.IsNotNull(message1);   3: Assert.IsTrue(message1.Text.StartsWith("Hi ArtOfTest")); 

Again, we are using the strongly typed objects of WebAii to help us easily craft and build test automation.

Summary

As you can see, lots of thought and innovation went into the design of Silverlight automation to make it as simple to use but also as rich as possible. What we discussed above is simply the tip of the iceberg. In the next blog, we will go over some of the more advanced scenarios in Silverlight that really show-off the power of the framework we have built! The best part of all this, It is FREE!!

Our preliminary documentation for WebAii 2.0 Beta can be found here, including its API Reference

ArtOfTest, Inc. Team.

First WebAii Webinar - May 21st

ArtOfTest — Wed, 22 Apr 2009 21:12:00 GMT

In parternship with Falafel Inc, we are excited to kick-off our first series of online webinars that target both our WebAii framework and Automation Design Canvas! The first webinar is scheduled for May 21st and will be an introduction to�the capabilities of both the framework and the automation design canvas.

To�sign-up please visit this link

Details:

TOPIC:�Introduction to Automation Design Canvas and WebAii

WHEN:�Thursday, May 21st,� 9:00 to 11:00 am PST

WHERE:�Anywhere with an internet connection.� You can use VOIP or phone line to listen in on the Webinar

AGENDA for the 2 hours is the following:

�

Introduction to ADC & WebAii
UI Overview
Browser Support and User Settings
DOM Explorer and Elements locations
Testing AJAX applications
Verification Builder
Testing with Code
Debugging WebAii in VS 2008
Recording Popups
TestCase Reuse
Finally the last 15 minutes will be open to Q&A.

�

Based on your feedback, we will plan the next set of webinar topics. If you have specific topics that you would like to see webinars built around, feel free to let us know by sending us�email directly at contact@artoftest.com.

Sign-up today!

WebAii 2.0 Beta Released!

ArtOfTest — Wed, 25 Mar 2009 18:12:08 GMT

WebAii 2.0 (Beta-v2.0.0.1) is ready for public consumption! Download it now from here.

Our 2.0 release is a big release. It contains tons of new features that we promised customers and have been working on for a while now. Our documentation for this release is being worked on as we speak.

Below is a break-down of all the main new features in 2.0!

1. Safari (Windows) Browser Support:

This is probably the feature that took the most effort to build but is the easiest to use. Simply set your "BrowserType" to Safari and your automation should execute against that browser. Make sure you have Safari installed though. That is Safari for Windows! You can also set that in your app.config file too.

You can easily test this feature out by taking one of your existing WebAii tests and simply switching the browser type to Safari. Who knows, you might find a new bug in your application ;)

Few things to keep in mind about our Safari support in this beta:

We require Silverlight 2.0 to be installed on the machine. You will find out why as soon as you run your first test :)
We currently do not support Html Pop-ups in Safari. That is something we are actively working on.
Safari 4 Beta is currently NOT supported.

2. Silverlight Automation Support:

This version of WebAii contains all the functionality that we previewed in our Silverlight Extension CTPs here. If you are not familiar with our Silverlight support in WebAii, please take a look at our support overview discussed here.

In 2.0 we attempted to fix all reported bugs against the CTPs. We believe we have a solid platform for testing Silverlight applications and we will continue to invest in making it richer and simpler.

Here are some of the highlights of what we added/fixed since our last CTP:

Performance Enhancements: Navigating the VisualTree is x100 faster now than the CTP.

Expanded Control Support. All controls under System.Windows.Controls.Data & System.Windows.Controls are now available.

Coordinates. There were minor bugs in how we calculate coordinates that we fixed.

Highlight On/Off Support: You can turn highlighting on/off for a specific element.

Support for Find.ByAutomationId: Although WebAii does not rely on UIAutomation, we know several customers have already invested in adding UIAutomation Ids to their UI components. It was easy for us to simply enable that as a mechanism for finding UI elements in the Visual Tree. So no effort wasted.

ScrollToVisible: You now have the ability to scroll a specific visual element into visibility.

For example:
 1: HyperlinkButton link = app.Find.ByName<HyperlinkButton>("link1");
 2: // Scroll the element to be visible within the browser
 3: // area
 4: link.ScrollToVisible();
 5: // Or
 6: link.ScrollToVisible(ScrollToVisibleType.ElementBottomAtWindowBottom);
 7: // Or 
 8: link.ScrollToVisible(ScrollToVisibleType.ElementTopAtWindowTop);

3. Enhanced Debugging Support:

In previous WebAii versions, when you are broken in a debugger and you try to inspect an HtmlControl or a FrameworkElement object using the hover-over debugger tooltip, many times you ended up with timeouts in the debugger view. This issue should be fixed. You now can inspect all properties and even change them live in the debugger. It is actually pretty cool seeing the browser react to your debugger changes. Try it out with a TextBox!

4. Built-In HTTP Proxy:

In WebAii 2.0, you will notice a new Manager.Http namespace. Under that namespace, you will find the following methods:

�

You now have the ability to intercept raw http traffic under the cover. You can intercept an Http request before it is issued by the browser or intercept http responses before they are rendered by the browser.

This functionality will open up WebAii to be used in a wider range of automation scenarios like:

Security Testing: In your listener you have access to all the basic Http Request/Response properties and you can inject, alter or do whatever you want with them.

Performance Testing: You can use the http listeners to look at file sizes you are sending or receiving and even build regression unit tests that make sure your files don't grow beyond a certain size!

Page Synchronization: You can now sync your test to specific requests and have the ability to detect Ajax requests over the wire. We plan to add more easy OM for this similar to out Wait.Forxxx syntax.

Note: Make sure the Settings.UseHttpProxy is set to 'true' to allow this feature to function. This feature is off by default.

Here are some code samples that leverage the HttpProxy:

The following code shows how to inspect response types:
 1: [TestMethod]
 2: public void ImageDetection()
 3: {
 4:     Manager.LaunchNewBrowser(BrowserType.InternetExplorer);
 5:     ResponseListenerInfo li = new ResponseListenerInfo(CheckTypeForImage);
 6:     Manager.Http.AddBeforeResponseListener(li);
 7:     ActiveBrowser.NavigateTo("http://news.google.com/");
 8:     Manager.Http.RemoveBeforeResponseListener(li);
 9: }
 10:� 
 11: private void CheckTypeForImage(object sender, HttpResponseEventArgs e)
 12: {
 13:     Log.WriteLine(String.Format("Request for {0}", e.Response.Request.RequestUri));
 14: if (e.Response.IsImage)
 15:     {
 16:         Log.WriteLine(String.Format("Image detected; MIME type: {0}",
 17:             e.Response.Headers["Content-Type"]));
 18:     }
 19: else
 20:     {
 21:         Log.WriteLine(String.Format("Not an image; MIME type: {0}",
 22:             e.Response.Headers["Content-Type"]));
 23:     }
 24: }

You can also validate response sizes:

  1: [TestMethod]  2: public void CheckImageSize()  3: {  4:     ResponseListenerInfo li = new ResponseListenerInfo(Check);  5:     Manager.Http.AddBeforeResponseListener(li);  6:     Manager.LaunchNewBrowser();  7:     ActiveBrowser.NavigateTo("http://my.homepage.com/");  8:     Assert.IsFalse(_imageTooLarge, "Some images in page >40k");  9: }  10:�   11: private volatile bool _imageTooLarge = false;  12: private void Check(object sender, HttpResponseEventArgs e)  13: {  14: if (e.Response.IsImage && Int32.Parse(e.Response.Headers["Content-Length"]) > 40000)  15:     {  16:         _imageTooLarge = true;  17:     }  18: } 

5. Enhanced JavaScript Support:

There are some key scenarios here that we wanted to enable given the nature of today's rich web applications that rely heavily on JavaScript. Below is a break-down of these features.

Make sure to include the ArtOfTest.WebAii.JavaScript namespace in your test first before trying these out.

1.Support for "eventArgs" for InvokeEvent: We had several customers request this. Now in addition to simply invoking an event with empty arguments, you can also include an event arg. We encapsulated all of that in one object called "ScriptEvent" and can be used with the InvokeEvent method. For example:
 1: public void MouseEvents()
 2: {
 3:     HtmlDiv target = Find.ById<HtmlDiv>("div1");
 4: 
 5: // middle-click on the div
 6:     MouseEvent arg1 = new MouseEvent("click");
 7:     arg1.Button = MouseButton.Middle;
 8:     target.InvokeEvent(arg1);
 9: }
2. Event Notification: You can now attach to javascript events on your page from your .NET code and have these events trigger an event handler in your test code. Here is an example:
 1: private volatile bool _clickHandled;
 2: private System.Threading.AutoResetEvent _clickARE;
 3:� 
 4: [TestMethod]
 5: public void ClickHandler()
 6: {
 7:     _clickARE = new System.Threading.AutoResetEvent(false);
 8:     _clickHandled = false;
 9:� 
 10:     HtmlButton b = Find.ById<HtmlButton>("b");
 11:� 
 12: // Attach a listener to the click event on the button.
 13:     b.AddEventListener("click", OnClick);
 14:� 
 15: // Invoke the event.
 16:     b.InvokeEvent(ScriptEventType.OnClick);
 17:� 
 18: // Wait until the event is fired.
 19:     _clickARE.WaitOne(500);
 20: 
 21:     Assert.IsTrue(_clickHandled);
 22: }
 23:� 
 24:� 
 25: private void OnClick(object sender, JavascriptEventArgs e)
 26: {
 27:     _clickHandled = true;
 28:     _clickARE.Set();
 29: }

�

3. Return JSON or Strongly-Typed objects from InvokeScript.Your tests can now understand JSON objects and can handle strongly typed objects returned from JavaScript. This might be a bit advanced for regular users but for customers building mini-frameworks on top of WebAii, it might be a great tool to get rid of having to parse back complex strings from InvokeScript. Here are a couple of samples on how to use this feature:

- Basic example using the built-in JsObject:
 1: [TestMethod]
 2: public void KeyValuePairs()
 3: {
 4:     Manager.LaunchNewBrowser();
 5: 
 6: // We are using a dummy call here. The call can be to any JS method on your page
 7:     JsonObject o = ActiveBrowser.Actions.InvokeScript<JsonObject>(
 8: "({key1:'value1', key2:'value2'})");
 9:� 
 10:     Assert.AreEqual<string>("value1", o["root"]["key1"]);
 11:     Assert.AreEqual<string>("value2", o["root"]["key2"]);
 12: }

- Or you can define your own object:

  1: [DataContract]  2: public class MyObject  3: {  4:     [DataMember(Name = "one")]  5: public int One { get; set; }  6:     [DataMember(Name = "fifteen")]  7: public int Fifteen { get; set; }  8: }  9:�   10: [TestMethod]  11: public void ReturnObject()  12: {  13:     Manager.LaunchNewBrowser();  14:     MyObject o = Actions.InvokeScript<MyObject>("({one:1, fifteen:15})");  15:     Assert.AreEqual<int>(1, o.One);  16:     Assert.AreEqual<int>(15, o.Fifteen);  17: } 

�

6. Firefox Execution Performance.

You will no longer see the weird mangled URL in the address bar and start-up time for firefox execution is faster than 1.1.

7. Firefox 3.1B/3.5 Support.

In case you plan to upgrade soon.

8. Extra HtmlControls like HtmlOrderedList & HtmlUnOrderedList.

9. Side By Side Support with WebAii 1.1 and Automation Design Canvas 1.1.

WebAii 2.0 Beta should run side by side with any previous WebAii installations on the machine.

DOWNLOAD 2.0 BETA NOW

We do hope you enjoy the new feature set and we look forward to your feedback!

The ArtOfTest Team.

ArtOfTest forges a strategic alliance with Telerik, Inc.

ArtOfTest — Mon, 16 Feb 2009 11:02:00 GMT

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 StudioT announced today is the first tangible result of this alliance. Telerik's WebUI Test StudioT is an automated testing solution featuring the innovative ArtOfTest Automation Design CanvasT and WebAiiTAutomation Framework�and is�specifically tailored for Telerik RadControlsT 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 CanvasT 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 www.telerik.com.

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 www.artoftest.com.

WebAii Automation Design Canvas 1.1 Preview now available

ArtOfTest — Sun, 01 Feb 2009 08:00:00 GMT

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.

Thanks,

ArtOfTest, Inc. Team.

WebAii 2.0 - Automate more than you expect!

ArtOfTest — Sat, 10 Jan 2009 12:50:00 GMT

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:

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.
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
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.
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.

HAPPY NEW YEAR!