Post summary: Using enumerations or specialized classes makes your automation tests easy to understand and maintain. Show with code samples how to define and read string value to enumeration elements.
When you do automation tests and have to pass a value to a method it is so easy and natural to just use strings. There are many cases where a string is a correct solution. There are also many cases where a string can be a solution, but enumeration or specialized class are better and more efficient solution.
Why not strings
Having the following example – web application with drop down which has several options. We are using Page objects pattern to model the page. Page object has a method which accepts the option to be selected. String seems like a natural solution but is wrong. Although string will work enumeration is the only right solution. Drop down has limited and already defined options that can be selected. Exposing just string may cause misinterpretations for the consumer of your method. It is much more easy to limit the consumer to several enumeration values. In this way, consumer knows what data to provide and this automatically keeps code clean from magic strings. If changes are needed they will be done only in the enumeration making code easier to maintain.
Problem with enumerations in C#
Using enumerations for example given above will not work. Unlike Java enumerations in C# are wrappers for int or other numeric types value. You are not able to use text with enumeration element.
Using string values with enumerations
Only way to use string values in enumerations is by adding it as an attribute to each enumeration’s element. It takes several steps in order to accomplish this.
- Create the attribute class that will be applied to enumeration element
- Create extension method that is responsible for reading a string value from enumeration element
- Apply string value attribute to enumeration element
- Use in code
Below are code samples how to use string values with enumerations in C#. Defining and reading of the attribute is functionality built in NTestsRunner.
Define attribute
The first step is to create a class that extends System. Attribute. It has only one string property to hold the text in it. The text is passed in the constructor. Note that this class is defined in System namespace in order to have it by default skipping the need of importing namespace you might not be aware of.
namespace System
{
public class StringValue : Attribute
{
public string Value { get; private set; }
public StringValue(string value)
{
Value = value;
}
}
}
Read the attribute
C# provides so-called extension methods, a great way to add new functionality to the existing type without creating new derived type. Reading of string value from enumeration element is done with a GetStringValue extension method. With reflection, all StringValue custom attributes of an element are obtained. If some found text of first is returned. If not then string representation of the element is returned.
using System.Reflection;
namespace System
{
public static class ExtensionMethods
{
public static string GetStringValue(this Enum value)
{
string stringValue = value.ToString();
Type type = value.GetType();
FieldInfo fieldInfo = type.GetField(value.ToString());
StringValue[] attrs = fieldInfo.
GetCustomAttributes(typeof(StringValue), false) as StringValue[];
if (attrs.Length > 0)
{
stringValue = attrs[0].Value;
}
return stringValue;
}
}
}
Apply to enumerations
Once StringValue class is ready it can be applied as an attribute to any enumeration.
public enum Messages
{
[StringValue("Problem occured, try again later")]
ProblemOccured,
[StringValue("Successfully done")]
Success
}
Use in code
In code string value can be obtained from enumeration’s element with a GetStringValue method.
Assert.AreEqual(Messages.ProblemOccured.GetStringValue(), App.MessageBox.GetText());
Conclusion
Using enumerations is mandatory to make readable and maintainable automation. Working effectively with enumerations will increase your value as automation specialist.
