QA Strategies

BDD framework to run groovy scripts using Eclipse, Maven and Cucumber

2012-06-19T19:33:00.000-07:00

Steps to install Ruby / Cucumber / Cucumber – jvm / Junit / Selenium Server / Selenium web driver / Maven / Eclipse / Ruby mine:

Download latest Ruby version (1.9.3) from http://www.rubyinstaller.org/downloads/
Download latest Ruby dev kit (DevKit-tdm-32-4.5.2-20111229-1559-sfx.exe ) from http://www.rubyinstaller.org/downloads/
Download latest Ansicon from https://github.com/adoxa/ansicon/downloads
Open ruby cmd and run “gem install cucumber” to download cucumber. If you are using proxy then you need to set it up before run this command. This will download all the cucumber dependencies. You can also download gems manually by - Download the gem from ruby gems site. Go to the download directory using ruby cmd and type “gem install ”
Once cucumber is installed run this “cucumber –help” on ruby cmd to see it shows all the cucumber commands help content.
You can also run “gem list” to see all the gems installed.

If you want to use Rubymine as writing feature/Step files in ruby and run feature files in cucumber then you only need ruby mine software from www.jetbrains.com/ruby/download/
Download it and you are ready to write the test cases for cucumber.

If you need cucumber tests to be run by Groovy, maven-Eclipse, Cucumber JVM then you need to do following installation steps as well:

Install Eclipse IDE (download eclipse zip “eclipse-jee-indigo-SR2-win32” from http://www.eclipse.org/downloads/)
Download Maven from http://maven.apache.org/download.html

Maven is a Java tool, so you must have Java installed in order to proceed. More precisely, you need a Java Development Kit (JDK), the Java Runtime Environment (JRE) is not sufficient.
Additional optional installation steps are listed after the platform specific instructions.

Windows 2000/XP Unzip the distribution archive, i.e. apache-maven-3.0.4-bin.zip to the directory you wish to install Maven 3.0.4. These instructions assume you choseC:\Program Files\Apache Software Foundation. The subdirectory apache-maven-3.0.4 will be created from the archive. Add the M2_HOME environment variable by opening up the system properties (WinKey + Pause), selecting the "Advanced" tab, and the "Environment Variables" button, then adding the M2_HOME variable in the user variables with the value C:\Program Files\Apache Software Foundation\apache-maven-3.0.4. Be sure to omit any quotation marks around the path even if it contains spaces. Note: For Maven < 2.0.9, also be sure that the M2_HOME doesn't have a '\' as last character.In the same dialog, add the M2 environment variable in the user variables with the value %M2_HOME%\bin.Optional: In the same dialog, add the MAVEN_OPTS environment variable in the user variables to specify JVM properties, e.g. the value -Xms256m -Xmx512m. This environment variable can be used to supply extra options to Maven. In the same dialog, update/create the Path environment variable in the user variables and prepend the value %M2% to add Maven available in the command line.In the same dialog, make sure that JAVA_HOME exists in your user variables or in the system variables and it is set to the location of your JDK, e.g.C:\Program Files\Java\jdk1.5.0_02 and that %JAVA_HOME%\bin is in your Path environment variable.

Unzip the contents in your root Eclipse folder. In my case I unzipped it in c:/java/eclipse
Run the ‘eclipse.exe’ in [eclipse root]/eclipse
Select a workspace location for Eclipse to store your projects. In my case I used the default location
·
Click on the ‘Workbench’ icon
·
Select Help -> Install New Software
·
Click the ‘Add…’ button
Name: m2eclipse
Location: http://m2eclipse.sonatype.org/sites/m2e
Click ‘OK’
·
Check the ‘Maven Integration for Eclipse’ option
Click ‘Next’
·
Click ‘Next >’
·
Select ‘I accept the terms of the license agreements’
Click ‘Finish’
·


Select Window -> Preferences
·
Add the Maven 3 location the you installed earlier
·
Similarly install another software "groovy eclipse plugin " to run groovy using eclipse ide. once it is installed restart the eclipse ide.Create a new Maven project by selecting File -> New -> Other…
·
Select Maven -> Maven Project
·
Check ‘Create a simple project (skip archetype selection)’
Click ‘Next >’
·

Add groovy nature to the project. Create following project structure:

Calculator.java:


package calc;

import java.util.ArrayList;
import java.util.List;

public class Calculator {
    List<Double> stack = new ArrayList<Double>();

    public void push(double arg) {
        stack.add(arg);
    }

    public double divide() {
        return stack.get(0) / stack.get(1);
    }
}


CalculatorSteps.groovy:

package calc

this.metaClass.mixin(cucumber.runtime.groovy.Hooks)
this.metaClass.mixin(cucumber.runtime.groovy.EN)

class CustomWorld {
    String customMethod() {
        "foo"
    }
}

World {
    new CustomWorld()
}

Before() {
    assert "foo" == customMethod()
    calc = new Calculator()
}

Before("@notused") {
    throw new RuntimeException("Never happens")
}

Before("@notused,@important", "@alsonotused") {
    throw new RuntimeException("Never happens")
}

Given(~"I have entered (\\d+) into (.*) calculator") { int number, String ignore ->
 print "Hello\n"
 calc.push number
}

Given(~"(\\d+) into the") {->
    throw new RuntimeException("should never get here since we're running with --guess")
}

When(~"I press (\\w+)") { String opname ->
    result = calc."$opname"()
 print result
}

Then(~"the stored result should be (.*)") { double expected ->
    assert expected == result
}


RunCuckesTest.java:


package calc;

import cucumber.junit.Cucumber;
import org.junit.runner.RunWith;

@RunWith(Cucumber.class)
@Cucumber.Options(/*glue= "src/test.groovy/calc"*/ features = "C:/Documents and Settings/sekhria/My Documents/Downloads/cucumber-cucumber-jvm-v1.0.9-14-g0f89d1a/cucumber-cucumber-jvm-0f89d1a/examples/groovy-calculator/src/test/resources/calc", glue= "C:/Documents and Settings/sekhria/My Documents/Downloads/cucumber-cucumber-jvm-v1.0.9-14-g0f89d1a/cucumber-cucumber-jvm-0f89d1a/examples/groovy-calculator/src/test/groovy/calc")
public class RunCukesTest {
}


division.feature:

# language: en
Feature: Division
  In order to avoid silly mistakes
  Cashiers must be able to calculate a fraction

  @important
  Scenario: Regular numbers
    Given I have entered 3 into the calculator
    And I have entered 2 into the calculator
    When I press divide
    Then the stored result should be 1.5

  Scenario: More numbers
    Given I have entered 6 into the calculator
    And I have entered 3 into the calculator
    When I press divide
    Then the stored result should be 2.0


pom.xml:


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>info.cukes</groupId>
        <artifactId>cucumber-jvm</artifactId>
        <relativePath>../../pom.xml</relativePath>
        <version>1.0.10-SNAPSHOT</version>
    </parent>

    <artifactId>groovy-calculator</artifactId>
    <packaging>jar</packaging>
    <name>Examples: Groovy Calculator</name>

    <properties>
        <gmaven.runtime>1.8</gmaven.runtime>
    </properties>

    <dependencies>
      <dependency>
             <groupId>info.cukes</groupId>
             <artifactId>gherkin</artifactId>
             <version>2.9.3</version>
        </dependency>
  <dependency>
   <groupId>info.cukes</groupId>
   <artifactId>cucumber-core</artifactId>
   <version>1.0.6</version>
  </dependency>
        <dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-groovy</artifactId>
            <version>1.0.9</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>info.cukes</groupId>
            <artifactId>cucumber-junit</artifactId>
            <version>1.0.6</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- These dependencies are required in order to find classes when running in an IDE - they haven't been jar-jarred -->
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.googlecode.java-diff-utils</groupId>
            <artifactId>diffutils</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.gmaven</groupId>
                <artifactId>gmaven-plugin</artifactId>
                <version>1.4</version>
                <executions>
                    <execution>
                        <goals>
                        <!--
                            <goal>generateStubs</goal>
                            -->
                            <goal>compile</goal>
                            <!--
                            <goal>generateTestStubs</goal>
                            -->
                            <!--
                            <goal>testCompile</goal>
                            -->
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Once all the files are added. Run the project using maven test option. You can see following results:

Hello
Hello
1.5Hello
Hello
2.0
Tests run: 10, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.296 sec

Now your project is ready to include further tests. You can use GEB tool with groovy script to Automate browser testing. You can use Jenkins to create a continuous integration task to run tests as part of build process.

Geb Page object - Groovy-Geb-Cucumber framework - Part 3

2012-06-08T00:21:00.000-07:00

Before reading this page, please make sure you have read the Part 2 and Part 1

1.4 “At” Verification

Each page can define a way to check whether the underling browser is at the page that the page class actually represents. This is done via a static at closure…

class ExamplePage extends Page {

    static at = { $("h1").text() == "Example" }

}

This closure can either return a false value or throw an AssertionError (via the assert method). The verifyAt() method call will either return true or throw an AssertionError even if there are no explicit assertions in the “at” checker.

Browser.drive {

    to ExamplePage

    verifyAt()

}

The verifyAt() method is used by the browser at() method which also returns true or throws an AssertionError even if there are no explicit assertions in the “at” checker…

Browser.drive {

    to ExamplePage

    at(ExamplePage)

}

At checkers are subject to “implicit assertions”. See the section on implicit assertions for more information.

If you don't wish to get an exception when “at” checking fails there are methods that return false in that case: Page#verifyAtSafely(), Browser#isAt(Class) and Browser#isAt(Page)

As mentioned previously, when a content template defines a “to” option of more than one page the page's verifyAt() method is used to determine which one of the pages to use. In this situation, anyAssertionErrors thrown by at checkers are suppressed.

The “at” checker is evaluated against the page instance, and can access defined content or any other variables or methods…

class ExamplePage extends Page {

    static at = { heading == "Example" }

    static content = {

        heading { $("h1").text() }

    }

}

If a page does not verify an “at” checker, the verifyAt() method will always return true.

1.5 Page URLs

Pages can define URLs via the static url property.

class ExamplePage extends Page {

    static url = "examples"

}

The url is used when using the browser to() method.

1

2

3

4

Browser.drive {

    go "http://myapp.com/"

    to ExamplePage

}

See the section on the base url for notes about urls and slashes.

1.6 Advanced Page Navigation

Page classes can customise how they generate URLs when used in conjunction with the browser to() method.

Consider the following example…

import geb.*

class ExamplePage extends Page {

    static url = "example"

}

Browser.drive("http://myapp.com/") {

    to ExamplePage

}

This will result in a request being made to “http://myapp.com/example”.

The to() method can also take arguments…

1

2

3

Browser.drive("http://myapp.com") {

    to ExamplePage, 1, 2

}

This will result in a request being made to “http://myapp.com/example/1/2”. This is because by default, any arguments passed to the to() method after the page class are converted to a URL path by callingtoString() on each argument and joining them with “/”.

However, this is extensible. You can specify how a set of arguments is converted to a URL path to be added to the page URL. This is done by overriding the convertToPath() method. The Page implementation of this method looks like this…

String convertToPath(Object[] args) {

    args ? '/' + args*.toString().join('/') : ""

}

You can either overwrite this catch all method control path conversion for all invocations, or provide an overloaded version for a specific type signature. Consider the following…

class Person {

    Long id

    String name

}

class PersonPage {

    static url = "person"

    String convertToPath(Person person) {

        person.id.toString()

    }

}

def newPerson = new Person(id: 5, name: "Bruce")

Browser.drive {

    go "http://myapp.com/"

    to PersonPage, newPerson

}

This will result in a request to “http://myapp.com/person/5”.

1.6.1 Named params

Any type of argument can be used with the to() method, except named parameters (i.e. a Map). Named parameters are always interpreted as query parameters. Using the classes from the above example…

1

2

3

4

Browser.driver {

    go "http://myapp.com/"

    to PersonPage, newPerson, flag: true

}

This will result in a request to “http://myapp.com/person/5?flag=true”. The query parameters are not sent to the convertToPath() method.

1.7 Inheritance

Pages can be arranged in an inheritance hierarchy. The content definitions are merged…

class ExamplePage extends Page {

    static content = {

        heading { $("h1") }

    }

}

class SpecialExamplePage extends ExamplePage {

    static content = {

        footer { $("div.footer") }

    }

}

Browser.drive {

    to SpecialExamplePage

    assert heading.text() == "Special Example"

    assert footer.text() == "This is the footer"

}

If a subclass defines a content template with the same name as a content template defined in a superclass, the subclass version replaces the version from the superclass.

1.8 Lifecycle Hooks

Page classes can optionally implement methods that are called when the page is set as the browser's current page and when it is swapped out for another page. This can be used to transfer state between pages.

1.8.1 onLoad(Page previousPage)

The onLoad() method is called with previous page object instance when the page becomes the new page object for a browser.

import geb.*

class SomePage extends Page {

    void onLoad(Page previousPage) {

        // do some stuff with the previous page

    }

}

1.8.2 onUnload(Page newPage)

The onUnload() method is called with next page object instance when the page is being replaced as the page object for the browser.

import geb.*

class SomePage extends Page {

    void onUnload(Page newPage) {

        // do some stuff with the new page

    }

}

1.9 Dealing with frames

Frames might seem a thing of the past but if you're accessing or testing some legacy application with Geb you might still need to deal with them. Thankfully Geb makes working with them groovier thanks to thewithFrame() method which is available on Browser, Page and Module. There are multiple flavours of the withFrame() method, but the for all of them the closure parameter is executed in the context of a frame specified by the first parameter:

withFrame(String, Closure) - String parameter contains the name or id of a frame element
withFrame(int, Closure) - int parameter contains the index of the frame element, that is, if a page has three frames, the first frame would be at index “0”, the second at index “1” and the third at index “2”
withFrame(Navigator, Closure) - Navigator parameter should point to a frame element
withFrame(SimplePageContent, Closure) - SimplePageContent should contain a frame element

...then this code will pass...

static content = {

    footerFrame { $('#footer') }

}

withFrame('header') { assert $('span') == 'frame text' }

withFrame('footer') { assert $('span') == 'frame text' }

withFrame(0) { assert $('span') == 'frame text' }

withFrame($('#footer')) { assert $('span') == 'frame text' }

withFrame(footerFrame) { assert $('span') == 'frame text' }

assert $('span') == 'main'

If a frame cannot be found for a given first argument of the withFrame() call then NoSuchFrameException is thrown.

Source is - http://www.gebish.org/manual/current/pages.html

Geb Page object - Groovy-Geb-Cucumber framework - Part2

2012-06-08T00:16:00.000-07:00

Before reading this page, please make sure you have read the Part 1

1.3.1 Template Options

Template definitions can take different options. The syntax is…

«name»(«options map») { «definition» }

For example…

theDiv(cache: false, required: false) { $("div", id: "a") }

The following are the available options.

1.3.1.1 required

Default value: true

The required option controls whether or not the content returned by the definition has to exist or not. This is only relevant when the definition returns a Navigator object (via the $() function), it is ignored if the definition returns anything else.

If the required option is set to true and the returned content does not exist, a RequiredPageContentNotPresent exception will be thrown.

class ExamplePage extends Page {

    static content = {

        theDiv { $('div', id: "b") }

    }

}

Browser.drive {

    to ExamplePage

    def thrown = false

    try {

        theDiv

    } catch (RequiredPageContentNotPresent e) {

        thrown = true

    }

    assert thrown

}

1.3.1.2 cache

Default value: false

The cache option controls whether or not the definition is evaluated each time the content is requested (the content is cached for each unique set of parameters).

class ExamplePage extends Page {

    def value = 1

    static content = {

        theValue(cache: true) { value }

    }

}

Browser.drive {

    to ExamplePage

    assert theValue == 1

    value = 2

    assert theValue == 1

}

With caching disabled…

class ExamplePage extends Page {

    def value = 1

    static content = {

        theValue(cache: false) { value }

    }

}

Browser.drive {

    to ExamplePage

    assert theValue == 1

    value = 2

    assert theValue == 2

}

Caching is a performance optimisation and is disabled by default. You may want to enable if you notice that the a particular content definition is taking a long time to resolve.

1.3.1.3 to

Default value: null

The to option allows the definition of which page the browser will be sent to if the content is clicked.

class ExamplePage extends Page {

    static content = {

        helpLink(to: HelpPage) { $("a", text: "Help") }

    }

}

class HelpPage extends Page {}

Browser.drive {

    to ExamplePage

    helpLink.click()

    assert at(HelpPage)

}

The to value will be implictly used as an argument to the content's click() method, effectively setting the new page type. See the section on clicking content for how this changes the browser's page object.

The list variant can also be used…

static content = {

    loginButton(to: [LoginSuccessfulPage, LoginFailedPage]) { $("input.loginButton") }

}

Which on click sets the brower's page to be the first page in the list whose at checker returns true. This is equivalent to the page(Class[] potentialPageTypes) browser method which is explained in the section on changing pages.

1.3.1.4 wait

Default value: false

The wait option allows Geb to wait an amount of time for content to appear on the page, instead of throwing a RequiredPageContentNotPresent exception if the content is not present when requested.

class DynamicPage extends Page {

    static content = {

        dynamicallyAdded(wait: true) { $("p.dynamic") }

    }

}

Browser.drive {

    to DynamicPage

    assert dynamicallyAdded.text() == "I'm here now"

}

This is equivalent to:

class DynamicPage extends Page {

    static content = {

        dynamicallyAdded(required: false) { $("p.dynamic") }

    }

}

Browser.drive {

    to DynamicPage

    assert waitFor { dynamicallyAdded }.text() == "I'm here now"

}

See the section on waiting for the semantics of the waitFor() method, that is used here internally. Like waitFor() a WaitTimeoutException will be thrown if the wait timeout expires.

The value for the wait option can be one of the following:

true - wait for the content using the default wait configuration
a string - wait for the content using the wait preset with this name from the configuration
a number - wait for the content for this many seconds, using the default retry interval from the configuration
a 2 element list of numbers - wait for the content using element 0 as the timeout seconds value, and element 1 as the retry interval seconds value

Any other value will be interpreted as false.

It is also possible to use wait when defining non element content, such as a string or number. Geb will wait until the content definition returns a value that conforms to the Groovy Truth.

class DynamicPage extends Page {

    static content = {

        status { $("p.status") }

        successStatus(wait: true) { status.text().contains("Success") }

    }

}

Browser.drive {

    to DynamicPage

    assert successStatus

}

In this case, we are inherently waiting for the status content to be on the page and for it to contain the string “Success”. If the status element is not present when we request successStatus, theRequiredPageContentNotPresent exception that would be thrown is swallowed and Geb will try again after the retry interval has expired.

You can modify the behaviour of content with wait option set to true if you use it together with required option set to false. Given a content definition:

static content = {

    dynamicallyAdded(wait: true, required: false) { $("p.dynamic") }

}

Then if wait timeout expires when retrieving dynamicallyAdded there will be no WaitTimeoutException thrown and null value will be returned.

Waiting content blocks are subject to “implicit assertions”. See the section on implicit assertions for more information.

1.3.2 Aliasing

If you wish to have the same content definitions available under diferent names you can create a content definition that specifies aliases parameter:

class AliasingPage extends Page {

    static content = {

        someButton { $("button", text: "foo") }

        someButtonByAnotherName(aliases: someButton)

    }

}

Browser.drive {

    to AliasingPage

    assert someButton.text() == someButtonByAnotherName.text()

}

Rember that the aliased content has to be defined before the aliasing content, otherwise you will get a InvalidPageContent exception.
Source is - http://www.gebish.org/manual/current/pages.html

Geb Page object - Groovy-Geb-Cucumber framework - Part1

2012-06-08T00:12:00.000-07:00

Pages

Before reading this page, please make sure you have read the section on the Browser.drive() method

1.1 The Page Object pattern

import geb.Browser

Browser.drive {

    go "http://google.com"

    $("input[name=q]").value() = "Chuck Norris"

    $("input[value=Google Search]").click()

    assert $("li.g", 0).get("a.l").text() ==~ /Chuck/

}

This is valid Geb code, and it works well for a one off script but there are two big issues with this approach. Imagine that you have many tests that involve searching and checking results. The implementation of how to search and how to find the results is going to have to be duplicated in every test, maybe many times per test. As soon as something as trivial as the name of the search field changes you have to update a lot of code. The Page Object Pattern allows us to apply the same principles of modularity, reuse and encapsulation that we use in other aspects of programming to avoid such issues in browser automation code.

Here is the same script, utilising page objects…

import geb.*

class GoogleHomePage extends Page {

    static url = "http://google.com"

    static at = { title == "Google" }

    static content = {

        searchField { $("input[name=q]") }

        searchButton(to: GoogleResultsPage) { $("input[value=Google Search]") }

    }

}

class GoogleResultsPage extends Page {

    static at = { title.endsWith("Google Search") }

    static content = {

        results { $("li.g") }

        result { index -> results[index] }

        resultLink { index -> result(index).find("a.l") }

    }

}

// Now the script

Browser.drive {

    to GoogleHomePage

    searchField.value = "Chuck Norris"

    searchButton.click()

    assert at(GoogleResultsPage)

    assert resultLink(0).text() ==~ /Chuck/

}

You have now encapsulated, in a reusable fashion, information about each page and how to interact with it. As anyone who has tried to knows, maintaining a large suite of functional web tests for a changing application can become an expensive and frustrating process. Geb's support for the Page Object pattern addresses this problem.

1.2 The Page superclass

All page objects must inherit from Page.

1.3 The Content DSL

Geb features a DSL for defining page content in a templated fashion, which allows very concise yet flexible page definitions. Pages define a static closure property called content that describes the page content.

Consider the following HTML…

"a">a

We could define this content as so…

class ExamplePage extends Page {

    static content = {

        theDiv { $('div', id: 'a') }

    }

}

The structure to the content DSL is…

«name» { «definition» }

Where «definition» is Groovy code that is evaluated against the instance of the page.

Here is how it could be used…

Browser.drive {

    to ExamplePage

    assert theDiv.text() == "a"

}

So how is this working? First, remember that the Browser instance delegates any method calls or property accesses that it doesn't know about to the current page instance. So the above code is the same as…

Browser.drive {

    to ExamplePage

    assert page.theDiv.text() == "a"

}

Secondly, defined content becomes available as properties and methods on instance of the page…

Browser.drive {

    to ExamplePage

    // Following two lines are equivalent

    assert theDiv.text() == "a"

    assert theDiv().text() == "a"

}

The Content DSL actually defines content templates. This is best illustrated by example…

class ExamplePage extends Page {

    static content = {

        theDiv { id -> $('div', id: id) }

    }

}

Browser.drive {

    to ExamplePage

    assert theDiv("a").text() == "a"

}

There are no restrictions on what arguments can be passed to content templates.

A content template can return anything. Typically they will return a Navigator object through the use of the $() function, but it can be anything.

class ExamplePage extends Page {

    static content = {

        theDivText { $('div#a').text() }

    }

}

Browser.drive {

    to ExamplePage

    assert theDivText == "a"

}

It's important to realise that «definition» code is evaluated against the page instance. This allows code like the following…

class ExamplePage extends Page {

    static content = {

        theDiv { $('div#a') }

        theDivText { theDiv.text() }

    }

}

And this is not restricted to other content…

class ExamplePage extends Page {

    def divId = a

    static content = {

        theDiv { $('div', id: divId) }

        theDivText { theDiv.text() }

    }

}

Or…

class ExamplePage extends Page {

    static content = {

        theDiv { $('div', id: getDivId()) }

        theDivText { theDiv.text() }

    }

    def getDivId() {

        "a"

    }

}

Source is - http://www.gebish.org/manual/current/pages.html

Continuous Integration and iOS

2012-06-07T23:58:00.001-07:00

There is a nice article on continuous Integration and iOS here http://hamishrickerby.com/2012/01/27/continuous-integration-and-ios/

Cucumber best practises

2012-06-07T00:36:00.004-07:00

Recently I came across several posts criticizing Cucumber and approach itself. Some of the links:

BEHAVIOR-DRIVEN DEVELOPMENT VS. TESTING by James Bach
Testing like the TSA (here is the criticizm of TDD approach but there is one recomendation here which fits the topic. I mean the recomendation not to use Cucumber)

and many others. Generally speaking the idea is that we should put off our pink sun glasses and look at the real world. Cucumber (and all it's analogs designed for other programming languages) is quite attractive solution providing the ability to write descriptive automated tests. But this attractiveness hides a myriad ways to "shoot your leg". And the more people use the approach of executable specifications the more people have bad experience. Why this happens? Key thing here is that each approach requires specific set of agreements as well as it always has some restrictions. BDD aproach itself is not an exception. So, before using it we should understand what the potential problems can be and where it is applicable at all. Most of failures related to BDD and Cucumber in particular are related to the fact that it was used in umproper way and at improper plase. At the same time there are some quite simple rules which can help to avoid essential part of the problems. Some of them are:

Do not use it for white box unit testing - Main reason is that BDD makes an overhead in a form of extra resources (like feature files) and the code binding text instructions to the actual executable code. Another key factor here is that white box unit testing is done by developers for developers. It means that the ability to represent readable tests isn't advantage here as developers understand the code pretty well. All the above facts are multiplied by the fact that test development shouldn't take more time than development as the value the developer brings is reflected in the code under test rether then in tests covering that code. All those things make Cucumber not applicable for developers
Make conventions for building test instructions - In many cases I encountered the situation when the same action was represented in many different forms with minimal differences. E.g. there were phrases like:
```
When I click on Submit button
When I click on Submit
When I click on the Submit button
When I click on the "Submit" button
```
As you can see the meaning of the above strings is the same though for Cucumber they are different. Use common convention to follow in order to prevent such chaos. E.g. you can state that all control names must be quoted and preceeded with the article. Also you should identify what the control type is. In this case only last line is valid. Of course, initially it will require a lot of reviews and corrections but after some time it becomes a habit. It's actually the same as coding style. It good practice when all people write the code in the same fashion so any developer can read and understand the code of others. The same thing is here.
Use proper level of detail - There are tests which verify some specific work flow checking all steps in detail. But also there are tests which just use that work flow but they are intereted in further checks affected by some other functionality. In this case we don't need to specify all details. Some general action description should be enough. E.g. we have test like:
```
Given I'm on home page
When I click on the "Orders" link
Then I should see the "Orders" page is open
When I click on the "Create" link
Then I should see the "Create Order" page is open
When I enter "Test" value into the "Order Name" field
And click on the "Submit" button
Then I should see the "Success" message appears
```
and we have another test which requires several orders for further processing. The second test can use the following:
```
When I create the "Test" order
And I create the "Test1" order
```
In this example we put instructions from the first test and wrapped them with the single instruction. Actually if we do the same with the code we just make a layer of re-usable functions which represent some domain layer. So, that would be done anyway. We just have to group that functionality properly. But the main idea is that if we don't care about how we do some actions but we just need the result then we can use more high-level instructions.
Use parameters - key flexibility of Cucumber and all other similar engines is in ability to vary some part of instructions. Actually the code is bound to some text in feature files using regular expressions with back-linked variables. E.g. if we have instructions like:
```
When I click on the "Create" button
And I click on the "Submit" button
```
we don't need to bind separately both instructions. We can create method for clicking any button by their name and bind it to the following regular expression:
```
/I click on the "(.*)" button/
```
In the cucumber the text in quotes will be passed as parameter. If we need to pass complex parameter (e.g. we need to fill some set of fields in some specific form) we can use tables and test instructions will look like:
```
When I fill in the "Order" form with the following options:
  | Order Name | Date       | Client  | Price |
  | Test1      | 2012-02-12 | John B. | 200$  |
```
Of course, we should implement appropriate method performing those actions.
Try to re-use text instructions as much as possible - BDD with it's extra layer of text instructions requires extra eforts to support them and their bindings to the actual code. In order to optimize that expences we should re-use existing text instructions. The more time each specific text instruction is in use the less effort is required to maintain the code in case we need to do some changes which should be reflected in all affected tests.
Use examples when you check multiple input options for the same work flow - It's more about test design and it can be the biggest pain. Actually, here is an example of such situation. Let's take an example of poorly designed test:
```
Scenario 1: Account is in credit+
Given the account is in credit
And the card is valid
And the dispenser contains cash
When the customer requests cash
Then check that the account is debited
And check that cash is dispensed
And check that the card is returned
And check that nothing happens that shouldn’t happen and everything else happens that should happen for all variations of this scenario and all possible states of the ATM and all possible states of the customer’s account and all possible states of the rest of the database and all possible states of the system as a whole, and anything happening in the cloud that should not matter but might matter.
```
The problem here is that there's necessity of tests verifying different combinations of inputs (different situation) but it was designed in plain manner where we perform basic check and then specify in high-level that we should check various combinations. Actually, when we want to check the system behavior under different input but with the same work flow we should use data-driven approach when we define common workflow, identify varying parameters and bind that work flow to the table of input data and expected results. In this example the common work flow skeleton can be represented in the following way:
```
Scenario Outline: Account is in credit+
Given the account is 
And the card is 
And the dispenser 
When the customer requests cash
Then check that the account 
And check that cash 
And check that the card 
```
Note that the keyword Scenario was replaced with Scenario Outline and varying parameters were replaced with some keywords between < and > characters. The only thing left here is to add the data table with inputs and expected results. So, the above test should be appended with the following lines:
```
Examples:
  | Account State | Card State | Dispenser State | Account Result | Cash Result     | Card Result |
  | in credit     | valid      | contains cash   | is debited     | is dispensed    | is returned |
  | in credit     | invalid    | contains cash   | isn't debited  | isn't dispensed | is returned |
  | in credit     | expired    | contains cash   | isn't debited  | isn't dispensed | is returned |
  ....
```
Here is example how we extend our test coverage varying Card State option. The more rows we add the more cases will be checked. The scenario outline will be executed as much as the number of rows and each run uses data from appropriate row.

This is the major list of good practices. Of course, it may be updated with many other practices but, anyway, if you follow the above rules you can seriously minimize the problems you may encounter which using BDD approach and Cucumber (or any similar engine) in your test automation.

Article source - http://mkolisnyk.blogspot.com.au/2012/05/cucumber-how-to-avoid-major-mistakes.html

Selenium Review

2012-06-06T23:51:00.003-07:00

Let’s say your organization has now a stable set of manual testcases that is used for regression every time your product releases. As you are aware this set keeps on increasing and soon you are seeing that the regression test cycle is weighing down on your product release timelines. In these days of Agile practices, the obvious next place you look at is to automate testing such that regression cycle is shortened. This is not the only benefit of automation, but we will leave that discussion to some other time. Also for purpose of this discussion, we will concentrate on GUI automation tools. So if you are responsible for GUI automation, the very first question that will come up is

“What is the best GUI test automation tool for my application”?

If you had asked this question in any QA forum or just done a plain search, atleast one of the answer to above question would be Selenium. To keep this discussion in perspective, I would like to discuss merits/demerits of Selenium being the tool of choice.

Merits of using Selenium

–Choice of using language of your choice.

This is an advantage which has an indirect benefit of plugging into your engineering architecture with ease. For example if your organization is a Java shop, you already have a knowledge and technical expertise available with range of tools (e.g IDE, build systems, reporting tools etc.) that your development branch uses. It would be just a matter of transferring this know-how to your QA team which they might already be familiar with it.

–Script once, Run on multiple browsers

While this is not exactly true in simplest sense of speaking, the advantage of running your tests on multiple browsers with the same set of scripts is an enormous advantage when you have to test your application on different browser version

–Inherent applicability to AJAX

Selenium works in browser, with the core technology that is driving your test case working along side your application under test (AUT). This provides incredible control over testing of AJAX web applications .

–A community supported Selenium Software suite

Selenium users can and should take advantage of Selenium IDE,A Firefox plugin which assists you in recording and running your tests.Selenium Grid allows you to take your tests and deploy it in a clustered environment optimizing use of your resources. For details please refer to this Selenium documentation

—Support multiple test frameworks

Contrary to common thinking, selenium is not a testing tool. It is more like a GUI driving library. This is a blessing. Selenium allows users to wrap the test scripts in the framework of their choice. So if you like JUnit vs TestNG,you have a choice and also taking advantage of reporting capabilities of this framework that your development team might be already using.

—Integration with the ecosystem

If your requirement is integration with different suite of tools like Hudson, QMetryetc,there are already solutions available out there which will make the integration easier.With almost no investment in purchasing tools,you can create a test automation infrastructure right on par with a commerical suite of tools. There are also multiple solutions available for you if you want to run tests in parallel. Check outselenium Grid and saucelabs

Having said all of the above,what are the areas where Selenium falls short

—Supporting non-web applications

Selenium is designed and growing keeping in mind that it would be used to automate web applications. So if you have a windows application or a Java applet or applications that use Flash, it’s not easy to use Selenium. However other tools also do not do a better job of supporting this applications. Technically there can be other solutions to take care of this shortcoming from selenium itself.

—Maintenance readiness is not inbuilt

If you look at commercial tools, there would always be a concept of storing UI object definitions separately from test code, test data management and other nice utilities built into the tool. In Selenium, this is left to individual’s implementation. While both approaches have it’s pros and cons, a well-written Selenium framework can go a long way in giving you a head start in writing Selenium test cases.

One last point…..

Often Selenium is offered as a low cost (opensource) alternative to commercial tools like QuickTest Pro or SilkTest. While this being true in terms of obtaining the actual software, i think it’s imperative to understand that since writing and maintaining various functionalities that would have been offered as part of the commercial tool package now falls on individuals, this cost should be taken into consideration while making the final decision

Where does all this information leave you in terms of answering the original question? The answer relies on number of factors, ranging from management goals to technical requirements but Selenium should be considered an important candidate along with the commercial tools which not only requires a huge upfront investment but also significant investment in learning a new suite of tools, a team dedicated to specific skillset etc.

This article source is http://blog.infostretch.com/gui-test-automationwhy-selenium-can-be-the-tool-of-your-choice

BDD framework to test web application using Watir-Cucumber tools

2012-06-04T18:46:00.001-07:00

I have created a framework to test cucumber scenarios using Watir tool. This framework is highly reusable and requires less maintenance.

Before starting look in to the folder structure first:

You can see Regression folder which contains all the features that you want to include in the regression testing suite. Like this you can create as many folders based on test suites.

Next folder is step_definitions this contains all the test cases with test steps. These steps call functions from pages folder files. Each web page in the application should contain a separate page file to support all object properties and their functions present on the page. The page objects functions further call generic methods from external FunctionLiberary file present in support folder.

Snapshot of different files are as follows:


File: login.feature

Feature: Login to POS System

  Scenario: Login to Pos with correct credentials
    Given I am on the Pos login screen
    And I enter credentials with:
    |username|password|
    |sekhria |sekhri1234|

    When I click on submit button
    Then I should land on the Account Management page



File: login_steps.rb


Given /^I am on the Pos login screen$/ do
    @pos_login=LoginPage.new
    @pos_login.go_loginpage
end

And /^I enter credentials with:$/ do |table|
  @pos_login.entercredentials(table.hashes.first)
end


When /^I click on submit button$/ do
  @pos_login.click_button("btnSubmit")
end

Then /^I should land on the Account Management page$/ do
  puts "done"
end

File: login_page.rb

class LoginPage

  def initialize
    @pos_setup=FunctionLibrary.new
    @browser=@pos_setup.SetUpBrowser
  end


  def go_loginpage
    @browser.goto "http://10.2.241.111:8080/pos/loginAction.action"
  end


  def entercredentials(data)
    @browser.text_field(:id => "userName").set(data['username'])
    @browser.text_field(:id => "password").set(data['password'])
  end


  def click_button(buttonname)
    @browser.image(:id => buttonname).click
  end

end



File: FunctionLibrary.rb


class FunctionLibrary

  def SetUpBrowser
    require "Watir-webdriver"
    @browser = Watir::Browser.new :chrome
    @browser
  end

end

Testing a Web Service with SoapUI, JUnit, Maven and Cucumber

2012-06-04T18:01:00.002-07:00

Testing SOAPUI test cases with feature files:

If you are interested to know how to implement BDD framework to test SOAPUI test cases using cucumber tool then you can follow step by step example mentioned here

http://thomassundberg.wordpress.com/2011/11/16/testing-a-web-service-with-soapui-junit-maven-and-cucumber/

Maven Cheat sheet

2012-05-31T22:28:00.001-07:00

To build and thus create the project's artifact (war, jar, etc):
mvn package

To clean all previous build files:
mvn clean

To clean all previous build files and then build:
mvn clean package

If you want to do the above but in a "off-line" mode
mvn -o clean package

To clean all previous build files, then build, then install in the local
repository:
mvn clean package install

---------------------------------

Installing Artifact in Local Repository
mvn clean install

To build the package file (jar, war, etc) allowing test failure:
mvn -Dmaven.test.failure.ignore=true package

To generate Eclipse project descriptor after configuring the dependencies in
pom.xml:
mvn eclipse:eclipse

To clean previous generated Eclipse support files and then generate Eclipse
project descriptor after configuring the dependencies in pom.xml:
mvn eclipse:clean eclipse:eclipse

To generate the project's development support site
mvn site

To generate site documentation without running the tests (handy while updating
the APTs):
mvn -Dmaven.test.skip=true clean site

To generate javadoc
mvn javadoc:javadoc

To generate javadoc stuffed into a jar file
mvn javadoc:jar

To create a new non web app Java project (artifact is jar):
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-app

To create a new web app Java project (artifact is war):
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-webapp
-DarchetypeArtifactId=maven-archetype-webapp

To check the version of Maven:
mvn --version

To run unit tests:
mvn test

To distribute the source code:
mvn assembly:assembly -DdescriptorId=src

To install a jar file on local repo:
mvn install:install-file -Dfile=foo.jar -DgroupId=bar -Dversion=x.y
-Dpackaging=jar -DartifactId=blah

To install the oracle ojdbc14_g.jar file on local repo:
Optionally Download the Oracle JDBC driver from
http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/index.html
Q:
cd C:\some\path\to\file\oracle
mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc14_g
-Dversion=10.2.0.1.0 -Dpackaging=jar -Dfile=ojdbc14_g.jar
Then add a dependency in the pom.xml file similar to the following
 <project>
 <dependencies>
        <dependency>
                <groupid>com.oracle</groupid>
                <artifactid>ojdbc14_g</artifactid>
                <version>10.2.0.1.0</version>
        </dependency>
 </dependencies>
 </project>

Installing 3rdParty jar in local repository:
mvn install:install-file -Dfile=foo.jar -DgroupId=org.foosoft -DartifactId=foo
-Dversion=1.2.3 -Dpackaging=jar

Setting Compiler Version
 <project>
   <build>
      <plugins>
         <plugin>
         <artifactid>maven-compiler-plugin</artifactid>
            <configuration>
               </source>1.6
               <target>1.6</target>
            </configuration>
         </plugin>
      </plugins>
   </build>
 </project>

Standard Project Structure
/new-app/pom.xml  maven2 project file
/new-app/src/   Sources
/new-app/src/main/java/  Java source tree
/new-app/src/test/java/  Java unit tests
/new-app/src/main/resources/ Java classpath resources
/new-app/src/test/resources/ Resources for unit-tests
/new-app/target/classes/ compiles classes
/new-app/target/test-classes/ compiles test classes
/new-app/target/dots  other plugins' output
/newwebapp/src/main/webapp root of webapp


Generic Create Commands using Archetypes
Create a jar artifact project
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-app

Create a web app, war artifact project
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-webapp
-DarchetypeArtifactId=maven-archetype-webapp

Add documentation source
mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes
-DarchetypeArtifactId=maven-archetype-site -DgroupId=com.mycompany.app
-DartifactId=my-app-site

Create a Groovy based project, groovy-jar artifact project
mvn archetype:create \
    -DarchetypeGroupId=org.codehaus.mojo.groovy \
    -DarchetypeArtifactId=groovy-maven-archetype \
    -DgroupId=com.mycompany.app \
    -DpackageName=com.mycompany.app.mygroovymodule \
    -DartifactId=my-groovy-module

Fake Specific Create Commands

create a jar artifact project
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-app

Create a web app, war artifact project
mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-app
-DarchetypeArtifactId=maven-archetype-webapp

Add documentation source
mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes
-DarchetypeArtifactId=maven-archetype-site -DgroupId=com.mycompany.app
-DartifactId=my-app
or cd into project dir
mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes
-DarchetypeArtifactId=maven-archetype-site

Creating a war project
http://maven.apache.org/guides/mini/guide-webapp.html


(based on http://nbtconsulting.com/cheat-sheets/maven-cheat-sheet.html)

UIAutomation instrument - Testing iOS Application using Cucumber style

2012-05-21T00:26:00.000-07:00

Testing framework - How to test an iOS application using Apple UIAutomation Instrument using Cucumber style:

I have used Scenario based testing (BDD) framework to test an iOS application. Here is the hierarchy of files:

Test Suite
Feature Files
Story Files
Test Scenario Files
Helper

All these files are java script files with include statements to have their child files (to make parent child relationship). Helper file is java script file that includes the functions to support Test scenario files to make it reusable.

With this approach you only need to run test suite or a feature file using UIAutomation instrument that will further call its child files. You can include exclude features, stories and Test scenarios as per demand by simply comment/uncomment the include statement in script file. This supports agile framework as not all features, stories or Test scenarios are implemented in an iteration. So even a subject expert can run the feature files easily without knowing the scripting.

Performance Testing using SOAPUI - Script to save session Ids

2012-05-17T23:02:00.000-07:00

How to save session details in a log file:

This script really helps in logging the session ids of all the requests when you do performance testing. This provide means to troubleshoot the performance scenario when high load is generated. You can easily pin point which session ids are faulty. If you are using LOADUI tool to call soapUI script you can turn On and OFF this script step (If you think this takes long according to total scenario performance). If you are using Amazon cloud load agents then you need to use their local file path to save the file on different load agents to see the details of session ids generated by each agent.

def testsuitename=testRunner.testCase.testSuite.name
def ResponseType = testRunner.testCase.getTestStepByName("SessionRequest").httpRequest.response.responseHeaders["Set-Cookie"]
ResponseType=ResponseType.toString()
log.info("Session Response: " + ResponseType)
//def folderName = "C:/Users/asekhri/Desktop/SoapUI/Automate/response" //to store the response
def folderName =testRunner.testCase.testSuite.project.getPropertyValue( "ResultsPath")
def createFolder = new File(folderName)
createFolder.mkdir()
date = new Date()
dateFormat = new java.text.SimpleDateFormat('MMM dd, yyyy kk:mm:ss.S')
shortDate = dateFormat.format(date)
f = new File( folderName + '/' + testsuitename + '.txt')
f.append("Test Suite executed on :" + shortDate + " Session Response :" + ResponseType +"\r\n" )

Advanced Cucumber syntax

2012-05-17T22:41:00.001-07:00

Background:

A background section in a feature file allows you to specify a set of steps that are common to every scenario in the file. Instead of having to repeat those steps over and over for each scenario, you move them up into a Background: element. You can have a single Background: element per feature file, and it must appear before any of the Scenario: or Scenario Outline: elements. Just like all the other Gherkin elements, you can give it a name, and you have space to put a multiline description before the first step.

Keep your Background: section short. After all, the user is expected to actually remember this stuff when reading your scenarios. If the background is more than 4 lines long, can you move some of the irrelevant details into high-level steps?

High-level steps

One of the most important features of the test scenarios is they are readable. If a test includes a long preamble of setup steps, this defects this purpose and makes the important parts of the tests difficult to see/find/understand. So one option is to request a new high level Cucumber Gherkin test step to be created that summaries (runs) multiple test steps. EG To enter advanced search information, a test may have steps:

       When text box "Author" is set to "book's author"
       And text box "Title" is set to "book's title"
       And text box "ISBN" is set to "book's ISBN"
       And text box "Publisher" is set to "book's publisher"
       And select list "Subject" is set to "book's subject"

Instead of this a new step can be specified

       When the base book info is supplied

Doc Strings

Doc strings just allow you to specify a larger piece of text than you could fit on a single line. For example, if you need to describe the precise content of an email message, you could do it like this:

Then I should receive an email containing:-
"""
Dear Sir,
Your account has been upgraded due to your 2 year membership.
Sincerely,
The Management
"""
And (next test step)

Scenario Outline

Sometimes you have several scenarios that follow exactly the same pattern of steps, just with different input values or expected outcomes. EG

As can be seen there is repetition in scenarios making it boring to read and hard to see the essence of each scenario., what different with each scenario, what is important? We can use a scenario outline to specify the steps once, and then play multiple sets of values through them. To do this we have placeholders within the scenario outline using angle brackets <..> where we want real values to be substituted. For these scenario outlines to work we add a table of Examples:, which lists rows of values to be substituted for each placeholder. Behind the scenes, Cucumber converts each row in the Examples: table into a scenario before executing it.

Here’s that scenario again, refactored to use a scenario outline:

Once this is completed, it is easy to add new tests for other categories, just by adding one more line to the Example Table. Also it is easy to see gaps in the tests because all categories/parameters/data are listed in one place.

The heading names in each Example: table are made up (by you) and should be given meaningful names that helps define the business meaning of each test.

Given using the cached page given by

Often tests will be created where there is a common starting web page, and navigation steps following by lots of tests for fields, select lists appearing, having certain content, etc. These Scenarios can get very wordy and are difficult to follow. Alternatively these Scenarios sometimes can be rewritten as Scenario Outlines and thus become much more readable but at the expense of longer execution times.

If you have a number of Scenarios or Scenario Outlines that have common starting web page, and initial navigation steps BUT THEN DO NOT make any changes to the web page objects or more navigation steps, then there is a Cucumber step created by Recurse that can be used to start each test from a cached web page to greatly increase execution speed but still keep the readability of Scenario Outlines.

For example, assume you have the following Cucumber steps:

   Given I am on the home page
   And select list "search" is set to "Movies & TV"
   And text box "search" is set to "woody allen"                
   And button "go" is selected
   Then format, results, etc are displayed

The first 4 steps are common, and so can be rewritten as follows:

     Given using the cached page given by:
        | step                                             |
        | Given I am on the home page                      |
        | And select list "search" is set to "Movies & TV" |
        | And text box "search" is set to "woody allen"    |            
        | And button "go" is selected                      |
     Then format, results, etc are displayed

This command can also be used across different Scenarios and even different feature files to give a speed increase BUT BUT BUT use this command very carefully, your Scenarios must not leave the cached page in a different state to the common setup steps contained in the data table, breaking this rule will leave your tests open to failure/being brittle.

This article is picked from http://wiki.recurse.com.au/index.php/Cucumber_Tips#Finding_cucumber_commands

Basic Cucumber Test files syntax

2012-05-17T22:18:00.001-07:00

How to write feature file

Cucumber test files are plain text files written in gherkin syntax and have .feature file extension. Being plain-text, they can be read and edited with simple tools, although we highly recommend developers and testers use an IDE or Rubymine.

A Gherkin file is given its structure and meaning using a set of special keywords:

Feature:
Scenario:
Given
When
Then
And

plus more keywords. Using only the above, extensive tests can be constructed.

In the following example, Feature: and Scenario: are important heading and sub-heading keywords, while the others are the main keywords for defining test steps that are parsed and executed. You can write your first script using just these commands.

  Feature: Login                                                  <- Heading/Label
    As a customer login user
    In order to contribute or buy on the website                  <- Treated as comments
    I need to login to the web site
 
  Scenario: valid credentials                                     <- Sub heading/Label
     Given I select any "consumer buyer" user
     And I am on the login page
     When I provide the email address "buyers email address"      } Each line is parsed and executed
     And I provide the password "buyers password"
     Then I should be successfully logged in

In the above example, the keywords in the Scenario, Given, And, When, Then are interchangeable and are effectively stripped out when the text is parsed. They are basically there to make the scenarios more readable/understandable.

Cucumber Cheat Sheet

2012-05-17T22:14:00.000-07:00

install cucumber

sudo gem sources -a http://gems.github.com

sudo gem install cucumber

install webrat

sudo apt-get install libxslt1-dev libxml2-dev

  ..needed by linux

sudo gem install webrat

In your test_helper.rb or env.rb (for Cucumber) add:

  require "webrat"

  Webrat.configure do |config|

    config.mode = :rails

end

install rspec

sudo gem install rspec rspec-rails

gem dependencies + rake commands

add to: config/environments/test.rb

config.gem "rspec", :lib => false, :version => '>=1.2.2'

config.gem "rspec-rails", :lib => false, :version => '>=1.2.2'

config.gem "webrat", :lib => false, :version => ">=0.4.3"

config.gem "cucumber", :lib => false, :version => '>=0.2.2'

sudo rake gems:install                :install gems

sudo rake gems:install RAILS_ENV=test :install gems for [test] env

sudo rake gems:build                  :build gems needing native extensions

sudo rake gems:unpack                 :unpack gems

sudo rake gems:unpack GEM=hpricot     :unpack specific gem

cucumber commands

script/generate cucumber    :setup cucumber in your app

cucumber features -n        :test against /features

script/generate rspec_model Article title:string content:text

  ..generate rspec model + db migrations

rake db:migrate             :migrate database

rake db:test:clone          :clone migrations to test database

script/generate rspec_controller articles index

  ..generate rspec controller

webrat commands

script/generate integration_test authentication

  ..generate integration test 'authentication'

rake test:integration       :run integration tests

For more details go to http://www.red91.com/2009/04/14/cucumber-cheat-sheet/

SOAPUI Response assertion using groovy script:

2012-05-15T17:26:00.001-07:00

SOAPUI Script assertion to evaluate different json :

In this example I evaluate the json response using node level assertions

SOAPUI - Fetch session id from response header

2012-05-14T20:12:00.002-07:00

How to get session id details from response header and use it for another requests:

Create a groovy script test step after session request and use below script to fetch session details from session request response and save it as test project/suite/test case property. This session id can be further use in another steps.

def header = testRunner.testCase.getTestStepByName("SessionRequest").httpRequest.response.responseHeaders["Set-Cookie"]
header=header.toString()
start=header.indexOf("JSESSIONID=")
end=header.indexOf("; Path=")
testCaseProperty= header.substring(start,end)
testRunner.testCase.getTestStepByName( "GetSessionID").setPropertyValue( "sessionID", testCaseProperty )
testRunner.testCase.testSuite.setPropertyValue( "GetSessionID", testCaseProperty )
testRunner.testCase.testSuite.project.setPropertyValue( "sessionID", testCaseProperty )

SOAPUI Assertion - checking response type

2012-05-14T20:04:00.003-07:00

How to check Rest service json response as a SOAPUI assertion:

def holder = net.sf.json.JSONSerializer.toJSON(messageExchange.responseContent);
assert holder.get("type")=="WildcardPlayResponse"

SOAPUI - Logging Test case results using groovy script

2012-05-14T19:58:00.001-07:00

How to log Test case results in a separate text file:

Add this script as a test case tear down script.

def testsuitename=testRunner.testCase.testSuite.name
def testcasename=testRunner.testCase.name
groovyUtils = new com.eviware.soapui.support.GroovyUtils( context )
def ResponseType = testRunner.testCase.testSteps["LoadGameDataSubscribeEventRequest_ChallengeSettlementResults"].testRequest.response.getContentAsXml()
def folderName =testRunner.testCase.testSuite.project.getPropertyValue( "ResultsPath")
def createFolder = new File(folderName)
createFolder.mkdir()
date = new Date()
dateFormat = new java.text.SimpleDateFormat('MMM dd, yyyy kk:mm:ss.S')
shortDate = dateFormat.format(date)
def eid=testRunner.testCase.getPropertyValue( "email")
def pass=testRunner.testCase.getPropertyValue( "password")
def results = testRunner.results
f = new File( folderName + '/' + testsuitename + '.txt')
f.append("\r\n" + testcasename + " executed on :" + shortDate + " using EmailId: " + "'" + eid + "'" + ", Password: " + "'" + pass + "'" + " is: " + ResponseType +"\r\n" )
for( r in testRunner.results )
{
f.append( "TestStep " + r.testStep.name + " finished with status " + r.status +"\r\n")
}

SOAPUI - Logging Test suite results using groovy script

2012-05-14T19:54:00.002-07:00

How to log Test Suite results in a separate text file:

Add this script as a test suite tear down script.

def testsuitename=testSuite.name
def folderName = testSuite.project.getPropertyValue( "ResultsPath")
def createFolder = new File(folderName)
createFolder.mkdir()
date = new Date()
dateFormat = new java.text.SimpleDateFormat('MMM dd, yyyy kk:mm:ss.S')
shortDate = dateFormat.format(date)
for ( testCaseResult in runner.results )
{
testCaseName = testCaseResult.getTestCase().name
log.info testCaseName
if ( testCaseResult.getStatus().toString() == 'FAILED' )
{
f = new File( folderName + '/' + testsuitename + '.txt')
f.append("\r\n"+ shortDate +" Test Case : " + testCaseName +" Failed."+ "\r\n" )
for ( testStepResult in testCaseResult.getResults() )
{
testStepResult.messages.each() { msg -> f.append(shortDate +" Test Step : "+ msg+ "\r\n") }
}
}
}

BDD framework to test Selenium test cases using Cucumber jvm, Junit, Selenium Server, Selenium web driver, Maven, Eclipse, Ruby mine

2012-05-11T00:58:00.000-07:00

Steps to install Ruby / Cucumber / Cucumber – jvm / Junit / Selenium Server / Selenium web driver / Maven / Eclipse / Ruby mine:

Download latest Ruby version (1.9.3) from http://www.rubyinstaller.org/downloads/
Download latest Ruby dev kit (DevKit-tdm-32-4.5.2-20111229-1559-sfx.exe ) from http://www.rubyinstaller.org/downloads/
Download latest Ansicon from https://github.com/adoxa/ansicon/downloads
Open ruby cmd and run “gem install cucumber” to download cucumber. If you are using proxy then you need to set it up before run this command. This will download all the cucumber dependencies. You can also download gems manually by - Download the gem from ruby gems site. Go to the download directory using ruby cmd and type “gem install ”
Once cucumber is installed run this “cucumber –help” on ruby cmd to see it shows all the cucumber commands help content.
You can also run “gem list” to see all the gems installed.

If you want to use Rubymine as writing feature/Step files in ruby and run feature files in cucumber then you only need ruby mine software from www.jetbrains.com/ruby/download/
Download it and you are ready to write the test cases for cucumber.

If you need cucumber tests to be run by maven-Eclipse-Junit-Selenium web driver / Selenium server – Cucumber JVM then you need to do following installation steps as well:

Install Eclipse IDE (download eclipse zip “eclipse-jee-indigo-SR2-win32” from http://www.eclipse.org/downloads/)
Download Maven from http://maven.apache.org/download.html

Maven is a Java tool, so you must have Java installed in order to proceed. More precisely, you need a Java Development Kit (JDK), the Java Runtime Environment (JRE) is not sufficient.
Additional optional installation steps are listed after the platform specific instructions.

Windows 2000/XP Unzip the distribution archive, i.e. apache-maven-3.0.4-bin.zip to the directory you wish to install Maven 3.0.4. These instructions assume you choseC:\Program Files\Apache Software Foundation. The subdirectory apache-maven-3.0.4 will be created from the archive. Add the M2_HOME environment variable by opening up the system properties (WinKey + Pause), selecting the "Advanced" tab, and the "Environment Variables" button, then adding the M2_HOME variable in the user variables with the value C:\Program Files\Apache Software Foundation\apache-maven-3.0.4. Be sure to omit any quotation marks around the path even if it contains spaces. Note: For Maven < 2.0.9, also be sure that the M2_HOME doesn't have a '\' as last character.In the same dialog, add the M2 environment variable in the user variables with the value %M2_HOME%\bin.Optional: In the same dialog, add the MAVEN_OPTS environment variable in the user variables to specify JVM properties, e.g. the value -Xms256m -Xmx512m. This environment variable can be used to supply extra options to Maven. In the same dialog, update/create the Path environment variable in the user variables and prepend the value %M2% to add Maven available in the command line.In the same dialog, make sure that JAVA_HOME exists in your user variables or in the system variables and it is set to the location of your JDK, e.g.C:\Program Files\Java\jdk1.5.0_02 and that %JAVA_HOME%\bin is in your Path environment variable.

·Open a new command prompt (Winkey + R then type cmd) and run mvn --version to verify that it is correctly installed.
Unzip the contents in your root Eclipse folder. In my case I unzipped it in c:/java/eclipse
Run the ‘eclipse.exe’ in [eclipse root]/eclipse
Select a workspace location for Eclipse to store your projects. In my case I used the default location
·
Click on the ‘Workbench’ icon
·
Select Help -> Install New Software
·
Click the ‘Add…’ button
Name: m2eclipse
Location: http://m2eclipse.sonatype.org/sites/m2e
Click ‘OK’
·
Check the ‘Maven Integration for Eclipse’ option
Click ‘Next’
·
Click ‘Next >’
·
Select ‘I accept the terms of the license agreements’
Click ‘Finish’
·
Select Window -> Preferences
·
Add the Maven 3 location the you installed earlier
·
Create a new Maven project by selecting File -> New -> Other…
·
Select Maven -> Maven Project
·
Check ‘Create a simple project (skip archetype selection)’
Click ‘Next >’
·
Enter Project Information

Enter Group Id. This is the domain where the project is hosted. For example if the ‘Awesome’ project was hosted at GitHub then the Group Id would be ‘com.github.awesome’.

Enter Artifact Id. This is the name of the resulting artifact. For example if Artifact Id is ‘awesome’ and the packaging is JAR the artifact will be named ‘awesome.jar’.

The version can remain 0.0.1-SNAPSHOT

Select the packaging that you desire

Enter a Name. This name will show up in the console when you run Maven. This will also show up in the documentation that Maven generates

Enter a Description. This is used in the documentation

Click ‘Next
·
Add a dependency on JUnit. One of the best features of m2eclipse plugin is the ability to search for available dependencies. (This feature does not work if you configure ‘M3_HOME’ instead of ‘M2_HOME’)
Click ‘Finish’
src – source and resource files

target – compiled files, reports and generated artifacts

main – application/library files

test – test files

java – java files

resources – non java files like XML
·
Maven’s default package structure:
Ok now its time to check my litlle example project:

project structure:
Create this structure in Eclipse first and then add files as mentioned below:
As cucumber-jvm isn't available as stable version it must be resolved from a snapshot repo:
pom.xml: This pom uses cucumber-jvm / junit / selenium server / maven integration: This pom will download all dependency from internet like Junit, selenium server, cucmber jvm etc.

     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     4.0.0
     net.ludeke.examples
     cucumber-jvm-example
     0.0.1-SNAPSHOT


          UTF-8





                    org.apache.maven.plugins
                    maven-compiler-plugin

                         1.6
                         1.6








               junit
               junit
               4.10
               test



               info.cukes
               cucumber-junit
               1.0.6
               test


               info.cukes
               cucumber-java
               1.0.6
               test


               info.cukes
               cucumber-picocontainer
               1.0.6
               test


               org.picocontainer
               picocontainer
               2.10.2
               test


      org.seleniumhq.selenium
      selenium-java
      2.21.0
      test


   org.seleniumhq.selenium
      selenium-server
      2.21.0
      test





               sonatype-snapshots
               https://oss.sonatype.org/content/repositories/snapshots


                   selenium-repository   http://selenium.googlecode.com/svn/repository/


CarMaintenance.feature:

Feature: Daily car maintenance
Cars need maintenance

Scenario: Fuelling
  Given a car with 10 litres of fuel in the tank
  When you fill it with 50 litres of fuel
  Then the tank contains 60 litres

Car.java:

package net.ludeke.example;

public class Car {
  private Integer fuelLevel;

  public Car(int initialFuelLevel) {
    fuelLevel = initialFuelLevel;
    System.out.println("Initial Level " + fuelLevel);
  }

  public void addFuel(int addedFuel) {
    fuelLevel = fuelLevel + addedFuel;
    System.out.println("More fuel " + fuelLevel);
  }

  public int getFuelLevel() {
      System.out.println("Final Level " + fuelLevel);
      return fuelLevel;


  }
}

FuelCarSteps.java:

package net.ludeke.example;
import org.openqa.selenium.server.RemoteControlConfiguration;
import org.openqa.selenium.server.SeleniumServer;

import com.thoughtworks.selenium.DefaultSelenium;
import cucumber.annotation.en.Given;
import cucumber.annotation.en.Then;
import cucumber.annotation.en.When;
import cucumber.junit.Cucumber;
import net.ludeke.example.Car;
import org.junit.runner.RunWith;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import cucumber.annotation.After;
import cucumber.annotation.Before;

public class FuelCarSteps {
  private Car car;
  private DefaultSelenium seleniumClient = new DefaultSelenium("localhost", 4444, "*firefox",
           "http://www.google.com");

           @Before
           public void initSelenium() throws Exception {
           seleniumClient.start();
           }


  @Given("^a car with (\\d*) litres of fuel in the tank$")
  public void createCar(int initialFuelLevel) {
    car = new Car(initialFuelLevel);

       seleniumClient.open("/");
   seleniumClient.waitForPageToLoad("2000");

   try {

               Thread.sleep(4000);

       } catch (InterruptedException e) {

               // TODO Auto-generated catch block

               e.printStackTrace();

       }

  }

  @When("^you fill it with (\\d*) litres of fuel$")
  public void addFuel(int addedFuel) {
    car.addFuel(addedFuel);
  }

  @Then("^the tank contains (\\d*) litres$")
  public void checkBalance(int expectedFuelLevel) {
    int actualFuelLevel = car.getFuelLevel();
    assertThat(actualFuelLevel, is(expectedFuelLevel));
  }
}
FuelCarTest.java:

package net.ludeke.example;

import cucumber.annotation.en.Given;
import cucumber.annotation.en.Then;
import cucumber.annotation.en.When;
import cucumber.junit.Cucumber;
import net.ludeke.example.Car;
import org.junit.runner.RunWith;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;

@RunWith(Cucumber.class)
@Cucumber.Options(features = "C:/Documents and Settings/sekhria/workspace/cucumber-jvm-example/src/main/resources", format = { "pretty","html:C:/Documents and Settings/sekhria/workspace/cucumber-jvm-example/target/surefire-reports/report.html" })
public class FuelCarTest {

}

Run ‘Maven install’ to verify that the project and environment is setup correctly
The build was successful
·

Maven will download all dependencies.

Run your feature by using run>maven test command from eclipse ide.

This command “@Cucumber.Options(features = "C:/Documents and Settings/sekhria/workspace/cucumber-jvm-example/src/main/resources", format = { "pretty","html:C:/Documents and Settings/sekhria/workspace/cucumber-jvm-example/target/surefire-reports/report.html" })” does two things first it tell which feature to run and second it creates nice html report at location specified.

If you want to run Selenium web driver instead of selenium server then use this pom.xml instead of previous one.

     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     4.0.0
     net.ludeke.examples
     cucumber-jvm-example
     0.0.1-SNAPSHOT


          UTF-8





                    org.apache.maven.plugins
                    maven-compiler-plugin

                         1.6
                         1.6








               junit
               junit
               4.10
               test



               info.cukes
               cucumber-junit
               1.0.6
               test


               info.cukes
               cucumber-java
               1.0.6
               test


               info.cukes
               cucumber-picocontainer
               1.0.6
               test


               org.picocontainer
               picocontainer
               2.10.2
               test


                   org.seleniumhq.selenium
                   selenium
               2.0a6





               sonatype-snapshots
               https://oss.sonatype.org/content/repositories/snapshots


                   selenium-repository   http://selenium.googlecode.com/svn/repository/







You also need to change FuelCarSteps.java:

package net.ludeke.example;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.htmlunit.HtmlUnitDriver;

import cucumber.annotation.en.Given;
import cucumber.annotation.en.Then;
import cucumber.annotation.en.When;
import cucumber.junit.Cucumber;
import net.ludeke.example.Car;
import org.junit.runner.RunWith;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;

public class FuelCarSteps {
  private Car car;
  private WebDriver driver;
  private WebElement element;
  public FuelCarSteps() {
      // Create a new instance of the html unit driver
      // Notice that the remainder of the code relies on the interface,
      // not the implementation.
      this.driver = new HtmlUnitDriver();
    }


  @Given("^a car with (\\d*) litres of fuel in the tank$")
  public void createCar(int initialFuelLevel) {
    car = new Car(initialFuelLevel);
    driver.get("http://www.google.com");
try {
           Thread.sleep(4000);
    } catch (InterruptedException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
    }
element = driver.findElement(By.name("q"));
// Enter something to search for
element.sendKeys("Amit");
element.submit();
  }

  @When("^you fill it with (\\d*) litres of fuel$")
  public void addFuel(int addedFuel) {
    car.addFuel(addedFuel);
  }

  @Then("^the tank contains (\\d*) litres$")
  public void checkBalance(int expectedFuelLevel) {
    int actualFuelLevel = car.getFuelLevel();
    assertThat(actualFuelLevel, is(expectedFuelLevel));
  }
}

Testing tools for iOS (iPhone/iPad) Testing

2012-04-30T23:42:00.000-07:00

Test Automation Tools Identification (iPhone/iPad)

	Apple UI Automation instrument	Fone Monkey	Frank	iCuke
Scripting Language	Java script	Objective C or java script for UI Automation	UI spec, Ruby, Java	Objective-C code, Ruby
Forums and Community Support	User guide and java script reference manual is provided by Apple, forums and community support available	Limited User guide available. Forums and community support available	Limited User guide available. Forums and community support available	Limited User guide available. Forums and community support available
Sample scripts availability	Yes	It uses Apple UI Automation instrument for UI Automation using java script	Yes	Yes
Compatibility with Xcode	in build tool provided by Xcode	Uses apple UI Automation instrument to run test scripts.	Complex installation procedure
Compatibility with Cucumber	No, It generates results in its own result pane from where it can be exported in CSV format. We can use Keyword driven framework to auto update automation results for user stories.	Yes for unit tests, No for UI tests.	Yes	Yes
Compatibility with other apple performance instruments	Yes, you can find performance issues like showing memory leaks using other in build Xcode automation instruments	yes, as it uses apple UI instrument to run java scripts created in FoneMonkey.	Don't know	Don't know
Is it Mature?	Yes, This project is maintained by Apple group.	Yes. This project is maintained by Gorilla Logic consulting company which also providepaid support.	Yes	Yes

Cucumber testing tool at a glance

2012-04-30T23:33:00.000-07:00

Cucumber Analysis:

Pros	Cons
It is relatively easy to set up.
It supports multiple report formats, including HTML and PDF.
It supports writing specifications in about 40 spoken languages, making it easy for teams outside of English-speaking territories or those working on internationally targeted software to engage their business users better.	You write features and scenarios first and then try to write code to pass these scenarios until the whole feature is marked as pass. You need to tie the Cucumber scenarios to a set of fixtures, so there's another layer of abstraction which makes them slower to write. English is harder to refactor than code - even with dynamic languages like Ruby (the difference is still more pronounced in the C# and Java variants like JBehave, SpecFlow, Cuke4Nuke and Cuke4Duke). It's harder to tell if steps are still being used, and harder to maintain the scenarios. It's also harder to manage state between the various steps.
It supports different ways of describing executable specifications — including story-like prose, lists and tabular data. You can unleash your inner writer, or more likely an inner accountant.
It allows scripting, abstraction and component reuse on several levels, allowing both technical and non-technical users to efficiently describe specifications and tests.
It integrates nicely with the rest of the development ecosystem. It does not try to impose a version control system, but works off plain-text files that can be stored in any version control system. For continuous build integration, it emulates JUnit. JUnit XML format is, of course, the equivalent of Star Trek transporters when it comes to testing — use it and you can beam your test results anywhere.
Although Cucumber is a Ruby tool, people who work on other platforms do not have to learn Ruby to use it. You can use Cucumber with .NET or JVM languages almost natively.
It's integrated with all the most popular web testing libraries.
It allows you to cross reference and index tests using tags, so that you can quickly find all tests related to a function or run a group of related tests (eg quick tests, slow tests, integration tests, accounting tests).
Cucumber files are plain-text which makes it very simple to edit them but does not allow any clever formatting. You can put a short description in a file header, but apart from that everything else in the file is related to scenarios and test cases.	That means that there is no way to include images, hyperlinks, rich-text descriptions and similar.
Cucumber's step definition (automation layer, integration to domain API) model is very simple, which is both a strength and a weakness in different contexts. A simple API makes it very easy to understand and learn what you can do with Cucumber, so you won't spend three months getting your head around all the possible ways to use tables.	On the other hand, it doesn't have the smart domain-object mapping features that some other tools have, which allow you to expose your domain objects and services directly for testing and provide lots of flexibility in how you can manage complex scenarios.
Using Cucumber in a Continuous Integration (CI) environment is relatively straightforward. The cucumber executable will exit with an exit status different from 0 if one or more scenarios are failing, and this is all your CI server needs to know. First, you have to make sure your CI server executes cucumber. Most CI setups invoke some kind of build tool, typically Rake, Ant or Maven and recommend you execute cucumber from one of these.
Many CI servers can interpret XML files produced by the Ant JUnit task and display them as HTML. Some can even create reports over time. If you’re using such a CI server, recommend you use Cucumber with the junit formatter. Example. To get started using cucumber in Hudson, just add a build step running ‘cucumber -f junit --out %WORKSPACE%’ and then check the ‘Publish JUnit test result report’, and enter *.xml in the ‘Test report XMLs’ field. Save and run.	It's a new process altogether and development team has no experience developing solutions with this approach.
Cucumber is compatible with Junit, Frank/Fonemonkey	More complex due to the Ruby/JRuby/Java chain
Cucumber has a Icuke for Xcode 4 to run Ruby test cases or can use frank tool to run Objective C unit and integration test cases which can be further link with CI server using Hudson and Jenkins to publish results.	Not much documentation and support available.
Cucumber is compatible with SOAPUI/Selenium/SAHI to run test cases for web applications.	I am not sure how Cucumber with non-functional testing like performance, data integrity testing etc.)

How to use Java script to insert data in Mongo JSON collection

2012-04-30T20:15:00.003-07:00

Java script - Insert multiple rows in mongo JSON collection:

db.program.insert({
"ImageUrl" : null,
"channel" : "ABC",
"shortTitle" : null,
"programId" : ObjectId("4e38a5e3f0719a05ca81dd3a"),
});
db.program.insert({
"ImageUrl" : null,
"channel" : "ABC",
"shortTitle" : null,
"programId" : ObjectId("4e38a5e3f0719a05ca81dd3b"),
});

save above code as .js file. Connect to database and run it like this:

C:\Program Files\MongoDB\mongodb-win32-x86_64-1.8.1\bin>mongo.exe 10.0.0.142:270
17/UserDB "C:\Mongo\Javascript Files\mongoinsertreminder.js"

How to count values in a mongo collection (JSON) using Python script

2012-04-29T22:44:00.003-07:00

Python Script - Count values in a mongo collection (JSON):

import pymongo

from pymongo import Connection
from pymongo.objectid import ObjectId

print "Started."

connection = Connection("10.0.0.142", 27017)
db = connection.UserDB

print ("User count: " + str(db.user.count()))