def test_object_from_module(self):
# try_import('thing.object') imports 'thing' and returns
# 'thing.object' if 'thing' is a module and 'object' is not.
result = try_import("os.path.join")
import os
self.assertThat(result, Is(os.path.join))
def test_existing_module(self):
# try_import('thing', foo) imports 'thing' and returns it if it's a
# module that exists.
result = try_import("os", object())
import os
self.assertThat(result, Is(os))
def test_existing_submodule(self):
# try_import('thing.another', foo) imports 'thing' and returns it if
# it's a module that exists.
result = try_import("os.path", object())
import os
self.assertThat(result, Is(os.path))
def hide_testtools_stack(should_hide=True):
modules = [
'testtools.matchers',
'testtools.runtest',
'testtools.testcase',
]
result = is_stack_hidden()
for module_name in modules:
module = try_import(module_name)
if should_hide:
setattr(module, '__unittest', True)
else:
try:
delattr(module, '__unittest')
except AttributeError:
# Attribute already doesn't exist. Our work here is done.
pass
return result
KeysEqual,
MatchesDict,
MatchesException,
MatchesListwise,
Not,
Raises,
)
from testtools.runtest import RunTest
from testtools.testresult.doubles import ExtendedTestResult
from testtools.tests.helpers import (
AsText,
MatchesEvents,
)
from ._helpers import NeedsTwistedTestCase
DebugTwisted = try_import(
'testtools.twistedsupport._deferreddebug.DebugTwisted')
assert_fails_with = try_import('testtools.twistedsupport.assert_fails_with')
AsynchronousDeferredRunTest = try_import(
'testtools.twistedsupport.AsynchronousDeferredRunTest')
flush_logged_errors = try_import(
'testtools.twistedsupport.flush_logged_errors')
SynchronousDeferredRunTest = try_import(
'testtools.twistedsupport.SynchronousDeferredRunTest')
defer = try_import('twisted.internet.defer')
failure = try_import('twisted.python.failure')
log = try_import('twisted.python.log')
DelayedCall = try_import('twisted.internet.base.DelayedCall')
_get_global_publisher_and_observers = try_import(
'testtools.twistedsupport._runtest._get_global_publisher_and_observers')
def test_object_from_module(self):
# try_import('thing.object') imports 'thing' and returns
# 'thing.object' if 'thing' is a module and 'object' is not.
result = try_import('os.path.join')
import os
self.assertThat(result, Is(os.path.join))
import sys
from textwrap import dedent
import unittest
from unittest import TestSuite
import testtools
from testtools import TestCase, run, skipUnless
from testtools.compat import _b
from testtools.helpers import try_import
from testtools.matchers import (
Contains,
DocTestMatches,
MatchesRegex,
)
fixtures = try_import('fixtures')
testresources = try_import('testresources')
if fixtures:
class SampleTestFixture(fixtures.Fixture):
"""Creates testtools.runexample temporarily."""
def __init__(self, broken=False):
"""Create a SampleTestFixture.
:param broken: If True, the sample file will not be importable.
"""
if not broken:
init_contents = _b("""\
from testtools import TestCase
# Copyright (c) 2010-2011 testtools developers. See LICENSE for details.
import unittest
from testtools import TestCase, content, content_type
from testtools.compat import _b, _u
from testtools.helpers import try_import
from testtools.testresult.doubles import ExtendedTestResult
fixtures = try_import("fixtures")
LoggingFixture = try_import("fixtures.tests.helpers.LoggingFixture")
class TestFixtureSupport(TestCase):
def setUp(self):
super(TestFixtureSupport, self).setUp()
if fixtures is None or LoggingFixture is None:
self.skipTest("Need fixtures")
def test_useFixture(self):
fixture = LoggingFixture()
class SimpleTest(TestCase):
def test_foo(self):
self.useFixture(fixture)
result = unittest.TestResult()
SimpleTest("test_foo").run(result)
self.assertTrue(result.wasSuccessful())
self.assertEqual(["setUp", "cleanUp"], fixture.calls)
# Copyright (c) 2010, 2016 testtools developers. See LICENSE for details.
__all__ = [
'NeedsTwistedTestCase',
]
from testtools.helpers import try_import
from testtools import TestCase
defer = try_import('twisted.internet.defer')
class NeedsTwistedTestCase(TestCase):
def setUp(self):
super().setUp()
if defer is None:
self.skipTest("Need Twisted to run")
# Copyright (c) 2010 testtools developers. See LICENSE for details.
"""Tests for the DeferredRunTest single test execution logic."""
import os
import signal
from testtools import skipIf, TestCase
from testtools.content import text_content
from testtools.helpers import try_import
from testtools.tests.helpers import ExtendedTestResult
from testtools.matchers import Equals, KeysEqual, MatchesException, Raises
from testtools.runtest import RunTest
from testtools.tests.test_spinner import NeedsTwistedTestCase
assert_fails_with = try_import("testtools.deferredruntest.assert_fails_with")
AsynchronousDeferredRunTest = try_import("testtools.deferredruntest.AsynchronousDeferredRunTest")
flush_logged_errors = try_import("testtools.deferredruntest.flush_logged_errors")
SynchronousDeferredRunTest = try_import("testtools.deferredruntest.SynchronousDeferredRunTest")
defer = try_import("twisted.internet.defer")
failure = try_import("twisted.python.failure")
log = try_import("twisted.python.log")
DelayedCall = try_import("twisted.internet.base.DelayedCall")
class X(object):
"""Tests that we run as part of our tests, nested to avoid discovery."""
class Base(TestCase):
def setUp(self):
)
from testtools.content import (
text_content,
)
from testtools.helpers import try_import
from testtools.matchers import (
Equals,
KeysEqual,
MatchesException,
Raises,
)
from testtools.runtest import RunTest
from testtools.testresult.doubles import ExtendedTestResult
from testtools.tests.test_spinner import NeedsTwistedTestCase
assert_fails_with = try_import('testtools.deferredruntest.assert_fails_with')
AsynchronousDeferredRunTest = try_import(
'testtools.deferredruntest.AsynchronousDeferredRunTest')
flush_logged_errors = try_import(
'testtools.deferredruntest.flush_logged_errors')
SynchronousDeferredRunTest = try_import(
'testtools.deferredruntest.SynchronousDeferredRunTest')
defer = try_import('twisted.internet.defer')
failure = try_import('twisted.python.failure')
log = try_import('twisted.python.log')
DelayedCall = try_import('twisted.internet.base.DelayedCall')
class X(object):
"""Tests that we run as part of our tests, nested to avoid discovery."""
def test_nonexistent_submodule(self):
# try_import('thing.another', foo) imports 'thing' and returns foo if
# 'another' doesn't exist.
marker = object()
result = try_import('os.doesntexist', marker)
self.assertThat(result, Is(marker))
def test_None_is_default_alternative(self):
# try_import('thing') returns None if 'thing' doesn't exist.
result = try_import('doesntexist')
self.assertThat(result, Is(None))
# Copyright (c) 2010-2011 testtools developers. See LICENSE for details.
import unittest
from testtools import (
TestCase,
content,
content_type,
)
from testtools.compat import _b, _u
from testtools.helpers import try_import
from testtools.testresult.doubles import (
ExtendedTestResult, )
fixtures = try_import('fixtures')
LoggingFixture = try_import('fixtures.tests.helpers.LoggingFixture')
class TestFixtureSupport(TestCase):
def setUp(self):
super(TestFixtureSupport, self).setUp()
if fixtures is None or LoggingFixture is None:
self.skipTest("Need fixtures")
def test_useFixture(self):
fixture = LoggingFixture()
class SimpleTest(TestCase):
def test_foo(self):
self.useFixture(fixture)
from testtools import (
ConcurrentTestSuite,
ConcurrentStreamTestSuite,
iterate_tests,
PlaceHolder,
TestByTestResult,
TestCase,
)
from testtools.helpers import try_import
from testtools.matchers import DocTestMatches, Equals
from testtools.testresult.doubles import StreamResult as LoggingStream
from testtools.testsuite import FixtureSuite, sorted_tests
from testtools.tests.helpers import LoggingResult
FunctionFixture = try_import('fixtures.FunctionFixture')
class Sample(TestCase):
def __hash__(self):
return id(self)
def test_method1(self):
pass
def test_method2(self):
pass
class TestConcurrentTestSuiteRun(TestCase):
def test_broken_test(self):
log = []
# Copyright (c) 2010 testtools developers. See LICENSE for details.
import unittest
from testtools import (
TestCase,
content,
content_type,
)
from testtools.helpers import try_import
from testtools.tests.helpers import (
ExtendedTestResult,
)
fixtures = try_import('fixtures')
LoggingFixture = try_import('fixtures.tests.helpers.LoggingFixture')
class TestFixtureSupport(TestCase):
def setUp(self):
super(TestFixtureSupport, self).setUp()
if fixtures is None or LoggingFixture is None:
self.skipTest("Need fixtures")
def test_useFixture(self):
fixture = LoggingFixture()
class SimpleTest(TestCase):
def test_foo(self):
self.useFixture(fixture)
result = unittest.TestResult()
# Copyright (c) 2010 testtools developers. See LICENSE for details.
"""Tests for the test runner logic."""
from testtools.compat import (
_b,
StringIO,
)
from testtools.helpers import try_import
fixtures = try_import('fixtures')
import testtools
from testtools import TestCase, run
if fixtures:
class SampleTestFixture(fixtures.Fixture):
"""Creates testtools.runexample temporarily."""
def __init__(self):
self.package = fixtures.PythonPackage('runexample',
[('__init__.py',
_b("""
from testtools import TestCase
class TestFoo(TestCase):
def test_bar(self):
pass
def test_quux(self):
pass
def test_suite():
from unittest import TestLoader
return TestLoader().loadTestsFromName(__name__)
# Copyright (c) testtools developers. See LICENSE for details.
"""Tests for testtools._deferred."""
from testtools.helpers import try_import
from testtools.matchers import (
Equals,
MatchesException,
Raises,
)
from ._helpers import NeedsTwistedTestCase
DeferredNotFired = try_import(
'testtools.twistedsupport._deferred.DeferredNotFired')
extract_result = try_import(
'testtools.twistedsupport._deferred.extract_result')
defer = try_import('twisted.internet.defer')
Failure = try_import('twisted.python.failure.Failure')
class TestExtractResult(NeedsTwistedTestCase):
"""Tests for ``extract_result``."""
def test_not_fired(self):
# _spinner.extract_result raises _spinner.DeferredNotFired if it's
# given a Deferred that has not fired.
self.assertThat(lambda: extract_result(defer.Deferred()),
Raises(MatchesException(DeferredNotFired)))
def test_success(self):
# _spinner.extract_result returns the value of the Deferred if it has
# fired successfully.
import sys
import six
from testtools.compat import (
advance_iterator,
reraise,
)
from testtools.helpers import try_import
from fixtures.callmany import (
CallMany,
# Deprecated, imported for compatibility.
MultipleExceptions,
)
gather_details = try_import("testtools.testcase.gather_details")
# This would be better in testtools (or a common library)
def combine_details(source_details, target_details):
"""Add every value from source to target deduping common keys."""
for name, content_object in source_details.items():
new_name = name
disambiguator = itertools.count(1)
while new_name in target_details:
new_name = '%s-%d' % (name, advance_iterator(disambiguator))
name = new_name
target_details[name] = content_object
class SetupError(Exception):
"""Setup failed.
TestResult,
)
from testtools.content import (
text_content, )
from testtools.helpers import try_import
from testtools.matchers import (
Equals,
KeysEqual,
MatchesException,
Raises,
)
from testtools.runtest import RunTest
from testtools.testresult.doubles import ExtendedTestResult
from testtools.tests.test_spinner import NeedsTwistedTestCase
assert_fails_with = try_import('testtools.deferredruntest.assert_fails_with')
AsynchronousDeferredRunTest = try_import(
'testtools.deferredruntest.AsynchronousDeferredRunTest')
flush_logged_errors = try_import(
'testtools.deferredruntest.flush_logged_errors')
SynchronousDeferredRunTest = try_import(
'testtools.deferredruntest.SynchronousDeferredRunTest')
defer = try_import('twisted.internet.defer')
failure = try_import('twisted.python.failure')
log = try_import('twisted.python.log')
DelayedCall = try_import('twisted.internet.base.DelayedCall')
class X(object):
"""Tests that we run as part of our tests, nested to avoid discovery."""
import os
import signal
from testtools import (
skipIf,
TestCase,
)
from testtools.helpers import try_import
from testtools.matchers import (
Equals,
Is,
MatchesException,
Raises,
)
_spinner = try_import('testtools._spinner')
defer = try_import('twisted.internet.defer')
Failure = try_import('twisted.python.failure.Failure')
class NeedsTwistedTestCase(TestCase):
def setUp(self):
super(NeedsTwistedTestCase, self).setUp()
if defer is None or Failure is None:
self.skipTest("Need Twisted to run")
class TestNotReentrant(NeedsTwistedTestCase):
import os
import signal
from testtools import (
skipIf,
TestCase,
)
from testtools.helpers import try_import
from testtools.matchers import (
Equals,
Is,
MatchesException,
Raises,
)
_spinner = try_import('testtools._spinner')
defer = try_import('twisted.internet.defer')
Failure = try_import('twisted.python.failure.Failure')
class NeedsTwistedTestCase(TestCase):
def setUp(self):
super(NeedsTwistedTestCase, self).setUp()
if defer is None or Failure is None:
self.skipTest("Need Twisted to run")
class TestNotReentrant(NeedsTwistedTestCase):
def test_not_reentrant(self):
# A function decorated as not being re-entrant will raise a
def test_doesnt_exist(self):
# try_import('thing', foo) returns foo if 'thing' doesn't exist.
marker = object()
result = try_import('doesntexist', marker)
self.assertThat(result, Is(marker))
def test_doesnt_exist(self):
# try_import('thing', foo) returns foo if 'thing' doesn't exist.
marker = object()
result = try_import('doesntexist', marker)
self.assertThat(result, Is(marker))
import itertools
import sys
from testtools.compat import (
advance_iterator,
reraise,
)
from testtools.helpers import try_import
from fixtures.callmany import (
CallMany,
# Deprecated, imported for compatibility.
MultipleExceptions,
)
gather_details = try_import("testtools.testcase.gather_details")
# This would be better in testtools (or a common library)
def combine_details(source_details, target_details):
"""Add every value from source to target deduping common keys."""
for name, content_object in source_details.items():
new_name = name
disambiguator = itertools.count(1)
while new_name in target_details:
new_name = '%s-%d' % (name, advance_iterator(disambiguator))
name = new_name
target_details[name] = content_object
class Fixture(object):
"""A Fixture representing some state or resource.
def test_None_is_default_alternative(self):
# try_import('thing') returns None if 'thing' doesn't exist.
result = try_import('doesntexist')
self.assertThat(result, Is(None))
__all__ = [
'CallMany',
]
import sys
from testtools.compat import (
reraise,
)
from testtools.helpers import try_import
class MultipleExceptions(Exception):
"""Report multiple exc_info tuples in self.args."""
MultipleExceptions = try_import(
"testtools.MultipleExceptions", MultipleExceptions)
class CallMany(object):
"""A stack of functions which will all be called on __call__.
CallMany also acts as a context manager for convenience.
Functions are called in last pushed first executed order.
This is used by Fixture to manage its addCleanup feature.
"""
def __init__(self):
self._cleanups = []
def test_existing_module(self):
# try_import('thing', foo) imports 'thing' and returns it if it's a
# module that exists.
result = try_import('os', object())
import os
self.assertThat(result, Is(os))
__metaclass__ = type
import unittest
from testtools import (
ConcurrentTestSuite,
iterate_tests,
PlaceHolder,
TestCase,
)
from testtools.helpers import try_import
from testtools.testsuite import FixtureSuite, iterate_tests, sorted_tests
from testtools.tests.helpers import LoggingResult
FunctionFixture = try_import('fixtures.FunctionFixture')
class Sample(TestCase):
def __hash__(self):
return id(self)
def test_method1(self):
pass
def test_method2(self):
pass
class TestConcurrentTestSuiteRun(TestCase):
def test_trivial(self):
log = []
result = LoggingResult(log)
test1 = Sample('test_method1')
def test_existing_submodule(self):
# try_import('thing.another', foo) imports 'thing' and returns it if
# it's a module that exists.
result = try_import('os.path', object())
import os
self.assertThat(result, Is(os.path))
# Copyright (c) 2010-2011 Testtools authors. See LICENSE for details.
"""Tests for the distutils test command logic."""
from distutils.dist import Distribution
from testtools.helpers import try_import, try_imports
fixtures = try_import('fixtures')
StringIO = try_imports(['StringIO.StringIO', 'io.StringIO'])
import testtools
from testtools import TestCase
from testtools.distutilscmd import TestCommand
if fixtures:
class SampleTestFixture(fixtures.Fixture):
"""Creates testtools.runexample temporarily."""
def __init__(self):
self.package = fixtures.PythonPackage(
'runexample', [('__init__.py', """
from testtools import TestCase
class TestFoo(TestCase):
def test_bar(self):
pass
def test_quux(self):
pass
def test_suite():
from unittest import TestLoader
def test_nonexistent_submodule(self):
# try_import('thing.another', foo) imports 'thing' and returns foo if
# 'another' doesn't exist.
marker = object()
result = try_import('os.doesntexist', marker)
self.assertThat(result, Is(marker))
