def emcxtremioblockdeviceapi_for_test(test_case):
"""
Create a ``EMCXtremIOBlockDeviceAPI`` instance for use in tests.
:returns: A ``EMCCinderBlockDeviceAPI`` instance
"""
user_id = os.getuid()
if user_id != 0:
raise SkipTest(
"``EMCXtremIOBlockDeviceAPI`` queries for iSCSI initiator name which is owned by root, "
"Required UID: 0, Found UID: {!r}".format(user_id))
xio = tidy_xio_client_for_test(test_case)
return xio
def test_parse_descriptors_parseExtraInfoFiles_benchmark_10000_bridges(self):
"""Benchmark test for ``b.p.descriptors.parseExtraInfoFiles``.
The algorithm should grow linearly in the number of duplicates.
"""
raise SkipTest(("This test can take several minutes to complete. "
"Run it on your own free time."))
print()
for i in range(1, 6):
descFiles = self.createDuplicatesForBenchmark(b=10000, n=i)
with Benchmarker():
routers = descriptors.parseExtraInfoFiles(*descFiles)
def wrapper(*a, **kw):
try:
func(*a, **kw)
except FailTest as e:
if e.args[0].startswith("'Failed to get object inventory from "):
raise SkipTest(
(
"This test is prone to intermittent network errors. "
"See ticket 8753. Exception was: {!r}"
).format(e)
)
raise
def setUp(self):
if not os.environ.get("CI"):
raise SkipTest(("The mechanize tests cannot handle self-signed "
"TLS certificates, and thus require opening "
"another port for running a plaintext HTTP-only "
"BridgeDB webserver. Because of this, these tests "
"are only run on CI servers."))
if not PID or not processExists(PID):
raise FailTest("Could not start BridgeDB process on CI server!")
self.br = None
def get_ibm_storage_backend_from_environment(cluster_id):
"""
:returns: An instance of IBMStorageBlockDeviceAPI
"""
config_file_path = os.environ.get(messages.ENV_NAME_YML_FILE)
if config_file_path is not None:
config_file = open(config_file_path)
else:
raise SkipTest(messages.MISSING_ENV_FILE_FOR_TESTING)
config = yaml.load(config_file.read())
return get_ibm_storage_backend_by_conf(cluster_id, config['ibm'])
def wrapper(*args, **kwargs):
client = DockerClient()
docker_version = LooseVersion(client._client.version()['Version'])
if docker_version < minimum_docker_version:
raise SkipTest('Minimum required Docker version: {}. '
'Actual Docker version: {}. '
'Details: {}'.format(
minimum_docker_version,
docker_version,
message,
))
return wrapped(*args, **kwargs)
def ioctl(self, *args, **kwargs):
"""
Attempt an ioctl, but translate permission denied errors into
L{SkipTest} so that tests that require elevated system privileges and
do not have them are skipped instead of failed.
"""
try:
return super(TestRealSystem, self).ioctl(*args, **kwargs)
except IOError as e:
if EPERM == e.errno:
raise SkipTest("Permission to configure device denied")
raise
def test_get_obfs4_ipv4_publickey(self):
"""Ask for obfs4 bridges and check that there is an 'public-key' PT
argument in the bridge lines.
"""
if os.environ.get("CI"):
if not self.pid or not processExists(self.pid):
raise FailTest(
"Could not start BridgeDB process on CI server!")
else:
raise SkipTest(("The mechanize tests cannot handle self-signed "
"TLS certificates, and thus require opening "
"another port for running a plaintext HTTP-only "
"BridgeDB webserver. Because of this, these tests "
"are only run on CI servers."))
self.openBrowser()
self.goToOptionsPage()
PT = 'obfs4'
try:
soup = self.submitOptions(transport=PT,
ipv6=False,
captchaResponse=CAPTCHA_RESPONSE)
except ValueError as error:
if 'non-disabled' in str(error):
raise SkipTest(
"Pluggable Transport obfs4 is currently disabled.")
bridges = self.getBridgeLinesFromSoup(soup, fieldsPerBridge=6)
for bridge in bridges:
ptArgs = bridge[-3:]
hasPublicKey = False
for arg in ptArgs:
if 'public-key' in arg:
hasPublicKey = True
self.assertTrue(
hasPublicKey,
"obfs4 bridge line is missing 'public-key' PT arg.")
def buildReactor(self):
"""
Create and return a reactor using C{self.reactorFactory}.
"""
try:
from twisted.internet.cfreactor import CFReactor
from twisted.internet import reactor as globalReactor
except ImportError:
pass
else:
if (isinstance(globalReactor, CFReactor)
and self.reactorFactory is CFReactor):
raise SkipTest(
"CFReactor uses APIs which manipulate global state, "
"so it's not safe to run its own reactor-builder tests "
"under itself")
try:
reactor = self.reactorFactory()
except:
# Unfortunately, not all errors which result in a reactor
# being unusable are detectable without actually
# instantiating the reactor. So we catch some more here
# and skip the test if necessary. We also log it to aid
# with debugging, but flush the logged error so the test
# doesn't fail.
log.err(None, "Failed to install reactor")
self.flushLoggedErrors()
raise SkipTest(Failure().getErrorMessage())
else:
if self.requiredInterfaces is not None:
missing = filter(
lambda required: not required.providedBy(reactor),
self.requiredInterfaces)
if missing:
self.unbuildReactor(reactor)
raise SkipTest("%s does not provide %s" % (
fullyQualifiedName(reactor.__class__),
",".join([fullyQualifiedName(x) for x in missing])))
self.addCleanup(self.unbuildReactor, reactor)
return reactor
def connectionMade(self):
if not ITLSTransport.providedBy(self.transport):
# Functionality isn't available to be tested.
finished = self.factory.finished
self.factory.finished = None
finished.errback(SkipTest("No ITLSTransport support"))
return
# Switch the transport to TLS.
self.transport.startTLS(self.factory.context)
# Force TLS to really get negotiated. If nobody talks, nothing
# will happen.
self.transport.write("x")
def test_component_start_error(self):
ComponentTesterUpdate('test_pause_c1')
yield component.start(['test_pause_c1'])
yield component.pause(['test_pause_c1'])
test_comp = component.get('test_pause_c1')
try:
result = self.failureResultOf(test_comp._component_start())
except AttributeError:
raise SkipTest(
'This test requires trial failureResultOf() in Twisted version >= 13'
)
self.assertEqual(result.check(component.ComponentException),
component.ComponentException)
def daterablockdeviceapi_for_test(test_case):
"""
Create a ``DateraBlockDeviceAPI`` instance for use in tests.
:returns: A ``DateraBlockDeviceAPI`` instance
"""
user_id = os.getuid()
if user_id != 0:
raise SkipTest(
"``DateraBlockDeviceAPI`` queries for iSCSI initiator name \
which is owned by root, "
"Required UID: 0, Found UID: {!r}".format(user_id))
dfs = cleanup_for_test(test_case)
return dfs
def test_parse_descriptors_parseExtraInfoFiles_benchmark_1000_bridges(
self):
"""Benchmark test for ``b.p.descriptors.parseExtraInfoFiles``."""
raise SkipTest(("This test can take several minutes to complete. "
"Run it on your own free time."))
print()
for i in range(1, 6):
descFiles = self.createDuplicatesForBenchmark(b=1000, n=i)
with Benchmarker():
routers = descriptors.parseExtraInfoFiles(*descFiles)
for descFile in descFiles:
self.assertTrue(self.removeTestDescriptorsFile(descFile))
def api_factory(test_case):
"""
:param test: A twisted.trial.unittest.TestCase instance
"""
flocker_functional_test = environ.get('FLOCKER_FUNCTIONAL_TEST')
if flocker_functional_test is None:
raise SkipTest(
'Please set FLOCKER_FUNCTIONAL_TEST environment variable to '
'run storage backend functional tests.')
api = rbd_from_configuration("flocker", "client.admin",
"/etc/ceph/ceph.conf", "rbd")
test_case.addCleanup(api.destroy_all_flocker_volumes)
return api
def cinder_volume_manager():
"""
Get an ``ICinderVolumeManager`` configured to work on this environment.
XXX: It will not automatically clean up after itself. See FLOC-1824.
"""
try:
config = get_blockdevice_config(ProviderType.openstack)
except InvalidConfig as e:
raise SkipTest(str(e))
region = get_openstack_region_for_test()
session = get_keystone_session(**config)
return get_cinder_v1_client(session, region).volumes
def test_noCompatibilityLayer(self):
"""
If no compatibility layer is present, imports of gobject and friends
are disallowed.
We do this by running a process where we make sure gi.pygtkcompat
isn't present.
"""
if _PY3:
raise SkipTest("Python3 always has the compatibility layer.")
from twisted.internet import reactor
if not IReactorProcess.providedBy(reactor):
raise SkipTest("No process support available in this reactor.")
result = Deferred()
class Stdout(ProcessProtocol):
data = b""
def errReceived(self, err):
print(err)
def outReceived(self, data):
self.data += data
def processExited(self, reason):
result.callback(self.data)
path = FilePath(__file__).sibling(b"process_gireactornocompat.py").path
pyExe = FilePath(sys.executable)._asBytesPath()
# Pass in a PYTHONPATH that is the test runner's os.path, to make sure
# we're running from a checkout
reactor.spawnProcess(Stdout(),
pyExe, [pyExe, path],
env={"PYTHONPATH": ":".join(os.path)})
result.addCallback(self.assertEqual, b"success")
return result
def test_badContext(self):
"""
If the context factory passed to L{ITCPTransport.startTLS} raises an
exception from its C{getContext} method, that exception is raised by
L{ITCPTransport.startTLS}.
"""
reactor = self.buildReactor()
brokenFactory = BrokenContextFactory()
results = []
serverFactory = ServerFactory()
serverFactory.protocol = Protocol
port = reactor.listenTCP(0, serverFactory, interface=self.interface)
endpoint = self.endpoints.client(reactor, port.getHost())
clientFactory = ClientFactory()
clientFactory.protocol = Protocol
connectDeferred = endpoint.connect(clientFactory)
def connected(protocol):
if not ITLSTransport.providedBy(protocol.transport):
results.append("skip")
else:
results.append(
self.assertRaises(ValueError, protocol.transport.startTLS,
brokenFactory))
def connectFailed(failure):
results.append(failure)
def whenRun():
connectDeferred.addCallback(connected)
connectDeferred.addErrback(connectFailed)
connectDeferred.addBoth(lambda ign: reactor.stop())
needsRunningReactor(reactor, whenRun)
self.runReactor(reactor)
self.assertEqual(len(results), 1,
"more than one callback result: %s" % (results, ))
if isinstance(results[0], Failure):
# self.fail(Failure)
results[0].raiseException()
if results[0] == "skip":
raise SkipTest("Reactor does not support ITLSTransport")
self.assertEqual(BrokenContextFactory.message, str(results[0]))
def test_bridgedb_SIGHUP_assignments_log(self):
"""Test that BridgeDB creates a new ``assignments.log`` file after
receiving a SIGHUP.
"""
if os.environ.get("CI"):
if not self.pid or not processExists(self.pid):
raise FailTest("Could not start BridgeDB process on CI server!")
if not self.pid or not processExists(self.pid):
raise SkipTest("Can't run test: no BridgeDB process running.")
os.unlink(self.assignmentsFile)
os.kill(self.pid, signal.SIGHUP)
self.doSleep()
self.assertTrue(os.path.isfile(self.assignmentsFile))
def testUpgrade(self):
try:
from PIL import Image
except ImportError:
raise SkipTest('PIL is not available')
m = self.store.findUnique(Mugshot)
p = self.store.findUnique(Person)
self.assertIdentical(m.person, p)
self.assertEqual(p.name, 'Bob')
img = Image.open(m.smallerBody.open())
self.assertEqual(img.size, (m.smallerSize, m.smallerSize))
def client_from_environment():
"""
Search the process environment for a DigitalOcean v2 API token and use it
to build an API client instance.
:returns: A ``pyocean.DigitalOcean`` client instance.
"""
token = os.environ.get('DIGITALOCEAN_TOKEN')
if token is None:
raise SkipTest(
'A DIGITALOCEAN_TOKEN environment variable is required to run '
'these tests.')
return pyocean.DigitalOcean(token)
def test_verify_false(self):
"""
With the peer_verify field set to False, connection to the
OpenStack servers always succeeds.
"""
try:
config = get_blockdevice_config(ProviderType.openstack)
except InvalidConfig as e:
raise SkipTest(str(e))
config['peer_verify'] = False
session = get_keystone_session(**config)
region = get_openstack_region_for_test()
cinder_client = get_cinder_v1_client(session, region)
self.assertTrue(self._authenticates_ok(cinder_client))
def setUp(self):
if not ssh:
raise SkipTest('Crypto requirements missing. Skipping Test.')
self.pub_key_file_name = self.mktemp()
self.pub_key_file = open(self.pub_key_file_name, 'w')
self.pub_key_file.write(public_key.toString('OPENSSH'))
self.pub_key_file.flush()
self._middlewares = []
self._client_sockets = []
self.mw = self.get_middleware(
{'authorized_keys': [self.pub_key_file.name]})
def check_missing_messages(reason):
reason.trap(RemoteFileNotFound)
# XXX It would be better to predict this case based on what we know
# about the OS the cluster is running. We don't currently have
# easy access to that information, though.
#
# Doing it this way is subject to incorrect skips if we happen to
# make a mistaken assumption about /var/log/messages (eg if we
# misspell the name or if it just hasn't been written *quite* yet
# at the time we check).
#
# Currently, CentOS and Ubuntu are supported and CentOS is expected
# to have this log file and Ubuntu is expected not to.
raise SkipTest("{} not found".format(reason.value))
def buildReactor(self):
"""
Create and return a reactor using C{self.reactorFactory}.
"""
try:
reactor = self.reactorFactory()
except:
# Unfortunately, not all errors which result in a reactor being
# unusable are detectable without actually instantiating the
# reactor. So we catch some more here and skip the test if
# necessary.
raise SkipTest(Failure().getErrorMessage())
self.addCleanup(self.unbuildReactor, reactor)
return reactor
def loopbackblockdeviceapi_for_test(test_case):
"""
:returns: A ``LoopbackBlockDeviceAPI`` with a temporary root directory
created for the supplied ``test_case``.
"""
user_id = os.getuid()
if user_id != 0:
raise SkipTest("``LoopbackBlockDeviceAPI`` uses ``losetup``, "
"which requires root privileges. "
"Required UID: 0, Found UID: {!r}".format(user_id))
root_path = test_case.mktemp()
test_case.addCleanup(losetup_detach_all, FilePath(root_path))
return LoopbackBlockDeviceAPI.from_path(root_path=root_path)
def open(self, filename, *args, **kwargs):
"""
Attempt an open, but if the file is /dev/net/tun and it does not exist,
translate the error into L{SkipTest} so that tests that require
platform support for tuntap devices are skipped instead of failed.
"""
try:
return super(TestRealSystem, self).open(filename, *args, **kwargs)
except OSError as e:
# The device file may simply be missing. The device file may also
# exist but be unsupported by the kernel.
if e.errno in (ENOENT, ENODEV) and filename == b"/dev/net/tun":
raise SkipTest("Platform lacks /dev/net/tun")
raise
def getListeningPort(self,
reactor,
protocol,
port=0,
interface='',
maxPacketSize=8192):
"""
Get a UDP port from a reactor, wrapping an already-initialized file
descriptor.
@param reactor: A reactor used to build the returned
L{IListeningPort} provider.
@type reactor: L{twisted.internet.interfaces.IReactorSocket}
@param port: A port number to which the adopted socket will be
bound.
@type port: C{int}
@param interface: The local IPv4 or IPv6 address to which the
adopted socket will be bound. defaults to '', ie all IPv4
addresses.
@type interface: C{str}
@see: L{twisted.internet.IReactorSocket.adoptDatagramPort} for other
argument and return types.
"""
if IReactorSocket.providedBy(reactor):
if ':' in interface:
domain = socket.AF_INET6
address = socket.getaddrinfo(interface, port)[0][4]
else:
domain = socket.AF_INET
address = (interface, port)
portSock = socket.socket(domain, socket.SOCK_DGRAM)
portSock.bind(address)
portSock.setblocking(False)
try:
return reactor.adoptDatagramPort(portSock.fileno(),
portSock.family, protocol,
maxPacketSize)
finally:
# The socket should still be open; fileno will raise if it is
# not.
portSock.fileno()
# Now clean it up, because the rest of the test does not need
# it.
portSock.close()
else:
raise SkipTest("Reactor does not provide IReactorSocket")
def test_stopStartReading(self):
"""
This test verifies transport socket read state after multiple
pause/resumeProducing calls.
"""
sf = ServerFactory()
reactor = sf.reactor = self.buildReactor()
skippedReactors = ["Glib2Reactor", "Gtk2Reactor"]
reactorClassName = reactor.__class__.__name__
if reactorClassName in skippedReactors and platform.isWindows():
raise SkipTest("This test is broken on gtk/glib under Windows.")
sf.protocol = StopStartReadingProtocol
sf.ready = Deferred()
sf.stop = Deferred()
p = reactor.listenTCP(0, sf)
port = p.getHost().port
def proceed(protos, port):
"""
Send several IOCPReactor's buffers' worth of data.
"""
self.assertTrue(protos[0])
self.assertTrue(protos[1])
protos = protos[0][1], protos[1][1]
protos[0].transport.write('x' * (2 * 4096) + 'y' * (2 * 4096))
return (sf.stop.addCallback(
cleanup, protos, port).addCallback(lambda ign: reactor.stop()))
def cleanup(data, protos, port):
"""
Make sure IOCPReactor didn't start several WSARecv operations
that clobbered each other's results.
"""
self.assertEquals(data, 'x' * (2 * 4096) + 'y' * (2 * 4096),
'did not get the right data')
return DeferredList([
maybeDeferred(protos[0].transport.loseConnection),
maybeDeferred(protos[1].transport.loseConnection),
maybeDeferred(port.stopListening)
])
cc = TCP4ClientEndpoint(reactor, '127.0.0.1', port)
cf = ClientFactory()
cf.protocol = Protocol
d = DeferredList([cc.connect(cf), sf.ready]).addCallback(proceed, p)
self.runReactor(reactor)
return d
def setUp(self):
"""
Add our example directory to the path and record which modules are
currently loaded.
"""
self.originalPath = sys.path[:]
self.originalModules = sys.modules.copy()
# Python usually expects native strs to be written to sys.stdout/stderr
self.fakeErr = NativeStringIO()
self.patch(sys, 'stderr', self.fakeErr)
self.fakeOut = NativeStringIO()
self.patch(sys, 'stdout', self.fakeOut)
# Get documentation root
try:
here = FilePath(os.environ['TOX_INI_DIR']).child('docs')
except KeyError:
raise SkipTest(
"Examples not found ($TOX_INI_DIR unset) - cannot test",
)
# Find the example script within this branch
for childName in self.exampleRelativePath.split('/'):
here = here.child(childName)
if not here.exists():
raise SkipTest(
"Examples (%s) not found - cannot test" % (here.path,))
self.examplePath = here
# Add the example parent folder to the Python path
sys.path.append(self.examplePath.parent().path)
# Import the example as a module
moduleName = self.examplePath.basename().split('.')[0]
self.example = __import__(moduleName)
def buildReactor(self):
"""
Create and return a reactor using C{self.reactorFactory}.
"""
try:
reactor = self.reactorFactory()
except:
# Unfortunately, not all errors which result in a reactor
# being unusable are detectable without actually
# instantiating the reactor. So we catch some more here
# and skip the test if necessary. We also log it to aid
# with debugging, but flush the logged error so the test
# doesn't fail.
log.err(None, "Failed to install reactor")
self.flushLoggedErrors()
raise SkipTest(Failure().getErrorMessage())
else:
if self.requiredInterface is not None:
if not self.requiredInterface.providedBy(reactor):
self.unbuildReactor(reactor)
raise SkipTest("%r does not provide %r" %
(reactor, self.requiredInterface))
self.addCleanup(self.unbuildReactor, reactor)
return reactor
