IT Really Matters

That’s why i always test in IE.

Wed, 16 May 2012 22:41:00 +0300

That’s why i always test in IE.

jQuery Deferred at HTML5 Meetup

Sun, 13 May 2012 20:06:19 +0300

I gave recently a short presentation about jQuery Deferred at HTML5 meetup. Here is the link to the presentation itself made with Prezi.

Hacker Says

Wed, 09 May 2012 00:55:00 +0300

Today is a special day, because Hacker Says - the micro-site created with the help of my friend Andri Möll - got released! Wohoo!

It has interesting, funny and important quotes which apply to software development, programming and life in general. And that all is available for viewing in three different themes!

Here’s a preview of Hacker Says using Sepia theme:

Backend has been written in Ruby using Sinatra, Sass and Haml. Front-end uses JavaScript with HTML5 pushState. It is deployed to Heroku.

Have fun and put it on some large screen at your office for that extra daily entertainment!

Update #2 (2012.05.24)

Today we released an improved version of Hacker Says. We took all the feedback into account. Let us know what you think of it!

Update

These are statistics for the first two days:

Not bad at all. We got the feedback from the users to prepare for another launch with improvements. This is how MVP should be done!

Stupidity Of Usability

Tue, 17 Apr 2012 23:56:58 +0300

Usability is one of the most required features of any website or product. If there’s no usability then there’s no product. In this short post i’m showing lack of usability on one of the most popular websites. I’m not gonna mention which website i’m talking about - i’m pretty sure that you won’t figure it out yourself either ;)

Let’s Start!

I have a conversation log and i wan’t to delete it. For this i will use the appropriate menu item under “Actions” (1 + 1 = 2 clicks):

Then i have to specify that i want to delete all the history (2 + 1 = 3 clicks):

Do i really mean it? Yes i do! (3 + 1 = 4 clicks)

Oops, what is that?

Of course it can’t be found because you just deleted it, doh! And i have to close that dialog too (4 + 1 = 5 clicks).

Conclusion

There you have it. There’s no way to make that process easier with less clicks than five and creating better user experience. Especially useful is that last error message. I don’t know what would i have done if that message hadn’t guided me through that painful process. Thank you very much! And of course good luck finding that “Action” menu item :)

This is how you delete a conversation from the gmail. Just click the recycle bin icon (1 click):

And you’re done:

Just one click! And you have this helpful message with even more helpful url to the help page if you’re still confused. And if you did delete that conversation by accident then just click on “Undo”.

Next time if you need to implement some new functionality then think twice before starting coding. Or thrice.

Would you accept that License Agreement?

Sat, 07 Apr 2012 02:19:18 +0300

Would you accept that License Agreement?

What if all these virtual constraints applied to real life too?

Thu, 22 Mar 2012 00:50:00 +0200

What if all these virtual constraints applied to real life too?

Real Life Photoshop

Sat, 04 Feb 2012 13:15:27 +0200

Real Life Photoshop

Browser Wars

Thu, 12 Jan 2012 18:33:59 +0200

Browser Wars

Today’s Marriage

Wed, 07 Dec 2011 17:00:06 +0200

Today’s Marriage

Harmless Checkin

Wed, 30 Nov 2011 17:02:05 +0200

Harmless Checkin

Freaky Wireless Technology

Wed, 23 Nov 2011 17:01:05 +0200

Freaky Wireless Technology

Speedup Ruby 1.9.3 On Windows

Thu, 17 Nov 2011 00:37:00 +0200

Ruby is a great programming language, but unfortunately it does have some problems when using on Windows. One of it’s biggest drawbacks is it’s slowness when loading files. This is also slower than it ought to be on Unix platforms, but not as slow as on Windows. Thankfully there is some work going on to make it faster in future versions. It’s already possible to make it faster yourself!

Benchmarks

I will conduct two types of benchmarks. Firstly i’m gonna create an empty Rails 3 project and see how much time would it boot up. Secondly there is a project called measurements which allows to perform some operations on your Ruby and one of these are benchmarks for loading files. Let’s see how it goes for Ruby 1.9.2, 1.9.3 from RubyInstaller and patched 1.9.3.

# ruby 1.9.2p136 C:\>rails new empty-192 -d sqlite3 # ... Using rails (3.1.1) C:\empty-192>timer ruby script\rails runner "" user system total real 0.000000 0.016000 0.016000 ( 28.808579) C:\measurements>rci bench core_require_empty && rci bench core_require_nested ruby 1.9.2p136 (2010-12-25) [i386-mingw32] Rehearsal ------------------------------------------------------ core_require_empty 2.917000 7.722000 10.639000 ( 10.755556) -------------------------------------------- total: 10.639000sec user system total real core_require_empty 3.167000 7.815000 10.982000 ( 11.133547) ruby 1.9.2p136 (2010-12-25) [i386-mingw32] Rehearsal ------------------------------------------------------- core_require_nested 3.556000 8.736000 12.292000 ( 12.453693) --------------------------------------------- total: 12.292000sec user system total real core_require_nested 3.526000 9.188000 12.714000 ( 13.157714) # ruby 1.9.3p0 from RubyInstaller C:\>rails new empty-193-p0 -d sqlite3 # ... Using rails (3.1.1) C:\empty-193-p0>timer ruby script\rails runner "" user system total real 0.000000 0.000000 0.000000 ( 17.425940) C:\measurements>rci bench core_require_empty && rci bench core_require_nested ruby 1.9.3p0 (2011-10-30) [i386-mingw32] Rehearsal ------------------------------------------------------ core_require_empty 3.120000 9.937000 13.057000 ( 13.278704) -------------------------------------------- total: 13.057000sec user system total real core_require_empty 3.167000 9.578000 12.745000 ( 13.231747) ruby 1.9.3p0 (2011-10-30) [i386-mingw32] Rehearsal ------------------------------------------------------- core_require_nested 3.822000 11.373000 15.195000 ( 15.853803) --------------------------------------------- total: 15.195000sec user system total real core_require_nested 3.822000 11.653000 15.475000 ( 16.779881) # Ruby 1.9.3p0 patched C:\>rails new empty-193-faster -d sqlite3 # ... Using rails (3.1.1) C:\empty-193-faster>timer ruby script\rails runner "" user system total real 0.000000 0.000000 0.000000 ( 9.184323) C:\measurements>rci bench core_require_empty && rci bench core_require_nested ruby 1.9.3p0 (2011-11-08 revision 33661) [i386-mingw32] Rehearsal ------------------------------------------------------ core_require_empty 2.620000 5.616000 8.236000 ( 9.144510) --------------------------------------------- total: 8.236000sec user system total real core_require_empty 2.247000 5.179000 7.426000 ( 7.930452) ruby 1.9.3p0 (2011-11-08 revision 33661) [i386-mingw32] Rehearsal ------------------------------------------------------- core_require_nested 2.496000 5.522000 8.018000 ( 8.123630) ---------------------------------------------- total: 8.018000sec user system total real core_require_nested 2.652000 5.960000 8.612000 ( 8.861500)

These benchmarks show that Ruby 1.9.2 is really slow and patched 1.9.3 got about 50% performance boost compared to regular 1.9.3. That’s something to be happy about! I’m using average laptop PC which means that if you have a more decent hardware then the results might be very different from me.

Prerequisites

The following components are needed to speedup your Ruby:

Ruby 1.9.3 from RubyInstaller
Devkit
Git

If you’d like to skip all that hassle of building all the things yourself then you can download already prebuilt patched Ruby versions too! Read the “Faster Way” part about that below.

Get Fenix

Fenix is a Ruby extension written by Luis Lavena. Luis is a really helpful and great guy, at least when it comes to Ruby on Windows. He is part of the Ruby core team, is the main man behind RubyInstaller and has created many nice libraries like sqlite3-ruby, rake-compiler and many others.

Back to Fenix. It changes File.expand_path method to be faster. All the 50% speedup seen from the benchmarks were coming from this change since this method is called more than once when loading files. Pretty impressive or rather sad bottleneck in Ruby. Get the Fenix extension, compile and benchmark it:

C:\>git clone git://github.com/luislavena/fenix.git Initialized empty Git repository in C:/fenix/.git/ # ... C:\>devkit\devkitvars.bat Adding the DevKit to PATH... C:\fenix>rake compile # ... install -c tmp/i386-mingw32/fenix/1.9.3/fenix.so lib/fenix.so C:\fenix>rake bench File.expand_path: 10000 times. user system total real Ruby '' 0.297000 0.593000 0.890000 ( 0.884027) Fenix '' 0.062000 0.000000 0.062000 ( 0.066004) Ruby '.' 0.312000 0.546000 0.858000 ( 0.876040) Fenix '.' 0.062000 0.000000 0.062000 ( 0.060000) Ruby 'foo', 'bar' 0.312000 0.983000 1.295000 ( 1.328060) Fenix 'foo', 'bar' 0.078000 0.000000 0.078000 ( 0.106003) Ruby '', 'C:/' 0.031000 0.000000 0.031000 ( 0.031000) Fenix '', 'C:/' 0.047000 0.000000 0.047000 ( 0.050000) Ruby 'foo', 'C:/' 0.171000 1.965000 2.136000 ( 2.248100) Fenix 'foo', 'C:/' 0.047000 0.000000 0.047000 ( 0.054003) Ruby '~' 0.530000 0.562000 1.092000 ( 1.111063) Fenix '~' 0.094000 0.000000 0.094000 ( 0.100006) Ruby '~/foo' 0.468000 0.827000 1.295000 ( 1.321076) Fenix '~/foo' 0.078000 0.000000 0.078000 ( 0.076005) Ruby 'foo/' 0.280000 0.624000 0.904000 ( 0.917052) Fenix 'foo/' 0.078000 0.000000 0.078000 ( 0.071004) Ruby '~', 'C:/Foo' 0.375000 0.717000 1.092000 ( 1.110063) Fenix '~', 'C:/Foo' 0.093000 0.000000 0.093000 ( 0.090005) Ruby long_path 0.203000 0.016000 0.219000 ( 0.214006) Fenix long_path 0.203000 0.000000 0.203000 ( 0.207005) Ruby long_path, 'rel' 0.421000 0.734000 1.155000 ( 1.237058) Fenix long_path, 'rel' 0.234000 0.000000 0.234000 ( 0.227013) Ruby long_path, 'C:/Foo' 0.375000 1.981000 2.356000 ( 2.470126) Fenix long_path, 'C:/Foo' 0.187000 0.000000 0.187000 ( 0.184010) Ruby full_long_path 0.156000 0.015000 0.171000 ( 0.170010) Fenix full_long_path 0.156000 0.000000 0.156000 ( 0.183011) Ruby to_path 0.234000 0.359000 0.593000 ( 0.619036) Fenix to_path 0.062000 0.000000 0.062000 ( 0.071004) Ruby to_path, 'rel' 0.468000 0.999000 1.467000 ( 1.455083) Fenix to_path, 'rel' 0.094000 0.000000 0.094000 ( 0.091006) Ruby to_path, 'C:/Foo' 0.390000 2.262000 2.652000 ( 2.844161) Fenix to_path, 'C:/Foo' 0.078000 0.000000 0.078000 ( 0.090005) Ruby full_to_path 0.390000 1.950000 2.340000 ( 2.526143) Fenix full_to_path 0.031000 0.000000 0.031000 ( 0.044003)

Not bad benchmark results.

Patching & Compiling Ruby

Unfortunately only File.expand_path method is faster when using this extension, but there’s Ruby’s require and load methods, which also execute expand_path, but they will do so by using internal C expand_path function instead. Solution for that problem is to patch Ruby code to use Fenix.expand_path internally also! First step would be to clone Ruby itself (make sure that line endings are not converted by Git):

Apply the patch created by Luis:

C:\ruby>git clone git://gist.github.com/1360449.git expand_path-patch C:\ruby>git apply -v expand_path-patch\0001-make-load-and-require-use-file-expand_path-and-file-realpath.diff Checking patch file.c... Checking patch load.c... Applied patch file.c cleanly. Applied patch load.c cleanly. C:\ruby>git status # On branch ruby_1_9_3 # Changed but not updated: # (use "git add ..." to update what will be committed) # (use "git checkout -- ..." to discard changes in working directory) # # modified: file.c # modified: load.c

`git status` shows us that file.c and load.c files are modified. It’s time to start compiling Ruby itself. Best way to do that would be to use RubyInstaller itself (how ironic, we’re using Ruby to build Ruby). Make sure to disable ANSICON too since it is known to cause problems during the compilation process:

This takes some time and if the process raises any errors, just try again. If there’s still errors don’t hesitate to write to RubyInstaller mailing list or contact Luis directly. He’s very helpful, as i already stated above.

After the process is done “install” new Ruby with Fenix and make sure that it’s used by setting environment variables too:

C:\rubyinstaller>xcopy /E /I sandbox\ruby19_mingw \ruby193-faster # ... C:\rubyinstaller>cd ..\fenix C:\fenix>xcopy /E /I lib \ruby193-faster\lib\ruby\1.9.1\i386-mingw32 lib\fenix.so lib\fenix\replace.rb 2 File(s) copied C:\fenix>set PATH=c:\ruby193-faster\bin;%PATH% C:\fenix>set RUBYOPT=-rfenix/replace

Make sure that the PATH and RUBYOPT environment variables are set permanently. And try it out if it’s faster for you too!

Faster Way

In case you don’t want to spend your time cloning, compiling and testing then there is a faster way to boost your Ruby. There exists a project called The Code Shop, which tries to solve the Ruby performance problem on Windows. It makes different builds available to download, each experimenting with different set of patches. I can recommend tcs-ruby193_require_winio_fenix-20111113 because it seems to be the fastest. Here are some benchmark results:

# tcs-ruby193_winio_fenix-20111113 C:\empty-193>timer ruby script\rails runner "" user system total real 0.000000 0.000000 0.000000 ( 6.802955) C:\measurements>rci bench core_require_empty && rci bench core_require_nested tcs-ruby 1.9.3p0 (2011-11-08) [i386-mingw32] Rehearsal ------------------------------------------------------ core_require_empty 2.044000 2.589000 4.633000 ( 4.726269) --------------------------------------------- total: 4.633000sec user system total real core_require_empty 1.778000 2.746000 4.524000 ( 4.652266) tcs-ruby 1.9.3p0 (2011-11-08) [i386-mingw32] Rehearsal ------------------------------------------------------- core_require_nested 2.075000 3.603000 5.678000 ( 5.779272) ---------------------------------------------- total: 5.678000sec user system total real core_require_nested 2.028000 3.526000 5.554000 ( 5.791128) # tcs-ruby193_require_winio_fenix-20111113 C:\empty-193>timer ruby script\rails runner "" user system total real 0.000000 0.000000 0.000000 ( 5.635120) C:\measurements>rci bench core_require_empty && rci bench core_require_nested tcs-ruby 1.9.3p0 (2011-11-08) [i386-mingw32] Rehearsal ------------------------------------------------------ core_require_empty 1.497000 2.948000 4.445000 ( 4.571255) --------------------------------------------- total: 4.445000sec user system total real core_require_empty 1.326000 3.151000 4.477000 ( 4.577208) tcs-ruby 1.9.3p0 (2011-11-08) [i386-mingw32] Rehearsal ------------------------------------------------------- core_require_nested 1.732000 3.650000 5.382000 ( 5.529468) ---------------------------------------------- total: 5.382000sec user system total real core_require_nested 1.716000 3.604000 5.320000 ( 5.437311)

Fenix is already precompiled into these builds. You still need to ~~compile and install Fenix and~~ set PATH and RUBYOPT environments as described above.

In Conclusion

The main point of this post is that things aren’t always as rosy as they could be, but it’s possible to make them better. It is really valuable that you give feedback to projects like The Code Shop (e.g. what are your benchmark results) so the final result could get better in the future without any additional hassle for everyone. I hope that you can now start your engines much faster!

An Update is Available for Your Computer

Wed, 09 Nov 2011 22:33:39 +0200

An Update is Available for Your Computer

Awesome Page Objects In Testing

Wed, 02 Nov 2011 17:41:00 +0200

I mentioned page objects in the post about WatirSplash 2. In this post i’m gonna explain what these things exactly are and how to use them.

What Is A Page?

When it comes to automated testing then the page is really nothing else than the page user sees when visiting the website. Any meaningful page consists of different components some of which just show information (e.g. text) others allow interaction (e.g. text fields and buttons). Different pages might also have some shared content like header, search field and footer. One important thing about components is that the result of some interactions is another page.

Let me bring you a concrete example. Let’s look at the Bing’s main page (enough of Google in all examples, alright). You can think of the possible sections (Web, Images, Videos, News and More) as a header. There is also the search field and button. Search button is special since clicking on it changes the current page to results page. Makes sense? Let’s see how to convert that information into WatirSplash Page Objects.

Point Of Having Page Objects

The point of having Page Objects is to have better structured code and keep it DRY in your tests too. This all makes your tests easier to maintain. If you’re a software developer then you care about these things when it comes to production code. Why not to use these good practices in tests also? Page Objects make it all possible. Having Page Objects means that it should be easier to change your tests if the application under test (AUT) changes since you need only one place (ideally) to change. Page Objects also make it very clear where to find existing and put the new code.

Let’s Get Rockin’ With Pages And Objects

Let’s get more concrete. I assume that you have created a WatirSplash 2 project already. If not then follow the instructions in the post about WatirSplash 2 or read everything you need to know straight from the README. Let’s create the Main page first:

C:\my_project\ui-test>watirsplash page main --url http://bing.com create lib create lib/app/page/main.rb exist spec create spec/app/page/main_spec.rb

This command created us the Main page object and a test for it. The generated file looks like this:

And the test itself is nothing fancy yet:

Let’s add something meaningful to our Main page object like search field and button:

You can use all the familiar Watir methods directly in your Page objects! For the sake of clarity let’s also add Header functionality. To do that we’d just use Ruby’s mixin functionality - the Header module:

And make sure to include it into your page object:

We can now update our main_spec to actually test something:

# spec/app/page/main_spec.rb describe App::Page::Main do let(:main_page) {App::Page::Main.new} it "has header with sections" do main_page.sections.should have(5).items end it "allows to search" do main_page.search_field.set "watirsplash jarmo" results_page = main_page.search_button.click results_page.results.count.should == 10 results_page.results[0].text.should =~ /watirsplash/i end end

I made two tests - one for the header and another for the search functionality. Since header should be on every page, i could have taken advantage of the RSpec’s Shared Examples feature, but for the sake of this post’s clarity i didn’t.

The second test is a failing test since there’s no way that Watir’s Button#click will return us a results page object. But hey, i’ve just done a little TDD here! Let’s make it work like we want it to work:

I’ve used the WatirSplash::Page::Base#modify method which takes some object as it’s first argument (here button) and a Hash as a second argument. Hash consists of method name as a key and value as Proc object. In this particular case the code above overrides this particular button’s #click method with my #click, which returns Results page object due to the usage of #redirect_to method. Since #click is already existing method on that button, then it will call the original method (e.g. performs the actual clicking) before calling the defined block. The #modify method does all that by using Ruby’s meta-programming. You can always look at the source itself if you’re more interested in the nitty-gritty details.

Let’s create ourselves a Results page object with the results method. This time, let’s be even cooler and generate more code than we did with the Main page object:

This generated us the Results class with the results method:

Let’s add the #count and #[] methods to our #results object by using #modify again so we could chain method invocations naturally as i’ve written in the search functionality test:

# lib/app/page/results.rb module App module Page class Results "wg0"), :count => lambda {results.lis(:class => "sa_wr").size}, :[] => lambda {|i| results.li(:class => "sa_wr", :index => i)} end end end end

I’m invoking the #results method again to get the Watir::Ul element to execute regular Watir methods on it - in these cases #li and #lis. This neat trick hides the implementation details from the tests and makes the tests even more natural to read.

In Conclusion

That’s it - we have created a few tests using Page Objects functionality in WatirSplash 2! Using Page Objects makes your tests (hopefully) more readable and easier to maintain. I like my implementation when compared to others because it makes your page objects to look really succinct and doesn’t add any additional complex API to learn - you can use already learnt Watir methods as you did before. And the code written to support creating and using these Page Objects is also quite clever and short. I love it! I hope you will too.

Solutions To The Hardest Problems

Tue, 18 Oct 2011 12:37:56 +0300

Solutions To The Hardest Problems

Angry Birds Anger Management

Sat, 08 Oct 2011 10:39:55 +0300

Angry Birds Anger Management

Facebook, Watir And Testing

Tue, 04 Oct 2011 00:19:19 +0300

I’ve known some time now that Facebook has been using Watir as their integration testing tool. Hell, there’s even a Facebook logo on the main page of watir.com. But today was a special day because i had to read one article about Facebook moving away from Watir.

Confusions

Since i’m one of the few core developers of Watir then this article made me notice statements which are not true or are just misleading. It seems to me that the author of that post doesn’t know the insights of Watir and other tools he’s mentioning or just uses wrong terminology by accident.

Watir & JavaScript

First statement which forced me to questioning myself was the following: “Watir automates the browser with JavaScript…”.

It took me some time before i understood that the author had FireWatir in his mind and not the Watir itself. FireWatir was used to automate Firefox browser and it truly used JavaScript as it’s engine to perform all the automations. Watir on the other hand controls Internet Explorer and uses it’s OLE interface instead to control the browser. This means in effect that there’s almost no JavaScript used in Watir.

Watir != Watir-WebDriver != WebDriver

The next statement causing confusion is: “The Watir we adopted in 2009 has since been improved, integrating a new protocol called WebDriver which allows you to automate the browser more accurately and with more power than could previously be done with straight JavaScript.”

First - Watir has been improved indeed when compared to year 2009 :) This is a good thing and a true statement. Second - Watir doesn’t integrate with the new protocol called WebDriver - it does still use OLE. I’m not exactly sure what the author means by the end of his statement about more accuracy and power. And of course - third - as mentioned already, Watir itself doesn’t use JavaScript and didn’t even do that in the year of 2009.

I think that you can call the WebDriver as a protocol, but the most famous implementation of that protocol is for sure Selenium-WebDriver aka Selenium 2. Watir-WebDriver is a library written on top of Selenium-WebDriver’s Ruby bindings. In other words it is an improved API over Selenium’s API. At least this is the way, we, Watir-loving people like to think. It does even have some API improvements which vanilla Watir doesn’t have yet. There is a project called WatirSpec, which is the specification for Watir’s API. Even Watir itself doesn’t conform to that yet. But the ultimate goal is to make Watir-WebDriver and Watir 100% compatible with each other. Latest releases of Watir have been moving towards that goal.

Abandoning Watir

And then i have to read the saddest statement of that article: “Once I understood all these factors, my course of action seemed clear: Abandon Watir, create a WebDriver client in PHP, and reuse our mature PHP unit test system for our browser tests. The WebDriver protocol was straightforward enough that I had a fully featured client in PHP by the end of a weekend’s work.”

On the one hand i’m happy that the engineers in the Facebook try to make things better - having the same technologies used between different projects is always a good thing. On the other hand i’m not sure i understand as to why they had to create a new PHP WebDriver bindings. Looking from the main page of Selenium 2 i can see that there’s already two seemingly active projects doing just that - php-webdriver-bindings and WebDriver-PHP. Maybe engineers at Facebook had good reasons why not to use something already existing. Maybe they just like to feel more challenged and want to invent few bicycles in a while. I don’t know.

Conclusion

After all it was an interesting read. Since i’ve used Watir about 4 years now then it’s nice to read that someone else had similar or completely different solutions to the same problems. I like the thing about Facebook that it tries to be more open to the world when it comes to the topics of the tools and processes used to make, maintain and release such a widely used product.

On the other hand, posts having false information in them tend to have a strong effect on people using the tools under fire. Especially if this kind of information is originating from a trustworthy source. From that post it seems that it is time to abandon Watir since it is too old and not developed anymore. That’s just plain wrong. Watir is still actively developed and one of the biggest reasons why not to abandon Watir at this moment is that it is still the best automation tool for Internet Explorer. Watir-WebDriver’s IE driver is just not mature enough. Sorry, WebDriver guys. I would be happy to run all my tests with Watir-WebDriver since that would give me an opportunity to test with different browsers, but as long as IE is not working properly, then i just can’t do that. Since IE is the brittlest and still most used browser, then testing with that browser just seems to be mandatory.

I have to agree that if the person is not tied with all or some of these projects on a daily basis then it is hard to understand the difference between Watir, Watir-WebDriver and WebDriver. Maybe the biggest problem is just that the topics aren’t documented enough?

Fighting Against Gem Hell

Tue, 06 Sep 2011 23:12:25 +0300

There is a term called DLL Hell which in my opinion exists also in the Ruby community with the different name - Gem Hell. This potential problem exists when dependencies for your project and/or libraries are not managed properly.

I’ve written in the post WatirSplash 2 about loading all the dependencies with the help of the Bundler, which helps to organize the dependencies in a sanely way and tries to eliminate the Gem Hell problem. In this post i’m gonna give a more detailed overview of how the things were before and how they are now in the WatirSplash framework.

Story Behind WatirSplash’ Dependencies

Since WatirSplash is a framework which supports using different frameworks for browser automation (Watir, Watir-WebDriver and FireWatir) then there needs to be some kind of a mechanism for defining the install and runtime dependencies. Install dependencies are easy to specify since they can be put right into the .gemspec file of the WatirSplash gem and RubyGems does all the heavylifting:

It gets trickier when it comes to specifying the runtime dependencies. “Why runtime dependencies at all?” - you might ask. The answer to this question is fairly simple - because the framework used for automating the browser is chosen during runtime and it’s not possible to put all these gems into installation dependencies due to the problem of Watir (for controlling the IE browser) not installing successfully on Linux or OS X operating systems for obvious reasons. There are also other OS-specific gems. Also, it’s not possible (at least not in my knowledge of) to specify platform specific dependencies right into the .gemspec file itself.

The Old Way

The runtime dependencies in WatirSplash 1 were loaded with the help of the RubyGems itself. When the desired framework was specified then WatirSplash loaded the appropriate file, which executed the code similar to this for Watir:

It meant that the user of WatirSplash needed to have the Watir version 2.0.1 installed and if he didn’t then the installation instructions were provided.

This solution seems to solve the problem of specifying runtime dependencies at first. There are still some problems with this approach. First of all, if Watir has a dependency for some other gem without any specific or with too loose version then it is possible that some newer version of that gem breaks the usage of WatirSplash and i, as a maintainer of the WatirSplash gem, have to release a new version of the WatirSplash gem by specifying the exact version of that gem as a runtime dependency. Second problem is that if a newer version of Watir (or any other among the runtime dependency gems) were released then it was not possible for the user of WatirSplash to try if it was working with the current version of WatirSplash (which was pretty often the case) without modifying the code of WatirSplash itself or waiting for the new release made by me with updated runtime dependencies. These are the two main and quite big problems with this approach.

The New Way

These problems were solved by introducing the usage of Bundler. Bundler allows to specify runtime dependencies exactly like with RubyGems, but it has a difference of locking down the dependencies versions. This means that user A and user B are always using the same versions of all the runtime dependencies no matter what other versions they have installed on their system.

By using WatirSplash 2, you will get the following Gemfile into your specs directory, when running new project generator, for specifying all the needed dependencies:

source :rubygems # load WatirSplash and it's dependencies gem "watirsplash", "2.1.1" platforms :mingw, :mswin do gem "watir", "2.0.1" gem "win32screenshot", "~>1.0.5", :require => "win32/screenshot" end gem "watir-webdriver", "~>0.3.1" gem "firewatir", ">= 1.9.3" gem "rspec", "~>2.6.0" gem "spork", "~>0.9.0.rc9" # add your project specific dependencies here: # gem "ruby-debug", "0.10.3"

After executing `bundle install` do not forget to add Gemfile.lock also into your VCS - this is the only way to guarantee that everyone who is running the tests are using the exact same versions of the dependencies.

This solution allows each user of the WatirSplash to specify their own dependency versions without any need to wait for the new release of the WatirSplash itself. In other words - this solution solves both of the problems existent in the previous RubyGems solution.

Conclusion

Bundler tries to make the Gem Hell problem disappear and is doing a pretty good job there, but if there are gems which depend on some external native library, which needs compilation then there is still the danger of having a wrong version of that dependency causing compilation errors. Probability of seeing that problem is quite low compared to the problems which Bundler solves. All in all Bundler is a really great tool and thanks to that WatirSplash has gotten even better.

I have been using the screenshot to obtain IE screen captures. This works well when have a remote desktop session to the IE virtual machine. However, I notice that the capture is a black screen when there is no remote desktop session even though the user session still exists.

Sun, 04 Sep 2011 14:31:49 +0300

Yes, that is a known limitation Windows blocking these system calls when the PC is locked. You can use VNC or some similar remote desktop alternative which emulates the remote PC in a different way and not locking the PC when you disconnect from the remote session.

WatirSplash 2

Thu, 18 Aug 2011 20:45:00 +0300

WatirSplash 2 has been released already some time ago, but i haven’t covered the nice things which came with it. This situation will be improved with the following posts.

New Features

The biggest changes in WatirSplash 2 compared to version 1.x are:

Loading all dependencies with the help of Bundler.
Fixed support for Ruby 1.9.
Introduced so called Page Objects.
Removed cumbersome and usually not needed “ui-test-common” functionality.
Made WatirSplash more transparent making it easier to follow what, when and how it does the things it does and giving better control over it.

Removed Features

It is quite easy to understand from the “New Features” list that projects generated with WatirSplash 1.x won’t work out of the box with WatirSplash 2. I had to break backwards compatibility due to the decisions made in the past which were in my way improving the framework to make it just a lot better.

I’ve paid attention to the users of WatirSplash and noticed what they didn’t like or what they have been wanting to do differently. This has caused me to use .rspec file to configure RSpec all the way instead of doing it programmatically from the WatirSplash itself. This gives a better control for tuning the usage of RSpec when needed.

Even browser window won’t be opened and maximized automatically anymore - you can still do it with the help of RSpec.configure block.

All these little details should make the experience of using WatirSplash even better!

Getting Started

Starting to use WatirSplash is as easy as splashin’ in the water. First you have to install the gem itself ofcourse:

After doing that you’d need to generate a default project structure. It can be done by using the “new” generator:

Being inside of the newly created project directory, install all the required dependencies aswell:

After having that done, generate the very first Page Object with the “page” generator. For example:

C:\my_project\ui-test>bundle exec watirsplash page search --url http://bing.com create lib create lib/app/page/search.rb create spec create spec/app/page/search_spec.rb

There you have it. Modify the newly generated files and start specc’ing. There will be a more thorough posts about the main new features including how to use Page Objects in the future - stay tuned. Feel free to read more information about WatirSplash from it’s repository at GitHub.