653 lines
22 KiB
Python
653 lines
22 KiB
Python
# Copyright (c) Twisted Matrix Laboratories.
|
|
# See LICENSE for details.
|
|
#
|
|
|
|
"""
|
|
Tests for L{twisted.trial.util}
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import locale
|
|
import os
|
|
import sys
|
|
from io import StringIO
|
|
from typing import Generator
|
|
|
|
from zope.interface import implementer
|
|
|
|
from hamcrest import assert_that, equal_to
|
|
|
|
from twisted.internet.base import DelayedCall
|
|
from twisted.internet.interfaces import IProcessTransport
|
|
from twisted.python import filepath
|
|
from twisted.python.failure import Failure
|
|
from twisted.trial import util
|
|
from twisted.trial.unittest import SynchronousTestCase
|
|
from twisted.trial.util import (
|
|
DirtyReactorAggregateError,
|
|
_Janitor,
|
|
acquireAttribute,
|
|
excInfoOrFailureToExcInfo,
|
|
openTestLog,
|
|
)
|
|
|
|
|
|
class MktempTests(SynchronousTestCase):
|
|
"""
|
|
Tests for L{TestCase.mktemp}, a helper function for creating temporary file
|
|
or directory names.
|
|
"""
|
|
|
|
def test_name(self) -> None:
|
|
"""
|
|
The path name returned by C{mktemp} is directly beneath a directory
|
|
which identifies the test method which created the name.
|
|
"""
|
|
name = self.mktemp()
|
|
dirs = os.path.dirname(name).split(os.sep)[:-1]
|
|
self.assertEqual(
|
|
dirs, ["twisted.trial.test.test_util", "MktempTests", "test_name"]
|
|
)
|
|
|
|
def test_unique(self) -> None:
|
|
"""
|
|
Repeated calls to C{mktemp} return different values.
|
|
"""
|
|
name = self.mktemp()
|
|
self.assertNotEqual(name, self.mktemp())
|
|
|
|
def test_created(self) -> None:
|
|
"""
|
|
The directory part of the path name returned by C{mktemp} exists.
|
|
"""
|
|
name = self.mktemp()
|
|
dirname = os.path.dirname(name)
|
|
self.assertTrue(os.path.exists(dirname))
|
|
self.assertFalse(os.path.exists(name))
|
|
|
|
def test_location(self) -> None:
|
|
"""
|
|
The path returned by C{mktemp} is beneath the current working directory.
|
|
"""
|
|
path = os.path.abspath(self.mktemp())
|
|
self.assertTrue(path.startswith(os.getcwd()))
|
|
|
|
|
|
class DirtyReactorAggregateErrorTests(SynchronousTestCase):
|
|
"""
|
|
Tests for the L{DirtyReactorAggregateError}.
|
|
"""
|
|
|
|
def test_formatDelayedCall(self) -> None:
|
|
"""
|
|
Delayed calls are formatted nicely.
|
|
"""
|
|
error = DirtyReactorAggregateError(["Foo", "bar"])
|
|
self.assertEqual(
|
|
str(error),
|
|
"""\
|
|
Reactor was unclean.
|
|
DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug)
|
|
Foo
|
|
bar""",
|
|
)
|
|
|
|
def test_formatSelectables(self) -> None:
|
|
"""
|
|
Selectables are formatted nicely.
|
|
"""
|
|
error = DirtyReactorAggregateError([], ["selectable 1", "selectable 2"])
|
|
self.assertEqual(
|
|
str(error),
|
|
"""\
|
|
Reactor was unclean.
|
|
Selectables:
|
|
selectable 1
|
|
selectable 2""",
|
|
)
|
|
|
|
def test_formatDelayedCallsAndSelectables(self) -> None:
|
|
"""
|
|
Both delayed calls and selectables can appear in the same error.
|
|
"""
|
|
error = DirtyReactorAggregateError(["bleck", "Boozo"], ["Sel1", "Sel2"])
|
|
self.assertEqual(
|
|
str(error),
|
|
"""\
|
|
Reactor was unclean.
|
|
DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug)
|
|
bleck
|
|
Boozo
|
|
Selectables:
|
|
Sel1
|
|
Sel2""",
|
|
)
|
|
|
|
|
|
class StubReactor:
|
|
"""
|
|
A reactor stub which contains enough functionality to be used with the
|
|
L{_Janitor}.
|
|
|
|
@ivar iterations: A list of the arguments passed to L{iterate}.
|
|
@ivar removeAllCalled: Number of times that L{removeAll} was called.
|
|
@ivar selectables: The value that will be returned from L{removeAll}.
|
|
@ivar delayedCalls: The value to return from L{getDelayedCalls}.
|
|
"""
|
|
|
|
def __init__(
|
|
self, delayedCalls: list[DelayedCall], selectables: list[object] | None = None
|
|
) -> None:
|
|
"""
|
|
@param delayedCalls: See L{StubReactor.delayedCalls}.
|
|
@param selectables: See L{StubReactor.selectables}.
|
|
"""
|
|
self.delayedCalls = delayedCalls
|
|
self.iterations: list[float | None] = []
|
|
self.removeAllCalled = 0
|
|
if not selectables:
|
|
selectables = []
|
|
self.selectables = selectables
|
|
|
|
def iterate(self, timeout: float | None = None) -> None:
|
|
"""
|
|
Increment C{self.iterations}.
|
|
"""
|
|
self.iterations.append(timeout)
|
|
|
|
def getDelayedCalls(self) -> list[DelayedCall]:
|
|
"""
|
|
Return C{self.delayedCalls}.
|
|
"""
|
|
return self.delayedCalls
|
|
|
|
def removeAll(self) -> list[object]:
|
|
"""
|
|
Increment C{self.removeAllCalled} and return C{self.selectables}.
|
|
"""
|
|
self.removeAllCalled += 1
|
|
return self.selectables
|
|
|
|
|
|
class StubErrorReporter:
|
|
"""
|
|
A subset of L{twisted.trial.itrial.IReporter} which records L{addError}
|
|
calls.
|
|
|
|
@ivar errors: List of two-tuples of (test, error) which were passed to
|
|
L{addError}.
|
|
"""
|
|
|
|
def __init__(self) -> None:
|
|
self.errors: list[tuple[object, Failure]] = []
|
|
|
|
def addError(self, test: object, error: Failure) -> None:
|
|
"""
|
|
Record parameters in C{self.errors}.
|
|
"""
|
|
self.errors.append((test, error))
|
|
|
|
|
|
class JanitorTests(SynchronousTestCase):
|
|
"""
|
|
Tests for L{_Janitor}!
|
|
"""
|
|
|
|
def test_cleanPendingSpinsReactor(self) -> None:
|
|
"""
|
|
During pending-call cleanup, the reactor will be spun twice with an
|
|
instant timeout. This is not a requirement, it is only a test for
|
|
current behavior. Hopefully Trial will eventually not do this kind of
|
|
reactor stuff.
|
|
"""
|
|
reactor = StubReactor([])
|
|
jan = _Janitor(None, None, reactor=reactor)
|
|
jan._cleanPending()
|
|
self.assertEqual(reactor.iterations, [0, 0])
|
|
|
|
def test_cleanPendingCancelsCalls(self) -> None:
|
|
"""
|
|
During pending-call cleanup, the janitor cancels pending timed calls.
|
|
"""
|
|
|
|
def func() -> str:
|
|
return "Lulz"
|
|
|
|
cancelled: list[DelayedCall] = []
|
|
delayedCall = DelayedCall(300, func, (), {}, cancelled.append, lambda x: None)
|
|
reactor = StubReactor([delayedCall])
|
|
jan = _Janitor(None, None, reactor=reactor)
|
|
jan._cleanPending()
|
|
self.assertEqual(cancelled, [delayedCall])
|
|
|
|
def test_cleanPendingReturnsDelayedCallStrings(self) -> None:
|
|
"""
|
|
The Janitor produces string representations of delayed calls from the
|
|
delayed call cleanup method. It gets the string representations
|
|
*before* cancelling the calls; this is important because cancelling the
|
|
call removes critical debugging information from the string
|
|
representation.
|
|
"""
|
|
delayedCall = DelayedCall(
|
|
300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0
|
|
)
|
|
delayedCallString = str(delayedCall)
|
|
reactor = StubReactor([delayedCall])
|
|
jan = _Janitor(None, None, reactor=reactor)
|
|
strings = jan._cleanPending()
|
|
self.assertEqual(strings, [delayedCallString])
|
|
|
|
def test_cleanReactorRemovesSelectables(self) -> None:
|
|
"""
|
|
The Janitor will remove selectables during reactor cleanup.
|
|
"""
|
|
reactor = StubReactor([])
|
|
jan = _Janitor(None, None, reactor=reactor)
|
|
jan._cleanReactor()
|
|
self.assertEqual(reactor.removeAllCalled, 1)
|
|
|
|
def test_cleanReactorKillsProcesses(self) -> None:
|
|
"""
|
|
The Janitor will kill processes during reactor cleanup.
|
|
"""
|
|
|
|
@implementer(IProcessTransport)
|
|
class StubProcessTransport: # type: ignore[misc]
|
|
"""
|
|
A stub L{IProcessTransport} provider which records signals.
|
|
@ivar signals: The signals passed to L{signalProcess}.
|
|
"""
|
|
|
|
def __init__(self) -> None:
|
|
self.signals: list[str | int] = []
|
|
|
|
def signalProcess(self, signal: str | int) -> None:
|
|
"""
|
|
Append C{signal} to C{self.signals}.
|
|
"""
|
|
self.signals.append(signal)
|
|
|
|
pt = StubProcessTransport()
|
|
reactor = StubReactor([], [pt])
|
|
jan = _Janitor(None, None, reactor=reactor)
|
|
jan._cleanReactor()
|
|
self.assertEqual(pt.signals, ["KILL"])
|
|
|
|
def test_cleanReactorReturnsSelectableStrings(self) -> None:
|
|
"""
|
|
The Janitor returns string representations of the selectables that it
|
|
cleaned up from the reactor cleanup method.
|
|
"""
|
|
|
|
class Selectable:
|
|
"""
|
|
A stub Selectable which only has an interesting string
|
|
representation.
|
|
"""
|
|
|
|
def __repr__(self) -> str:
|
|
return "(SELECTABLE!)"
|
|
|
|
reactor = StubReactor([], [Selectable()])
|
|
jan = _Janitor(None, None, reactor=reactor)
|
|
self.assertEqual(jan._cleanReactor(), ["(SELECTABLE!)"])
|
|
|
|
def test_postCaseCleanupNoErrors(self) -> None:
|
|
"""
|
|
The post-case cleanup method will return True and not call C{addError}
|
|
on the result if there are no pending calls.
|
|
"""
|
|
reactor = StubReactor([])
|
|
test = object()
|
|
reporter = StubErrorReporter()
|
|
jan = _Janitor(test, reporter, reactor=reactor)
|
|
self.assertTrue(jan.postCaseCleanup())
|
|
self.assertEqual(reporter.errors, [])
|
|
|
|
def test_postCaseCleanupWithErrors(self) -> None:
|
|
"""
|
|
The post-case cleanup method will return False and call C{addError} on
|
|
the result with a L{DirtyReactorAggregateError} Failure if there are
|
|
pending calls.
|
|
"""
|
|
delayedCall = DelayedCall(
|
|
300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0
|
|
)
|
|
delayedCallString = str(delayedCall)
|
|
reactor = StubReactor([delayedCall], [])
|
|
test = object()
|
|
reporter = StubErrorReporter()
|
|
jan = _Janitor(test, reporter, reactor=reactor)
|
|
self.assertFalse(jan.postCaseCleanup())
|
|
self.assertEqual(len(reporter.errors), 1)
|
|
self.assertEqual(reporter.errors[0][1].value.delayedCalls, [delayedCallString])
|
|
|
|
def test_postClassCleanupNoErrors(self) -> None:
|
|
"""
|
|
The post-class cleanup method will not call C{addError} on the result
|
|
if there are no pending calls or selectables.
|
|
"""
|
|
reactor = StubReactor([])
|
|
test = object()
|
|
reporter = StubErrorReporter()
|
|
jan = _Janitor(test, reporter, reactor=reactor)
|
|
jan.postClassCleanup()
|
|
self.assertEqual(reporter.errors, [])
|
|
|
|
def test_postClassCleanupWithPendingCallErrors(self) -> None:
|
|
"""
|
|
The post-class cleanup method call C{addError} on the result with a
|
|
L{DirtyReactorAggregateError} Failure if there are pending calls.
|
|
"""
|
|
delayedCall = DelayedCall(
|
|
300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0
|
|
)
|
|
delayedCallString = str(delayedCall)
|
|
reactor = StubReactor([delayedCall], [])
|
|
test = object()
|
|
reporter = StubErrorReporter()
|
|
jan = _Janitor(test, reporter, reactor=reactor)
|
|
jan.postClassCleanup()
|
|
self.assertEqual(len(reporter.errors), 1)
|
|
self.assertEqual(reporter.errors[0][1].value.delayedCalls, [delayedCallString])
|
|
|
|
def test_postClassCleanupWithSelectableErrors(self) -> None:
|
|
"""
|
|
The post-class cleanup method call C{addError} on the result with a
|
|
L{DirtyReactorAggregateError} Failure if there are selectables.
|
|
"""
|
|
selectable = "SELECTABLE HERE"
|
|
reactor = StubReactor([], [selectable])
|
|
test = object()
|
|
reporter = StubErrorReporter()
|
|
jan = _Janitor(test, reporter, reactor=reactor)
|
|
jan.postClassCleanup()
|
|
self.assertEqual(len(reporter.errors), 1)
|
|
self.assertEqual(reporter.errors[0][1].value.selectables, [repr(selectable)])
|
|
|
|
|
|
class RemoveSafelyTests(SynchronousTestCase):
|
|
"""
|
|
Tests for L{util._removeSafely}.
|
|
"""
|
|
|
|
def test_removeSafelyNoTrialMarker(self) -> None:
|
|
"""
|
|
If a path doesn't contain a node named C{"_trial_marker"}, that path is
|
|
not removed by L{util._removeSafely} and a L{util._NoTrialMarker}
|
|
exception is raised instead.
|
|
"""
|
|
directory = self.mktemp().encode("utf-8")
|
|
os.mkdir(directory)
|
|
dirPath = filepath.FilePath(directory)
|
|
self.assertRaises(util._NoTrialMarker, util._removeSafely, dirPath)
|
|
|
|
def test_removeSafelyRemoveFailsMoveSucceeds(self) -> None:
|
|
"""
|
|
If an L{OSError} is raised while removing a path in
|
|
L{util._removeSafely}, an attempt is made to move the path to a new
|
|
name.
|
|
"""
|
|
|
|
def dummyRemove() -> None:
|
|
"""
|
|
Raise an C{OSError} to emulate the branch of L{util._removeSafely}
|
|
in which path removal fails.
|
|
"""
|
|
raise OSError()
|
|
|
|
# Patch stdout so we can check the print statements in _removeSafely
|
|
out = StringIO()
|
|
self.patch(sys, "stdout", out)
|
|
|
|
# Set up a trial directory with a _trial_marker
|
|
directory = self.mktemp().encode("utf-8")
|
|
os.mkdir(directory)
|
|
dirPath = filepath.FilePath(directory)
|
|
dirPath.child(b"_trial_marker").touch()
|
|
# Ensure that path.remove() raises an OSError
|
|
dirPath.remove = dummyRemove # type: ignore[method-assign]
|
|
|
|
util._removeSafely(dirPath)
|
|
self.assertIn("could not remove FilePath", out.getvalue())
|
|
|
|
def test_removeSafelyRemoveFailsMoveFails(self) -> None:
|
|
"""
|
|
If an L{OSError} is raised while removing a path in
|
|
L{util._removeSafely}, an attempt is made to move the path to a new
|
|
name. If that attempt fails, the L{OSError} is re-raised.
|
|
"""
|
|
|
|
def dummyRemove() -> None:
|
|
"""
|
|
Raise an C{OSError} to emulate the branch of L{util._removeSafely}
|
|
in which path removal fails.
|
|
"""
|
|
raise OSError("path removal failed")
|
|
|
|
def dummyMoveTo(destination: object, followLinks: bool = True) -> None:
|
|
"""
|
|
Raise an C{OSError} to emulate the branch of L{util._removeSafely}
|
|
in which path movement fails.
|
|
"""
|
|
raise OSError("path movement failed")
|
|
|
|
# Patch stdout so we can check the print statements in _removeSafely
|
|
out = StringIO()
|
|
self.patch(sys, "stdout", out)
|
|
|
|
# Set up a trial directory with a _trial_marker
|
|
directory = self.mktemp().encode("utf-8")
|
|
os.mkdir(directory)
|
|
dirPath = filepath.FilePath(directory)
|
|
dirPath.child(b"_trial_marker").touch()
|
|
|
|
# Ensure that path.remove() and path.moveTo() both raise OSErrors
|
|
dirPath.remove = dummyRemove # type: ignore[method-assign]
|
|
dirPath.moveTo = dummyMoveTo # type: ignore[method-assign]
|
|
|
|
error = self.assertRaises(OSError, util._removeSafely, dirPath)
|
|
self.assertEqual(str(error), "path movement failed")
|
|
self.assertIn("could not remove FilePath", out.getvalue())
|
|
|
|
|
|
class ExcInfoTests(SynchronousTestCase):
|
|
"""
|
|
Tests for L{excInfoOrFailureToExcInfo}.
|
|
"""
|
|
|
|
def test_excInfo(self) -> None:
|
|
"""
|
|
L{excInfoOrFailureToExcInfo} returns exactly what it is passed, if it is
|
|
passed a tuple like the one returned by L{sys.exc_info}.
|
|
"""
|
|
info = (ValueError, ValueError("foo"), None)
|
|
self.assertTrue(info is excInfoOrFailureToExcInfo(info))
|
|
|
|
def test_failure(self) -> None:
|
|
"""
|
|
When called with a L{Failure} instance, L{excInfoOrFailureToExcInfo}
|
|
returns a tuple like the one returned by L{sys.exc_info}, with the
|
|
elements taken from the type, value, and traceback of the failure.
|
|
"""
|
|
try:
|
|
1 / 0
|
|
except BaseException:
|
|
f = Failure()
|
|
self.assertEqual((f.type, f.value, f.tb), excInfoOrFailureToExcInfo(f))
|
|
|
|
|
|
class AcquireAttributeTests(SynchronousTestCase):
|
|
"""
|
|
Tests for L{acquireAttribute}.
|
|
"""
|
|
|
|
def test_foundOnEarlierObject(self) -> None:
|
|
"""
|
|
The value returned by L{acquireAttribute} is the value of the requested
|
|
attribute on the first object in the list passed in which has that
|
|
attribute.
|
|
"""
|
|
self.value = value = object()
|
|
self.assertTrue(value is acquireAttribute([self, object()], "value"))
|
|
|
|
def test_foundOnLaterObject(self) -> None:
|
|
"""
|
|
The same as L{test_foundOnEarlierObject}, but for the case where the 2nd
|
|
element in the object list has the attribute and the first does not.
|
|
"""
|
|
self.value = value = object()
|
|
self.assertTrue(value is acquireAttribute([object(), self], "value"))
|
|
|
|
def test_notFoundException(self) -> None:
|
|
"""
|
|
If none of the objects passed in the list to L{acquireAttribute} have
|
|
the requested attribute, L{AttributeError} is raised.
|
|
"""
|
|
self.assertRaises(AttributeError, acquireAttribute, [object()], "foo")
|
|
|
|
def test_notFoundDefault(self) -> None:
|
|
"""
|
|
If none of the objects passed in the list to L{acquireAttribute} have
|
|
the requested attribute and a default value is given, the default value
|
|
is returned.
|
|
"""
|
|
default = object()
|
|
self.assertTrue(default is acquireAttribute([object()], "foo", default))
|
|
|
|
|
|
class ListToPhraseTests(SynchronousTestCase):
|
|
"""
|
|
Input is transformed into a string representation of the list,
|
|
with each item separated by delimiter (defaulting to a comma) and the final
|
|
two being separated by a final delimiter.
|
|
"""
|
|
|
|
def test_empty(self) -> None:
|
|
"""
|
|
If things is empty, an empty string is returned.
|
|
"""
|
|
sample: list[None] = []
|
|
expected = ""
|
|
result = util._listToPhrase(sample, "and")
|
|
self.assertEqual(expected, result)
|
|
|
|
def test_oneWord(self) -> None:
|
|
"""
|
|
With a single item, the item is returned.
|
|
"""
|
|
sample = ["One"]
|
|
expected = "One"
|
|
result = util._listToPhrase(sample, "and")
|
|
self.assertEqual(expected, result)
|
|
|
|
def test_twoWords(self) -> None:
|
|
"""
|
|
Two words are separated by the final delimiter.
|
|
"""
|
|
sample = ["One", "Two"]
|
|
expected = "One and Two"
|
|
result = util._listToPhrase(sample, "and")
|
|
self.assertEqual(expected, result)
|
|
|
|
def test_threeWords(self) -> None:
|
|
"""
|
|
With more than two words, the first two are separated by the delimiter.
|
|
"""
|
|
sample = ["One", "Two", "Three"]
|
|
expected = "One, Two, and Three"
|
|
result = util._listToPhrase(sample, "and")
|
|
self.assertEqual(expected, result)
|
|
|
|
def test_fourWords(self) -> None:
|
|
"""
|
|
If a delimiter is specified, it is used instead of the default comma.
|
|
"""
|
|
sample = ["One", "Two", "Three", "Four"]
|
|
expected = "One; Two; Three; or Four"
|
|
result = util._listToPhrase(sample, "or", delimiter="; ")
|
|
self.assertEqual(expected, result)
|
|
|
|
def test_notString(self) -> None:
|
|
"""
|
|
If something in things is not a string, it is converted into one.
|
|
"""
|
|
sample = [1, 2, "three"]
|
|
expected = "1, 2, and three"
|
|
result = util._listToPhrase(sample, "and")
|
|
self.assertEqual(expected, result)
|
|
|
|
def test_stringTypeError(self) -> None:
|
|
"""
|
|
If things is a string, a TypeError is raised.
|
|
"""
|
|
sample = "One, two, three"
|
|
error = self.assertRaises(TypeError, util._listToPhrase, sample, "and")
|
|
self.assertEqual(str(error), "Things must be a list or a tuple")
|
|
|
|
def test_iteratorTypeError(self) -> None:
|
|
"""
|
|
If things is an iterator, a TypeError is raised.
|
|
"""
|
|
sample = iter([1, 2, 3])
|
|
error = self.assertRaises(TypeError, util._listToPhrase, sample, "and")
|
|
self.assertEqual(str(error), "Things must be a list or a tuple")
|
|
|
|
def test_generatorTypeError(self) -> None:
|
|
"""
|
|
If things is a generator, a TypeError is raised.
|
|
"""
|
|
|
|
def sample() -> Generator[int, None, None]:
|
|
yield from range(2)
|
|
|
|
error = self.assertRaises(TypeError, util._listToPhrase, sample, "and")
|
|
self.assertEqual(str(error), "Things must be a list or a tuple")
|
|
|
|
|
|
class OpenTestLogTests(SynchronousTestCase):
|
|
"""
|
|
Tests for C{openTestLog}.
|
|
"""
|
|
|
|
def test_utf8(self) -> None:
|
|
"""
|
|
The log file is opened in text mode and uses UTF-8 for encoding.
|
|
"""
|
|
# Modern OSes are running default locale in UTF-8 and this is what is
|
|
# used by Python at startup. For this test, we force an ASCII default
|
|
# encoding so that we can see that UTF-8 is used even if it isn't the
|
|
# platform default.
|
|
currentLocale = locale.getlocale()
|
|
self.addCleanup(locale.setlocale, locale.LC_ALL, currentLocale)
|
|
locale.setlocale(locale.LC_ALL, ("C", "ascii"))
|
|
|
|
text = "Here comes the \N{SUN}"
|
|
p = filepath.FilePath(self.mktemp())
|
|
with openTestLog(p) as f:
|
|
f.write(text)
|
|
|
|
with open(p.path, "rb") as f:
|
|
written = f.read()
|
|
|
|
assert_that(text.encode("utf-8"), equal_to(written))
|
|
|
|
def test_append(self) -> None:
|
|
"""
|
|
The log file is opened in append mode so if runner configuration specifies
|
|
an existing log file its contents are not wiped out.
|
|
"""
|
|
existingText = "Hello, world.\n "
|
|
newText = "Goodbye, world.\n"
|
|
expected = f"Hello, world.{os.linesep} Goodbye, world.{os.linesep}"
|
|
p = filepath.FilePath(self.mktemp())
|
|
with openTestLog(p) as f:
|
|
f.write(existingText)
|
|
with openTestLog(p) as f:
|
|
f.write(newText)
|
|
|
|
assert_that(
|
|
p.getContent().decode("utf-8"),
|
|
equal_to(expected),
|
|
)
|