Behave用户自定义数据类型

在step句子中, 所有的参数默认是string类型, 如果用户想使用复杂的或者其他数据类型, 就需要了解以下bahave中的数据类型.

behave的数据类型转换器是在parse和cfparse中支持.

parse模块是string.format的逆函数.  parse_type是基于parse的扩展, 简化了自定义数据类型的产生.

parse feature

• • 在类型转换器中可选pattern
  • 函数描述符with_pattern()

parse_type feature

• • 简化类型转换器的生成
  • 基于cardinality创建类型转换器
  • 提供扩展的解析器支持cardinality field
    
    

    Cardinality	Example	Description
    0..1	“{person:Person?}”	Zero or one: For optional parts.
    0..*	“{persons:Person*}”	Zero or more: For list<T> (many0).
    1..*	“{persons:Person+}”	One or more: For list<T> (many).

如何定义自定义数据类型

1. 用户注册一个数据类型, 例如在environment.py文件中
2. parse.Parse匹配string作为一个数据类型, 然后它调用类型转换器去转换匹配的文本为目标数据类型

   #普通的类型转换
   from behave import register_type
   
   def parse_number(text):
       """
       Convert parsed text into a number.
       :param text: Parsed text, called by :py:meth:`parse.Parser.parse()`.
       :return: Number instance (integer), created from parsed text.
       """
       return int(text)
   # -- REGISTER: User-defined type converter (parse_type).
   register_type(Number=parse_number)
   
   #带有正则的类型转换
   @parse.with_pattern(r"a\s+")
   def parse_word_a(text):
       """Type converter for "a " (followed by one/more spaces)."""
       return text.strip()
   
   register_type(a_=parse_word_a)

parse中预定义的数据类型

http://jenisys.github.io/behave.example/datatype/builtin_types.html

Cardinality 0 or 1(optional)

#这个实现比上一个实现多了一步 TypeBuilder.with_optional(parse_word_a).
from behave import register_type
from parse_type import TypeBuilder
import parse

@parse.with_pattern(r"a\s+")
def parse_word_a(text):
    """Type converter for "a " (followed by one/more spaces)."""
    return text.strip()

# -- SAME:
# parse_optional_word_a = TypeBuilder.with_zero_or_one(parse_word_a)
parse_optional_word_a   = TypeBuilder.with_optional(parse_word_a)
register_type(optional_a_=parse_optional_word_a)

#step_impl中{:optional_a_}是一个可选项, 在step既可以有"a "也可以没有
@when('attacked by {:optional_a_}{opponent}')
def step_attacked_by(context, a_, opponent):
    context.ninja_fight.opponent = opponent

Cardinality 1++

from behave import register_type
from parse_type import TypeBuilder

company_persons = [ "Alice", "Bob", "Charly", "Dodo" ]
parse_person = TypeBuilder.make_choice(company_persons)
register_type(Person=parse_person)

# -- MANY-TYPE: Persons := list<Person> with list-separator = "and"
# parse_persons = TypeBuilder.with_one_or_more(parse_person, listsep="and")
parse_persons = TypeBuilder.with_many(parse_person, listsep="and")
register_type(PersonAndMore=parse_persons)

# -- NEEDED-UNTIL: parse_type.cfparse.Parser is used by behave.
# parse_persons2 = TypeBuilder.with_many(parse_person)
# type_dict = {"Person+": parse_persons2}
# register_type(**type_dict)

　　Cardinality 0++

from behave import register_type
from parse_type import TypeBuilder

def slurp_space(text):
    return text
slurp_space.pattern = r"\s*"
register_type(slurp_space=slurp_space)

parse_color = TypeBuilder.make_choice([ "red", "green", "blue", "yellow" ])
register_type(Color=parse_color)

# -- MANY-TYPE: Persons := list<Person> with list-separator = "and"
# parse_colors = TypeBuilder.with_many0(parse_color, listsep="and")
parse_colors0A= TypeBuilder.with_zero_or_more(parse_color, listsep="and")
register_type(OptionalColorAndMore=parse_colors0A)