Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | """ |
| 3 | @package oft |
| 4 | |
| 5 | OpenFlow test framework top level script |
| 6 | |
Rich Lane | ea5060d | 2013-01-06 13:59:00 -0800 | [diff] [blame] | 7 | This script is the entry point for running OpenFlow tests using the OFT |
| 8 | framework. For usage information, see --help or the README. |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 9 | |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 10 | To add a new command line option, edit both the CONFIG_DEFAULT dictionary and |
Rich Lane | ea5060d | 2013-01-06 13:59:00 -0800 | [diff] [blame] | 11 | the config_setup function. The option's result will end up in the global |
| 12 | oftest.config dictionary. |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 13 | """ |
| 14 | |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 15 | from __future__ import print_function |
| 16 | |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 17 | import sys |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 18 | import optparse |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 19 | import logging |
| 20 | import unittest |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 21 | import time |
Brandon Heller | 446c143 | 2010-04-01 12:43:27 -0700 | [diff] [blame] | 22 | import os |
Rich Lane | 6b452bc | 2012-07-09 16:52:21 -0700 | [diff] [blame] | 23 | import imp |
Rich Lane | 8592bec | 2012-09-03 09:06:59 -0700 | [diff] [blame] | 24 | import random |
Rich Lane | 5bd6cf9 | 2012-10-04 17:57:24 -0700 | [diff] [blame] | 25 | import signal |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 26 | import fnmatch |
Rich Lane | 2d6d482 | 2013-01-08 10:49:16 -0800 | [diff] [blame] | 27 | import copy |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 28 | |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 29 | ROOT_DIR = os.path.dirname(os.path.realpath(__file__)) |
Rich Lane | fadf345 | 2012-10-03 16:23:37 -0700 | [diff] [blame] | 30 | |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 31 | PY_SRC_DIR = os.path.join(ROOT_DIR, 'src', 'python') |
| 32 | if os.path.exists(os.path.join(PY_SRC_DIR, 'oftest')): |
Rich Lane | 3987804 | 2012-07-09 14:45:35 -0700 | [diff] [blame] | 33 | # Running from source tree |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 34 | sys.path.insert(0, PY_SRC_DIR) |
Rich Lane | 3987804 | 2012-07-09 14:45:35 -0700 | [diff] [blame] | 35 | |
Rich Lane | 477f481 | 2012-10-04 22:49:00 -0700 | [diff] [blame] | 36 | import oftest |
| 37 | from oftest import config |
Rich Lane | e55abf7 | 2012-07-26 20:11:42 -0700 | [diff] [blame] | 38 | import oftest.ofutils |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 39 | import oftest.help_formatter |
Rich Lane | 3f7098c | 2013-03-12 10:28:32 -0700 | [diff] [blame] | 40 | import loxi |
Dan Talayco | ba3745c | 2010-07-21 21:51:08 -0700 | [diff] [blame] | 41 | |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 42 | ##@var DEBUG_LEVELS |
| 43 | # Map from strings to debugging levels |
| 44 | DEBUG_LEVELS = { |
| 45 | 'debug' : logging.DEBUG, |
| 46 | 'verbose' : logging.DEBUG, |
| 47 | 'info' : logging.INFO, |
| 48 | 'warning' : logging.WARNING, |
| 49 | 'warn' : logging.WARNING, |
| 50 | 'error' : logging.ERROR, |
| 51 | 'critical' : logging.CRITICAL |
| 52 | } |
| 53 | |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 54 | ##@var CONFIG_DEFAULT |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 55 | # The default configuration dictionary for OFT |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 56 | CONFIG_DEFAULT = { |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 57 | # Miscellaneous options |
| 58 | "list" : False, |
| 59 | "list_test_names" : False, |
| 60 | "allow_user" : False, |
| 61 | |
| 62 | # Test selection options |
Rich Lane | c76b09a | 2013-01-02 16:53:22 -0800 | [diff] [blame] | 63 | "test_spec" : "", |
Rich Lane | 1a08d23 | 2013-01-04 16:03:50 -0800 | [diff] [blame] | 64 | "test_file" : None, |
Rich Lane | 74b13d1 | 2013-05-03 17:58:50 -0700 | [diff] [blame] | 65 | "test_dir" : None, |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 66 | |
| 67 | # Switch connection options |
| 68 | "controller_host" : "0.0.0.0", # For passive bind |
Rich Lane | 4d1f3eb | 2013-10-03 13:45:57 -0700 | [diff] [blame] | 69 | "controller_port" : 6653, |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 70 | "switch_ip" : None, # If not none, actively connect to switch |
Rich Lane | 15f2632 | 2013-01-08 11:23:24 -0800 | [diff] [blame] | 71 | "platform" : "eth", |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 72 | "platform_args" : None, |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 73 | "platform_dir" : os.path.join(ROOT_DIR, "platforms"), |
Rich Lane | 2d6d482 | 2013-01-08 10:49:16 -0800 | [diff] [blame] | 74 | "interfaces" : [], |
Rich Lane | 9fd0568 | 2013-01-10 15:30:38 -0800 | [diff] [blame] | 75 | "openflow_version" : "1.0", |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 76 | |
| 77 | # Logging options |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 78 | "log_file" : "oft.log", |
Rich Lane | 69fd8e0 | 2013-08-23 16:23:42 -0700 | [diff] [blame] | 79 | "log_dir" : None, |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 80 | "debug" : "verbose", |
Rich Lane | 9631f00 | 2014-03-21 18:05:16 -0700 | [diff] [blame] | 81 | "profile" : False, |
Stephen Finucane | 6219af7 | 2014-05-14 21:08:30 +0100 | [diff] [blame] | 82 | "profile_file" : "profile.out", |
Stephen Finucane | e016cf2 | 2014-04-16 22:04:11 +0100 | [diff] [blame] | 83 | "xunit" : False, |
| 84 | "xunit_dir" : "xunit", |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 85 | |
| 86 | # Test behavior options |
| 87 | "relax" : False, |
Dan Talayco | d7c80d1 | 2012-04-03 15:20:57 -0700 | [diff] [blame] | 88 | "test_params" : "None", |
Rich Lane | 9a84a4f | 2012-07-17 12:27:42 -0700 | [diff] [blame] | 89 | "fail_skipped" : False, |
Rich Lane | 48f6aed | 2014-03-23 15:51:02 -0700 | [diff] [blame] | 90 | "default_timeout" : 2.0, |
| 91 | "default_negative_timeout" : 0.01, |
Jeffrey Townsend | 5cb7ed3 | 2012-08-17 18:11:01 +0000 | [diff] [blame] | 92 | "minsize" : 0, |
Rich Lane | 8592bec | 2012-09-03 09:06:59 -0700 | [diff] [blame] | 93 | "random_seed" : None, |
Stephen Finucane | 92f7cf6 | 2014-03-13 15:08:11 +0000 | [diff] [blame] | 94 | "disable_ipv6" : False, |
Rich Lane | 62b4fb1 | 2015-04-02 18:04:10 -0700 | [diff] [blame^] | 95 | "random_order" : False, |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 96 | |
| 97 | # Other configuration |
Rich Lane | 15f2632 | 2013-01-08 11:23:24 -0800 | [diff] [blame] | 98 | "port_map" : {}, |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 99 | } |
| 100 | |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 101 | def config_setup(): |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 102 | """ |
| 103 | Set up the configuration including parsing the arguments |
| 104 | |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 105 | @return A pair (config, args) where config is an config |
| 106 | object and args is any additional arguments from the command line |
| 107 | """ |
| 108 | |
Rich Lane | 4113a58 | 2013-01-03 10:13:02 -0800 | [diff] [blame] | 109 | usage = "usage: %prog [options] (test|group)..." |
| 110 | |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 111 | description = """\ |
Rich Lane | 4113a58 | 2013-01-03 10:13:02 -0800 | [diff] [blame] | 112 | OFTest is a framework and set of tests for validating OpenFlow switches. |
| 113 | |
| 114 | The default configuration assumes that an OpenFlow 1.0 switch is attempting to |
Rich Lane | 4d1f3eb | 2013-10-03 13:45:57 -0700 | [diff] [blame] | 115 | connect to a controller on the machine running OFTest, port 6653. Additionally, |
Rich Lane | 4113a58 | 2013-01-03 10:13:02 -0800 | [diff] [blame] | 116 | the interfaces veth1, veth3, veth5, and veth7 should be connected to the switch's |
| 117 | dataplane. |
| 118 | |
| 119 | If no positional arguments are given then OFTest will run all tests that |
| 120 | depend only on standard OpenFlow 1.0. Otherwise each positional argument |
| 121 | is interpreted as either a test name or a test group name. The union of |
| 122 | these will be executed. To see what groups each test belongs to use the |
Rich Lane | 948f030 | 2013-01-07 10:59:08 -0800 | [diff] [blame] | 123 | --list option. Tests and groups can be subtracted from the result by |
| 124 | prefixing them with the '^' character. |
Rich Lane | 4113a58 | 2013-01-03 10:13:02 -0800 | [diff] [blame] | 125 | """ |
| 126 | |
Rich Lane | 2d6d482 | 2013-01-08 10:49:16 -0800 | [diff] [blame] | 127 | # Parse --interface |
| 128 | def check_interface(option, opt, value): |
| 129 | try: |
| 130 | ofport, interface = value.split('@', 1) |
| 131 | ofport = int(ofport) |
| 132 | except ValueError: |
| 133 | raise optparse.OptionValueError("incorrect interface syntax (got %s, expected 'ofport@interface')" % repr(value)) |
| 134 | return (ofport, interface) |
| 135 | |
| 136 | class Option(optparse.Option): |
| 137 | TYPES = optparse.Option.TYPES + ("interface",) |
| 138 | TYPE_CHECKER = copy.copy(optparse.Option.TYPE_CHECKER) |
| 139 | TYPE_CHECKER["interface"] = check_interface |
| 140 | |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 141 | parser = optparse.OptionParser(version="%prog 0.1", |
| 142 | usage=usage, |
| 143 | description=description, |
Rich Lane | 2d6d482 | 2013-01-08 10:49:16 -0800 | [diff] [blame] | 144 | formatter=oftest.help_formatter.HelpFormatter(), |
| 145 | option_class=Option) |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 146 | |
| 147 | # Set up default values |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 148 | parser.set_defaults(**CONFIG_DEFAULT) |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 149 | |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 150 | parser.add_option("--list", action="store_true", |
Brandon Heller | 824504e | 2010-04-01 12:21:37 -0700 | [diff] [blame] | 151 | help="List all tests and exit") |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 152 | parser.add_option("--list-test-names", action='store_true', |
| 153 | help="List test names matching the test spec and exit") |
Rich Lane | ee57ad0 | 2012-07-13 15:40:36 -0700 | [diff] [blame] | 154 | parser.add_option("--allow-user", action="store_true", |
| 155 | help="Proceed even if oftest is not run as root") |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 156 | |
| 157 | group = optparse.OptionGroup(parser, "Test selection options") |
| 158 | group.add_option("-T", "--test-spec", "--test-list", help="Tests to run, separated by commas") |
| 159 | group.add_option("-f", "--test-file", help="File of tests to run, one per line") |
| 160 | group.add_option("--test-dir", type="string", help="Directory containing tests") |
| 161 | parser.add_option_group(group) |
| 162 | |
| 163 | group = optparse.OptionGroup(parser, "Switch connection options") |
| 164 | group.add_option("-H", "--host", dest="controller_host", |
| 165 | help="IP address to listen on (default %default)") |
| 166 | group.add_option("-p", "--port", dest="controller_port", |
| 167 | type="int", help="Port number to listen on (default %default)") |
| 168 | group.add_option("-S", "--switch-ip", dest="switch_ip", |
| 169 | help="If set, actively connect to this switch by IP") |
| 170 | group.add_option("-P", "--platform", help="Platform module name (default %default)") |
| 171 | group.add_option("-a", "--platform-args", help="Custom arguments for the platform") |
| 172 | group.add_option("--platform-dir", type="string", help="Directory containing platform modules") |
Rich Lane | 2d6d482 | 2013-01-08 10:49:16 -0800 | [diff] [blame] | 173 | group.add_option("--interface", "-i", type="interface", dest="interfaces", metavar="INTERFACE", action="append", |
| 174 | help="Specify a OpenFlow port number and the dataplane interface to use. May be given multiple times. Example: 1@eth1") |
Rich Lane | 50cfa50 | 2013-04-25 13:45:08 -0700 | [diff] [blame] | 175 | group.add_option("--of-version", "-V", dest="openflow_version", choices=loxi.version_names.values(), |
Rich Lane | 9fd0568 | 2013-01-10 15:30:38 -0800 | [diff] [blame] | 176 | help="OpenFlow version to use") |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 177 | parser.add_option_group(group) |
| 178 | |
| 179 | group = optparse.OptionGroup(parser, "Logging options") |
Rich Lane | 69fd8e0 | 2013-08-23 16:23:42 -0700 | [diff] [blame] | 180 | group.add_option("--log-file", help="Name of log file (default %default)") |
| 181 | group.add_option("--log-dir", help="Name of log directory") |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 182 | dbg_lvl_names = sorted(DEBUG_LEVELS.keys(), key=lambda x: DEBUG_LEVELS[x]) |
| 183 | group.add_option("--debug", choices=dbg_lvl_names, |
| 184 | help="Debug lvl: debug, info, warning, error, critical (default %default)") |
| 185 | group.add_option("-v", "--verbose", action="store_const", dest="debug", |
| 186 | const="verbose", help="Shortcut for --debug=verbose") |
| 187 | group.add_option("-q", "--quiet", action="store_const", dest="debug", |
| 188 | const="warning", help="Shortcut for --debug=warning") |
Stephen Finucane | 6219af7 | 2014-05-14 21:08:30 +0100 | [diff] [blame] | 189 | group.add_option("--profile", action="store_true", help="Enable Python profiling") |
| 190 | group.add_option("--profile-file", help="Output file for Python profiler") |
Stephen Finucane | e016cf2 | 2014-04-16 22:04:11 +0100 | [diff] [blame] | 191 | group.add_option("--xunit", action="store_true", help="Enable xUnit-formatted results") |
| 192 | group.add_option("--xunit-dir", help="Output directory for xUnit-formatted results") |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 193 | parser.add_option_group(group) |
| 194 | |
| 195 | group = optparse.OptionGroup(parser, "Test behavior options") |
| 196 | group.add_option("--relax", action="store_true", |
| 197 | help="Relax packet match checks allowing other packets") |
| 198 | test_params_help = """Set test parameters: key=val;... (see --list) |
| 199 | """ |
| 200 | group.add_option("-t", "--test-params", help=test_params_help) |
| 201 | group.add_option("--fail-skipped", action="store_true", |
Rich Lane | 9a84a4f | 2012-07-17 12:27:42 -0700 | [diff] [blame] | 202 | help="Return failure if any test was skipped") |
Rich Lane | 48f6aed | 2014-03-23 15:51:02 -0700 | [diff] [blame] | 203 | group.add_option("--default-timeout", type=float, |
Rich Lane | e55abf7 | 2012-07-26 20:11:42 -0700 | [diff] [blame] | 204 | help="Timeout in seconds for most operations") |
Rich Lane | 48f6aed | 2014-03-23 15:51:02 -0700 | [diff] [blame] | 205 | group.add_option("--default-negative-timeout", type=float, |
| 206 | help="Timeout in seconds for negative checks") |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 207 | group.add_option("--minsize", type="int", |
| 208 | help="Minimum allowable packet size on the dataplane.") |
| 209 | group.add_option("--random-seed", type="int", |
| 210 | help="Random number generator seed") |
Stephen Finucane | 92f7cf6 | 2014-03-13 15:08:11 +0000 | [diff] [blame] | 211 | group.add_option("--disable-ipv6", action="store_true", |
| 212 | help="Disable IPv6 tests") |
Rich Lane | 62b4fb1 | 2015-04-02 18:04:10 -0700 | [diff] [blame^] | 213 | group.add_option("--random-order", action="store_true", |
| 214 | help="Randomize order of tests") |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 215 | parser.add_option_group(group) |
Jeffrey Townsend | 5cb7ed3 | 2012-08-17 18:11:01 +0000 | [diff] [blame] | 216 | |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 217 | # Might need this if other parsers want command line |
| 218 | # parser.allow_interspersed_args = False |
| 219 | (options, args) = parser.parse_args() |
| 220 | |
Rich Lane | 74b13d1 | 2013-05-03 17:58:50 -0700 | [diff] [blame] | 221 | # If --test-dir wasn't given, pick one based on the OpenFlow version |
| 222 | if options.test_dir == None: |
| 223 | if options.openflow_version == "1.0": |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 224 | options.test_dir = os.path.join(ROOT_DIR, "tests") |
Rich Lane | 74b13d1 | 2013-05-03 17:58:50 -0700 | [diff] [blame] | 225 | else: |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 226 | options.test_dir = os.path.join(ROOT_DIR, "tests-" + options.openflow_version) |
Rich Lane | 74b13d1 | 2013-05-03 17:58:50 -0700 | [diff] [blame] | 227 | |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 228 | # Convert options from a Namespace to a plain dictionary |
Stephen Finucane | 7424a74 | 2014-05-15 19:46:06 +0100 | [diff] [blame] | 229 | config = CONFIG_DEFAULT.copy() |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 230 | for key in config.keys(): |
| 231 | config[key] = getattr(options, key) |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 232 | |
| 233 | return (config, args) |
| 234 | |
| 235 | def logging_setup(config): |
| 236 | """ |
| 237 | Set up logging based on config |
| 238 | """ |
Rich Lane | 69fd8e0 | 2013-08-23 16:23:42 -0700 | [diff] [blame] | 239 | |
| 240 | logging.getLogger().setLevel(DEBUG_LEVELS[config["debug"]]) |
| 241 | |
| 242 | if config["log_dir"] != None: |
| 243 | if os.path.exists(config["log_dir"]): |
| 244 | import shutil |
| 245 | shutil.rmtree(config["log_dir"]) |
| 246 | os.makedirs(config["log_dir"]) |
| 247 | else: |
| 248 | if os.path.exists(config["log_file"]): |
| 249 | os.remove(config["log_file"]) |
| 250 | |
| 251 | oftest.open_logfile('main') |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 252 | |
Stephen Finucane | e016cf2 | 2014-04-16 22:04:11 +0100 | [diff] [blame] | 253 | def xunit_setup(config): |
| 254 | """ |
| 255 | Set up xUnit output based on config |
| 256 | """ |
| 257 | |
| 258 | if not config["xunit"]: |
| 259 | return |
| 260 | |
Stephen Finucane | 6219af7 | 2014-05-14 21:08:30 +0100 | [diff] [blame] | 261 | if os.path.exists(config["xunit_dir"]): |
| 262 | import shutil |
| 263 | shutil.rmtree(config["xunit_dir"]) |
| 264 | os.makedirs(config["xunit_dir"]) |
Stephen Finucane | e016cf2 | 2014-04-16 22:04:11 +0100 | [diff] [blame] | 265 | |
Rich Lane | 472aaea | 2013-08-27 09:27:38 -0700 | [diff] [blame] | 266 | def pcap_setup(config): |
| 267 | """ |
| 268 | Set up dataplane packet capturing based on config |
| 269 | """ |
| 270 | |
| 271 | if config["log_dir"] == None: |
| 272 | filename = os.path.splitext(config["log_file"])[0] + '.pcap' |
| 273 | oftest.dataplane_instance.start_pcap(filename) |
| 274 | else: |
| 275 | # start_pcap is called per-test in base_tests |
| 276 | pass |
| 277 | |
Stephen Finucane | 6219af7 | 2014-05-14 21:08:30 +0100 | [diff] [blame] | 278 | def profiler_setup(config): |
| 279 | """ |
| 280 | Set up profiler based on config |
| 281 | """ |
| 282 | |
| 283 | if not config["profile"]: |
| 284 | return |
| 285 | |
| 286 | import cProfile |
| 287 | profiler = cProfile.Profile() |
| 288 | profiler.enable() |
| 289 | |
| 290 | return profiler |
| 291 | |
| 292 | def profiler_teardown(profiler): |
| 293 | """ |
| 294 | Tear down profiler based on config |
| 295 | """ |
| 296 | |
| 297 | if not config["profile"]: |
| 298 | return |
| 299 | |
| 300 | profiler.disable() |
| 301 | profiler.dump_stats(config["profile_file"]) |
| 302 | |
Rich Lane | 472aaea | 2013-08-27 09:27:38 -0700 | [diff] [blame] | 303 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 304 | def load_test_modules(config): |
| 305 | """ |
| 306 | Load tests from the test_dir directory. |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 307 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 308 | Test cases are subclasses of unittest.TestCase |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 309 | |
Rich Lane | cc45b8e | 2013-01-02 15:55:02 -0800 | [diff] [blame] | 310 | Also updates the _groups member to include "standard" and |
| 311 | module test groups if appropriate. |
| 312 | |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 313 | @param config The oft configuration dictionary |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 314 | @returns A dictionary from test module names to tuples of |
| 315 | (module, dictionary from test names to test classes). |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 316 | """ |
| 317 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 318 | result = {} |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 319 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 320 | for root, dirs, filenames in os.walk(config["test_dir"]): |
| 321 | # Iterate over each python file |
| 322 | for filename in fnmatch.filter(filenames, '[!.]*.py'): |
| 323 | modname = os.path.splitext(os.path.basename(filename))[0] |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 324 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 325 | try: |
| 326 | if sys.modules.has_key(modname): |
| 327 | mod = sys.modules[modname] |
| 328 | else: |
| 329 | mod = imp.load_module(modname, *imp.find_module(modname, [root])) |
| 330 | except: |
| 331 | logging.warning("Could not import file " + filename) |
| 332 | raise |
Rich Lane | 520e415 | 2012-07-09 16:18:16 -0700 | [diff] [blame] | 333 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 334 | # Find all testcases defined in the module |
| 335 | tests = dict((k, v) for (k, v) in mod.__dict__.items() if type(v) == type and |
Rich Lane | 9cef274 | 2013-07-16 13:27:00 -0700 | [diff] [blame] | 336 | issubclass(v, unittest.TestCase) and |
| 337 | hasattr(v, "runTest")) |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 338 | if tests: |
Rich Lane | cc45b8e | 2013-01-02 15:55:02 -0800 | [diff] [blame] | 339 | for (testname, test) in tests.items(): |
| 340 | # Set default annotation values |
| 341 | if not hasattr(test, "_groups"): |
| 342 | test._groups = [] |
| 343 | if not hasattr(test, "_nonstandard"): |
| 344 | test._nonstandard = False |
| 345 | if not hasattr(test, "_disabled"): |
| 346 | test._disabled = False |
| 347 | |
| 348 | # Put test in its module's test group |
| 349 | if not test._disabled: |
| 350 | test._groups.append(modname) |
| 351 | |
| 352 | # Put test in the standard test group |
| 353 | if not test._disabled and not test._nonstandard: |
| 354 | test._groups.append("standard") |
| 355 | test._groups.append("all") # backwards compatibility |
| 356 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 357 | result[modname] = (mod, tests) |
Rich Lane | 520e415 | 2012-07-09 16:18:16 -0700 | [diff] [blame] | 358 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 359 | return result |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 360 | |
Rich Lane | 5a9a192 | 2013-01-11 14:29:30 -0800 | [diff] [blame] | 361 | def prune_tests(test_specs, test_modules, version): |
Rich Lane | 15f64de | 2012-10-04 21:25:57 -0700 | [diff] [blame] | 362 | """ |
Rich Lane | 5a9a192 | 2013-01-11 14:29:30 -0800 | [diff] [blame] | 363 | Return tests matching the given test-specs and OpenFlow version |
Rich Lane | c76b09a | 2013-01-02 16:53:22 -0800 | [diff] [blame] | 364 | @param test_specs A list of group names or test names. |
Rich Lane | 5a9a192 | 2013-01-11 14:29:30 -0800 | [diff] [blame] | 365 | @param version An OpenFlow version (e.g. "1.0") |
Rich Lane | 15f64de | 2012-10-04 21:25:57 -0700 | [diff] [blame] | 366 | @param test_modules Same format as the output of load_test_modules. |
| 367 | @returns Same format as the output of load_test_modules. |
| 368 | """ |
| 369 | result = {} |
Rich Lane | c76b09a | 2013-01-02 16:53:22 -0800 | [diff] [blame] | 370 | for e in test_specs: |
Rich Lane | 15f64de | 2012-10-04 21:25:57 -0700 | [diff] [blame] | 371 | matched = False |
Rich Lane | 948f030 | 2013-01-07 10:59:08 -0800 | [diff] [blame] | 372 | |
| 373 | if e.startswith('^'): |
| 374 | negated = True |
| 375 | e = e[1:] |
| 376 | else: |
| 377 | negated = False |
| 378 | |
Rich Lane | 15f64de | 2012-10-04 21:25:57 -0700 | [diff] [blame] | 379 | for (modname, (mod, tests)) in test_modules.items(): |
Rich Lane | cc45b8e | 2013-01-02 15:55:02 -0800 | [diff] [blame] | 380 | for (testname, test) in tests.items(): |
| 381 | if e in test._groups or e == "%s.%s" % (modname, testname): |
| 382 | result.setdefault(modname, (mod, {})) |
Rich Lane | 948f030 | 2013-01-07 10:59:08 -0800 | [diff] [blame] | 383 | if not negated: |
Rich Lane | 5a9a192 | 2013-01-11 14:29:30 -0800 | [diff] [blame] | 384 | if not hasattr(test, "_versions") or version in test._versions: |
| 385 | result[modname][1][testname] = test |
Rich Lane | 948f030 | 2013-01-07 10:59:08 -0800 | [diff] [blame] | 386 | else: |
| 387 | if modname in result and testname in result[modname][1]: |
| 388 | del result[modname][1][testname] |
| 389 | if not result[modname][1]: |
| 390 | del result[modname] |
Rich Lane | cc45b8e | 2013-01-02 15:55:02 -0800 | [diff] [blame] | 391 | matched = True |
Rich Lane | 948f030 | 2013-01-07 10:59:08 -0800 | [diff] [blame] | 392 | |
Rich Lane | 15f64de | 2012-10-04 21:25:57 -0700 | [diff] [blame] | 393 | if not matched: |
Rich Lane | cc45b8e | 2013-01-02 15:55:02 -0800 | [diff] [blame] | 394 | die("test-spec element %s did not match any tests" % e) |
Rich Lane | 948f030 | 2013-01-07 10:59:08 -0800 | [diff] [blame] | 395 | |
Rich Lane | 15f64de | 2012-10-04 21:25:57 -0700 | [diff] [blame] | 396 | return result |
| 397 | |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 398 | def die(msg, exit_val=1): |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 399 | logging.critical(msg) |
| 400 | sys.exit(exit_val) |
| 401 | |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 402 | # |
| 403 | # Main script |
| 404 | # |
| 405 | |
Rich Lane | 477f481 | 2012-10-04 22:49:00 -0700 | [diff] [blame] | 406 | # Setup global configuration |
Rich Lane | 95f078b | 2013-01-06 13:24:58 -0800 | [diff] [blame] | 407 | (new_config, args) = config_setup() |
Rich Lane | 477f481 | 2012-10-04 22:49:00 -0700 | [diff] [blame] | 408 | oftest.config.update(new_config) |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 409 | |
Rich Lane | d7a85c4 | 2012-09-28 15:38:45 -0700 | [diff] [blame] | 410 | logging_setup(config) |
Stephen Finucane | e016cf2 | 2014-04-16 22:04:11 +0100 | [diff] [blame] | 411 | xunit_setup(config) |
Rich Lane | d7a85c4 | 2012-09-28 15:38:45 -0700 | [diff] [blame] | 412 | logging.info("++++++++ " + time.asctime() + " ++++++++") |
| 413 | |
Rich Lane | 9fd0568 | 2013-01-10 15:30:38 -0800 | [diff] [blame] | 414 | # Pick an OpenFlow protocol module based on the configured version |
Rich Lane | 50cfa50 | 2013-04-25 13:45:08 -0700 | [diff] [blame] | 415 | name_to_version = dict((v,k) for k, v in loxi.version_names.iteritems()) |
| 416 | sys.modules["ofp"] = loxi.protocol(name_to_version[config["openflow_version"]]) |
Rich Lane | 9fd0568 | 2013-01-10 15:30:38 -0800 | [diff] [blame] | 417 | |
| 418 | # HACK: testutils.py imports controller.py, which needs the ofp module |
| 419 | import oftest.testutils |
| 420 | |
Rich Lane | e284b6b | 2012-10-03 09:19:58 -0700 | [diff] [blame] | 421 | # Allow tests to import each other |
| 422 | sys.path.append(config["test_dir"]) |
| 423 | |
Rich Lane | c76b09a | 2013-01-02 16:53:22 -0800 | [diff] [blame] | 424 | test_specs = args |
| 425 | if config["test_spec"] != "": |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 426 | logging.warning("The '--test-spec' option is deprecated.") |
Rich Lane | c76b09a | 2013-01-02 16:53:22 -0800 | [diff] [blame] | 427 | test_specs += config["test_spec"].split(',') |
Rich Lane | 1a08d23 | 2013-01-04 16:03:50 -0800 | [diff] [blame] | 428 | if config["test_file"] != None: |
| 429 | with open(config["test_file"], 'r') as f: |
| 430 | for line in f: |
| 431 | line, _, _ = line.partition('#') # remove comments |
| 432 | line = line.strip() |
| 433 | if line: |
| 434 | test_specs.append(line) |
Rich Lane | c76b09a | 2013-01-02 16:53:22 -0800 | [diff] [blame] | 435 | if test_specs == []: |
| 436 | test_specs = ["standard"] |
| 437 | |
Rich Lane | d8e4548 | 2013-01-02 17:36:21 -0800 | [diff] [blame] | 438 | test_modules = load_test_modules(config) |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 439 | |
| 440 | # Check if test list is requested; display and exit if so |
| 441 | if config["list"]: |
Dan Talayco | 7f8dba8 | 2012-04-12 12:58:52 -0700 | [diff] [blame] | 442 | mod_count = 0 |
| 443 | test_count = 0 |
Rich Lane | 37f4211 | 2013-01-03 13:41:49 -0800 | [diff] [blame] | 444 | all_groups = set() |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 445 | |
| 446 | print(""" |
| 447 | Tests are shown grouped by module. If a test is in any groups beyond |
| 448 | "standard" and its module's group then they are shown in parentheses. |
| 449 | |
Rich Lane | e811e7b | 2013-01-03 13:36:54 -0800 | [diff] [blame] | 450 | Tests marked with '*' are non-standard and may require vendor extensions or |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 451 | special switch configuration. These are not part of the "standard" test group. |
| 452 | |
| 453 | Tests marked with '!' are disabled because they are experimental, |
| 454 | special-purpose, or are too long to be run normally. These are not part of |
| 455 | the "standard" test group or their module's test group. |
| 456 | |
| 457 | Tests marked (TP1) after name take --test-params including: |
| 458 | |
| 459 | 'vid=N;strip_vlan=bool;add_vlan=bool' |
| 460 | |
| 461 | Test List: |
| 462 | """) |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 463 | for (modname, (mod, tests)) in test_modules.items(): |
Dan Talayco | 7f8dba8 | 2012-04-12 12:58:52 -0700 | [diff] [blame] | 464 | mod_count += 1 |
Rich Lane | 80efd65 | 2013-01-02 14:05:20 -0800 | [diff] [blame] | 465 | desc = (mod.__doc__ or "No description").strip().split('\n')[0] |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 466 | print(" Module %13s: %s" % (mod.__name__, desc)) |
| 467 | |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 468 | for (testname, test) in tests.items(): |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 469 | desc = (test.__doc__ or "No description").strip().split('\n')[0] |
| 470 | |
Rich Lane | e811e7b | 2013-01-03 13:36:54 -0800 | [diff] [blame] | 471 | groups = set(test._groups) - set(["all", "standard", modname]) |
Rich Lane | 37f4211 | 2013-01-03 13:41:49 -0800 | [diff] [blame] | 472 | all_groups.update(test._groups) |
Rich Lane | e811e7b | 2013-01-03 13:36:54 -0800 | [diff] [blame] | 473 | if groups: |
| 474 | desc = "(%s) %s" % (",".join(groups), desc) |
Rich Lane | 5a9a192 | 2013-01-11 14:29:30 -0800 | [diff] [blame] | 475 | if hasattr(test, "_versions"): |
| 476 | desc = "(%s) %s" % (",".join(sorted(test._versions)), desc) |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 477 | |
Rich Lane | e811e7b | 2013-01-03 13:36:54 -0800 | [diff] [blame] | 478 | start_str = " %s%s %s:" % (test._nonstandard and "*" or " ", |
| 479 | test._disabled and "!" or " ", |
| 480 | testname) |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 481 | print(" %22s : %s" % (start_str, desc)) |
Dan Talayco | 7f8dba8 | 2012-04-12 12:58:52 -0700 | [diff] [blame] | 482 | test_count += 1 |
Dan Talayco | 79f3608 | 2010-03-11 16:53:53 -0800 | [diff] [blame] | 483 | print |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 484 | print("'%d' modules shown with a total of '%d' tests\n" % |
| 485 | (mod_count, test_count)) |
| 486 | print("Test groups: %s" % (', '.join(sorted(all_groups)))) |
Rich Lane | 37f4211 | 2013-01-03 13:41:49 -0800 | [diff] [blame] | 487 | |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 488 | sys.exit(0) |
| 489 | |
Rich Lane | 5a9a192 | 2013-01-11 14:29:30 -0800 | [diff] [blame] | 490 | test_modules = prune_tests(test_specs, test_modules, config["openflow_version"]) |
Rich Lane | d8e4548 | 2013-01-02 17:36:21 -0800 | [diff] [blame] | 491 | |
Jeffrey Townsend | 6614f97 | 2012-08-16 13:27:18 -0700 | [diff] [blame] | 492 | # Check if test list is requested; display and exit if so |
| 493 | if config["list_test_names"]: |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 494 | for (modname, (mod, tests)) in test_modules.items(): |
Rich Lane | 943be67 | 2012-10-04 19:20:16 -0700 | [diff] [blame] | 495 | for (testname, test) in tests.items(): |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 496 | print("%s.%s" % (modname, testname)) |
| 497 | |
Jeffrey Townsend | 6614f97 | 2012-08-16 13:27:18 -0700 | [diff] [blame] | 498 | sys.exit(0) |
| 499 | |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 500 | # Generate the test suite |
| 501 | #@todo Decide if multiple suites are ever needed |
| 502 | suite = unittest.TestSuite() |
| 503 | |
Rich Lane | 62b4fb1 | 2015-04-02 18:04:10 -0700 | [diff] [blame^] | 504 | sorted_tests = [] |
Rich Lane | c72ef46 | 2015-04-02 17:52:44 -0700 | [diff] [blame] | 505 | for (modname, (mod, tests)) in sorted(test_modules.items()): |
| 506 | for (testname, test) in sorted(tests.items()): |
Rich Lane | 62b4fb1 | 2015-04-02 18:04:10 -0700 | [diff] [blame^] | 507 | sorted_tests.append(test) |
| 508 | |
| 509 | if config["random_order"]: |
| 510 | random.shuffle(sorted_tests) |
| 511 | |
| 512 | for test in sorted_tests: |
| 513 | suite.addTest(test()) |
Dan Talayco | 2c0dba3 | 2010-03-06 22:47:06 -0800 | [diff] [blame] | 514 | |
Rich Lane | 51590f6 | 2012-10-09 15:06:29 -0700 | [diff] [blame] | 515 | # Allow platforms to import each other |
| 516 | sys.path.append(config["platform_dir"]) |
| 517 | |
Rich Lane | 8aebc5e | 2012-09-25 17:57:53 -0700 | [diff] [blame] | 518 | # Load the platform module |
| 519 | platform_name = config["platform"] |
| 520 | logging.info("Importing platform: " + platform_name) |
| 521 | platform_mod = None |
| 522 | try: |
Rich Lane | 483e154 | 2012-10-05 09:29:39 -0700 | [diff] [blame] | 523 | platform_mod = imp.load_module(platform_name, *imp.find_module(platform_name, [config["platform_dir"]])) |
Rich Lane | 8aebc5e | 2012-09-25 17:57:53 -0700 | [diff] [blame] | 524 | except: |
| 525 | logging.warn("Failed to import " + platform_name + " platform module") |
| 526 | raise |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 527 | |
| 528 | try: |
Rich Lane | 8aebc5e | 2012-09-25 17:57:53 -0700 | [diff] [blame] | 529 | platform_mod.platform_config_update(config) |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 530 | except: |
| 531 | logging.warn("Could not run platform host configuration") |
Rich Lane | ef403e5 | 2012-07-09 14:59:43 -0700 | [diff] [blame] | 532 | raise |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 533 | |
| 534 | if not config["port_map"]: |
Rich Lane | 8aebc5e | 2012-09-25 17:57:53 -0700 | [diff] [blame] | 535 | die("Interface port map was not defined by the platform. Exiting.") |
Dan Talayco | 4837010 | 2010-03-03 15:17:33 -0800 | [diff] [blame] | 536 | |
| 537 | logging.debug("Configuration: " + str(config)) |
| 538 | logging.info("OF port map: " + str(config["port_map"])) |
| 539 | |
Rich Lane | e55abf7 | 2012-07-26 20:11:42 -0700 | [diff] [blame] | 540 | oftest.ofutils.default_timeout = config["default_timeout"] |
Rich Lane | 48f6aed | 2014-03-23 15:51:02 -0700 | [diff] [blame] | 541 | oftest.ofutils.default_negative_timeout = config["default_negative_timeout"] |
Rich Lane | da3b5ad | 2012-10-03 09:05:32 -0700 | [diff] [blame] | 542 | oftest.testutils.MINSIZE = config['minsize'] |
Rich Lane | e55abf7 | 2012-07-26 20:11:42 -0700 | [diff] [blame] | 543 | |
Rich Lane | ee57ad0 | 2012-07-13 15:40:36 -0700 | [diff] [blame] | 544 | if os.getuid() != 0 and not config["allow_user"]: |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 545 | die("Super-user privileges required. Please re-run with sudo or as root.") |
Rich Lane | d1d9c28 | 2012-10-04 22:07:10 -0700 | [diff] [blame] | 546 | sys.exit(1) |
Brandon Heller | 446c143 | 2010-04-01 12:43:27 -0700 | [diff] [blame] | 547 | |
Rich Lane | 8592bec | 2012-09-03 09:06:59 -0700 | [diff] [blame] | 548 | if config["random_seed"] is not None: |
| 549 | logging.info("Random seed: %d" % config["random_seed"]) |
| 550 | random.seed(config["random_seed"]) |
Dan Talayco | ec6084d | 2013-03-14 10:38:22 -0700 | [diff] [blame] | 551 | else: |
| 552 | # Generate random seed and report to log file |
| 553 | seed = random.randrange(100000000) |
| 554 | logging.info("Autogen random seed: %d" % seed) |
| 555 | random.seed(seed) |
Rich Lane | 8592bec | 2012-09-03 09:06:59 -0700 | [diff] [blame] | 556 | |
Rich Lane | 5bd6cf9 | 2012-10-04 17:57:24 -0700 | [diff] [blame] | 557 | # Remove python's signal handler which raises KeyboardError. Exiting from an |
| 558 | # exception waits for all threads to terminate which might not happen. |
| 559 | signal.signal(signal.SIGINT, signal.SIG_DFL) |
Dan Talayco | ac25cf3 | 2010-07-20 14:08:28 -0700 | [diff] [blame] | 560 | |
| 561 | if __name__ == "__main__": |
Stephen Finucane | 6219af7 | 2014-05-14 21:08:30 +0100 | [diff] [blame] | 562 | profiler = profiler_setup(config) |
Rich Lane | 9631f00 | 2014-03-21 18:05:16 -0700 | [diff] [blame] | 563 | |
Rich Lane | 2c7812c | 2012-12-27 17:52:23 -0800 | [diff] [blame] | 564 | # Set up the dataplane |
| 565 | oftest.dataplane_instance = oftest.dataplane.DataPlane(config) |
Rich Lane | 472aaea | 2013-08-27 09:27:38 -0700 | [diff] [blame] | 566 | pcap_setup(config) |
Rich Lane | 2c7812c | 2012-12-27 17:52:23 -0800 | [diff] [blame] | 567 | for of_port, ifname in config["port_map"].items(): |
| 568 | oftest.dataplane_instance.port_add(ifname, of_port) |
| 569 | |
Dan Talayco | ac25cf3 | 2010-07-20 14:08:28 -0700 | [diff] [blame] | 570 | logging.info("*** TEST RUN START: " + time.asctime()) |
Stephen Finucane | e016cf2 | 2014-04-16 22:04:11 +0100 | [diff] [blame] | 571 | if config["xunit"]: |
Stephen Finucane | 1278255 | 2014-05-20 21:55:04 +0100 | [diff] [blame] | 572 | try: |
| 573 | import xmlrunner # fail-fast if module missing |
| 574 | except ImportError as ex: |
| 575 | oftest.dataplane_instance.kill() |
| 576 | profiler_teardown(profiler) |
| 577 | raise ex |
Stephen Finucane | e016cf2 | 2014-04-16 22:04:11 +0100 | [diff] [blame] | 578 | runner = xmlrunner.XMLTestRunner(output=config["xunit_dir"], |
| 579 | outsuffix="", |
| 580 | verbosity=2) |
| 581 | result = runner.run(suite) |
| 582 | else: |
| 583 | result = unittest.TextTestRunner(verbosity=2).run(suite) |
Rich Lane | 69fd8e0 | 2013-08-23 16:23:42 -0700 | [diff] [blame] | 584 | oftest.open_logfile('main') |
Rich Lane | da3b5ad | 2012-10-03 09:05:32 -0700 | [diff] [blame] | 585 | if oftest.testutils.skipped_test_count > 0: |
Stephen Finucane | 0158865 | 2014-05-15 20:03:12 +0100 | [diff] [blame] | 586 | message = "Skipped %d test(s)" % oftest.testutils.skipped_test_count |
| 587 | logging.info(message) |
| 588 | logging.info("*** TEST RUN END : %s", time.asctime()) |
Rich Lane | 2c7812c | 2012-12-27 17:52:23 -0800 | [diff] [blame] | 589 | |
| 590 | # Shutdown the dataplane |
| 591 | oftest.dataplane_instance.kill() |
| 592 | oftest.dataplane_instance = None |
| 593 | |
Stephen Finucane | 6219af7 | 2014-05-14 21:08:30 +0100 | [diff] [blame] | 594 | profiler_teardown(profiler) |
Rich Lane | 9631f00 | 2014-03-21 18:05:16 -0700 | [diff] [blame] | 595 | |
Rich Lane | 50d42eb | 2012-07-16 11:57:03 -0700 | [diff] [blame] | 596 | if result.failures or result.errors: |
Shudong Zhou | d895fcb | 2012-08-01 19:09:55 -0700 | [diff] [blame] | 597 | # exit(1) hangs sometimes |
| 598 | os._exit(1) |
Rich Lane | da3b5ad | 2012-10-03 09:05:32 -0700 | [diff] [blame] | 599 | if oftest.testutils.skipped_test_count > 0 and config["fail_skipped"]: |
Shudong Zhou | d895fcb | 2012-08-01 19:09:55 -0700 | [diff] [blame] | 600 | os._exit(1) |