Enumerations in step definition - custom Exception

[tamtadam]

Hi all!

I've tried to put an enumeration in a step definition to restrict the choices in the parameter values but I faced that I cannot set custom Exception for not valid values.
I tried the following code:

from inspect import Arguments
from logging import raiseExceptions

from behave.matchers import NoMatch
from test_app.steps.poms.LoginPOM import LoginPOM
from test_app.steps.poms.MenuPOM import MenuPOM
from enum import Enum

from selenium.common.exceptions import UnexpectedAlertPresentException

from behave import register_type
from parse_type import TypeBuilder

class Fruit( Enum ):
    APPLE      = 'app'
    PINEAPPLE  = 'papp'

choices = TypeBuilder.make_choice(["cucumbers", "lettuce"])
choices_enum = TypeBuilder.make_enum( Fruit )

def dict_parser( text, behave_enum ):
    try:
        behave_enum[ text ]
    except:
        return None
        raise NoMatch( 'Expect True or False, got {}'.format(text) )

register_type( Fruits = lambda text: dict_parser( text, Fruit ) )
register_type( Choices = choices )
register_type( ChoicesEnum = choices_enum )

@step( "Choose from fruits by using function: {param:Fruits}" )
def step_impl(c, param):
    pass

@step( "Choose from Choices: {param:Choices}" )
def step_impl(c, param):
    pass

@step( "Choose from ChoicesEnum: {param:ChoicesEnum}" )
def step_impl(c, param):
    pass

And I got the following output:
@when(u'Choose from Choices: dddd')
def step_impl(context):
raise NotImplementedError(u'STEP: When Choose from Choices: dddd')

@when(u'Choose from ChoicesEnum: dddd')
def step_impl(context):
raise NotImplementedError(u'STEP: When Choose from ChoicesEnum: dddd')

But if I change the dict_parser method to raise en Exception than the code fails with an error because the library couldn't handle the exception.

def dict_parser( text, behave_enum ):
    try:
        behave_enum[ text ]
    except:
        raise NoMatch( 'Expect True or False, got {}'.format(text) )

behave\formatter\pretty.py", line 290, in print_step
for arg in arguments:
TypeError: 'NoneType' object is not iterable

It is possible somehow to handle it or does it require code change?

Thanks in advance!
Br.:
Adam

[jenisys]

All of the examples only match the known values and not the unknown ones (else/otherwise case).
In your case, the problem was that feature file writer has used an "invalid step".
You can check for these kind of problems with: behave --dry-run (detects undefined steps without paying the runtime costs)

POSSIBLE SOLUTIONS (at runtime):

• Add another step-definition after the one for the Enum/Choices that matches the otherwise case
• Use parse_type Variant to handle the otherwise case

EXAMPLE FOR SOLUTION 1:

@step("Choose from Choices: {param:Choices}")
def step_choices(ctx, param):
    # -- CASE: Valid Choices values
    pass

@step("Choose from Choices: {param}")  # OR: {param:w} that only one word should be matched
def step_choices_otherwise(ctx, param):
    # -- CASE: Invalid Choices values
    # POSSIBLE REACTIONS: fail (HERE), ignore it, report problem, ...
    assert false, "INVALID-CHOICES VALUE: %s" % param

[jenisys]

Regarding the Exception in the dict_parser() method:
You should have used StepParseError or ValueError. NoMatch is not an exception class.

HINT:
The dict_parser() method should return something in the good case.