testplan.testing package
Subpackages
- testplan.testing.multitest package
- Subpackages
- testplan.testing.multitest.driver package
- Subpackages
- testplan.testing.multitest.driver.tcp package
- Submodules
- testplan.testing.multitest.driver.tcp.client module
TCPClient
TCPClient.CONFIG
TCPClient.EXTRACTORS
TCPClient.STATUS
TCPClient.abort()
TCPClient.abort_dependencies()
TCPClient.aborted
TCPClient.aborting()
TCPClient.active
TCPClient.async_start
TCPClient.auto_start
TCPClient.cfg
TCPClient.close()
TCPClient.connect()
TCPClient.connection_identifier
TCPClient.context
TCPClient.context_input()
TCPClient.define_runpath()
TCPClient.errpath
TCPClient.extract_values()
TCPClient.failover()
TCPClient.fetch_error_log()
TCPClient.filter_locals()
TCPClient.force_started()
TCPClient.force_stop()
TCPClient.get_connections()
TCPClient.host
TCPClient.install_files()
TCPClient.is_alive
TCPClient.local_host
TCPClient.local_port
TCPClient.logger
TCPClient.logpath
TCPClient.make_runpath_dirs()
TCPClient.name
TCPClient.outpath
TCPClient.parent
TCPClient.pause()
TCPClient.pausing()
TCPClient.pending_work()
TCPClient.port
TCPClient.post_start()
TCPClient.post_stop()
TCPClient.pre_start()
TCPClient.pre_stop()
TCPClient.receive()
TCPClient.receive_text()
TCPClient.reconnect()
TCPClient.register_failover()
TCPClient.report
TCPClient.restart()
TCPClient.resume()
TCPClient.resuming()
TCPClient.runpath
TCPClient.scratch
TCPClient.send()
TCPClient.send_text()
TCPClient.send_tsp()
TCPClient.server_port
TCPClient.start()
TCPClient.start_timeout
TCPClient.started_check()
TCPClient.started_check_interval
TCPClient.starting()
TCPClient.status
TCPClient.stop()
TCPClient.stop_timeout
TCPClient.stopped_check()
TCPClient.stopped_check_interval
TCPClient.stopped_check_with_watch()
TCPClient.stopping()
TCPClient.timer
TCPClient.uid()
TCPClient.wait()
TCPClientConfig
- testplan.testing.multitest.driver.tcp.server module
TCPServer
TCPServer.CONFIG
TCPServer.EXTRACTORS
TCPServer.STATUS
TCPServer.abort()
TCPServer.abort_dependencies()
TCPServer.aborted
TCPServer.aborting()
TCPServer.accept_connection()
TCPServer.active
TCPServer.async_start
TCPServer.auto_start
TCPServer.cfg
TCPServer.close_connection()
TCPServer.connection_identifier
TCPServer.context
TCPServer.context_input()
TCPServer.define_runpath()
TCPServer.errpath
TCPServer.extract_values()
TCPServer.failover()
TCPServer.fetch_error_log()
TCPServer.filter_locals()
TCPServer.force_started()
TCPServer.force_stop()
TCPServer.get_connections()
TCPServer.host
TCPServer.install_files()
TCPServer.is_alive
TCPServer.local_host
TCPServer.local_port
TCPServer.logger
TCPServer.logpath
TCPServer.make_runpath_dirs()
TCPServer.name
TCPServer.outpath
TCPServer.parent
TCPServer.pause()
TCPServer.pausing()
TCPServer.pending_work()
TCPServer.port
TCPServer.post_start()
TCPServer.post_stop()
TCPServer.pre_start()
TCPServer.pre_stop()
TCPServer.receive()
TCPServer.receive_text()
TCPServer.register_failover()
TCPServer.report
TCPServer.restart()
TCPServer.resume()
TCPServer.resuming()
TCPServer.runpath
TCPServer.scratch
TCPServer.send()
TCPServer.send_text()
TCPServer.socket
TCPServer.start()
TCPServer.start_timeout
TCPServer.started_check()
TCPServer.started_check_interval
TCPServer.starting()
TCPServer.status
TCPServer.stop()
TCPServer.stop_timeout
TCPServer.stopped_check()
TCPServer.stopped_check_interval
TCPServer.stopped_check_with_watch()
TCPServer.stopping()
TCPServer.timer
TCPServer.uid()
TCPServer.wait()
TCPServerConfig
- testplan.testing.multitest.driver.tcp.client module
- Module contents
- Submodules
- testplan.testing.multitest.driver.zmq package
- Submodules
- testplan.testing.multitest.driver.zmq.client module
ZMQClient
ZMQClient.CONFIG
ZMQClient.EXTRACTORS
ZMQClient.STATUS
ZMQClient.abort()
ZMQClient.abort_dependencies()
ZMQClient.aborted
ZMQClient.aborting()
ZMQClient.active
ZMQClient.async_start
ZMQClient.auto_start
ZMQClient.cfg
ZMQClient.connect()
ZMQClient.context
ZMQClient.context_input()
ZMQClient.define_runpath()
ZMQClient.disconnect()
ZMQClient.errpath
ZMQClient.extract_values()
ZMQClient.failover()
ZMQClient.fetch_error_log()
ZMQClient.filter_locals()
ZMQClient.flush()
ZMQClient.force_started()
ZMQClient.force_stop()
ZMQClient.get_connections()
ZMQClient.hosts
ZMQClient.install_files()
ZMQClient.is_alive
ZMQClient.logger
ZMQClient.logpath
ZMQClient.make_runpath_dirs()
ZMQClient.name
ZMQClient.outpath
ZMQClient.parent
ZMQClient.pause()
ZMQClient.pausing()
ZMQClient.pending_work()
ZMQClient.ports
ZMQClient.post_start()
ZMQClient.post_stop()
ZMQClient.pre_start()
ZMQClient.pre_stop()
ZMQClient.receive()
ZMQClient.reconnect()
ZMQClient.register_failover()
ZMQClient.report
ZMQClient.restart()
ZMQClient.resume()
ZMQClient.resuming()
ZMQClient.runpath
ZMQClient.scratch
ZMQClient.send()
ZMQClient.start()
ZMQClient.start_timeout
ZMQClient.started_check()
ZMQClient.started_check_interval
ZMQClient.starting()
ZMQClient.status
ZMQClient.stop()
ZMQClient.stop_timeout
ZMQClient.stopped_check()
ZMQClient.stopped_check_interval
ZMQClient.stopped_check_with_watch()
ZMQClient.stopping()
ZMQClient.subscribe()
ZMQClient.timer
ZMQClient.uid()
ZMQClient.unsubscribe()
ZMQClient.wait()
ZMQClientConfig
- testplan.testing.multitest.driver.zmq.server module
ZMQServer
ZMQServer.CONFIG
ZMQServer.EXTRACTORS
ZMQServer.STATUS
ZMQServer.abort()
ZMQServer.abort_dependencies()
ZMQServer.aborted
ZMQServer.aborting()
ZMQServer.active
ZMQServer.async_start
ZMQServer.auto_start
ZMQServer.cfg
ZMQServer.connection_identifier
ZMQServer.context
ZMQServer.context_input()
ZMQServer.define_runpath()
ZMQServer.errpath
ZMQServer.extract_values()
ZMQServer.failover()
ZMQServer.fetch_error_log()
ZMQServer.filter_locals()
ZMQServer.force_started()
ZMQServer.force_stop()
ZMQServer.get_connections()
ZMQServer.host
ZMQServer.install_files()
ZMQServer.is_alive
ZMQServer.local_host
ZMQServer.local_port
ZMQServer.logger
ZMQServer.logpath
ZMQServer.make_runpath_dirs()
ZMQServer.name
ZMQServer.outpath
ZMQServer.parent
ZMQServer.pause()
ZMQServer.pausing()
ZMQServer.pending_work()
ZMQServer.port
ZMQServer.post_start()
ZMQServer.post_stop()
ZMQServer.pre_start()
ZMQServer.pre_stop()
ZMQServer.receive()
ZMQServer.register_failover()
ZMQServer.report
ZMQServer.restart()
ZMQServer.resume()
ZMQServer.resuming()
ZMQServer.runpath
ZMQServer.scratch
ZMQServer.send()
ZMQServer.socket
ZMQServer.start()
ZMQServer.start_timeout
ZMQServer.started_check()
ZMQServer.started_check_interval
ZMQServer.starting()
ZMQServer.status
ZMQServer.stop()
ZMQServer.stop_timeout
ZMQServer.stopped_check()
ZMQServer.stopped_check_interval
ZMQServer.stopped_check_with_watch()
ZMQServer.stopping()
ZMQServer.timer
ZMQServer.uid()
ZMQServer.wait()
ZMQServerConfig
- testplan.testing.multitest.driver.zmq.client module
- Module contents
- Submodules
- testplan.testing.multitest.driver.fix package
- Submodules
- testplan.testing.multitest.driver.fix.client module
FixClient
FixClient.CONFIG
FixClient.EXTRACTORS
FixClient.STATUS
FixClient.abort()
FixClient.abort_dependencies()
FixClient.aborted
FixClient.aborting()
FixClient.active
FixClient.async_start
FixClient.auto_start
FixClient.cfg
FixClient.connect()
FixClient.connection_identifier
FixClient.context
FixClient.context_input()
FixClient.define_runpath()
FixClient.errpath
FixClient.extract_values()
FixClient.failover()
FixClient.fetch_error_log()
FixClient.filter_locals()
FixClient.flush()
FixClient.force_started()
FixClient.force_stop()
FixClient.get_connections()
FixClient.host
FixClient.install_files()
FixClient.is_alive
FixClient.local_host
FixClient.local_port
FixClient.logger
FixClient.logoff()
FixClient.logon()
FixClient.logpath
FixClient.make_runpath_dirs()
FixClient.name
FixClient.outpath
FixClient.parent
FixClient.pause()
FixClient.pausing()
FixClient.pending_work()
FixClient.port
FixClient.post_start()
FixClient.post_stop()
FixClient.pre_start()
FixClient.pre_stop()
FixClient.receive()
FixClient.reconnect()
FixClient.register_failover()
FixClient.report
FixClient.restart()
FixClient.resume()
FixClient.resuming()
FixClient.runpath
FixClient.scratch
FixClient.send()
FixClient.send_tsp()
FixClient.sender
FixClient.sendersub
FixClient.start()
FixClient.start_timeout
FixClient.started_check()
FixClient.started_check_interval
FixClient.starting()
FixClient.status
FixClient.stop()
FixClient.stop_timeout
FixClient.stopped_check()
FixClient.stopped_check_interval
FixClient.stopped_check_with_watch()
FixClient.stopping()
FixClient.target
FixClient.timer
FixClient.uid()
FixClient.wait()
FixClientConfig
- testplan.testing.multitest.driver.fix.server module
FixServer
FixServer.CONFIG
FixServer.EXTRACTORS
FixServer.STATUS
FixServer.abort()
FixServer.abort_dependencies()
FixServer.aborted
FixServer.aborting()
FixServer.active
FixServer.active_connections()
FixServer.async_start
FixServer.auto_start
FixServer.cfg
FixServer.connection_identifier
FixServer.context
FixServer.context_input()
FixServer.define_runpath()
FixServer.errpath
FixServer.extract_values()
FixServer.failover()
FixServer.fetch_error_log()
FixServer.filter_locals()
FixServer.flush()
FixServer.force_started()
FixServer.force_stop()
FixServer.get_connections()
FixServer.host
FixServer.install_files()
FixServer.is_alive
FixServer.is_connection_active()
FixServer.local_host
FixServer.local_port
FixServer.logger
FixServer.logpath
FixServer.make_runpath_dirs()
FixServer.name
FixServer.outpath
FixServer.parent
FixServer.pause()
FixServer.pausing()
FixServer.pending_work()
FixServer.port
FixServer.post_start()
FixServer.post_stop()
FixServer.pre_start()
FixServer.pre_stop()
FixServer.receive()
FixServer.register_failover()
FixServer.report
FixServer.restart()
FixServer.resume()
FixServer.resuming()
FixServer.runpath
FixServer.scratch
FixServer.send()
FixServer.start()
FixServer.start_timeout
FixServer.started_check()
FixServer.started_check_interval
FixServer.starting()
FixServer.status
FixServer.stop()
FixServer.stop_timeout
FixServer.stopped_check()
FixServer.stopped_check_interval
FixServer.stopped_check_with_watch()
FixServer.stopping()
FixServer.timer
FixServer.uid()
FixServer.wait()
FixServerConfig
- testplan.testing.multitest.driver.fix.client module
- Module contents
- Submodules
- testplan.testing.multitest.driver.http package
- Submodules
- testplan.testing.multitest.driver.http.client module
HTTPClient
HTTPClient.CONFIG
HTTPClient.EXTRACTORS
HTTPClient.STATUS
HTTPClient.abort()
HTTPClient.abort_dependencies()
HTTPClient.aborted
HTTPClient.aborting()
HTTPClient.active
HTTPClient.async_start
HTTPClient.auto_start
HTTPClient.cfg
HTTPClient.connection_identifier
HTTPClient.context
HTTPClient.context_input()
HTTPClient.define_runpath()
HTTPClient.delete()
HTTPClient.errpath
HTTPClient.extract_values()
HTTPClient.failover()
HTTPClient.fetch_error_log()
HTTPClient.filter_locals()
HTTPClient.flush()
HTTPClient.force_started()
HTTPClient.force_stop()
HTTPClient.get()
HTTPClient.get_connections()
HTTPClient.head()
HTTPClient.host
HTTPClient.install_files()
HTTPClient.is_alive
HTTPClient.logger
HTTPClient.logpath
HTTPClient.make_runpath_dirs()
HTTPClient.name
HTTPClient.options()
HTTPClient.outpath
HTTPClient.parent
HTTPClient.patch()
HTTPClient.pause()
HTTPClient.pausing()
HTTPClient.pending_work()
HTTPClient.port
HTTPClient.post()
HTTPClient.post_start()
HTTPClient.post_stop()
HTTPClient.pre_start()
HTTPClient.pre_stop()
HTTPClient.put()
HTTPClient.receive()
HTTPClient.register_failover()
HTTPClient.report
HTTPClient.restart()
HTTPClient.resume()
HTTPClient.resuming()
HTTPClient.runpath
HTTPClient.scratch
HTTPClient.send()
HTTPClient.start()
HTTPClient.start_timeout
HTTPClient.started_check()
HTTPClient.started_check_interval
HTTPClient.starting()
HTTPClient.status
HTTPClient.stop()
HTTPClient.stop_timeout
HTTPClient.stopped_check()
HTTPClient.stopped_check_interval
HTTPClient.stopped_check_with_watch()
HTTPClient.stopping()
HTTPClient.timer
HTTPClient.uid()
HTTPClient.wait()
HTTPClientConfig
- testplan.testing.multitest.driver.http.server module
HTTPRequestHandler
HTTPRequestHandler.MessageClass
HTTPRequestHandler.address_string()
HTTPRequestHandler.date_time_string()
HTTPRequestHandler.default_request_version
HTTPRequestHandler.disable_nagle_algorithm
HTTPRequestHandler.do_DELETE()
HTTPRequestHandler.do_GET()
HTTPRequestHandler.do_HEAD()
HTTPRequestHandler.do_OPTIONS()
HTTPRequestHandler.do_PATCH()
HTTPRequestHandler.do_POST()
HTTPRequestHandler.do_PUT()
HTTPRequestHandler.end_headers()
HTTPRequestHandler.error_content_type
HTTPRequestHandler.error_message_format
HTTPRequestHandler.finish()
HTTPRequestHandler.flush_headers()
HTTPRequestHandler.get_response()
HTTPRequestHandler.handle()
HTTPRequestHandler.handle_expect_100()
HTTPRequestHandler.handle_one_request()
HTTPRequestHandler.log_date_time_string()
HTTPRequestHandler.log_error()
HTTPRequestHandler.log_message()
HTTPRequestHandler.log_request()
HTTPRequestHandler.monthname
HTTPRequestHandler.parse_request()
HTTPRequestHandler.protocol_version
HTTPRequestHandler.rbufsize
HTTPRequestHandler.responses
HTTPRequestHandler.send_error()
HTTPRequestHandler.send_header()
HTTPRequestHandler.send_response()
HTTPRequestHandler.send_response_only()
HTTPRequestHandler.server_version
HTTPRequestHandler.setup()
HTTPRequestHandler.sys_version
HTTPRequestHandler.timeout
HTTPRequestHandler.version_string()
HTTPRequestHandler.wbufsize
HTTPRequestHandler.weekdayname
HTTPResponse
HTTPServer
HTTPServer.CONFIG
HTTPServer.EXTRACTORS
HTTPServer.STATUS
HTTPServer.abort()
HTTPServer.abort_dependencies()
HTTPServer.aborted
HTTPServer.aborting()
HTTPServer.active
HTTPServer.async_start
HTTPServer.auto_start
HTTPServer.cfg
HTTPServer.connection_identifier
HTTPServer.context
HTTPServer.context_input()
HTTPServer.define_runpath()
HTTPServer.errpath
HTTPServer.extract_values()
HTTPServer.failover()
HTTPServer.fetch_error_log()
HTTPServer.filter_locals()
HTTPServer.flush_request_queue()
HTTPServer.force_started()
HTTPServer.force_stop()
HTTPServer.get_connections()
HTTPServer.get_full_request()
HTTPServer.get_request()
HTTPServer.host
HTTPServer.install_files()
HTTPServer.is_alive
HTTPServer.local_host
HTTPServer.local_port
HTTPServer.logger
HTTPServer.logpath
HTTPServer.make_runpath_dirs()
HTTPServer.name
HTTPServer.outpath
HTTPServer.parent
HTTPServer.pause()
HTTPServer.pausing()
HTTPServer.pending_work()
HTTPServer.port
HTTPServer.post_start()
HTTPServer.post_stop()
HTTPServer.pre_start()
HTTPServer.pre_stop()
HTTPServer.queue_response()
HTTPServer.receive()
HTTPServer.register_failover()
HTTPServer.report
HTTPServer.respond()
HTTPServer.restart()
HTTPServer.resume()
HTTPServer.resuming()
HTTPServer.runpath
HTTPServer.scratch
HTTPServer.start()
HTTPServer.start_timeout
HTTPServer.started_check()
HTTPServer.started_check_interval
HTTPServer.starting()
HTTPServer.status
HTTPServer.stop()
HTTPServer.stop_timeout
HTTPServer.stopped_check()
HTTPServer.stopped_check_interval
HTTPServer.stopped_check_with_watch()
HTTPServer.stopping()
HTTPServer.timer
HTTPServer.uid()
HTTPServer.wait()
HTTPServerConfig
ReceivedRequest
- testplan.testing.multitest.driver.http.client module
- Module contents
- Submodules
- testplan.testing.multitest.driver.connection package
- Submodules
- testplan.testing.multitest.driver.connection.base module
- testplan.testing.multitest.driver.connection.connection_info module
- testplan.testing.multitest.driver.connection.connection_extractor module
- Module contents
- Submodules
- testplan.testing.multitest.driver.tcp package
- Submodules
- testplan.testing.multitest.driver.app module
App
App.CONFIG
App.EXTRACTORS
App.STATUS
App.abort()
App.abort_dependencies()
App.aborted
App.aborting()
App.active
App.alive_child_procs
App.app_path
App.async_start
App.auto_start
App.binary
App.binpath
App.cfg
App.cmd
App.context
App.context_input()
App.define_runpath()
App.env
App.errpath
App.etcpath
App.extract_values()
App.failover()
App.fetch_error_log()
App.filter_locals()
App.force_started()
App.force_stop()
App.get_connections()
App.hostname
App.install_files()
App.is_alive
App.log_matcher
App.logger
App.logname
App.logpath
App.make_runpath_dirs()
App.name
App.outpath
App.parent
App.pause()
App.pausing()
App.pending_work()
App.pid
App.post_start()
App.post_stop()
App.pre_start()
App.pre_stop()
App.register_failover()
App.report
App.resolved_bin
App.restart()
App.resume()
App.resuming()
App.retcode
App.runpath
App.scratch
App.start()
App.start_timeout
App.started_check()
App.started_check_interval
App.starting()
App.status
App.stop()
App.stop_timeout
App.stopped_check()
App.stopped_check_interval
App.stopped_check_with_watch()
App.stopping()
App.timer
App.uid()
App.wait()
AppConfig
OrphanedProcessException
- testplan.testing.multitest.driver.base module
Driver
Driver.CONFIG
Driver.EXTRACTORS
Driver.aborting()
Driver.async_start
Driver.errpath
Driver.extract_values()
Driver.fetch_error_log()
Driver.get_connections()
Driver.install_files()
Driver.logpath
Driver.name
Driver.outpath
Driver.pre_start()
Driver.start_timeout
Driver.started_check()
Driver.started_check_interval
Driver.starting()
Driver.stop_timeout
Driver.stopped_check()
Driver.stopped_check_interval
Driver.stopped_check_with_watch()
Driver.stopping()
Driver.uid()
Driver.wait()
DriverConfig
- testplan.testing.multitest.driver.sqlite module
Sqlite3
Sqlite3.CONFIG
Sqlite3.EXTRACTORS
Sqlite3.STATUS
Sqlite3.abort()
Sqlite3.abort_dependencies()
Sqlite3.aborted
Sqlite3.aborting()
Sqlite3.active
Sqlite3.async_start
Sqlite3.auto_start
Sqlite3.cfg
Sqlite3.commit()
Sqlite3.commit_at_exit()
Sqlite3.connect()
Sqlite3.context
Sqlite3.context_input()
Sqlite3.db_path
Sqlite3.define_runpath()
Sqlite3.errpath
Sqlite3.execute()
Sqlite3.executemany()
Sqlite3.extract_values()
Sqlite3.failover()
Sqlite3.fetch_error_log()
Sqlite3.fetch_table()
Sqlite3.fetchall()
Sqlite3.fetchone()
Sqlite3.filter_locals()
Sqlite3.force_started()
Sqlite3.force_stop()
Sqlite3.get_connections()
Sqlite3.install_files()
Sqlite3.is_alive
Sqlite3.logger
Sqlite3.logpath
Sqlite3.make_runpath_dirs()
Sqlite3.name
Sqlite3.outpath
Sqlite3.parent
Sqlite3.pause()
Sqlite3.pausing()
Sqlite3.pending_work()
Sqlite3.post_start()
Sqlite3.post_stop()
Sqlite3.pre_start()
Sqlite3.pre_stop()
Sqlite3.register_failover()
Sqlite3.report
Sqlite3.restart()
Sqlite3.resume()
Sqlite3.resuming()
Sqlite3.runpath
Sqlite3.scratch
Sqlite3.start()
Sqlite3.start_timeout
Sqlite3.started_check()
Sqlite3.started_check_interval
Sqlite3.starting()
Sqlite3.status
Sqlite3.stop()
Sqlite3.stop_timeout
Sqlite3.stopped_check()
Sqlite3.stopped_check_interval
Sqlite3.stopped_check_with_watch()
Sqlite3.stopping()
Sqlite3.timer
Sqlite3.uid()
Sqlite3.wait()
Sqlite3Config
- testplan.testing.multitest.driver.kafka module
- testplan.testing.multitest.driver.zookeeper module
ZookeeperStandalone
ZookeeperStandalone.CONFIG
ZookeeperStandalone.EXTRACTORS
ZookeeperStandalone.connection_identifier
ZookeeperStandalone.connection_str
ZookeeperStandalone.env
ZookeeperStandalone.host
ZookeeperStandalone.local_host
ZookeeperStandalone.local_port
ZookeeperStandalone.port
ZookeeperStandalone.post_start()
ZookeeperStandalone.pre_start()
ZookeeperStandalone.starting()
ZookeeperStandalone.stopping()
ZookeeperStandaloneConfig
- testplan.testing.multitest.driver.app module
- Module contents
Driver
Driver.CONFIG
Driver.EXTRACTORS
Driver.aborting()
Driver.async_start
Driver.errpath
Driver.extract_values()
Driver.fetch_error_log()
Driver.get_connections()
Driver.install_files()
Driver.logpath
Driver.name
Driver.outpath
Driver.pre_start()
Driver.start_timeout
Driver.started_check()
Driver.started_check_interval
Driver.starting()
Driver.stop_timeout
Driver.stopped_check()
Driver.stopped_check_interval
Driver.stopped_check_with_watch()
Driver.stopping()
Driver.uid()
Driver.wait()
DriverConfig
- Subpackages
- testplan.testing.multitest.entries package
- Subpackages
- testplan.testing.multitest.entries.schemas package
- Submodules
- testplan.testing.multitest.entries.schemas.assertions module
ApproximateEqualitySchema
ApproximateEqualitySchema.Meta
ApproximateEqualitySchema.Meta.additional
ApproximateEqualitySchema.Meta.dateformat
ApproximateEqualitySchema.Meta.datetimeformat
ApproximateEqualitySchema.Meta.dump_only
ApproximateEqualitySchema.Meta.exclude
ApproximateEqualitySchema.Meta.fields
ApproximateEqualitySchema.Meta.include
ApproximateEqualitySchema.Meta.index_errors
ApproximateEqualitySchema.Meta.load_only
ApproximateEqualitySchema.Meta.many
ApproximateEqualitySchema.Meta.ordered
ApproximateEqualitySchema.Meta.register
ApproximateEqualitySchema.Meta.render_module
ApproximateEqualitySchema.Meta.timeformat
ApproximateEqualitySchema.Meta.unknown
ApproximateEqualitySchema.OPTIONS_CLASS
ApproximateEqualitySchema.TYPE_MAPPING
ApproximateEqualitySchema.dict_class
ApproximateEqualitySchema.dump()
ApproximateEqualitySchema.dumps()
ApproximateEqualitySchema.error_messages
ApproximateEqualitySchema.fields
ApproximateEqualitySchema.from_dict()
ApproximateEqualitySchema.get_attribute()
ApproximateEqualitySchema.handle_error()
ApproximateEqualitySchema.load()
ApproximateEqualitySchema.loads()
ApproximateEqualitySchema.on_bind_field()
ApproximateEqualitySchema.opts
ApproximateEqualitySchema.set_class
ApproximateEqualitySchema.streamline()
ApproximateEqualitySchema.validate()
AssertionSchema
AssertionSchema.Meta
AssertionSchema.Meta.additional
AssertionSchema.Meta.dateformat
AssertionSchema.Meta.datetimeformat
AssertionSchema.Meta.dump_only
AssertionSchema.Meta.exclude
AssertionSchema.Meta.fields
AssertionSchema.Meta.include
AssertionSchema.Meta.index_errors
AssertionSchema.Meta.load_only
AssertionSchema.Meta.many
AssertionSchema.Meta.ordered
AssertionSchema.Meta.register
AssertionSchema.Meta.render_module
AssertionSchema.Meta.timeformat
AssertionSchema.Meta.unknown
AssertionSchema.OPTIONS_CLASS
AssertionSchema.TYPE_MAPPING
AssertionSchema.dict_class
AssertionSchema.dump()
AssertionSchema.dumps()
AssertionSchema.error_messages
AssertionSchema.fields
AssertionSchema.from_dict()
AssertionSchema.get_attribute()
AssertionSchema.handle_error()
AssertionSchema.load()
AssertionSchema.loads()
AssertionSchema.on_bind_field()
AssertionSchema.opts
AssertionSchema.set_class
AssertionSchema.streamline()
AssertionSchema.validate()
AtMostOneList
BooleanSchema
BooleanSchema.Meta
BooleanSchema.Meta.additional
BooleanSchema.Meta.dateformat
BooleanSchema.Meta.datetimeformat
BooleanSchema.Meta.dump_only
BooleanSchema.Meta.exclude
BooleanSchema.Meta.fields
BooleanSchema.Meta.include
BooleanSchema.Meta.index_errors
BooleanSchema.Meta.load_only
BooleanSchema.Meta.many
BooleanSchema.Meta.ordered
BooleanSchema.Meta.register
BooleanSchema.Meta.render_module
BooleanSchema.Meta.timeformat
BooleanSchema.Meta.unknown
BooleanSchema.OPTIONS_CLASS
BooleanSchema.TYPE_MAPPING
BooleanSchema.dict_class
BooleanSchema.dump()
BooleanSchema.dump_fields
BooleanSchema.dumps()
BooleanSchema.error_messages
BooleanSchema.exclude
BooleanSchema.fields
BooleanSchema.from_dict()
BooleanSchema.get_attribute()
BooleanSchema.handle_error()
BooleanSchema.load()
BooleanSchema.load_fields
BooleanSchema.loads()
BooleanSchema.on_bind_field()
BooleanSchema.opts
BooleanSchema.set_class
BooleanSchema.streamline()
BooleanSchema.validate()
ColumnContainSchema
ColumnContainSchema.Meta
ColumnContainSchema.Meta.additional
ColumnContainSchema.Meta.dateformat
ColumnContainSchema.Meta.datetimeformat
ColumnContainSchema.Meta.dump_only
ColumnContainSchema.Meta.exclude
ColumnContainSchema.Meta.fields
ColumnContainSchema.Meta.include
ColumnContainSchema.Meta.index_errors
ColumnContainSchema.Meta.load_only
ColumnContainSchema.Meta.many
ColumnContainSchema.Meta.ordered
ColumnContainSchema.Meta.register
ColumnContainSchema.Meta.render_module
ColumnContainSchema.Meta.timeformat
ColumnContainSchema.Meta.unknown
ColumnContainSchema.OPTIONS_CLASS
ColumnContainSchema.TYPE_MAPPING
ColumnContainSchema.dict_class
ColumnContainSchema.dump()
ColumnContainSchema.dump_fields
ColumnContainSchema.dumps()
ColumnContainSchema.error_messages
ColumnContainSchema.exclude
ColumnContainSchema.fields
ColumnContainSchema.from_dict()
ColumnContainSchema.get_attribute()
ColumnContainSchema.handle_error()
ColumnContainSchema.load()
ColumnContainSchema.load_fields
ColumnContainSchema.loads()
ColumnContainSchema.on_bind_field()
ColumnContainSchema.opts
ColumnContainSchema.set_class
ColumnContainSchema.streamline()
ColumnContainSchema.validate()
DictCheckSchema
DictCheckSchema.Meta
DictCheckSchema.Meta.additional
DictCheckSchema.Meta.dateformat
DictCheckSchema.Meta.datetimeformat
DictCheckSchema.Meta.dump_only
DictCheckSchema.Meta.exclude
DictCheckSchema.Meta.fields
DictCheckSchema.Meta.include
DictCheckSchema.Meta.index_errors
DictCheckSchema.Meta.load_only
DictCheckSchema.Meta.many
DictCheckSchema.Meta.ordered
DictCheckSchema.Meta.register
DictCheckSchema.Meta.render_module
DictCheckSchema.Meta.timeformat
DictCheckSchema.Meta.unknown
DictCheckSchema.OPTIONS_CLASS
DictCheckSchema.TYPE_MAPPING
DictCheckSchema.dict_class
DictCheckSchema.dump()
DictCheckSchema.dump_fields
DictCheckSchema.dumps()
DictCheckSchema.error_messages
DictCheckSchema.exclude
DictCheckSchema.fields
DictCheckSchema.from_dict()
DictCheckSchema.get_attribute()
DictCheckSchema.handle_error()
DictCheckSchema.load()
DictCheckSchema.load_fields
DictCheckSchema.loads()
DictCheckSchema.on_bind_field()
DictCheckSchema.opts
DictCheckSchema.set_class
DictCheckSchema.streamline()
DictCheckSchema.validate()
DictMatchAllSchema
DictMatchAllSchema.Meta
DictMatchAllSchema.Meta.additional
DictMatchAllSchema.Meta.dateformat
DictMatchAllSchema.Meta.datetimeformat
DictMatchAllSchema.Meta.dump_only
DictMatchAllSchema.Meta.exclude
DictMatchAllSchema.Meta.fields
DictMatchAllSchema.Meta.include
DictMatchAllSchema.Meta.index_errors
DictMatchAllSchema.Meta.load_only
DictMatchAllSchema.Meta.many
DictMatchAllSchema.Meta.ordered
DictMatchAllSchema.Meta.register
DictMatchAllSchema.Meta.render_module
DictMatchAllSchema.Meta.timeformat
DictMatchAllSchema.Meta.unknown
DictMatchAllSchema.OPTIONS_CLASS
DictMatchAllSchema.TYPE_MAPPING
DictMatchAllSchema.compress_level()
DictMatchAllSchema.dict_class
DictMatchAllSchema.dump()
DictMatchAllSchema.dump_fields
DictMatchAllSchema.dumps()
DictMatchAllSchema.error_messages
DictMatchAllSchema.exclude
DictMatchAllSchema.fields
DictMatchAllSchema.from_dict()
DictMatchAllSchema.get_attribute()
DictMatchAllSchema.handle_error()
DictMatchAllSchema.load()
DictMatchAllSchema.load_fields
DictMatchAllSchema.loads()
DictMatchAllSchema.on_bind_field()
DictMatchAllSchema.opts
DictMatchAllSchema.set_class
DictMatchAllSchema.streamline()
DictMatchAllSchema.validate()
DictMatchSchema
DictMatchSchema.Meta
DictMatchSchema.Meta.additional
DictMatchSchema.Meta.dateformat
DictMatchSchema.Meta.datetimeformat
DictMatchSchema.Meta.dump_only
DictMatchSchema.Meta.exclude
DictMatchSchema.Meta.fields
DictMatchSchema.Meta.include
DictMatchSchema.Meta.index_errors
DictMatchSchema.Meta.load_only
DictMatchSchema.Meta.many
DictMatchSchema.Meta.ordered
DictMatchSchema.Meta.register
DictMatchSchema.Meta.render_module
DictMatchSchema.Meta.timeformat
DictMatchSchema.Meta.unknown
DictMatchSchema.OPTIONS_CLASS
DictMatchSchema.TYPE_MAPPING
DictMatchSchema.compress_level()
DictMatchSchema.dict_class
DictMatchSchema.dump()
DictMatchSchema.dump_fields
DictMatchSchema.dumps()
DictMatchSchema.error_messages
DictMatchSchema.exclude
DictMatchSchema.fields
DictMatchSchema.from_dict()
DictMatchSchema.get_attribute()
DictMatchSchema.handle_error()
DictMatchSchema.load()
DictMatchSchema.load_fields
DictMatchSchema.loads()
DictMatchSchema.on_bind_field()
DictMatchSchema.opts
DictMatchSchema.set_class
DictMatchSchema.streamline()
DictMatchSchema.validate()
EqualSchema
EqualSchema.Meta
EqualSchema.Meta.additional
EqualSchema.Meta.dateformat
EqualSchema.Meta.datetimeformat
EqualSchema.Meta.dump_only
EqualSchema.Meta.exclude
EqualSchema.Meta.fields
EqualSchema.Meta.include
EqualSchema.Meta.index_errors
EqualSchema.Meta.load_only
EqualSchema.Meta.many
EqualSchema.Meta.ordered
EqualSchema.Meta.register
EqualSchema.Meta.render_module
EqualSchema.Meta.timeformat
EqualSchema.Meta.unknown
EqualSchema.OPTIONS_CLASS
EqualSchema.TYPE_MAPPING
EqualSchema.dict_class
EqualSchema.dump()
EqualSchema.dump_fields
EqualSchema.dumps()
EqualSchema.error_messages
EqualSchema.exclude
EqualSchema.fields
EqualSchema.from_dict()
EqualSchema.get_attribute()
EqualSchema.handle_error()
EqualSchema.load()
EqualSchema.load_fields
EqualSchema.loads()
EqualSchema.on_bind_field()
EqualSchema.opts
EqualSchema.set_class
EqualSchema.streamline()
EqualSchema.validate()
EqualSlicesSchema
EqualSlicesSchema.Meta
EqualSlicesSchema.Meta.additional
EqualSlicesSchema.Meta.dateformat
EqualSlicesSchema.Meta.datetimeformat
EqualSlicesSchema.Meta.dump_only
EqualSlicesSchema.Meta.exclude
EqualSlicesSchema.Meta.fields
EqualSlicesSchema.Meta.include
EqualSlicesSchema.Meta.index_errors
EqualSlicesSchema.Meta.load_only
EqualSlicesSchema.Meta.many
EqualSlicesSchema.Meta.ordered
EqualSlicesSchema.Meta.register
EqualSlicesSchema.Meta.render_module
EqualSlicesSchema.Meta.timeformat
EqualSlicesSchema.Meta.unknown
EqualSlicesSchema.OPTIONS_CLASS
EqualSlicesSchema.TYPE_MAPPING
EqualSlicesSchema.dict_class
EqualSlicesSchema.dump()
EqualSlicesSchema.dump_fields
EqualSlicesSchema.dumps()
EqualSlicesSchema.error_messages
EqualSlicesSchema.exclude
EqualSlicesSchema.fields
EqualSlicesSchema.from_dict()
EqualSlicesSchema.get_attribute()
EqualSlicesSchema.handle_error()
EqualSlicesSchema.load()
EqualSlicesSchema.load_fields
EqualSlicesSchema.loads()
EqualSlicesSchema.on_bind_field()
EqualSlicesSchema.opts
EqualSlicesSchema.set_class
EqualSlicesSchema.streamline()
EqualSlicesSchema.validate()
ExceptionRaisedSchema
ExceptionRaisedSchema.Meta
ExceptionRaisedSchema.Meta.additional
ExceptionRaisedSchema.Meta.dateformat
ExceptionRaisedSchema.Meta.datetimeformat
ExceptionRaisedSchema.Meta.dump_only
ExceptionRaisedSchema.Meta.exclude
ExceptionRaisedSchema.Meta.fields
ExceptionRaisedSchema.Meta.include
ExceptionRaisedSchema.Meta.index_errors
ExceptionRaisedSchema.Meta.load_only
ExceptionRaisedSchema.Meta.many
ExceptionRaisedSchema.Meta.ordered
ExceptionRaisedSchema.Meta.register
ExceptionRaisedSchema.Meta.render_module
ExceptionRaisedSchema.Meta.timeformat
ExceptionRaisedSchema.Meta.unknown
ExceptionRaisedSchema.OPTIONS_CLASS
ExceptionRaisedSchema.TYPE_MAPPING
ExceptionRaisedSchema.dict_class
ExceptionRaisedSchema.dump()
ExceptionRaisedSchema.dump_fields
ExceptionRaisedSchema.dumps()
ExceptionRaisedSchema.error_messages
ExceptionRaisedSchema.exclude
ExceptionRaisedSchema.fields
ExceptionRaisedSchema.from_dict()
ExceptionRaisedSchema.get_attribute()
ExceptionRaisedSchema.handle_error()
ExceptionRaisedSchema.load()
ExceptionRaisedSchema.load_fields
ExceptionRaisedSchema.loads()
ExceptionRaisedSchema.on_bind_field()
ExceptionRaisedSchema.opts
ExceptionRaisedSchema.set_class
ExceptionRaisedSchema.streamline()
ExceptionRaisedSchema.validate()
FailSchema
FailSchema.Meta
FailSchema.Meta.additional
FailSchema.Meta.dateformat
FailSchema.Meta.datetimeformat
FailSchema.Meta.dump_only
FailSchema.Meta.exclude
FailSchema.Meta.fields
FailSchema.Meta.include
FailSchema.Meta.index_errors
FailSchema.Meta.load_only
FailSchema.Meta.many
FailSchema.Meta.ordered
FailSchema.Meta.register
FailSchema.Meta.render_module
FailSchema.Meta.timeformat
FailSchema.Meta.unknown
FailSchema.OPTIONS_CLASS
FailSchema.TYPE_MAPPING
FailSchema.dict_class
FailSchema.dump()
FailSchema.dump_fields
FailSchema.dumps()
FailSchema.error_messages
FailSchema.exclude
FailSchema.fields
FailSchema.from_dict()
FailSchema.get_attribute()
FailSchema.handle_error()
FailSchema.load()
FailSchema.load_fields
FailSchema.loads()
FailSchema.on_bind_field()
FailSchema.opts
FailSchema.set_class
FailSchema.streamline()
FailSchema.validate()
FuncAssertionSchema
FuncAssertionSchema.Meta
FuncAssertionSchema.Meta.additional
FuncAssertionSchema.Meta.dateformat
FuncAssertionSchema.Meta.datetimeformat
FuncAssertionSchema.Meta.dump_only
FuncAssertionSchema.Meta.exclude
FuncAssertionSchema.Meta.fields
FuncAssertionSchema.Meta.include
FuncAssertionSchema.Meta.index_errors
FuncAssertionSchema.Meta.load_only
FuncAssertionSchema.Meta.many
FuncAssertionSchema.Meta.ordered
FuncAssertionSchema.Meta.register
FuncAssertionSchema.Meta.render_module
FuncAssertionSchema.Meta.timeformat
FuncAssertionSchema.Meta.unknown
FuncAssertionSchema.OPTIONS_CLASS
FuncAssertionSchema.TYPE_MAPPING
FuncAssertionSchema.dict_class
FuncAssertionSchema.dump()
FuncAssertionSchema.dump_fields
FuncAssertionSchema.dumps()
FuncAssertionSchema.error_messages
FuncAssertionSchema.exclude
FuncAssertionSchema.fields
FuncAssertionSchema.from_dict()
FuncAssertionSchema.get_attribute()
FuncAssertionSchema.handle_error()
FuncAssertionSchema.load()
FuncAssertionSchema.load_fields
FuncAssertionSchema.loads()
FuncAssertionSchema.on_bind_field()
FuncAssertionSchema.opts
FuncAssertionSchema.set_class
FuncAssertionSchema.streamline()
FuncAssertionSchema.validate()
LineDiffSchema
LineDiffSchema.Meta
LineDiffSchema.Meta.additional
LineDiffSchema.Meta.dateformat
LineDiffSchema.Meta.datetimeformat
LineDiffSchema.Meta.dump_only
LineDiffSchema.Meta.exclude
LineDiffSchema.Meta.fields
LineDiffSchema.Meta.include
LineDiffSchema.Meta.index_errors
LineDiffSchema.Meta.load_only
LineDiffSchema.Meta.many
LineDiffSchema.Meta.ordered
LineDiffSchema.Meta.register
LineDiffSchema.Meta.render_module
LineDiffSchema.Meta.timeformat
LineDiffSchema.Meta.unknown
LineDiffSchema.OPTIONS_CLASS
LineDiffSchema.TYPE_MAPPING
LineDiffSchema.dict_class
LineDiffSchema.dump()
LineDiffSchema.dump_fields
LineDiffSchema.dumps()
LineDiffSchema.error_messages
LineDiffSchema.exclude
LineDiffSchema.fields
LineDiffSchema.from_dict()
LineDiffSchema.get_attribute()
LineDiffSchema.handle_error()
LineDiffSchema.load()
LineDiffSchema.load_fields
LineDiffSchema.loads()
LineDiffSchema.on_bind_field()
LineDiffSchema.opts
LineDiffSchema.set_class
LineDiffSchema.streamline()
LineDiffSchema.validate()
LogfileMatchResultSchema
LogfileMatchResultSchema.Meta
LogfileMatchResultSchema.Meta.additional
LogfileMatchResultSchema.Meta.dateformat
LogfileMatchResultSchema.Meta.datetimeformat
LogfileMatchResultSchema.Meta.dump_only
LogfileMatchResultSchema.Meta.exclude
LogfileMatchResultSchema.Meta.fields
LogfileMatchResultSchema.Meta.include
LogfileMatchResultSchema.Meta.index_errors
LogfileMatchResultSchema.Meta.load_only
LogfileMatchResultSchema.Meta.many
LogfileMatchResultSchema.Meta.ordered
LogfileMatchResultSchema.Meta.register
LogfileMatchResultSchema.Meta.render_module
LogfileMatchResultSchema.Meta.timeformat
LogfileMatchResultSchema.Meta.unknown
LogfileMatchResultSchema.OPTIONS_CLASS
LogfileMatchResultSchema.TYPE_MAPPING
LogfileMatchResultSchema.dict_class
LogfileMatchResultSchema.dump()
LogfileMatchResultSchema.dumps()
LogfileMatchResultSchema.error_messages
LogfileMatchResultSchema.fields
LogfileMatchResultSchema.from_dict()
LogfileMatchResultSchema.get_attribute()
LogfileMatchResultSchema.handle_error()
LogfileMatchResultSchema.load()
LogfileMatchResultSchema.loads()
LogfileMatchResultSchema.on_bind_field()
LogfileMatchResultSchema.opts
LogfileMatchResultSchema.set_class
LogfileMatchResultSchema.validate()
LogfileMatchSchema
LogfileMatchSchema.Meta
LogfileMatchSchema.Meta.additional
LogfileMatchSchema.Meta.dateformat
LogfileMatchSchema.Meta.datetimeformat
LogfileMatchSchema.Meta.dump_only
LogfileMatchSchema.Meta.exclude
LogfileMatchSchema.Meta.fields
LogfileMatchSchema.Meta.include
LogfileMatchSchema.Meta.index_errors
LogfileMatchSchema.Meta.load_only
LogfileMatchSchema.Meta.many
LogfileMatchSchema.Meta.ordered
LogfileMatchSchema.Meta.register
LogfileMatchSchema.Meta.render_module
LogfileMatchSchema.Meta.timeformat
LogfileMatchSchema.Meta.unknown
LogfileMatchSchema.OPTIONS_CLASS
LogfileMatchSchema.TYPE_MAPPING
LogfileMatchSchema.dict_class
LogfileMatchSchema.dump()
LogfileMatchSchema.dump_fields
LogfileMatchSchema.dumps()
LogfileMatchSchema.error_messages
LogfileMatchSchema.exclude
LogfileMatchSchema.fields
LogfileMatchSchema.from_dict()
LogfileMatchSchema.get_attribute()
LogfileMatchSchema.handle_error()
LogfileMatchSchema.load()
LogfileMatchSchema.load_fields
LogfileMatchSchema.loads()
LogfileMatchSchema.on_bind_field()
LogfileMatchSchema.opts
LogfileMatchSchema.set_class
LogfileMatchSchema.streamline()
LogfileMatchSchema.validate()
MembershipSchema
MembershipSchema.Meta
MembershipSchema.Meta.additional
MembershipSchema.Meta.dateformat
MembershipSchema.Meta.datetimeformat
MembershipSchema.Meta.dump_only
MembershipSchema.Meta.exclude
MembershipSchema.Meta.fields
MembershipSchema.Meta.include
MembershipSchema.Meta.index_errors
MembershipSchema.Meta.load_only
MembershipSchema.Meta.many
MembershipSchema.Meta.ordered
MembershipSchema.Meta.register
MembershipSchema.Meta.render_module
MembershipSchema.Meta.timeformat
MembershipSchema.Meta.unknown
MembershipSchema.OPTIONS_CLASS
MembershipSchema.TYPE_MAPPING
MembershipSchema.dict_class
MembershipSchema.dump()
MembershipSchema.dump_fields
MembershipSchema.dumps()
MembershipSchema.error_messages
MembershipSchema.exclude
MembershipSchema.fields
MembershipSchema.from_dict()
MembershipSchema.get_attribute()
MembershipSchema.handle_error()
MembershipSchema.load()
MembershipSchema.load_fields
MembershipSchema.loads()
MembershipSchema.on_bind_field()
MembershipSchema.opts
MembershipSchema.set_class
MembershipSchema.streamline()
MembershipSchema.validate()
RawAssertionSchema
RawAssertionSchema.Meta
RawAssertionSchema.Meta.additional
RawAssertionSchema.Meta.dateformat
RawAssertionSchema.Meta.datetimeformat
RawAssertionSchema.Meta.dump_only
RawAssertionSchema.Meta.exclude
RawAssertionSchema.Meta.fields
RawAssertionSchema.Meta.include
RawAssertionSchema.Meta.index_errors
RawAssertionSchema.Meta.load_only
RawAssertionSchema.Meta.many
RawAssertionSchema.Meta.ordered
RawAssertionSchema.Meta.register
RawAssertionSchema.Meta.render_module
RawAssertionSchema.Meta.timeformat
RawAssertionSchema.Meta.unknown
RawAssertionSchema.OPTIONS_CLASS
RawAssertionSchema.TYPE_MAPPING
RawAssertionSchema.dict_class
RawAssertionSchema.dump()
RawAssertionSchema.dump_fields
RawAssertionSchema.dumps()
RawAssertionSchema.error_messages
RawAssertionSchema.exclude
RawAssertionSchema.fields
RawAssertionSchema.from_dict()
RawAssertionSchema.get_attribute()
RawAssertionSchema.handle_error()
RawAssertionSchema.load()
RawAssertionSchema.load_fields
RawAssertionSchema.loads()
RawAssertionSchema.on_bind_field()
RawAssertionSchema.opts
RawAssertionSchema.set_class
RawAssertionSchema.streamline()
RawAssertionSchema.validate()
RegexFindIterSchema
RegexFindIterSchema.Meta
RegexFindIterSchema.Meta.additional
RegexFindIterSchema.Meta.dateformat
RegexFindIterSchema.Meta.datetimeformat
RegexFindIterSchema.Meta.dump_only
RegexFindIterSchema.Meta.exclude
RegexFindIterSchema.Meta.fields
RegexFindIterSchema.Meta.include
RegexFindIterSchema.Meta.index_errors
RegexFindIterSchema.Meta.load_only
RegexFindIterSchema.Meta.many
RegexFindIterSchema.Meta.ordered
RegexFindIterSchema.Meta.register
RegexFindIterSchema.Meta.render_module
RegexFindIterSchema.Meta.timeformat
RegexFindIterSchema.Meta.unknown
RegexFindIterSchema.OPTIONS_CLASS
RegexFindIterSchema.TYPE_MAPPING
RegexFindIterSchema.dict_class
RegexFindIterSchema.dump()
RegexFindIterSchema.dump_fields
RegexFindIterSchema.dumps()
RegexFindIterSchema.error_messages
RegexFindIterSchema.exclude
RegexFindIterSchema.fields
RegexFindIterSchema.from_dict()
RegexFindIterSchema.get_attribute()
RegexFindIterSchema.handle_error()
RegexFindIterSchema.load()
RegexFindIterSchema.load_fields
RegexFindIterSchema.loads()
RegexFindIterSchema.on_bind_field()
RegexFindIterSchema.opts
RegexFindIterSchema.set_class
RegexFindIterSchema.streamline()
RegexFindIterSchema.validate()
RegexSchema
RegexSchema.Meta
RegexSchema.Meta.additional
RegexSchema.Meta.dateformat
RegexSchema.Meta.datetimeformat
RegexSchema.Meta.dump_only
RegexSchema.Meta.exclude
RegexSchema.Meta.fields
RegexSchema.Meta.include
RegexSchema.Meta.index_errors
RegexSchema.Meta.load_only
RegexSchema.Meta.many
RegexSchema.Meta.ordered
RegexSchema.Meta.register
RegexSchema.Meta.render_module
RegexSchema.Meta.timeformat
RegexSchema.Meta.unknown
RegexSchema.OPTIONS_CLASS
RegexSchema.TYPE_MAPPING
RegexSchema.dict_class
RegexSchema.dump()
RegexSchema.dump_fields
RegexSchema.dumps()
RegexSchema.error_messages
RegexSchema.exclude
RegexSchema.fields
RegexSchema.from_dict()
RegexSchema.get_attribute()
RegexSchema.handle_error()
RegexSchema.load()
RegexSchema.load_fields
RegexSchema.loads()
RegexSchema.on_bind_field()
RegexSchema.opts
RegexSchema.set_class
RegexSchema.streamline()
RegexSchema.validate()
TableMatchSchema
TableMatchSchema.Meta
TableMatchSchema.Meta.additional
TableMatchSchema.Meta.dateformat
TableMatchSchema.Meta.datetimeformat
TableMatchSchema.Meta.dump_only
TableMatchSchema.Meta.exclude
TableMatchSchema.Meta.fields
TableMatchSchema.Meta.include
TableMatchSchema.Meta.index_errors
TableMatchSchema.Meta.load_only
TableMatchSchema.Meta.many
TableMatchSchema.Meta.ordered
TableMatchSchema.Meta.register
TableMatchSchema.Meta.render_module
TableMatchSchema.Meta.timeformat
TableMatchSchema.Meta.unknown
TableMatchSchema.OPTIONS_CLASS
TableMatchSchema.TYPE_MAPPING
TableMatchSchema.dict_class
TableMatchSchema.dump()
TableMatchSchema.dump_fields
TableMatchSchema.dumps()
TableMatchSchema.error_messages
TableMatchSchema.exclude
TableMatchSchema.fields
TableMatchSchema.from_dict()
TableMatchSchema.get_attribute()
TableMatchSchema.handle_error()
TableMatchSchema.load()
TableMatchSchema.load_fields
TableMatchSchema.loads()
TableMatchSchema.on_bind_field()
TableMatchSchema.opts
TableMatchSchema.set_class
TableMatchSchema.streamline()
TableMatchSchema.validate()
XMLCheckSchema
XMLCheckSchema.Meta
XMLCheckSchema.Meta.additional
XMLCheckSchema.Meta.dateformat
XMLCheckSchema.Meta.datetimeformat
XMLCheckSchema.Meta.dump_only
XMLCheckSchema.Meta.exclude
XMLCheckSchema.Meta.fields
XMLCheckSchema.Meta.include
XMLCheckSchema.Meta.index_errors
XMLCheckSchema.Meta.load_only
XMLCheckSchema.Meta.many
XMLCheckSchema.Meta.ordered
XMLCheckSchema.Meta.register
XMLCheckSchema.Meta.render_module
XMLCheckSchema.Meta.timeformat
XMLCheckSchema.Meta.unknown
XMLCheckSchema.OPTIONS_CLASS
XMLCheckSchema.TYPE_MAPPING
XMLCheckSchema.dict_class
XMLCheckSchema.dump()
XMLCheckSchema.dump_fields
XMLCheckSchema.dumps()
XMLCheckSchema.error_messages
XMLCheckSchema.exclude
XMLCheckSchema.fields
XMLCheckSchema.from_dict()
XMLCheckSchema.get_attribute()
XMLCheckSchema.handle_error()
XMLCheckSchema.load()
XMLCheckSchema.load_fields
XMLCheckSchema.loads()
XMLCheckSchema.on_bind_field()
XMLCheckSchema.opts
XMLCheckSchema.set_class
XMLCheckSchema.streamline()
XMLCheckSchema.validate()
- testplan.testing.multitest.entries.schemas.base module
AssertionSchemaRegistry
AttachmentSchema
AttachmentSchema.Meta
AttachmentSchema.Meta.additional
AttachmentSchema.Meta.dateformat
AttachmentSchema.Meta.datetimeformat
AttachmentSchema.Meta.dump_only
AttachmentSchema.Meta.exclude
AttachmentSchema.Meta.fields
AttachmentSchema.Meta.include
AttachmentSchema.Meta.index_errors
AttachmentSchema.Meta.load_only
AttachmentSchema.Meta.many
AttachmentSchema.Meta.ordered
AttachmentSchema.Meta.register
AttachmentSchema.Meta.render_module
AttachmentSchema.Meta.timeformat
AttachmentSchema.Meta.unknown
AttachmentSchema.OPTIONS_CLASS
AttachmentSchema.TYPE_MAPPING
AttachmentSchema.dict_class
AttachmentSchema.dump()
AttachmentSchema.dumps()
AttachmentSchema.error_messages
AttachmentSchema.fields
AttachmentSchema.from_dict()
AttachmentSchema.get_attribute()
AttachmentSchema.handle_error()
AttachmentSchema.load()
AttachmentSchema.loads()
AttachmentSchema.on_bind_field()
AttachmentSchema.opts
AttachmentSchema.set_class
AttachmentSchema.streamline()
AttachmentSchema.validate()
BaseSchema
BaseSchema.Meta
BaseSchema.Meta.additional
BaseSchema.Meta.dateformat
BaseSchema.Meta.datetimeformat
BaseSchema.Meta.dump_only
BaseSchema.Meta.exclude
BaseSchema.Meta.fields
BaseSchema.Meta.include
BaseSchema.Meta.index_errors
BaseSchema.Meta.load_only
BaseSchema.Meta.many
BaseSchema.Meta.ordered
BaseSchema.Meta.register
BaseSchema.Meta.render_module
BaseSchema.Meta.timeformat
BaseSchema.Meta.unknown
BaseSchema.OPTIONS_CLASS
BaseSchema.TYPE_MAPPING
BaseSchema.dict_class
BaseSchema.dump()
BaseSchema.dumps()
BaseSchema.error_messages
BaseSchema.fields
BaseSchema.from_dict()
BaseSchema.get_attribute()
BaseSchema.handle_error()
BaseSchema.load()
BaseSchema.loads()
BaseSchema.on_bind_field()
BaseSchema.opts
BaseSchema.set_class
BaseSchema.streamline()
BaseSchema.validate()
CodeLogSchema
CodeLogSchema.Meta
CodeLogSchema.Meta.additional
CodeLogSchema.Meta.dateformat
CodeLogSchema.Meta.datetimeformat
CodeLogSchema.Meta.dump_only
CodeLogSchema.Meta.exclude
CodeLogSchema.Meta.fields
CodeLogSchema.Meta.include
CodeLogSchema.Meta.index_errors
CodeLogSchema.Meta.load_only
CodeLogSchema.Meta.many
CodeLogSchema.Meta.ordered
CodeLogSchema.Meta.register
CodeLogSchema.Meta.render_module
CodeLogSchema.Meta.timeformat
CodeLogSchema.Meta.unknown
CodeLogSchema.OPTIONS_CLASS
CodeLogSchema.TYPE_MAPPING
CodeLogSchema.dict_class
CodeLogSchema.dump()
CodeLogSchema.dump_fields
CodeLogSchema.dumps()
CodeLogSchema.error_messages
CodeLogSchema.exclude
CodeLogSchema.fields
CodeLogSchema.from_dict()
CodeLogSchema.get_attribute()
CodeLogSchema.handle_error()
CodeLogSchema.load()
CodeLogSchema.load_fields
CodeLogSchema.loads()
CodeLogSchema.on_bind_field()
CodeLogSchema.opts
CodeLogSchema.set_class
CodeLogSchema.streamline()
CodeLogSchema.validate()
DictLogSchema
DictLogSchema.Meta
DictLogSchema.Meta.additional
DictLogSchema.Meta.dateformat
DictLogSchema.Meta.datetimeformat
DictLogSchema.Meta.dump_only
DictLogSchema.Meta.exclude
DictLogSchema.Meta.fields
DictLogSchema.Meta.include
DictLogSchema.Meta.index_errors
DictLogSchema.Meta.load_only
DictLogSchema.Meta.many
DictLogSchema.Meta.ordered
DictLogSchema.Meta.register
DictLogSchema.Meta.render_module
DictLogSchema.Meta.timeformat
DictLogSchema.Meta.unknown
DictLogSchema.OPTIONS_CLASS
DictLogSchema.TYPE_MAPPING
DictLogSchema.compress_level()
DictLogSchema.dict_class
DictLogSchema.dump()
DictLogSchema.dump_fields
DictLogSchema.dumps()
DictLogSchema.error_messages
DictLogSchema.exclude
DictLogSchema.fields
DictLogSchema.from_dict()
DictLogSchema.get_attribute()
DictLogSchema.handle_error()
DictLogSchema.load()
DictLogSchema.load_fields
DictLogSchema.loads()
DictLogSchema.on_bind_field()
DictLogSchema.opts
DictLogSchema.set_class
DictLogSchema.streamline()
DictLogSchema.validate()
DirectorySchema
DirectorySchema.Meta
DirectorySchema.Meta.additional
DirectorySchema.Meta.dateformat
DirectorySchema.Meta.datetimeformat
DirectorySchema.Meta.dump_only
DirectorySchema.Meta.exclude
DirectorySchema.Meta.fields
DirectorySchema.Meta.include
DirectorySchema.Meta.index_errors
DirectorySchema.Meta.load_only
DirectorySchema.Meta.many
DirectorySchema.Meta.ordered
DirectorySchema.Meta.register
DirectorySchema.Meta.render_module
DirectorySchema.Meta.timeformat
DirectorySchema.Meta.unknown
DirectorySchema.OPTIONS_CLASS
DirectorySchema.TYPE_MAPPING
DirectorySchema.dict_class
DirectorySchema.dump()
DirectorySchema.dump_fields
DirectorySchema.dumps()
DirectorySchema.error_messages
DirectorySchema.exclude
DirectorySchema.fields
DirectorySchema.from_dict()
DirectorySchema.get_attribute()
DirectorySchema.handle_error()
DirectorySchema.load()
DirectorySchema.load_fields
DirectorySchema.loads()
DirectorySchema.on_bind_field()
DirectorySchema.opts
DirectorySchema.set_class
DirectorySchema.streamline()
DirectorySchema.validate()
EdgeSchema
EdgeSchema.Meta
EdgeSchema.Meta.additional
EdgeSchema.Meta.dateformat
EdgeSchema.Meta.datetimeformat
EdgeSchema.Meta.dump_only
EdgeSchema.Meta.exclude
EdgeSchema.Meta.fields
EdgeSchema.Meta.include
EdgeSchema.Meta.index_errors
EdgeSchema.Meta.load_only
EdgeSchema.Meta.many
EdgeSchema.Meta.ordered
EdgeSchema.Meta.register
EdgeSchema.Meta.render_module
EdgeSchema.Meta.timeformat
EdgeSchema.Meta.unknown
EdgeSchema.OPTIONS_CLASS
EdgeSchema.TYPE_MAPPING
EdgeSchema.dict_class
EdgeSchema.dump()
EdgeSchema.dumps()
EdgeSchema.error_messages
EdgeSchema.fields
EdgeSchema.from_dict()
EdgeSchema.get_attribute()
EdgeSchema.handle_error()
EdgeSchema.load()
EdgeSchema.loads()
EdgeSchema.on_bind_field()
EdgeSchema.opts
EdgeSchema.set_class
EdgeSchema.validate()
FlowChartSchema
FlowChartSchema.Meta
FlowChartSchema.Meta.additional
FlowChartSchema.Meta.dateformat
FlowChartSchema.Meta.datetimeformat
FlowChartSchema.Meta.dump_only
FlowChartSchema.Meta.exclude
FlowChartSchema.Meta.fields
FlowChartSchema.Meta.include
FlowChartSchema.Meta.index_errors
FlowChartSchema.Meta.load_only
FlowChartSchema.Meta.many
FlowChartSchema.Meta.ordered
FlowChartSchema.Meta.register
FlowChartSchema.Meta.render_module
FlowChartSchema.Meta.timeformat
FlowChartSchema.Meta.unknown
FlowChartSchema.OPTIONS_CLASS
FlowChartSchema.TYPE_MAPPING
FlowChartSchema.dict_class
FlowChartSchema.dump()
FlowChartSchema.dump_fields
FlowChartSchema.dumps()
FlowChartSchema.error_messages
FlowChartSchema.exclude
FlowChartSchema.fields
FlowChartSchema.from_dict()
FlowChartSchema.get_attribute()
FlowChartSchema.handle_error()
FlowChartSchema.load()
FlowChartSchema.load_fields
FlowChartSchema.loads()
FlowChartSchema.on_bind_field()
FlowChartSchema.opts
FlowChartSchema.set_class
FlowChartSchema.streamline()
FlowChartSchema.validate()
GenericEntryList
GraphSchema
GraphSchema.Meta
GraphSchema.Meta.additional
GraphSchema.Meta.dateformat
GraphSchema.Meta.datetimeformat
GraphSchema.Meta.dump_only
GraphSchema.Meta.exclude
GraphSchema.Meta.fields
GraphSchema.Meta.include
GraphSchema.Meta.index_errors
GraphSchema.Meta.load_only
GraphSchema.Meta.many
GraphSchema.Meta.ordered
GraphSchema.Meta.register
GraphSchema.Meta.render_module
GraphSchema.Meta.timeformat
GraphSchema.Meta.unknown
GraphSchema.OPTIONS_CLASS
GraphSchema.TYPE_MAPPING
GraphSchema.dict_class
GraphSchema.dump()
GraphSchema.dump_fields
GraphSchema.dumps()
GraphSchema.error_messages
GraphSchema.exclude
GraphSchema.fields
GraphSchema.from_dict()
GraphSchema.get_attribute()
GraphSchema.handle_error()
GraphSchema.load()
GraphSchema.load_fields
GraphSchema.loads()
GraphSchema.on_bind_field()
GraphSchema.opts
GraphSchema.set_class
GraphSchema.streamline()
GraphSchema.validate()
GroupSchema
GroupSchema.Meta
GroupSchema.Meta.additional
GroupSchema.Meta.dateformat
GroupSchema.Meta.datetimeformat
GroupSchema.Meta.dump_only
GroupSchema.Meta.exclude
GroupSchema.Meta.fields
GroupSchema.Meta.include
GroupSchema.Meta.index_errors
GroupSchema.Meta.load_only
GroupSchema.Meta.many
GroupSchema.Meta.ordered
GroupSchema.Meta.register
GroupSchema.Meta.render_module
GroupSchema.Meta.timeformat
GroupSchema.Meta.unknown
GroupSchema.OPTIONS_CLASS
GroupSchema.TYPE_MAPPING
GroupSchema.dict_class
GroupSchema.dump()
GroupSchema.dumps()
GroupSchema.error_messages
GroupSchema.fields
GroupSchema.from_dict()
GroupSchema.get_attribute()
GroupSchema.handle_error()
GroupSchema.load()
GroupSchema.loads()
GroupSchema.on_bind_field()
GroupSchema.opts
GroupSchema.set_class
GroupSchema.validate()
LogSchema
LogSchema.Meta
LogSchema.Meta.additional
LogSchema.Meta.dateformat
LogSchema.Meta.datetimeformat
LogSchema.Meta.dump_only
LogSchema.Meta.exclude
LogSchema.Meta.fields
LogSchema.Meta.include
LogSchema.Meta.index_errors
LogSchema.Meta.load_only
LogSchema.Meta.many
LogSchema.Meta.ordered
LogSchema.Meta.register
LogSchema.Meta.render_module
LogSchema.Meta.timeformat
LogSchema.Meta.unknown
LogSchema.OPTIONS_CLASS
LogSchema.TYPE_MAPPING
LogSchema.dict_class
LogSchema.dump()
LogSchema.dump_fields
LogSchema.dumps()
LogSchema.error_messages
LogSchema.exclude
LogSchema.fields
LogSchema.from_dict()
LogSchema.get_attribute()
LogSchema.handle_error()
LogSchema.load()
LogSchema.load_fields
LogSchema.loads()
LogSchema.on_bind_field()
LogSchema.opts
LogSchema.set_class
LogSchema.streamline()
LogSchema.validate()
MarkdownSchema
MarkdownSchema.Meta
MarkdownSchema.Meta.additional
MarkdownSchema.Meta.dateformat
MarkdownSchema.Meta.datetimeformat
MarkdownSchema.Meta.dump_only
MarkdownSchema.Meta.exclude
MarkdownSchema.Meta.fields
MarkdownSchema.Meta.include
MarkdownSchema.Meta.index_errors
MarkdownSchema.Meta.load_only
MarkdownSchema.Meta.many
MarkdownSchema.Meta.ordered
MarkdownSchema.Meta.register
MarkdownSchema.Meta.render_module
MarkdownSchema.Meta.timeformat
MarkdownSchema.Meta.unknown
MarkdownSchema.OPTIONS_CLASS
MarkdownSchema.TYPE_MAPPING
MarkdownSchema.dict_class
MarkdownSchema.dump()
MarkdownSchema.dump_fields
MarkdownSchema.dumps()
MarkdownSchema.error_messages
MarkdownSchema.exclude
MarkdownSchema.fields
MarkdownSchema.from_dict()
MarkdownSchema.get_attribute()
MarkdownSchema.handle_error()
MarkdownSchema.load()
MarkdownSchema.load_fields
MarkdownSchema.loads()
MarkdownSchema.on_bind_field()
MarkdownSchema.opts
MarkdownSchema.set_class
MarkdownSchema.streamline()
MarkdownSchema.validate()
NodeSchema
NodeSchema.Meta
NodeSchema.Meta.additional
NodeSchema.Meta.dateformat
NodeSchema.Meta.datetimeformat
NodeSchema.Meta.dump_only
NodeSchema.Meta.exclude
NodeSchema.Meta.fields
NodeSchema.Meta.include
NodeSchema.Meta.index_errors
NodeSchema.Meta.load_only
NodeSchema.Meta.many
NodeSchema.Meta.ordered
NodeSchema.Meta.register
NodeSchema.Meta.render_module
NodeSchema.Meta.timeformat
NodeSchema.Meta.unknown
NodeSchema.OPTIONS_CLASS
NodeSchema.TYPE_MAPPING
NodeSchema.dict_class
NodeSchema.dump()
NodeSchema.dumps()
NodeSchema.error_messages
NodeSchema.fields
NodeSchema.from_dict()
NodeSchema.get_attribute()
NodeSchema.handle_error()
NodeSchema.load()
NodeSchema.loads()
NodeSchema.on_bind_field()
NodeSchema.opts
NodeSchema.set_class
NodeSchema.validate()
PlotlySchema
PlotlySchema.Meta
PlotlySchema.Meta.additional
PlotlySchema.Meta.dateformat
PlotlySchema.Meta.datetimeformat
PlotlySchema.Meta.dump_only
PlotlySchema.Meta.exclude
PlotlySchema.Meta.fields
PlotlySchema.Meta.include
PlotlySchema.Meta.index_errors
PlotlySchema.Meta.load_only
PlotlySchema.Meta.many
PlotlySchema.Meta.ordered
PlotlySchema.Meta.register
PlotlySchema.Meta.render_module
PlotlySchema.Meta.timeformat
PlotlySchema.Meta.unknown
PlotlySchema.OPTIONS_CLASS
PlotlySchema.TYPE_MAPPING
PlotlySchema.dict_class
PlotlySchema.dump()
PlotlySchema.dump_fields
PlotlySchema.dumps()
PlotlySchema.error_messages
PlotlySchema.exclude
PlotlySchema.fields
PlotlySchema.from_dict()
PlotlySchema.get_attribute()
PlotlySchema.handle_error()
PlotlySchema.load()
PlotlySchema.load_fields
PlotlySchema.loads()
PlotlySchema.on_bind_field()
PlotlySchema.opts
PlotlySchema.set_class
PlotlySchema.streamline()
PlotlySchema.validate()
TableLogSchema
TableLogSchema.Meta
TableLogSchema.Meta.additional
TableLogSchema.Meta.dateformat
TableLogSchema.Meta.datetimeformat
TableLogSchema.Meta.dump_only
TableLogSchema.Meta.exclude
TableLogSchema.Meta.fields
TableLogSchema.Meta.include
TableLogSchema.Meta.index_errors
TableLogSchema.Meta.load_only
TableLogSchema.Meta.many
TableLogSchema.Meta.ordered
TableLogSchema.Meta.register
TableLogSchema.Meta.render_module
TableLogSchema.Meta.timeformat
TableLogSchema.Meta.unknown
TableLogSchema.OPTIONS_CLASS
TableLogSchema.TYPE_MAPPING
TableLogSchema.dict_class
TableLogSchema.dump()
TableLogSchema.dump_fields
TableLogSchema.dumps()
TableLogSchema.error_messages
TableLogSchema.exclude
TableLogSchema.fields
TableLogSchema.from_dict()
TableLogSchema.get_attribute()
TableLogSchema.handle_error()
TableLogSchema.load()
TableLogSchema.load_fields
TableLogSchema.loads()
TableLogSchema.on_bind_field()
TableLogSchema.opts
TableLogSchema.set_class
TableLogSchema.streamline()
TableLogSchema.validate()
- testplan.testing.multitest.entries.schemas.assertions module
- Module contents
- Submodules
- testplan.testing.multitest.entries.stdout package
- Submodules
- testplan.testing.multitest.entries.stdout.assertions module
ApproximateEqualityAssertionRenderer
ApproximateEqualityAssertionRenderer.get_assertion_details()
ApproximateEqualityAssertionRenderer.get_default_header()
ApproximateEqualityAssertionRenderer.get_details()
ApproximateEqualityAssertionRenderer.get_header()
ApproximateEqualityAssertionRenderer.get_header_text()
ApproximateEqualityAssertionRenderer.pass_label()
AssertionRenderer
ColumnContainRenderer
DictCheckRenderer
DictMatchAllRenderer
DictMatchRenderer
EqualExcludeSlicesRenderer
EqualSlicesRenderer
ExceptionRaisedRenderer
FailRenderer
FunctionAssertionRenderer
LineDiffRenderer
LogfileMatchRender
MembershipRenderer
RegexFindIterRenderer
RegexMatchLineRenderer
RegexMatchRenderer
RegexNotMatchRenderer
TableMatchRenderer
XMLCheckRenderer
add_printable_dict_comparison()
- testplan.testing.multitest.entries.stdout.base module
- testplan.testing.multitest.entries.stdout.assertions module
- Module contents
- Submodules
- testplan.testing.multitest.entries.schemas package
- Submodules
- testplan.testing.multitest.entries.assertions module
Assertion
ColumnContain
Contain
DictCheck
DictMatch
DictMatchAll
Equal
EqualExcludeSlices
EqualSlices
ExceptionRaised
Fail
FixCheck
FixMatch
FixMatchAll
FuncAssertion
Greater
GreaterEqual
IsClose
IsFalse
IsTrue
Less
LessEqual
LineDiff
LogfileMatch
NotContain
NotEqual
RawAssertion
RegexAssertion
RegexFindIter
RegexMatch
RegexMatchLine
RegexMatchNotExists
RegexSearch
RegexSearchNotExists
TableDiff
TableMatch
XMLCheck
- testplan.testing.multitest.entries.base module
- testplan.testing.multitest.entries.summarization module
- testplan.testing.multitest.entries.assertions module
- Module contents
- Subpackages
- testplan.testing.multitest.driver package
- Submodules
- testplan.testing.multitest.base module
MultiTest
MultiTest.CONFIG
MultiTest.DEFAULT_THREAD_POOL_SIZE
MultiTest.ENVIRONMENT
MultiTest.RESULT
MultiTest.STATUS
MultiTest.abort()
MultiTest.abort_dependencies()
MultiTest.aborted
MultiTest.aborting()
MultiTest.active
MultiTest.add_main_batch_steps()
MultiTest.add_post_main_steps()
MultiTest.add_post_resource_steps()
MultiTest.add_pre_main_steps()
MultiTest.add_pre_resource_steps()
MultiTest.add_resource()
MultiTest.add_start_resource_steps()
MultiTest.add_stop_resource_steps()
MultiTest.apply_xfail_tests()
MultiTest.cfg
MultiTest.collect_code_context
MultiTest.context_input()
MultiTest.define_runpath()
MultiTest.description
MultiTest.driver_info
MultiTest.dry_run()
MultiTest.filter_levels
MultiTest.filter_locals()
MultiTest.get_filter_levels()
MultiTest.get_metadata()
MultiTest.get_stdout_style()
MultiTest.get_tags_index()
MultiTest.get_test_context()
MultiTest.i
MultiTest.interactive
MultiTest.log_test_results()
MultiTest.logger
MultiTest.make_runpath_dirs()
MultiTest.name
MultiTest.parent
MultiTest.pause()
MultiTest.pausing()
MultiTest.post_step_call()
MultiTest.pre_step_call()
MultiTest.propagate_tag_indices()
MultiTest.report
MultiTest.reset_context()
MultiTest.resources
MultiTest.result
MultiTest.resume()
MultiTest.resuming()
MultiTest.run()
MultiTest.run_result()
MultiTest.run_testcases_iter()
MultiTest.run_tests()
MultiTest.runpath
MultiTest.scratch
MultiTest.set_discover_path()
MultiTest.set_part()
MultiTest.setup()
MultiTest.should_log_test_result()
MultiTest.should_run()
MultiTest.skip_step()
MultiTest.start_test_resources()
MultiTest.status
MultiTest.stdout_style
MultiTest.stop_test_resources()
MultiTest.suites
MultiTest.teardown()
MultiTest.test_context
MultiTest.timer
MultiTest.uid()
MultiTest.unset_part()
MultiTest.wait()
MultiTestConfig
MultiTestRuntimeInfo
RuntimeEnvironment
deprecate_stop_on_error()
iterable_suites()
- testplan.testing.multitest.logging module
- testplan.testing.multitest.parametrization module
- testplan.testing.multitest.suite module
add_testcase_metadata()
get_suite_metadata()
get_testcase_desc()
get_testcase_metadata()
get_testcase_methods()
get_testsuite_desc()
get_testsuite_name()
is_testcase()
propagate_tag_indices()
set_testsuite_testcases()
skip_if()
skip_if_testcase()
testcase()
testsuite()
timeout()
update_tag_index()
xfail()
- testplan.testing.multitest.test_metadata module
- testplan.testing.multitest.base module
- Module contents
- Subpackages
- testplan.testing.cpp package
- Submodules
- testplan.testing.cpp.gtest module
GTest
GTest.CONFIG
GTest.ENVIRONMENT
GTest.RESULT
GTest.STATUS
GTest.abort()
GTest.abort_dependencies()
GTest.aborted
GTest.aborting()
GTest.active
GTest.add_main_batch_steps()
GTest.add_post_main_steps()
GTest.add_post_resource_steps()
GTest.add_pre_main_steps()
GTest.add_pre_resource_steps()
GTest.add_resource()
GTest.add_start_resource_steps()
GTest.add_stop_resource_steps()
GTest.apply_xfail_tests()
GTest.base_command()
GTest.cfg
GTest.collect_code_context
GTest.context_input()
GTest.define_runpath()
GTest.description
GTest.driver_info
GTest.dry_run()
GTest.filter_levels
GTest.filter_locals()
GTest.get_filter_levels()
GTest.get_metadata()
GTest.get_proc_env()
GTest.get_process_check_report()
GTest.get_stdout_style()
GTest.get_tags_index()
GTest.get_test_context()
GTest.i
GTest.interactive
GTest.list_command()
GTest.list_command_filter()
GTest.log_test_results()
GTest.logger
GTest.make_runpath_dirs()
GTest.name
GTest.parent
GTest.parse_test_context()
GTest.pause()
GTest.pausing()
GTest.post_step_call()
GTest.pre_step_call()
GTest.prepare_binary()
GTest.process_test_data()
GTest.propagate_tag_indices()
GTest.read_test_data()
GTest.report
GTest.report_path
GTest.reset_context()
GTest.resolved_bin
GTest.resources
GTest.result
GTest.resume()
GTest.resuming()
GTest.run()
GTest.run_result()
GTest.run_testcases_iter()
GTest.run_tests()
GTest.runpath
GTest.scratch
GTest.set_discover_path()
GTest.setup()
GTest.should_log_test_result()
GTest.should_run()
GTest.skip_step()
GTest.start_test_resources()
GTest.status
GTest.stderr
GTest.stdout
GTest.stdout_style
GTest.stop_test_resources()
GTest.teardown()
GTest.test_command()
GTest.test_command_filter()
GTest.test_context
GTest.timeout_callback()
GTest.timeout_log
GTest.timer
GTest.uid()
GTest.update_test_report()
GTest.wait()
GTestConfig
- testplan.testing.cpp.cppunit module
Cppunit
Cppunit.CONFIG
Cppunit.ENVIRONMENT
Cppunit.RESULT
Cppunit.STATUS
Cppunit.abort()
Cppunit.abort_dependencies()
Cppunit.aborted
Cppunit.aborting()
Cppunit.active
Cppunit.add_main_batch_steps()
Cppunit.add_post_main_steps()
Cppunit.add_post_resource_steps()
Cppunit.add_pre_main_steps()
Cppunit.add_pre_resource_steps()
Cppunit.add_resource()
Cppunit.add_start_resource_steps()
Cppunit.add_stop_resource_steps()
Cppunit.apply_xfail_tests()
Cppunit.cfg
Cppunit.collect_code_context
Cppunit.context_input()
Cppunit.define_runpath()
Cppunit.description
Cppunit.driver_info
Cppunit.dry_run()
Cppunit.filter_levels
Cppunit.filter_locals()
Cppunit.get_filter_levels()
Cppunit.get_metadata()
Cppunit.get_proc_env()
Cppunit.get_process_check_report()
Cppunit.get_stdout_style()
Cppunit.get_tags_index()
Cppunit.get_test_context()
Cppunit.i
Cppunit.interactive
Cppunit.list_command()
Cppunit.list_command_filter()
Cppunit.log_test_results()
Cppunit.logger
Cppunit.make_runpath_dirs()
Cppunit.name
Cppunit.parent
Cppunit.parse_test_context()
Cppunit.pause()
Cppunit.pausing()
Cppunit.post_step_call()
Cppunit.pre_step_call()
Cppunit.prepare_binary()
Cppunit.process_test_data()
Cppunit.propagate_tag_indices()
Cppunit.read_test_data()
Cppunit.report
Cppunit.report_path
Cppunit.reset_context()
Cppunit.resolved_bin
Cppunit.resources
Cppunit.result
Cppunit.resume()
Cppunit.resuming()
Cppunit.run()
Cppunit.run_result()
Cppunit.run_testcases_iter()
Cppunit.run_tests()
Cppunit.runpath
Cppunit.scratch
Cppunit.set_discover_path()
Cppunit.setup()
Cppunit.should_log_test_result()
Cppunit.should_run()
Cppunit.skip_step()
Cppunit.start_test_resources()
Cppunit.status
Cppunit.stderr
Cppunit.stdout
Cppunit.stdout_style
Cppunit.stop_test_resources()
Cppunit.teardown()
Cppunit.test_command()
Cppunit.test_command_filter()
Cppunit.test_context
Cppunit.timeout_callback()
Cppunit.timeout_log
Cppunit.timer
Cppunit.uid()
Cppunit.update_test_report()
Cppunit.wait()
CppunitConfig
- testplan.testing.cpp.hobbestest module
HobbesTest
HobbesTest.CONFIG
HobbesTest.ENVIRONMENT
HobbesTest.RESULT
HobbesTest.STATUS
HobbesTest.abort()
HobbesTest.abort_dependencies()
HobbesTest.aborted
HobbesTest.aborting()
HobbesTest.active
HobbesTest.add_main_batch_steps()
HobbesTest.add_post_main_steps()
HobbesTest.add_post_resource_steps()
HobbesTest.add_pre_main_steps()
HobbesTest.add_pre_resource_steps()
HobbesTest.add_resource()
HobbesTest.add_start_resource_steps()
HobbesTest.add_stop_resource_steps()
HobbesTest.apply_xfail_tests()
HobbesTest.cfg
HobbesTest.collect_code_context
HobbesTest.context_input()
HobbesTest.define_runpath()
HobbesTest.description
HobbesTest.driver_info
HobbesTest.dry_run()
HobbesTest.filter_levels
HobbesTest.filter_locals()
HobbesTest.get_filter_levels()
HobbesTest.get_metadata()
HobbesTest.get_proc_env()
HobbesTest.get_process_check_report()
HobbesTest.get_stdout_style()
HobbesTest.get_tags_index()
HobbesTest.get_test_context()
HobbesTest.i
HobbesTest.interactive
HobbesTest.list_command()
HobbesTest.list_command_filter()
HobbesTest.log_test_results()
HobbesTest.logger
HobbesTest.make_runpath_dirs()
HobbesTest.name
HobbesTest.parent
HobbesTest.parse_test_context()
HobbesTest.pause()
HobbesTest.pausing()
HobbesTest.post_step_call()
HobbesTest.pre_step_call()
HobbesTest.prepare_binary()
HobbesTest.process_test_data()
HobbesTest.propagate_tag_indices()
HobbesTest.read_test_data()
HobbesTest.report
HobbesTest.report_path
HobbesTest.reset_context()
HobbesTest.resolved_bin
HobbesTest.resources
HobbesTest.result
HobbesTest.resume()
HobbesTest.resuming()
HobbesTest.run()
HobbesTest.run_result()
HobbesTest.run_testcases_iter()
HobbesTest.run_tests()
HobbesTest.runpath
HobbesTest.scratch
HobbesTest.set_discover_path()
HobbesTest.setup()
HobbesTest.should_log_test_result()
HobbesTest.should_run()
HobbesTest.skip_step()
HobbesTest.start_test_resources()
HobbesTest.status
HobbesTest.stderr
HobbesTest.stdout
HobbesTest.stdout_style
HobbesTest.stop_test_resources()
HobbesTest.teardown()
HobbesTest.test_command()
HobbesTest.test_command_filter()
HobbesTest.test_context
HobbesTest.timeout_callback()
HobbesTest.timeout_log
HobbesTest.timer
HobbesTest.uid()
HobbesTest.update_test_report()
HobbesTest.wait()
HobbesTestConfig
- testplan.testing.cpp.gtest module
- Submodules
- testplan.testing.bdd package
Submodules
testplan.testing.base module
Base classes for all Tests
- class testplan.testing.base.ProcessRunnerTest(**options)[source]
Bases:
Test
A test runner that runs the tests in a separate subprocess. This is useful for running 3rd party testing frameworks (e.g. JUnit, GTest)
Test report will be populated by parsing the generated report output file (report.xml file by default.)
- Parameters:
name – Test instance name, often used as uid of test entity.
binary – Path to the application binary or script.
description – Description of test instance.
proc_env – Environment overrides for
subprocess.Popen
; context value (when referring to other driver) and jinja2 template (when referring to self) will be resolved.proc_cwd – Directory override for
subprocess.Popen
.timeout –
Optional timeout for the subprocess. If a process runs longer than this limit, it will be killed and test will be marked as
ERROR
.String representations can be used as well as duration in seconds. (e.g. 10, 2.3, ‘1m 30s’, ‘1h 15m’)
ignore_exit_codes – When the test process exits with nonzero status code, the test will be marked as
ERROR
. This can be disabled by providing a list of numbers to ignore.pre_args – List of arguments to be prepended before the arguments of the test runnable.
post_args – List of arguments to be appended before the arguments of the test runnable.
Also inherits all
Test
options.- CONFIG
alias of
ProcessRunnerTestConfig
- apply_xfail_tests() None [source]
Apply xfail tests specified via –xfail-tests or @test_plan(xfail_tests=…).
- get_proc_env() Dict [source]
Fabricate the env var for subprocess. Precedence: user-specified > hardcoded > system env
- get_process_check_report(retcode: int, stdout: str, stderr: str) TestGroupReport [source]
When running a process fails (e.g. binary crash, timeout etc) we can still generate dummy testsuite / testcase reports with a certain hierarchy compatible with exporters and XUnit conventions. And logs of stdout & stderr can be saved as attachment.
- get_test_context(list_cmd=None)[source]
Run the shell command generated by list_command in a subprocess, parse and return the stdout generated via parse_test_context.
- Parameters:
list_cmd (
str
) – Command to list all test suites and testcases- Returns:
Result returned by parse_test_context.
- Return type:
list
oflist
- list_command() List[str] | None [source]
List custom arguments before and after the executable if they are defined. :return: List of commands to run before and after the test process,
as well as the test executable itself.
- list_command_filter(testsuite_pattern: str, testcase_pattern: str)[source]
Return the base list command with additional filtering to list a specific set of testcases. To be implemented by concrete subclasses.
- parse_test_context(test_list_output: bytes) List[List] [source]
Override this to generate a nested list of test suite and test case context. Only required if list_command is overridden to return a command.
The result will later on be used by test listers to generate the test context output for this test instance.
Sample output:
[ ['SuiteAlpha', ['testcase_one', 'testcase_two'], ['SuiteBeta', ['testcase_one', 'testcase_two'], ]
- Parameters:
test_list_output – stdout from the list command
- Returns:
Parsed test context from command line output of the 3rd party testing library.
- process_test_data(test_data)[source]
Process raw test data that was collected and return a list of entries (e.g. TestGroupReport, TestCaseReport) that will be appended to the current test instance’s report as children.
- Parameters:
test_data (
xml.etree.Element
) – Root node of parsed raw test data- Returns:
List of sub reports
- Return type:
list
ofTestGroupReport
/TestCaseReport
- read_test_data()[source]
Parse output generated by the 3rd party testing tool, and then the parsed content will be handled by
process_test_data
.You should override this function with custom logic to parse the contents of generated file.
- property report_path: str | None
- property resolved_bin: str
- run_testcases_iter(testsuite_pattern: str = '*', testcase_pattern: str = '*', shallow_report: Dict = None) Generator [source]
Runs testcases as defined by the given filter patterns and yields testcase reports. A single testcase report is made for general checks of the test process, including checking the exit code and logging stdout and stderr of the process. Then, testcase reports are generated from the output of the test process.
For efficiency, we run all testcases in a single subprocess rather than running each testcase in a seperate process. This reduces the total time taken to run all testcases, however it will mean that testcase reports will not be generated until all testcases have finished running.
- Parameters:
testsuite_pattern – pattern to match for testsuite names
testcase_pattern – pattern to match for testcase names
shallow_report – shallow report entry
- Returns:
generator yielding testcase reports and UIDs for merge step
- run_tests() None [source]
Run the tests in a subprocess, record stdout & stderr on runpath. Optionally enforce a timeout and log timeout related messages in the given timeout log path.
- Raises:
ValueError – upon invalid test command
- property stderr: str | None
- property stdout: str | None
- test_command() List[str] [source]
Add custom arguments before and after the executable if they are defined. :return: List of commands to run before and after the test process,
as well as the test executable itself.
- test_command_filter(testsuite_pattern: str, testcase_pattern: str)[source]
Return the base test command with additional filtering to run a specific set of testcases. To be implemented by concrete subclasses.
- timeout_callback()[source]
Callback function that will be called by the daemon thread if a timeout occurs (e.g. process runs longer than specified timeout value).
- Raises:
RuntimeError –
- property timeout_log: str | None
- class testplan.testing.base.ProcessRunnerTestConfig(**options)[source]
Bases:
TestConfig
Configuration object for
ProcessRunnerTest
.
- class testplan.testing.base.ResourceHooks(*values)[source]
Bases:
str
,Enum
- AFTER_START = 'After Start'
- AFTER_STOP = 'After Stop'
- BEFORE_START = 'Before Start'
- BEFORE_STOP = 'Before Stop'
- ENVIRONMENT_START = 'Environment Start'
- ENVIRONMENT_STOP = 'Environment Stop'
- ERROR_HANDLER = 'Error Handler'
- STARTING = 'Starting'
- STOPPING = 'Stopping'
- class testplan.testing.base.Test(name: str, description: str = None, environment: list | ~typing.Callable = None, dependencies: dict | ~typing.Callable = None, initial_context: dict | ~typing.Callable = None, before_start: callable = None, after_start: callable = None, before_stop: callable = None, after_stop: callable = None, error_handler: callable = None, test_filter: ~testplan.testing.filtering.BaseFilter = None, test_sorter: ~testplan.testing.ordering.BaseSorter = None, stdout_style: ~testplan.report.testing.styles.Style = None, tags: str | ~typing.Iterable[str] = None, result: ~typing.Type[~testplan.testing.result.Result] = <class 'testplan.testing.result.Result'>, **options)[source]
Bases:
Runnable
Base test instance class. Any runnable that runs a test can inherit from this class and override certain methods to customize functionality.
- Parameters:
name – Test instance name, often used as uid of test entity.
description – Description of test instance.
environment – List of
drivers
to be started and made available on tests execution. Can also take a callable that returns the list of drivers.dependencies – driver start-up dependencies as a directed graph, e.g {server1: (client1, client2)} indicates server1 shall start before client1 and client2. Can also take a callable that returns a dict.
initial_context – key: value pairs that will be made available as context for drivers in environment. Can also take a callable that returns a dict.
test_filter – Class with test filtering logic.
test_sorter – Class with tests sorting logic.
before_start – Callable to execute before starting the environment.
after_start – Callable to execute after starting the environment.
before_stop – Callable to execute before stopping the environment.
after_stop – Callable to execute after stopping the environment.
error_handler – Callable to execute when a step hits an exception.
stdout_style – Console output style.
tags – User defined tag value.
result – Result class definition for result object made available from within the testcases.
Also inherits all
Runnable
options.- CONFIG
alias of
TestConfig
- ENVIRONMENT
alias of
TestEnvironment
- RESULT
alias of
TestResult
- property collect_code_context: bool
Collecting the file path, line number and code context of the assertions if enabled.
- property description: str
- property driver_info: bool
- dry_run() RunnableResult [source]
Return an empty report skeleton for this test including all testsuites, testcases etc. hierarchy. Does not run any tests.
- filter_levels = [FilterLevel.TEST]
- get_filter_levels() List[FilterLevel] [source]
- get_metadata() TestMetadata [source]
- get_tags_index() str | Iterable[str] | Dict [source]
Return the tag index that will be used for filtering. By default, this is equal to the native tags for this object.
However, subclasses may build larger tag indices by collecting tags from their children for example.
- log_test_results(top_down: bool = True)[source]
Log test results. i.e. ProcessRunnerTest or PyTest.
- Parameters:
top_down – Flag logging test results using a top-down approach or a bottom-up approach.
- property name: str
Instance name.
- propagate_tag_indices() None [source]
Basic step for propagating tag indices of the test report tree. This step may be necessary if the report tree is created in parts and then added up.
- property report: TestGroupReport
Shortcut for the test report.
- run_testcases_iter(testsuite_pattern: str = '*', testcase_pattern: str = '*') None [source]
For a Test to be run interactively, it must implement this method.
It is expected to run tests iteratively and yield a tuple containing a testcase report and the list of parent UIDs required to merge the testcase report into the main report tree.
If it is not possible or very inefficient to run individual testcases in an iteratie manner, this method may instead run all the testcases in a batch and then return an iterator for the testcase reports and parent UIDs.
- Parameters:
testsuite_pattern – Filter pattern for testsuite level.
testcase_pattern – Filter pattern for testcase level.
- Yield:
generate tuples containing testcase reports and a list of the UIDs required to merge this into the main report tree, starting with the UID of this test.
- set_discover_path(path: str) None [source]
If the Test is materialized from a task that is discovered outside pwd(), this might be needed for binary/library path derivation to work properly. :param path: the absolute path where the task has been discovered
- should_log_test_result(depth: int, test_obj, style) Tuple[bool, int] [source]
Whether to log test result and if yes, then with what indent.
- Returns:
whether to log test results (Suite report, Testcase report, or result of assertions) and the indent that should be kept at start of lines
- Raises:
ValueError – if met with an unexpected test group category
TypeError – if meth with an unsupported test object
- start_test_resources() None [source]
Start all test resources but do not run any tests. Used in the interactive mode when environments may be started/stopped on demand. The base implementation is very simple but may be overridden in sub- classes to run additional setup pre- and post-environment start.
- property stdout_style
Stdout style input.
- stop_test_resources() None [source]
Stop all test resources. As above, this method is used for the interactive mode and is very simple in this base Test class, but may be overridden by sub-classes.
- property test_context
- class testplan.testing.base.TestConfig(**options)[source]
Bases:
RunnableConfig
Configuration object for
Test
.
- class testplan.testing.base.TestResult[source]
Bases:
RunnableResult
Result object for
Test
runnable test execution framework base class and all sub classes.Contains a test
report
object.
testplan.testing.filtering module
Filtering logic for Multitest, Suites and testcase methods (of Suites)
- class testplan.testing.filtering.And(*filters)[source]
Bases:
MetaFilter
Meta filter that returns True if ALL of the child filters return True.
- operator_str = '&'
- class testplan.testing.filtering.BaseFilter[source]
Bases:
object
Base class for filters, supports bitwise operators for composing multiple filters.
e.g. (FilterA(…) & FilterB(…)) | ~FilterC(…)
- class testplan.testing.filtering.BaseTagFilter(tags)[source]
Bases:
Filter
Base filter class for tag based filtering.
- category = 3
- class testplan.testing.filtering.Filter[source]
Bases:
BaseFilter
Noop filter class, users can inherit from this to implement their own filters.
Returns True by default for all filtering operations, implicitly checks for test instances
filter_levels
declaration to apply the filtering logic.- category = 1
- class testplan.testing.filtering.FilterCategory(*values)[source]
Bases:
IntEnum
- COMMON = 1
- PATTERN = 2
- TAG = 3
- class testplan.testing.filtering.FilterLevel(*values)[source]
Bases:
Enum
This enum is used by test classes (e.g. ~testplan.testing.base.Test) to declare the depth of filtering logic while
filter
method is run.By default only
test
(e.g. top) level filtering is used.- TEST = 'test'
- TESTCASE = 'testcase'
- TESTSUITE = 'testsuite'
- class testplan.testing.filtering.MetaFilter(*filters)[source]
Bases:
BaseFilter
Higher level filter that allow composition of other filters.
- operator_str = None
- class testplan.testing.filtering.Not(filter_obj)[source]
Bases:
BaseFilter
Meta filter that returns the inverse of the original filter result.
- class testplan.testing.filtering.Or(*filters)[source]
Bases:
MetaFilter
Meta filter that returns True if ANY of the child filters return True.
- operator_str = '|'
- class testplan.testing.filtering.Pattern(pattern, match_uid=False)[source]
Bases:
Filter
Base class for name based, glob style filtering.
https://docs.python.org/3/library/fnmatch.html
Examples:
<Multitest name>:<suite name>:<testcase name> <Multitest name>::<testcase name> *:<suite name>:
- ALL_MATCH = '*'
- MAX_LEVEL = 3
- classmethod any(*patterns: str)[source]
Shortcut for filtering against multiple patterns.
e.g. Pattern.any(<pattern 1>, <pattern 2>…)
- category = 2
- property pattern
- class testplan.testing.filtering.PatternAction(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None, deprecated=False)[source]
Bases:
Action
Parser action for generating Pattern filters. Returns a list of Pattern filter objects.
In:
--patterns foo bar --patterns baz
Out:
[Pattern('foo'), Pattern('bar'), Pattern('baz')]
- class testplan.testing.filtering.Tags(tags)[source]
Bases:
BaseTagFilter
Tag filter that returns True if ANY of the given tags match.
- class testplan.testing.filtering.TagsAction(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None, deprecated=False)[source]
Bases:
Action
Parser action for generating tags (any) filters.
In:
--tags foo bar hello=world --tags baz hello=mars
Out:
[ Tags({ 'simple': {'foo', 'bar'}, 'hello': {'world'}, }), Tags({ 'simple': {'baz'}, 'hello': {'mars'}, }) ]
- class testplan.testing.filtering.TagsAll(tags)[source]
Bases:
BaseTagFilter
Tag filter that returns True if ALL of the given tags match.
- class testplan.testing.filtering.TagsAllAction(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None, deprecated=False)[source]
Bases:
TagsAction
Parser action for generating tags (all) filters.
In:
--tags-all foo bar hello=world --tags-all baz hello=mars
Out:
[ TagsAll({ 'simple': {'foo', 'bar'}, 'hello': {'world'}, }), TagsAll({ 'simple': {'baz'}, 'hello': {'mars'}, }) ]
- testplan.testing.filtering.flatten_filters(metafilter_kls: Type[MetaFilter], filters: List[Filter]) List[Filter] [source]
This is used for flattening nested filters of same type
So when we have something like:
Or(filter-1, filter-2) | Or(filter-3, filter-4)
We end up with:
Or(filter-1, filter-2, filter-3, filter-4)
Instead of:
Or(Or(filter-1, filter-2), Or(filter-3, filter-4))
- testplan.testing.filtering.parse_filter_args(parsed_args, arg_names)[source]
Utility function that’s used for grouping filters of the same category together. Will be used while parsing command line arguments for test filters.
Filters that belong to the same category will be grouped under Or whereas filters of different categories will be grouped under And.
In:
--patterns my_pattern --tags foo --tags-all bar baz
Out:
And( Pattern('my_pattern'), Or( Tags({'simple': {'foo'}}), TagsAll({'simple': {'bar', 'baz'}}), ) )
testplan.testing.listing module
This module contains logic for listing representing test context of a plan.
- class testplan.testing.listing.BaseLister[source]
Bases:
Listertype
Base of all listers, implement the
get_output()
give it a name inNAME
and a description inDESCRIPTION
or alternatively overridename()
and/ordescription()
and it is good to be added tolisting_registry
.
- class testplan.testing.listing.CountLister[source]
Bases:
BaseLister
Displays the number of suites and total testcases per test instance.
- DESCRIPTION = 'Lists top level instances and total number of suites & testcases per instance.'
- NAME = 'COUNT'
- class testplan.testing.listing.ExpandedNameLister[source]
Bases:
BaseLister
Lists names of the items within the test context:
Sample output:
- MultitestAlpha
- SuiteOne
testcase_foo testcase_bar
- SuiteTwo
testcase_baz
- MultitestBeta
…
- DESCRIPTION = 'List tests in readable format.'
- NAME = 'NAME_FULL'
- class testplan.testing.listing.ExpandedPatternLister[source]
Bases:
ExpandedNameLister
Lists the items in test context in a copy-pasta friendly format compatible with –patterns and –tags arguments.
Example:
- MultitestAlpha
- MultitestAlpha:SuiteOne –tags color=red
MultitestAlpha:SuiteOne:testcase_foo MultitestAlpha:SuiteOne:testcase_bar –tags color=blue
- MultitestAlpha:SuiteTwo
MultitestAlpha:SuiteTwo:testcase_baz
- MultitestBeta
…
- DESCRIPTION = 'List tests in `--patterns` / `--tags` compatible format.'
- NAME = 'PATTERN_FULL'
- class testplan.testing.listing.Listertype[source]
Bases:
object
- DESCRIPTION = None
- NAME = None
- metadata_based = False
- class testplan.testing.listing.ListingArgMixin[source]
Bases:
ArgMixin
- classmethod get_descriptions()[source]
Override this method to return a dictionary with Enums as keys and description strings as values.
This will later on be rendered via –help command.
- class testplan.testing.listing.ListingRegistry[source]
Bases:
object
A registry to store listers, add listers to the
listing_registry
instance which is used to create the commandline parser.
- class testplan.testing.listing.MetadataBasedLister[source]
Bases:
Listertype
Base of all metadata based listers, implement the
get_output()
give it a name inNAME
and a description inDESCRIPTION
or alternatively overridename()
and/ordescription()
and it is good to be added tolisting_registry
.- get_output(metadata: TestPlanMetadata)[source]
- log_test_info(metadata: TestPlanMetadata)[source]
- metadata_based = True
- class testplan.testing.listing.NameLister[source]
Bases:
TrimMixin
,ExpandedNameLister
Trimmed version of ExpandedNameLister
- DESCRIPTION = 'List tests in readable format.\n\tMax 25 testcases per suite will be displayed'
- NAME = 'NAME'
- class testplan.testing.listing.PatternLister[source]
Bases:
TrimMixin
,ExpandedPatternLister
Like test lister, but trims list of testcases if they exceed <MAX_TESTCASES>.
This is useful if the user has generated hundreds of testcases via parametrization.
- DESCRIPTION = 'List tests in `--patterns` / `--tags` compatible format.\n\tMax 25 testcases per suite will be displayed'
- NAME = 'PATTERN'
- class testplan.testing.listing.SimpleJsonLister[source]
Bases:
MetadataBasedLister
- DESCRIPTION = 'Dump test information in json. Can take json:/path/to/output.json as well, then the result is dumped to the file'
- NAME = 'JSON'
- get_output(metadata: TestPlanMetadata)[source]
- class testplan.testing.listing.TrimMixin[source]
Bases:
object
- DESCRIPTION = '\tMax 25 testcases per suite will be displayed'
- testplan.testing.listing.listing_registry = <testplan.testing.listing.ListingRegistry object>
Registry instance that will be used to create the commandline parser, this can be extended with new listers
testplan.testing.ordering module
Classes for sorting test context before a test run.
Warning: sort_instances functionality is not supported yet, but the API is available for future compatibility.
- class testplan.testing.ordering.AlphanumericSorter(sort_type=SortType.ALL)[source]
Bases:
TypedSorter
Sorter that uses basic alphanumeric ordering.
- class testplan.testing.ordering.NoopSorter[source]
Bases:
BaseSorter
Sorter that returns the original ordering.
- class testplan.testing.ordering.ShuffleSorter(shuffle_type=SortType.ALL, seed=None)[source]
Bases:
TypedSorter
Sorter that shuffles the ordering. It is idempotent in a way that, it will return the same ordering for the same seed for the same list.
- property randomizer
- class testplan.testing.ordering.SortType(*values)[source]
Bases:
Enum
Helper enum used by sorter classes.
- ALL = 'all'
- INSTANCES = 'instances'
- SUITES = 'suites'
- TEST_CASES = 'testcases'
- class testplan.testing.ordering.TypedSorter(sort_type=SortType.ALL)[source]
Bases:
BaseSorter
Base sorter that allows configuration of sort levels via sort_type argument.
testplan.testing.result module
Defines the Result object and its sub-namepsaces.
The Result object is the interface used by testcases to make assertions and log data. Entries contained in the result are copied into the Report object after testcases have finished running.
- class testplan.testing.result.AssertionNamespace(result)[source]
Bases:
object
Base class for assertion namespaces. Users can inherit from this class to implement custom namespaces.
- class testplan.testing.result.DictNamespace(result)[source]
Bases:
AssertionNamespace
Contains logic for Dictionary related assertions.
- check(dictionary, description=None, category=None, has_keys=None, absent_keys=None)[source]
Checks for existence / absence of dictionary keys, uses top level keys in case of nested dictionaries.
result.dict.check( dictionary={ 'foo': 1, 'bar': 2, 'baz': 3, }, has_keys=['foo', 'alpha'], absent_keys=['bar', 'beta'] )
- Parameters:
dictionary (
dict
) – Dict object to check.has_keys (
list
orobject
(items must be hashable)) – List of keys to check for existence.absent_keys (
list
orobject
(items must be hashable)) – List of keys to check for absence.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- log(dictionary, description=None)[source]
Logs a dictionary to the report.
result.dict.log( dictionary={ 'foo': [1, 2, 3], 'bar': {'color': 'blue'}, 'baz': 'hello world', } )
- Parameters:
dictionary (
dict
) – Dict object to log.description (
str
) – Text description for the assertion.
- Returns:
Always returns True, this is not an assertion so it cannot fail.
- Return type:
bool
- match(actual: ~typing.Dict, expected: ~typing.Dict, include_only_expected: bool = False, description: str = None, category: str = None, include_keys: ~typing.List[~typing.Hashable] = None, exclude_keys: ~typing.List[~typing.Hashable] = None, report_mode=ReportOptions.ALL, actual_description: str = None, expected_description: str = None, value_cmp_func: ~typing.Callable[[~typing.Any, ~typing.Any], bool] = <built-in function eq>) DictMatch [source]
Matches two dictionaries, supports nested data. Custom comparators can be used as values on the
expected
dict.from testplan.common.utils import comparison result.dict.match( actual={ 'foo': 1, 'bar': 2, }, expected={ 'foo': 1, 'bar': 5, 'extra-key': 10, }, ) result.dict.match( actual={ 'foo': [1, 2, 3], 'bar': {'color': 'blue'}, 'baz': 'hello world', }, expected={ 'foo': [1, 2, lambda v: isinstance(v, int)], 'bar': { 'color': comparison.In(['blue', 'red', 'yellow']) }, 'baz': re.compile(r'\w+ world'), } )
- Parameters:
actual – Original dictionary.
expected – Comparison dictionary, can contain custom comparators (e.g. regex, lambda functions)
include_only_expected – Use the keys present in the expected dictionary.
include_keys – Keys to exclusively consider in the comparison.
exclude_keys – Keys to ignore in the comparison.
report_mode – Specify which comparisons should be kept and reported. Default option is to report all comparisons but this can be restricted if desired. See ReportOptions enum for more detail.
actual_description – Column header description for original dict.
expected_description – Column header description for expected dict.
description – Text description for the assertion.
category – Custom category that will be used for summarization.
value_cmp_func – Function to use to compare values in expected and actual dicts. Defaults to using operator.eq().
- Returns:
Assertion pass status
- match_all(values, comparisons, description=None, category=None, key_weightings=None)[source]
Match multiple unordered dictionaries.
Initially all value/expected comparison combinations are evaluated and converted to an error weight.
If certain keys are more important than others, it is possible to give them additional weighting during the comparison, by specifying a “key_weightings” dict. The default weight of a mismatch is 100.
The values/comparisons permutation that results in the least error appended to the report.
result.dict.match_all( values=[ {'foo': 12, ...}, {'foo': 13, ...}, ... ], comparisons=[ Expected({'foo': 12, ...}), Expected({'foo': 15, ...}) ... ], # twice the default weight of 100 key_weightings={'foo': 200})
- Parameters:
values (
list
ofdict
) – Original values.comparisons (
list
oftestplan.common.utils.comparison.Expected
) – Comparison objects.key_weightings (
dict
) – Per-key overrides that specify a different weight for different keys.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- class testplan.testing.result.ExceptionCapture(result, assertion_kls, exceptions, pattern=None, func=None, description=None, category=None)[source]
Bases:
object
Exception capture scope, will be used by exception related assertions. An instance of this class will be used as a context manager by exception related assertion methods.
- class testplan.testing.result.FixNamespace(result)[source]
Bases:
AssertionNamespace
Contains assertion logic that operates on fix messages.
- check(msg, description=None, category=None, has_tags=None, absent_tags=None)[source]
Checks existence / absence of tags in a Fix message. Checks top level tags only.
result.fix.check( msg={ 36: 6, 22: 5, 55: 2, 38: 5, 555: [ .. more nested data here ... ] }, has_tags=[26, 22, 11], absent_tags=[444, 555], )
- Parameters:
msg (
dict
) – Fix message.has_tags (
list
ofobject
(items must be hashable)) – List of tags to check for existence.absent_tags (
list
ofobject
(items must be hashable)) – List of tags to check for absence.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- log(msg, description=None)[source]
Logs a fix message to the report.
result.fix.log( msg={ 36: 6, 22: 5, 55: 2, 38: 5, 555: [ .. more nested data here ... ] } )
- Parameters:
msg (
dict
orpyfixmsg.fixmessage.FixMessage
) – Fix message.description (
str
) – Text description for the assertion.
- Returns:
Always returns True, this is not an assertion so it cannot fail.
- Return type:
bool
- match(actual: Dict, expected: Dict, include_only_expected: bool = False, description: str = None, category: str = None, include_tags: List[Hashable] = None, exclude_tags: List[Hashable] = None, report_mode=ReportOptions.ALL, actual_description: str = None, expected_description: str = None) FixMatch [source]
Matches two FIX messages, supports repeating groups (nested data). Custom comparators can be used as values on the
expected
msg.result.fix.match( actual={ 36: 6, 22: 5, 55: 2, 38: 5, 555: [ .. more nested data here ... ] }, expected={ 36: 6, 22: 5, 55: lambda val: val in [2, 3, 4], 38: 5, 555: [ .. more nested data here ... ] } )
- Parameters:
actual – Original FIX message.
expected – Expected FIX message, can include compiled regex patterns or callables for advanced comparison.
include_only_expected – Use the tags present in the expected message.
include_tags – Tags to exclusively consider in the comparison.
exclude_tags – Keys to ignore in the comparison.
report_mode – Specify which comparisons should be kept and reported. Default option is to report all comparisons but this can be restricted if desired. See ReportOptions enum for more detail.
actual_description – Column header description for original msg.
expected_description – Column header description for expected msg.
description – Text description for the assertion.
category – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- match_all(values, comparisons, description=None, category=None, tag_weightings=None)[source]
Match multiple unordered FIX messages.
Initially all value/expected comparison combinations are evaluated and converted to an error weight.
If certain fix tags are more important than others (e.g. ID FIX tags), it is possible to give them additional weighting during the comparison, by specifying a “tag_weightings” dict.
The default weight of a mismatch is 100.
The values/comparisons permutation that results in the least error appended to the report.
result.dict.match_all( values=[ { 36: 6, 22: 5, 55: 2, ...}, { 36: 7, ...}, ... ], comparisons=[ Expected({ 36: 6, 22: 5, 55: 2, ...},), Expected({ 36: 7, ...}) ... ], # twice the default weight of 100 key_weightings={36: 200})
- Parameters:
values (
list
ofdict
) – Original values.comparisons (
list
oftestplan.common.utils.comparison.Expected
) – Comparison objects.tag_weightings (
dict
) – Per-tag overrides that specify a different weight for different tags.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- class testplan.testing.result.LogfileExpect(result, log_matcher, regex, timeout, description, category)[source]
Bases:
ScopedLogfileMatch
ScopedLogfileMatch with assertion operation.
- class testplan.testing.result.LogfileNamespace(result)[source]
Bases:
AssertionNamespace
Contains assertion methods that operates on log files equipped with
LogMatcher
.- expect(log_matcher: LogMatcher, regex: str | bytes | Pattern, timeout: float = 5.0, description: str | None = None, category: str | None = None)[source]
Call as context manager for pattern matching in logfile, given expected lines (indirectly) produced by context manager body, with matching results logged to the report. On enter doing position setting to EOF operation as
result.logfile.seek_eof
, on exit doing matching operation asresult.logfile.match
.with result.logfile.expect( log_matcher, r".*passed.*", timeout=2.0, description="my logfile match assertion", ): ...
- Parameters:
log_matcher – LogMatcher on target logfile.
regex – Regular expression as expected pattern in target logfile.
timeout – Match timeout value in seconds.
description – Text description for the assertion.
category – Custom category that will be used for summarization.
- match(log_matcher: LogMatcher, regex: str | bytes | Pattern, timeout: float = 5.0, description: str | None = None, category: str | None = None)[source]
Match patterns in logfile using LogMatcher, with matching results logged to the report.
result.logfile.match( log_matcher, r".*passed.*", timeout=2.0, description="my logfile match assertion", )
- Parameters:
log_matcher – LogMatcher on target logfile.
regex – Regular expression as expected pattern in target logfile.
timeout – Match timeout value in seconds.
description – Text description for the assertion.
category – Custom category that will be used for summarization.
- seek_eof(log_matcher: LogMatcher, description: str | None = None)[source]
Set the position of LogMatcher to end of logfile, with operation logged to the report.
result.logfile.seek_eof(log_matcher)
- Parameters:
log_matcher – LogMatcher on target logfile.
description – Custom text description for the entry.
- class testplan.testing.result.RegexNamespace(result)[source]
Bases:
AssertionNamespace
Contains logic for regular expression assertions.
- findall(regexp, value, description=None, category=None, flags=0, condition=None)[source]
Checks if there are one or more matches of the
regexp
exist in thevalue
viare.finditer
. Can apply further assertions viacondition
func.result.regex.findall( regexp='foo', value='foo foo foo bar bar foo bar', condition=lambda num_matches: 2 < num_matches < 5, )
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.flags (
int
) – Regex flags that will be passed to there.finditer
function.condition (
callable
) – A callable that accepts a single argument, which is the number of matches (int).description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- match(regexp, value, description=None, category=None, flags=0)[source]
Checks if the given
regexp
matches thevalue
viare.match
operation.result.regex.match(regexp='foo', value='foobar')
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.flags (
int
) – Regex flags that will be passed to there.match
function.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- matchline(regexp, value, description=None, category=None, flags=0)[source]
Checks if the given
regexp
returns a match (re.match
) for any of the lines in thevalue
.result.regex.matchline( regexp=re.compile(r'\w+ line$'), value=os.linesep.join([ 'first line', 'second aaa', 'third line' ]), )
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.flags (
int
) – Regex flags that will be passed to there.match
function.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- multiline_match(regexp, value, description=None, category=None)[source]
Checks if the given
regexp
matches thevalue
viare.match
operation, usesre.MULTILINE
andre.DOTALL
flags implicitly.result.regex.multiline_match( regexp='first line.*second', value=os.linesep.join([ 'first line', 'second line', 'third line' ]), )
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.description (
str
) – text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status.
- Return type:
bool
- multiline_not_match(regexp, value, description=None, category=None)[source]
Checks if the given
regexp
does not match thevalue
viare.match
operation, usesre.MULTILINE
andre.DOTALL
flags implicitly.result.regex.multiline_not_match( regexp='foobar', value=os.linesep.join([ 'first line', 'second line', 'third line' ]), )
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- not_match(regexp, value, description=None, category=None, flags=0)[source]
Checks if the given
regexp
does not match thevalue
viare.match
operation.result.regex.not_match('baz', 'foobar')
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.flags (
int
) – Regex flags that will be passed to there.match
function.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status.
- Return type:
bool
- search(regexp, value, description=None, category=None, flags=0)[source]
Checks if the given
regexp
exists in thevalue
viare.search
operation.result.regex.search('bar', 'foobarbaz')
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.flags (
int
) – Regex flags that will be passed to there.search
function.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- search_empty(regexp, value, description=None, category=None, flags=0)[source]
Checks if the given
regexp
does not exist in thevalue
viare.search
operation.result.regex.search_empty('aaa', 'foobarbaz')
- Parameters:
regexp (
str
or compiled regex) – String pattern or compiled regexp object.value (
str
) – String to match against.flags (
int
) – Regex flags that will be passed to there.search
function.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- class testplan.testing.result.Result(stdout_style=None, continue_on_failure=True, _group_description=None, _parent=None, _summarize=False, _num_passing=5, _num_failing=5, _scratch=None, _collect_code_context=False)[source]
Bases:
object
Contains assertion methods and namespaces for generating test data. A new instance of
Result
object is passed to each testcase when a suite is run.- attach(path, description=None, ignore=None, only=None, recursive=False)[source]
Attaches a file to the report.
- Parameters:
path (
str
) – Path to the file or directory be to attached.description (
str
) – Text description for the assertion.ignore (
list
orNoneType
) – List of patterns of file name to ignore when attaching a directory.only (
list
orNoneType
) – List of patterns of file name to include when attaching a directory.recursive (
bool
) – Recursively traverse sub-directories and attach all files, default is to only attach files in top directory.
- Returns:
Always returns True, this is not an assertion so it cannot fail.
- Return type:
bool
- conditional_log(condition, log_message, log_description, fail_description, flag=None)[source]
A compound assertion that does result.log() or result.fail() depending on the truthiness of condition.
result.conditional_log( some_condition, log_message, log_description, fail_description, )
is a shortcut for writing:
if some_condition: result.log(log_message, description=log_description) else: result.fail(fail_description)
- Parameters:
condition – Value to be evaluated for truthiness
condition –
object
log_message (
str
) – Message to pass to result.log if condition evaluates to True.log_description (
str
) – Description to pass to result.log if condition evaluates to True.fail_description (
str
) – Description to pass to result.fail if condition evaluates to False.flag – Custom flag of the assertion which is reserved and can be used for some special purpose.
- Returns:
True
- Return type:
bool
- contain(member, container, description=None, category=None)[source]
Checks if
member in container
.result.contain(1, [1, 2, 3, 4], 'Custom description')
- Parameters:
member (
object
) – Item to be checked for existence in the container.container (
object
) – Container object, should support item lookup operations.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- diff(first, second, ignore_space_change=False, ignore_whitespaces=False, ignore_blank_lines=False, unified=False, context=False, description=None, category=None)[source]
Line diff assertion. Fail if at least one difference found.
text1 = 'a b c\nd\n' text2 = 'a b c\nd\t\n' result.diff(text1, text2, ignore_space_change=True)
- Parameters:
first (
str
orlist
) – The first piece of textual content to be compared.second (
str
orlist
) – The second piece of textual content to be compared.ignore_space_change (
bool
) – Ignore changes in the amount of whitespace.ignore_whitespaces (
bool
) – Ignore all white space.ignore_blank_lines (
bool
) – Ignore changes whose lines are all blank.unified (
bool
orint
) – If truth value, output differences in unified context. Use an integer to specify the number of lines of leading context before matching lines and trailing context after matching lines. Defaults to 3.context (
bool
orint
) – If truth value, output differences in copied context. Use an integer to specify the number of lines of leading context before matching lines and trailing context after matching lines. Defaults to 3.
- Returns:
Assertion pass status
- Return type:
bool
- eq(actual, expected, description=None, category=None)
Equality assertion, checks if
actual == expected
. Can be used via shortcut:result.eq
.result.equal('foo', 'foo', 'Custom description')
- Parameters:
actual (
object
) – First (actual) value of the comparison.expected (
object
) – Second (expected) value of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- equal(actual, expected, description=None, category=None)[source]
Equality assertion, checks if
actual == expected
. Can be used via shortcut:result.eq
.result.equal('foo', 'foo', 'Custom description')
- Parameters:
actual (
object
) – First (actual) value of the comparison.expected (
object
) – Second (expected) value of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- equal_exclude_slices(actual, expected, slices, description=None, category=None)[source]
Checks if items that exist outside the given slices of
actual
andexpected
are equal.result.equal_exclude_slices( [1, 2, 3, 4, 5, 6, 7, 8], ['a', 'b', 3, 4, 'c', 'd', 'e', 'f'], slices=[slice(0, 2), slice(4, 8)], description='Comparison of slices (exclusion)' )
- Parameters:
actual (
object
that supports slice operations.) – First (actual) value of the comparison.expected (
object
that supports slice operations.) – Second (expected) value of the comparison.slices (
list
ofslice
) – Slices that will be used for exclusion of items fromactual
andexpected
.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- equal_slices(actual, expected, slices, description=None, category=None)[source]
Checks if given slices of
actual
andexpected
are equal.result.equal_slices( [1, 2, 3, 4, 5, 6, 7, 8], ['a', 'b', 3, 4, 'c', 'd', 7, 8], slices=[slice(2, 4), slice(6, 8)], description='Comparison of slices' )
- Parameters:
actual (
object
that supports slice operations.) – First (actual) value of the comparison.expected (
object
that supports slice operations.) – Second (expected) value of the comparison.slices (
list
ofslice
) – Slices that will be applied toactual
andexpected
.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- fail(message: str, description: str | None = None, flag: str | None = None, category: str | None = None) Fail [source]
Failure assertion, can be used for explicitly failing a testcase. The message will be included by email exporter. Most common usage is within a conditional block.
if some_condition: result.fail('Unexpected failure: {}'.format(...))
- Parameters:
description – Text description of the failure.
category – Custom category that will be used for summarization.
flag – custom flag - reserved parameter
- Returns:
False
- false(value, description=None, category=None)[source]
Boolean assertion, checks if
value
is falsy.result.false(some_obj, 'Custom description')
- Parameters:
value (
object
) – Value to be evaluated for falsiness.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- flow_chart(nodes, edges, description=None)[source]
Displays a flow chart in the report.
- Parameters:
nodes (
list
ofstr
) – List of nodesedges (
list
ofdict
) – List of edges
- Returns:
Always returns True, this is not an assertion so it cannot fail.
- Return type:
bool
- ge(first, second, description=None, category=None)
Checks if
first >= second
. Can be used via shortcut:result.ge
result.greater_equal(5, 3, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- get_namespaces()[source]
This method can be overridden for enabling custom assertion namespaces for child classes.
- graph(graph_type, graph_data, description, series_options, graph_options)[source]
Displays a Graph in the report.
result.graph('Line', { 'graph 1':[{'x': 0, 'y': 8},{'x': 1, 'y': 5}] }, description='Line Graph', series_options={'graph 1':{"colour": "red"}}, graph_options=None)
- Parameters:
graph_type (
str
) – Type of graph user wants to create. Currently implemented: ‘Line’, ‘Scatter’, ‘Bar’, ‘Hexbin’, ‘Pie’, ‘Whisker’, ‘Contour’graph_data (
dict[str, list]
) – Data to plot on the graph, for each series.description (
str
) – Text description for the graph.series_options (
dict[str, dict[str, object]]`
.) – Customisation parameters for each individual series. Currently implemented: 1){‘Colour’:str
} - colour of that series (str can be either basic colour name or RGB)graph_options (
dict[str, object]
.) –Customisation parameters for overall graph Currently implemented:
1){‘xAxisTitle’:
str
} - x axis graph title 2){‘yAxisTitle’:str
} - y axis graph title 3){‘legend’:bool
} - to display legend legend (Default: false)
- greater(first, second, description=None, category=None)[source]
Checks if
first > second
. Can be used via shortcut:result.gt
result.greater(5, 3, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- greater_equal(first, second, description=None, category=None)[source]
Checks if
first >= second
. Can be used via shortcut:result.ge
result.greater_equal(5, 3, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- group(description=None, summarize=False, num_passing=5, num_failing=5)[source]
Creates an assertion group or summary, which is helpful for formatting assertion data on certain output targets (e.g. PDF, JSON) and reducing the amount of content that gets displayed.
Should be used as a context manager.
# Group and sub groups with result.group(description='Custom group description') as group: group.not_equal(2, 3, description='Assertion within a group') group.greater(5, 3) with group.group() as sub_group: sub_group.less(6, 3, description='Assertion in sub group') # Summary example with result.group( summarize=True, num_passing=4, num_failing=10, ) as group: for i in range(500): # First 4 passing assertions will be displayed group.equal(i, i) # First 10 failing assertions will be displayed group.equal(i, i + 1)
- Parameters:
description (
str
) – Text description for the assertion group.summarize (
bool
) – Flag for enabling summarization.num_passing (
int
) – Max limit for number of passing assertions per category & assertion type.num_failing (
int
) – Max limit for number of failing assertions per category & assertion type.
- Returns:
A new result object that refers the current result as a parent.
- Return type:
Result object
- gt(first, second, description=None, category=None)
Checks if
first > second
. Can be used via shortcut:result.gt
result.greater(5, 3, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- isclose(first, second, rel_tol=1e-09, abs_tol=0.0, description=None, category=None)[source]
Checks if
first
andsecond
are approximately equal.result.isclose(99.99, 100, 0.001, 0.0, 'Custom description')
- Parameters:
first (
numbers.Number
) – The first item to be compared for approximate equality.second (
numbers.Number
) – The second item to be compared for approximate equality.rel_tol (
numbers.Real
) – The relative tolerance.abs_tol (
numbers.Real
) – The minimum absolute tolerance level.
- Returns:
Assertion pass status
- Return type:
bool
- le(first, second, description=None, category=None)
Checks if
first <= second
. Can be used via shortcut:result.le
result.less_equal(5, 3, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- less(first, second, description=None, category=None)[source]
Checks if
first < second
. Can be used via shortcut:result.lt
result.less(3, 5, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- less_equal(first, second, description=None, category=None)[source]
Checks if
first <= second
. Can be used via shortcut:result.le
result.less_equal(5, 3, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- log(message, description=None, flag=None)[source]
Create a string message entry, can be used for providing additional context related to test steps.
result.log('Custom log message ...')
- Parameters:
message (
str
or instance) – Log messagedescription (
str
) – Text description for the assertion.flag – Custom flag of the assertion which is reserved and can be used for some special purpose.
flag –
str
orNoneType
- Returns:
Always returns True, this is not an assertion so it cannot fail.
- Return type:
bool
- log_code(code, language='python', description=None)[source]
Create a codelog message entry which contains code snippet, can be used for providing additional context related to test steps.
- Parameters:
code (
str
) – The source code string.language (
str
) – The language of source code. e.g. js, xml, python, java, c, cpp, bash. Defaults to python.description (
str
) – Text description for the assertion.
- Returns:
True
- Return type:
bool
- log_html(code, description='Embedded HTML')[source]
Create a markdown message entry without escape, can be used for providing additional context related to test steps.
- Parameters:
code (
str
) – HTML code string. Tag <script> will not be executed.description (
str
) – Text description for the assertion.
- Returns:
True
- Return type:
bool
- lt(first, second, description=None, category=None)
Checks if
first < second
. Can be used via shortcut:result.lt
result.less(3, 5, 'Custom description')
- Parameters:
first (
object
) – Left side of the comparison.second (
object
) – Right side of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- markdown(message, description=None, escape=True)[source]
Create a markdown message entry, can be used for providing additional context related to test steps.
result.markdown( 'Markdown string ....', description='Test', escape=False )
- Parameters:
message (
str
) – Markdown stringdescription (
str
) – Text description for the assertion.escape – Escape html.
escape –
bool
- Returns:
True
- Return type:
bool
- matplot(pyplot, width=None, height=None, description=None)[source]
Displays a Matplotlib plot in the report.
- Parameters:
pyplot (
matplotlib.pyplot
) – Matplotlib pyplot object to be displayed.width (
int
) – Figure width in inches, use pyplot defaul if not specifiedheight (
int
) – Figure height in inches, use pyplot default if not specifieddescription (
str
) – Text description for the assertion.
- Returns:
Always returns True, this is not an assertion so it cannot fail.
- Return type:
bool
- namespaces = {'dict': <class 'testplan.testing.result.DictNamespace'>, 'fix': <class 'testplan.testing.result.FixNamespace'>, 'logfile': <class 'testplan.testing.result.LogfileNamespace'>, 'regex': <class 'testplan.testing.result.RegexNamespace'>, 'table': <class 'testplan.testing.result.TableNamespace'>, 'xml': <class 'testplan.testing.result.XMLNamespace'>}
- ne(actual, expected, description=None, category=None)
Inequality assertion, checks if
actual != expected
. Can be used via shortcut:result.ne
.result.not_equal('foo', 'bar', 'Custom description')
- Parameters:
actual (
object
) – First (actual) value of the comparison.expected (
object
) – Second (expected) value of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- not_contain(member, container, description=None, category=None)[source]
Checks if
member not in container
.result.not_contain(5, [1, 2, 3, 4], 'Custom description')
- Parameters:
member (
object
) – Item to be checked for absence from the container.container (
object
) – Container object, should support item lookup operations.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- not_equal(actual, expected, description=None, category=None)[source]
Inequality assertion, checks if
actual != expected
. Can be used via shortcut:result.ne
.result.not_equal('foo', 'bar', 'Custom description')
- Parameters:
actual (
object
) – First (actual) value of the comparison.expected (
object
) – Second (expected) value of the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- not_raises(exceptions, description=None, category=None, pattern=None, func=None)[source]
Checks if given code block does not raise certain type(s) of exception(s).
Supports further checks via
pattern
andfunc
arguments.with result.not_raises(AttributeError): {'foo': 3}['bar'] with result.raises(ValueError, pattern='foo') raise ValueError('abc xyz') def check_exception(exc): ... with result.raises(TypeError, func=check_exception): raise TypeError(...)
- Parameters:
exceptions (
list
ofException
classes or a singleException
class) – Exception types to check.pattern (
str
or compiled regex object) – String pattern that will be searched (re.searched
) within exception message.func (
callable
) – Callable that accepts a single argument (the exception object)description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- property passed
Entries stored passed status.
- raises(exceptions, description=None, category=None, pattern=None, func=None)[source]
Checks if given code block raises certain type(s) of exception(s). Supports further checks via
pattern
andfunc
arguments.with result.raises(KeyError): {'foo': 3}['bar'] with result.raises(ValueError, pattern='foo') raise ValueError('abc foobar xyz') def check_exception(exc): ... with result.raises(TypeError, func=check_exception): raise TypeError(...)
- Parameters:
exceptions (
list
ofException
classes or a singleException
class) – Exception types to check.pattern (
str
or compiled regex object) – String pattern that will be searched (re.searched
) within exception message.func (
callable
) – Callable that accepts a single argument (the exception object)description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- property serialized_entries
Return entry data in dictionary form. This will then be stored in related
TestCaseReport
’sentries
attribute.
- skip(reason: str, description: str | None = None)[source]
Skip a testcase with the given reason.
- Parameters:
reason (
str
) – The message to show the user as reason for the skip.description (
str
) – Text description for the assertion.
- true(value, description=None, category=None)[source]
Boolean assertion, checks if
value
is truthy.result.true(some_obj, 'Custom description')
- Parameters:
value (
object
) – Value to be evaluated for truthiness.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- class testplan.testing.result.TableNamespace(result)[source]
Bases:
AssertionNamespace
Contains logic for regular expression assertions.
- column_contain(table, values, column, description=None, category=None, limit=None, report_fails_only=False)[source]
Checks if all of the values of a table’s column contain values from a given list.
result.table.column_contain( table=[ ['symbol', 'amount'], ['AAPL', 12], ['GOOG', 21], ['FB', 32], ['AMZN', 5], ['MSFT', 42] ], values=['AAPL', 'AMZN'], column='symbol', )
- Parameters:
table (
list
oflist
orlist
ofdict
.) – Tabular datavalues (
iterable
ofobject
) – Values that will be checked against each cell.column (
str
) – Column name to check.limit (
int
) – Maximum number of rows to process, can be used for limiting output.report_fails_only (
bool
) – Filtering option, output will contain failures only if this argument is True.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- diff(actual, expected, description=None, category=None, include_columns=None, exclude_columns=None, report_all=True, fail_limit=0)[source]
Find differences of two tables, uses equality for each table cell for plain values and supports regex / custom comparators as well. The result will contain only failing comparisons.
If the columns of the two tables are not the same, either
include_columns
orexclude_columns
arguments must be used to have column uniformity.result.table.diff( actual=[ ['name', 'age'], ['Bob', 32], ['Susan', 24], ], expected=[ ['name', 'age'], ['Bob', 33], ['David', 24], ] ) result.table.diff( actual=[ ['name', 'age'], ['Bob', 32], ['Susan', 24], ], expected=[ ['name', 'age'], [re.compile(r'^B\w+'), 33], ['David', lambda age: 20 < age < 50], ] )
- Parameters:
actual (
list
oflist
orlist
ofdict
.) – Tabular dataexpected (
list
oflist
orlist
ofdict
.) – Tabular data, which can contain custom comparators.include_columns (
list
ofstr
) – List of columns to include in the comparison. Cannot be used withexclude_columns
.exclude_columns (
list
ofstr
) – List of columns to exclude from the comparison. Cannot be used withinclude_columns
.report_all (
bool
) – Boolean flag for configuring output. If True then all columns of the original table will be displayed.fail_limit (
int
) – Max number of failures before aborting the comparison run. Useful for large tables, when we want to stop after we have N rows that fail the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- log(table, display_index=False, description=None)[source]
Logs a table to the report.
result.table.log( table=[ ['name', 'age', 'gender'], ['Bob', 32, 'M'], ['Susan', 24, 'F'], ] )
- Parameters:
table (
list
oflist
orlist
ofdict
) – Tabular data.display_index (
bool
) – Flag whether to display row indices.description (
str
) – Text description for the assertion.
- Returns:
Always returns True, this is not an assertion so it cannot fail.
- Return type:
bool
- match(actual, expected, description=None, category=None, include_columns=None, exclude_columns=None, report_all=True, fail_limit=0)[source]
Compares two tables, uses equality for each table cell for plain values and supports regex / custom comparators as well.
If the columns of the two tables are not the same, either
include_columns
orexclude_columns
arguments must be used to have column uniformity.result.table.match( actual=[ ['name', 'age'], ['Bob', 32], ['Susan', 24], ], expected=[ ['name', 'age'], ['Bob', 33], ['David', 24], ] ) result.table.match( actual=[ ['name', 'age'], ['Bob', 32], ['Susan', 24], ], expected=[ ['name', 'age'], [re.compile(r'^B\w+'), 33], ['David', lambda age: 20 < age < 50], ] )
- Parameters:
actual (
list
oflist
orlist
ofdict
.) – Tabular dataexpected (
list
oflist
orlist
ofdict
.) – Tabular data, which can contain custom comparators.include_columns (
list
ofstr
) – List of columns to include in the comparison. Cannot be used withexclude_columns
.exclude_columns (
list
ofstr
) – List of columns to exclude from the comparison. Cannot be used withinclude_columns
.report_all (
bool
) – Boolean flag for configuring output. If True then all columns of the original table will be displayed.fail_limit (
int
) – Max number of failures before aborting the comparison run. Useful for large tables, when we want to stop after we have N rows that fail the comparison.description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- class testplan.testing.result.XMLNamespace(result)[source]
Bases:
AssertionNamespace
Contains logic for XML related assertions.
- check(element, xpath, description=None, category=None, tags=None, namespaces=None)[source]
Checks if given xpath and tags exist in the XML body. Supports namespace based matching as well.
result.xml.check( element=''' <Root> <Test>Value1</Test> <Test>Value2</Test> </Root> ''', xpath='/Root/Test', tags=['Value1', 'Value2'], ) result.xml.check( element=''' <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"> <SOAP-ENV:Header/> <SOAP-ENV:Body> <ns0:message xmlns:ns0="http://testplan">Hello world!</ns0:message> </SOAP-ENV:Body> </SOAP-ENV:Envelope> ''', xpath='//*/a:message', tags=[re.compile(r'Hello*')], namespaces={"a": "http://testplan"}, )
- Parameters:
element (
str
orlxml.etree.Element
) – XML elementxpath (
str
) – XPath expression to be used for navigation & check.tags (
list
ofstr
or compiled regex patterns) – Tag values to match against in the given xpath.namespaces (
dict
) – Prefix mapping for xpath expressions. (namespace prefixes as keys and URIs for values.)description (
str
) – Text description for the assertion.category (
str
) – Custom category that will be used for summarization.
- Returns:
Assertion pass status
- Return type:
bool
- testplan.testing.result.report_target(func: Callable, ref_func: Callable = None) Callable [source]
Sets the decorated function’s filepath and line-range in assertion state. If the target function is a parametrized function, should refer to its parametrized template to find information of the original function.
- Parameters:
func – The target function about which the information of source path and line range will be retrieved.
ref_func – The parametrized template if func is a generated function, otherwise
None
.
testplan.testing.tagging module
Generic Tagging logic.
- testplan.testing.tagging.check_all_matching_tags(tag_arg_dict, target_tag_dict)[source]
Return True if all tag sets in tag_arg_dict is a subset of the matching categories in target_tag_dict.
- testplan.testing.tagging.check_any_matching_tags(tag_arg_dict, target_tag_dict)[source]
Return true if there is at least one match for a category.
- testplan.testing.tagging.merge_tag_dicts(*tag_dicts)[source]
Utility function for merging tag dicts for easy comparisons.
- testplan.testing.tagging.parse_tag_arguments(*tag_arguments)[source]
Parse command line tag arguments into a dictionary of sets.
For the call below:
--tags foo bar named-tag=one,two named-tag=three hello=world
We will get:
[ {'simple': {'foo'}, {'simple', {'bar'}, {'named_tag', {'one', 'two'}, {'named_tag', {'three'}, {'hello', {'world'} ]
The repeated tag values will later on be grouped together via TagsAction.
- testplan.testing.tagging.tag_label(tag_dict)[source]
Return tag data in readable format.
>>> tag_dict = { 'simple': set(['foo', 'bar']), 'tag_group_1': set(['some-value']), 'other_group': set(['one', 'two', 'three']) }
>>> tag_label(tag_dict) Tags: foo bar tag_group_1=some-value other_group=one,two,three
- testplan.testing.tagging.validate_tag_value(tag_value)[source]
Validate a tag value, make sure it is of correct type. Return a tag dict for internal representation.
Sample input / output:
‘foo’ -> {‘simple’: {‘foo’} (‘foo’, ‘bar’) -> {‘simple’: {‘foo’, ‘bar’} {‘color’: ‘red’} -> {‘color’: {‘red’} {‘color’: (‘red’, ‘blue’)} -> {‘color’: {‘red’, ‘blue’}
- Parameters:
tag_value (
string
,iterable
ofstring
or adict
withstring
keys andstring
oriterable
ofstring
as values.) – User defined tag value.- Returns:
Internal representation of the tag context.
- Return type:
dict
ofset
testplan.testing.py_test module
PyTest test runner.
- class testplan.testing.py_test.PyTest(name, target, description=None, select='', extra_args=None, result=<class 'testplan.testing.result.Result'>, **options)[source]
Bases:
Test
PyTest plugin for Testplan. Allows tests written for PyTest to be run from Testplan, with the test results logged and included in the Testplan report.
- Parameters:
name (
str
) – Test instance name, often used as uid of test entity.target (
str
orlist
ofstr
) – Target of PyTest configuration.description (
str
) – Description of test instance.select (
str
) – Selection of PyTest configuration.extra_args (
NoneType
orlist
ofstr
) – Extra arguments passed to pytest.result (
Result
) – Result that contains assertion entries.
Also inherits all
Test
options.- CONFIG
alias of
PyTestConfig
- get_test_context()[source]
Inspect the test suites and cases by running PyTest with the –collect-only flag and passing in our collection plugin.
- Returns:
List containing pairs of suite name and testcase names.
- Return type:
List[Tuple[str, List[str]]]
- run_testcases_iter(testsuite_pattern: str = '*', testcase_pattern: str = '*', shallow_report: Dict = None) Generator [source]
Run all testcases and yield testcase reports.
- Parameters:
testsuite_pattern – pattern to match for testsuite names
testcase_pattern – pattern to match for testcase names
shallow_report – shallow report entry
- Returns:
generator yielding testcase reports and UIDs for merge step
testplan.testing.pyunit module
PyUnit test runner.
- class testplan.testing.pyunit.PyUnit(name, testcases, description=None, **kwargs)[source]
Bases:
Test
Test runner for PyUnit unit tests.
- Parameters:
name (
str
) – Test instance name, often used as uid of test entity.testcases (
TestCase
) – PyUnit testcases.description (
str
) – Description of test instance.
Also inherits all
Test
options.- CONFIG
alias of
PyUnitConfig
- get_test_context()[source]
Currently we do not inspect individual PyUnit testcases - only allow the whole suite to be run.
- run_testcases_iter(testsuite_pattern: str = '*', testcase_pattern: str = '*', shallow_report: Dict = None) Generator [source]
Run all testcases and yield testcase reports.
- Parameters:
testsuite_pattern – pattern to match for testsuite names
testcase_pattern – pattern to match for testcase names
shallow_report – shallow report entry
- Returns:
generator yielding testcase reports and UIDs for merge step
- class testplan.testing.pyunit.PyUnitConfig(**options)[source]
Bases:
TestConfig
Configuration object for :py:class`~testplan.testing.pyunit.PyUnit` test runner.
testplan.testing.junit module
JUnit test runner.
- class testplan.testing.junit.JUnit(name, binary, results_dir, junit_args=None, junit_filter=None, **options)[source]
Bases:
ProcessRunnerTest
Subprocess test runner for JUnit: https://junit.org/junit5/docs/current/user-guide/
Please note that the test (either native binary or script) should generate XML format report so that Testplan is able to parse the result.
gradle test
- Parameters:
name (
str
) – Test instance name, often used as uid of test entity.binary (
str
) – Path to the gradle binary or script.description (
str
) – Description of test instance.junit_args (
NoneType
orlist
) – Customized command line arguments for Junit testresults_dir (
str
) – Where saved the test xml report.junit_filter (
NoneType
orlist
) – Customized command line arguments for filtering testcases.
Also inherits all
ProcessRunnerTest
options.- CONFIG
alias of
JUnitConfig
- list_command_filter(testsuite_pattern, testcase_pattern)[source]
Return the base list command with additional filtering to list a specific set of testcases.
- class testplan.testing.junit.JUnitConfig(**options)[source]
Bases:
ProcessRunnerTestConfig
Configuration object for :py:class`~testplan.testing.junit.JUnit` test runner.