def test():
"""
Verify we can make firewalls non-fatal
"""
# get the journal
import journal
# make a firewall channel
channel = journal.firewall(name="tests.journal.firewall")
# make it non-fatal
channel.fatal = False
# send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# carefully
try:
# inject
channel.line("firewall:")
channel.log(" a nasty bug was detected")
# if the correct exception was raised
except channel.FirewallError as error:
# shouldn't get here
assert False, "unreachable"
# all done
return
def test():
"""
Exercise a channel with a realistic example when the channel is fatal
"""
# the journal
import journal
# make a channel
channel = journal.debug(name="tests.journal.debug")
# activate it
channel.active = True
# make it fatal
channel.fatal = True
# but send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# we asked for this to be fatal, so carefully
try:
# inject something
channel.line("debug channel:")
channel.log(" hello world!")
# this should be unreachable
assert False, "unreachable"
# if all goes well, the channel raised an error
except channel.DebugError:
# all good
pass
# all done
return
def test():
"""
Verify that the channel buffers are cleared after flushing a message; this is a non-trivial
test because it guarantees that the implementation handles the transaction correctly
"""
# get the journal
import journal
# make a channel
channel = journal.error(name="test.journal.error")
# send the output to the trash
channel.device = journal.trash()
# carefully
try:
# inject
channel.log("hello world!")
# shouldn't get here
assert False, "unreachable"
# if the correct exception was raised
except channel.ApplicationError as error:
# no problem
pass
# verify that the buffer is empty after the flush
assert len(channel.page) == 0
# all done
return
def test():
"""
Exercise the common use case
"""
# get the journal
import journal
# make a channel
channel = journal.firewall(name="test.journal.firewall")
# send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# carefully
try:
# inject
channel.line("firewall:")
channel.log(" a nasty bug was detected")
# shouldn't get here
assert False, "unreachable"
# if the correct exception was raised
except channel.FirewallError as error:
# check the description
assert str(error) == "test.journal.firewall: FIREWALL BREACHED!"
# all done
return
def test():
"""
Verify that channels lower in the hierarchy inherit their parent default state
"""
# get the journal
import journal
# make a channel
parent = journal.error(name="test.index.parent")
# verify that the state is off
assert parent.active is True
# that it is fatal
assert parent.fatal is True
# and the device is at the default value
assert parent.device is parent.chronicler.device
# deactivate it
parent.active = False
# make it non fatal
parent.fatal = False
# set the device to a trash can
parent.device = journal.trash()
# lookup a name that is lower in the hierarchy
child = journal.error(name="test.index.parent.blah.blah.child")
# that its state is the same as the parent
assert child.active == parent.active
assert child.fatal == parent.fatal
# and that it inherited the device correctly
assert child.device is parent.device
# all done
return
def test():
"""
Exercise the channel with a realistic example when it is fatal
"""
# get the journal
import journal
# make a channel
channel = journal.warning(name="tests.journal.warning")
# make it fatal
channel.fatal = True
# send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# we asked for this to be fatal, so carefully
try:
# inject something
channel.line("warning channel:")
channel.log(" hello world!")
# this should be unreachable
assert False, "unreachable"
# if all goes well
except channel.ApplicationError:
# all good
pass
# all done
return
def test():
"""
Exercise the usual test case
"""
# get the journal
import journal
# make a channel
channel = journal.error(name="test.journal.error")
# send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# carefully
try:
# inject
channel.line("error:")
channel.log(" a nasty bug was detected")
# shouldn't get here
assert False, "unreachable"
# if the correct exception was raised
except channel.ApplicationError as error:
# check the description
assert str(error) == "test.journal.error: application error"
# all done
return
def test():
"""
Verify that flushing clears the message buffers
"""
# get the journal
import journal
# make a channel
channel = journal.firewall(name="test.journal.firewall")
# send the output to the trash
channel.device = journal.trash()
# carefully
try:
# inject
channel.log("hello world!")
# shouldn't get here
assert False, "unreachable"
# if the correct exception was raised
except channel.FirewallError as error:
# no problem
pass
# verify that the buffer is empty after the flush
assert len(channel.page) == 0
# all done
return
def test():
"""
Exercise the usual test case with an non-fatal channel
"""
# get the journal
import journal
# make an error channel
channel = journal.error(name="tests.journal.error")
# make it non-fatal
channel.fatal = False
# send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# carefully
try:
# inject
channel.line("error channel:")
channel.log(" hello world!")
# if the correct exception was raised
except channel.ApplicationError as error:
# shouldn't get here
assert False, "unreachable"
# all done
return
def test():
"""
Verify access to the channel properties
"""
# access
import journal
# make a channel
channel = journal.warning("test.channel")
# verify its name
assert channel.name == "test.channel"
# check that it is read-only
try:
# by attempting to modify
channel.name = "foo"
# hence, we can't get here
assert False, "unreachable"
# if all goes well
except AttributeError as error:
# no problem
pass
# verify its verbosity is at 1 by default
assert channel.verbosity == 1
# that it can be modified
channel.verbosity = 5
# and the assignment sticks
assert channel.verbosity == 5
# verify its activation state is on by default
assert channel.active is True
# that it can be modified
channel.active = False
# and the assignment sticks
assert channel.active is False
# verify its not fatal
assert channel.fatal is False
# that it can be modified
channel.fatal = True
# and the assignment sticks
assert channel.fatal is True
# verify that the accessible device is the console
assert channel.device.name == "cout"
# make a trash can
trash = journal.trash()
# register it as the device
channel.device = trash
# and verify that the assignment sticks
assert channel.device is trash
# check the name
assert channel.device.name == "trash"
# and verify that it's different from the default device held by the class
assert channel.device is not channel.defaultDevice
# all done
return
def test():
"""
Exercise adding multiple lines at once
"""
# get the journal
import journal
# make a channel
channel = journal.error(name="test.journal.error")
# activate it
channel.activate()
# but send the output to trash
channel.device = journal.trash()
# content in a tuple
reptuple = (
"report from tuple:",
" tuple line 1",
" tuple line 2",
)
# content in a list
replist = [
"report from list:",
" list line 1",
" list line 2",
]
# content in a generator
def repgen():
yield "report from generator:"
yield " generator line 1"
yield " generator line 2"
return
# carefully
try:
# inject
channel.report(report=reptuple)
channel.report(report=replist)
channel.report(report=repgen())
# flush
channel.log()
# shouldn't get here
assert False, "unreachable"
# if the correct exception was raised
except channel.ApplicationError as error:
# check the description
assert str(error) == "test.journal.error: application error"
# all done
return
def test():
"""
Verify that the trash can is accessible
"""
# access
import journal
# make a trash can
trash = journal.trash()
# verify its name is what we expect
assert trash.name == "trash"
# all done
return
def test():
"""
Exercise the simplest non-trivial use case
"""
# get the journal
import journal
# make a channel
channel = journal.help(name="tests.journal.help")
# send the output to the trash
channel.device = journal.trash()
# inject
channel.log("hello world!")
# all done
return
def test():
"""
Exercise adding multiple lines at once
"""
# get the journal
import journal
# make a channel
channel = journal.debug(name="test.journal.debug")
# activate it
channel.activate()
# but send the output to trash
channel.device = journal.trash()
# content in a tuple
reptuple = (
"report from tuple:",
" tuple line 1",
" tuple line 2",
)
# content in a list
replist = [
"report from list:",
" list line 1",
" list line 2",
]
# content in a generator
def repgen():
yield "report from generator:"
yield " generator line 1"
yield " generator line 2"
return
# inject
channel.report(report=reptuple)
channel.report(report=replist)
channel.report(report=repgen())
# flush
channel.log()
# all done
return
def test():
"""
Verify that repeated access to the same channel does not accumulate extraneous material
"""
# get the journal
import journal
# make a channel
channel = journal.info(name="tests.journal.info")
# send the output to the trash
channel.device = journal.trash()
# for a few times
for _ in range(10):
# inject
channel.log("hello world!")
# all done
return
def test():
"""
Verify that we can inject simple messages correctly
"""
# get the journal
import journal
# make a channel
channel = journal.error(name="test.journal.error")
# make it non-fatal
channel.fatal = False
# send the output to the trash
channel.device = journal.trash()
# inject
channel.log("hello world!")
# all done
return
def test():
"""
Exercise the simplest non-trivial use case
"""
# get the journal
import journal
# make a channel
channel = journal.firewall(name="test.journal.firewall")
# send the output to the trash
channel.device = journal.trash()
# make the firewall non-fatal
channel.fatal = False
# inject
channel.log("hello world!")
# all done
return
def test():
"""
Verify that the channel buffers get flushed properly after {log}
"""
# get the journal
import journal
# make a channel
channel = journal.info(name="tests.journal.info")
# send the output to the trash
channel.device = journal.trash()
# inject
channel.log("hello world!")
# verify that the buffer is empty after the flush
assert len(channel.page) == 0
# all done
return
def test():
"""
Exercise the channel with a realistic example
"""
# get the journal
import journal
# make a channel
channel = journal.help(name="tests.journal.help")
# send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# inject
channel.line("help channel:")
channel.log(" hello world!")
# all done
return
def test():
"""
Exercise the common use case
"""
# get the journal
import journal
# make a channel
channel = journal.info(name="tests.journal.info")
# send the output to the trash
channel.device = journal.trash()
# add some metadata
channel.notes["time"] = "now"
# inject
channel.line("info channel:")
channel.log(" hello world!")
# all done
return
def test():
"""
Verify that content is flushed correctly when the same channel instance is used multiple times
"""
# get the journal
import journal
# make a channel
channel = journal.firewall(name="test.journal.firewall")
# make it non-fatal
channel.fatal = False
# send the output to the trash
channel.device = journal.trash()
# a few times
for _ in range(10):
# inject
channel.log("hello world!")
# all done
return
def test():
"""
Verify that content is flushed correctly when the same channel instance is used multiple times
"""
# get the journal
import journal
# make a channel
channel = journal.debug(name="test.journal.debug")
# activate it
channel.activate()
# but send the output to the trash
channel.device = journal.trash()
# for a few times
for _ in range(10):
# inject
channel.log("hello world!")
# all done
return
def test():
"""
Verify that the message buffers reset correctly after flushing
"""
# get the journal
import journal
# make a channel
channel = journal.debug(name="test.journal.debug")
# activate it
channel.activate()
# but send the output to the trash
channel.device = journal.trash()
# inject
channel.log("hello world!")
# verify that the buffer is empty after the flush
assert len(channel.page) == 0
# all done
return
def test():
"""
Verify that the channel wide defaults are as expected
"""
# access
import journal
# verify that firewall channels are active by default
assert journal.firewall.defaultActive == True
# and fatal
assert journal.firewall.defaultFatal == True
# verify that the channel default device is not set
assert journal.firewall.defaultDevice == None
# make a trash can
trash = journal.trash()
# make it the default device
journal.firewall.defaultDevice = trash
# and make sure the assignment sticks
assert journal.firewall.defaultDevice is trash
# make a channel
channel = journal.firewall("test.channel")
# verify that its view of its default state is consistent
assert channel.defaultActive == journal.firewall.defaultActive
assert channel.defaultFatal == journal.firewall.defaultFatal
# similarly for the default device
assert channel.defaultDevice == journal.firewall.defaultDevice
# and now, the instance state
assert channel.active == channel.defaultActive
assert channel.fatal == channel.defaultFatal
assert channel.device == channel.defaultDevice
# all done
return
def test():
"""
Verify that we can set the global default device
"""
# access
import journal
# get the global state
chronicler = journal.chronicler
# verify that the default device is the console
assert chronicler.device.name == "cout"
# make a trash can
trash = journal.trash()
# set it as the device
chronicler.device = trash
# verify the assignment sticks
assert chronicler.device is trash
# and that the name is correct
assert chronicler.device.name == "trash"
# all done
return
