Create a Java Class

Each plug-in has a FunctionTag which was written to be extended by all function tags for that specific plug-in. This function tag should exist in the net.sf.jameleon.plugins.plugin-name package and usually ends in FunctionTag. For example, in the JUnit plug-in there is a class named net.sf.jameleon.plugin.junit.JUnitFunctionTag.

To write a function tag, you must create a java class that extends the plug-in's function tag. So to write a function tag for the Jiffie plug-in, create a java class that extends net.sf.jameleon.plugin.jiffie.IEFunctionTag.

If using the jameleon-test-suite-x.x.x.zip package the Ant task that registers all tags expects that all tags end in Tag. If the tag isn't recognized by Jameleon even after building and registering, then this is likely the problem. Some bad tag name examples would be: AssertNull.java, Login.java, or CreateUser.java. None of those classes will be recognized by Jameleon. For them to be recongized, simply change their names to: AssertNullTag.java, LoginTag.java and CreateUserTag.java.

Implement a method called testBlock The public void testBlock() method is where the code that drives the tag must go. An example that checks whether the given value is contained with the provided text would look like:

public void testBlock(){
    assertTextContains("some text that should contain some value", "some value");
}
                        

Java Packages

It is best to come up with a good directory structure that represents the flow or functional areas of the application to be tested. Then place the Java implementation of that functional point in the corresponding directory and set the package accordingly. This will be very important once more than twenty or thirty functional points have been written. This helps make it easier to find functional points available for a certain application and/or functional area.

If the package statement in the java file doesn't match the directory structure, then your tag will likely not get registered. Be sure to add the package statement at the top of your tag. For example, if your java source files exist in the src/java directory and you want a certain tag to exist in the admin/logon directory (src/java/admin/logon), then add package admin.logon; to the top of the java file.

Attributes or Variables

Functional points will usually need to use variables that can be set via the test case script. To do this, simply ahere to the following guidelines:

1. Decide which type the variable should be (String, int, File, List ...). It is recommend to use Objects instead of primitives because it makes it easier to see if they have been set or not (simply check for null against Objects).
2. Come up with a short, but descriptive variable name. This is important as these descriptions will show up in the GUI under available attributes for the tag.
3. Declare the variable along with the following Javadocs. If you don't use the following Jameleon-provided javadocs taglets, Jameleon will not recognize the attributes and they won't be setable via the test case script. @jameleon.attribute must be the last javadoc comment for each attribute defined. That means that the javadocs actually affect the hehavior of your code. @jameleon.attribute supports the following attributes.

   Attribute Name	Description
   required	Set this to true or false. If set to true and if the attribute isn't set in the script, then a failure will occur. Defaults to false.
   default	Sets the default value of the attribute to the value provided. If there is no value provided in the script then the value will be set to the default value
   contextName	Binds the value to a context variable which is usually defined in a properties file. This is nice for custom tags that use static data like form field names or titles. WARNING: This feature should not be used to communicate data between tags. This can make your scripts hard to read, difficult to debug and fragile. Thus it should be used sparingly.

   The followiing is an example:

   /**
    * The username of the logon
    * @jameleon.attribute required="true"
    */
    protected String username;
   /**
    * The password of the logon
    * @jameleon.attribute default="foobar"
    */
    protected String password;
   /**
    * The form name of the logon form
    * @jameleon.attribute default="foobar" contextName="appNameLogonFormName"
    */
    protected String formName;
                                   

   If username is not set, then a failure will occur, stating that the username field is required. If password is not provided in the script, then the value will be set to "foobar". If a contextVariable named appNameLogonFormName exists from a properties file or a data-drivable tag or was even just created in the context, then the value of formName will be set to the value of appNameLogonFormName.
   
   Be careful about making an attribute required since that means the value must be set. This will likely end up restricting how the tag can be used to test the feature. For example, the application may require the firstName field to be set. How can this be tested other than by trying to update the information when leaving the field blank? If the attribute in the tag is required, that means the field can't be blank, making it impossible to test that business rule.

Class File Declarations

In order for Jameleon to recognize your function tag, you must javadoc it with the Jaemeleon-provided tags. These tags are used for both documentation and execution:

/**
 * Logs onto admin applications
 * @jameleon.function name="admin-logon" type="action"
 * @jameleon.step enter username
 * @jameleon.step enter password
 * @jameleon.step click the logon button
 * @jameleon.application userAdmin
 * @jameleon.application customerAdmin
 */
public class SomeTag extends JUnitFunctionTag{
}

The Full Lifecycle

The following is an example tag taken from an acceptance test tag in the Jiffie-plugin.

package foo.bar;

import com.tapsterrock.jiffie.IHTMLFormElement;
import com.tapsterrock.jiffie.IHTMLInputElement;

import net.sf.jameleon.plugin.jiffie.IEFunctionTag;

/**
 * Represents the customer information form on the blah application
 * @jameleon.function name="submit-customer-form" type="action"
 * @jameleon.step enter first name
 * @jameleon.step enter last name
 * @jameleon.step submit the form
 */
public class SubmitFormTag extends IEFunctionTag {

    /**
     * @jameleon.attribute required="true" default="formName"
     */
    protected String formNameOrId;
    /**
     * @jameleon.attribute contextName="ieSubmitFormFirstName"
     */
    protected String fName;
    /**
     * @jameleon.attribute contextName="ieSubmitFormLastName"
     */
    protected String lName;

    public void testBlock(){
        setWorkingForm(formNameOrId);
        setTextFieldValue("fName", fName);
        setTextFieldValue("lName", lName);
        submitWorkingForm();
    }

}

A use of this function point might look like:

<jmln:submit-customer-form 
    functionId="Enter valid parameters"
    fName="Joe"
    ieSubmitFormLastName="Smith"/>

The above example sets the fName attribute directly and the ieSubmitFormLastName via the context. The lName attribute will then get the value Smith from the context variable.