def test_encode_multipart_data_produces_bytes(self):
data = {
factory.make_string(): factory.make_string().encode('ascii'),
}
files = {
factory.make_string(): (
BytesIO(factory.make_string().encode('ascii'))),
}
body, headers = encode_multipart_data(data, files)
self.assertIsInstance(body, bytes)
def test__returns_standard_output(self):
output = factory.make_string().encode("ascii")
self.assertEqual(output, call_and_check(['/bin/echo', '-n', output]))
def test__compares_in_text_mode_when_encoding_supplied(self):
contents = factory.make_string() # text
filename = self.make_file(contents=contents.encode("ascii"))
self.assertThat(filename,
FileContains(contents=contents, encoding="ascii"))
def test__returns_none_if_attribute_exists(self):
attribute = factory.make_string(3, prefix="attr")
setattr(self, attribute, factory.make_name("value"))
matcher = HasAttribute(attribute)
result = matcher.match(self)
self.assertIsNone(result)
def test_exits_when_file_has_no_options_block(self):
content = factory.make_string()
self.assertContentFailsWithMessage(content,
"Can't find options {} block")
def test_read_snippet_reads_snippet_file(self):
contents = factory.make_string()
snippet = self.make_file(contents=contents)
self.assertEqual(
contents,
read_snippet(os.path.dirname(snippet), os.path.basename(snippet)))
def test_doesnt_affect_general_logger_class(self):
self.patch(logging, 'Formatter')
name = factory.make_string()
get_maas_logger(name)
self.assertIsNot(MAASLogger, logging.getLoggerClass())
def test_sets_logger_name(self):
self.patch(_maaslog, 'SysLogHandler')
self.patch(logging, 'Formatter')
name = factory.make_string()
maaslog = get_maas_logger(name)
self.assertEqual("maas.%s" % name, maaslog.name)
def test_rejects_non_bytes_contents(self):
self.assertRaises(TypeError, sudo_write_file, self.make_file(),
factory.make_string())
def test_atomic_write_rejects_non_bytes_contents(self):
self.assertRaises(TypeError, atomic_write, factory.make_string(),
factory.make_string())
def test_report_power_state_reports_all_exceptions(self):
logger_twisted = self.useFixture(TwistedLoggerFixture())
logger_maaslog = self.useFixture(FakeLogger("maas"))
# Avoid threads here.
self.patch(power, "deferToThread", maybeDeferred)
exception_type = factory.make_exception_type()
exception_message = factory.make_string()
exception = exception_type(exception_message)
# Pretend the query always fails with `exception`.
query = self.patch_autospec(power, self.func)
query.side_effect = always_fail_with(exception)
# Intercept calls to power_state_update() and send_node_event().
power_state_update = self.patch_autospec(power, "power_state_update")
power_state_update.return_value = succeed(None)
send_node_event = self.patch_autospec(power, "send_node_event")
send_node_event.return_value = succeed(None)
self.patch(self.power_driver,
"detect_missing_packages").return_value = []
system_id = factory.make_name("system_id")
hostname = factory.make_name("hostname")
context = sentinel.context
clock = Clock()
d = power.get_power_state(system_id, hostname, self.power_type,
context, clock)
d = power.report_power_state(d, system_id, hostname)
# Crank through some number of retries.
for wait in self.waits:
self.assertFalse(d.called)
clock.advance(wait)
self.assertTrue(d.called)
# Finally the exception from the query is raised.
self.assertRaises(exception_type, extract_result, d)
# The broken power query function patched earlier was called the same
# number of times as there are steps in the default waiting policy.
expected_call = call(system_id, hostname, self.power_type, context)
expected_calls = [expected_call] * self.calls
self.assertThat(query, MockCallsMatch(*expected_calls))
expected_message = "%s: Power state could not be queried: %s" % (
hostname,
exception_message,
)
# An attempt was made to report the failure to the region.
self.assertThat(power_state_update,
MockCalledOnceWith(system_id, "error"))
# An attempt was made to log a node event with details.
self.assertThat(
send_node_event,
MockCalledOnceWith(
EVENT_TYPES.NODE_POWER_QUERY_FAILED,
system_id,
hostname,
exception_message,
),
)
# Nothing was logged to the Twisted log.
self.assertEqual("", logger_twisted.output)
# A brief message is written to maaslog.
self.assertEqual(expected_message + "\n", logger_maaslog.output)
def test_mismatching_content_is_compared_False(self):
content = factory.make_string()
storage, meta_file = self.make_meta_file()
self.assertFalse(boot_resources.meta_contains(storage, content))
def test_accepts_all_args(self):
all_test_arguments = cluster_config_command.all_arguments
default_arg_values = {
"--region-url": None,
"--uuid": None,
"--init": False,
"--tftp-port": None,
"--tftp-root": None,
"--debug": None,
}
failures = {}
# Try all cardinalities of combinations of arguments
for r in range(len(all_test_arguments) + 1):
for test_arg_names in combinations(all_test_arguments, r):
test_values = {
"--region-url": factory.make_simple_http_url(),
"--uuid": str(uuid.uuid4()),
"--init": "",
"--tftp-port": str(factory.pick_port()),
"--tftp-root": factory.make_string(),
"--debug": str(factory.pick_bool()),
}
# Build a query dictionary for the given combination of args
args_under_test = []
for param_name in test_arg_names:
args_under_test.append(param_name)
if param_name != "--init":
args_under_test.append(test_values[param_name])
parser = ArgumentParser()
cluster_config_command.add_arguments(parser)
# If both init and uuid are passed, argparse will generate
# a nice ArgumentError exception, which unfortunately,
# gets caught and sent to exit.
if "--init" in test_arg_names and "--uuid" in test_arg_names:
expected_exception = ExpectedException(SystemExit, "2")
with expected_exception, patch("sys.stderr"):
parser.parse_known_args(args_under_test)
else:
# Otherwise, parsed args with defaults as usual
observed_args = vars(parser.parse_args(args_under_test))
expected_args = {}
for param_name in all_test_arguments:
parsed_param_name = param_name[2:].replace("-", "_")
if param_name not in test_arg_names:
expected_args[
parsed_param_name] = default_arg_values[
param_name]
else:
expected_args[parsed_param_name] = observed_args[
parsed_param_name]
if expected_args != observed_args:
failures[str(test_arg_names)] = {
"expected_args": expected_args,
"observed_args": observed_args,
}
error_message = io.StringIO()
error_message.write("One or more key / value argument list(s)"
"passed in the query string (expected_args)"
"to the API do not match the values in "
"the returned query string. This "
"means that some arguments were "
"dropped / added / changed by the "
"the function, which is incorrect "
"behavior. The list of incorrect "
"arguments is as follows: \n")
pp = pprint.PrettyPrinter(depth=3, stream=error_message)
pp.pprint(failures)
self.assertDictEqual({}, failures, error_message.getvalue())
def test__first_encrypt_caches_psk(self):
self.write_secret()
self.assertIsNone(security._fernet_psk)
testdata = factory.make_string()
fernet_encrypt_psk(testdata)
self.assertIsNotNone(security._fernet_psk)
def test_encode_multipart_data_closes_with_closing_boundary_line(self):
data = {"foo": factory.make_string().encode("ascii")}
files = {"bar": BytesIO(factory.make_string().encode("ascii"))}
body, headers = encode_multipart_data(data, files)
self.assertTrue(body.endswith("--"))
def test_encode_multipart_data_closes_with_closing_boundary_line(self):
data = {b'foo': factory.make_string().encode('ascii')}
files = {b'bar': BytesIO(factory.make_string().encode('ascii'))}
body, headers = encode_multipart_data(data, files)
self.assertThat(body, EndsWith(b'--'))
def test_deferredDHCPRequestErrback_ignores_cancelled(self):
logger = self.useFixture(TwistedLoggerFixture())
monitor = DHCPRequestMonitor("lo")
error = factory.make_string()
monitor.deferredDHCPRequestErrback(make_Failure(CancelledError, error))
self.assertThat(logger.output, DocTestMatches(""))
def test_uses_prefix(self):
prefix = factory.make_string(3)
with tempdir(prefix=prefix) as directory:
pass
self.assertThat(os.path.basename(directory), StartsWith(prefix))
def test_returns_MAASLogger_instances(self):
self.patch(_maaslog, 'SysLogHandler')
self.patch(logging, 'Formatter')
name = factory.make_string()
maaslog = get_maas_logger(name)
self.assertIsInstance(maaslog, MAASLogger)
def test_uses_suffix(self):
suffix = factory.make_string(3)
with tempdir(suffix=suffix) as directory:
pass
self.assertThat(os.path.basename(directory), EndsWith(suffix))
def test_general_logger_class_accepts_exceptions(self):
self.patch(logging, 'Formatter')
name = factory.make_string()
get_maas_logger(name)
other_logger = logging.getLogger()
self.assertIsNone(other_logger.exception(factory.make_string()))
def test_reads_file(self):
text = factory.make_string()
self.assertEqual(text, read_text_file(self.make_file(contents=text)))
def test_strip_name_leaves_simple_names_intact(self):
simple_name = factory.make_string()
self.assertEqual(simple_name, strip_name(simple_name))
def test_creates_file(self):
path = os.path.join(self.make_dir(), factory.make_name('text'))
text = factory.make_string()
write_text_file(path, text)
self.assertThat(path, FileContains(text, encoding="ascii"))
def test_write_config_errors_if_unexpected_exception(self):
dnsconfig = DNSConfig()
exception = IOError(errno.EBUSY, factory.make_string())
self.patch(config, "atomic_write", Mock(side_effect=exception))
self.assertRaises(IOError, dnsconfig.write_config)
def test_overwrites_file(self):
path = self.make_file(contents="original text")
text = factory.make_string()
write_text_file(path, text)
self.assertThat(path, FileContains(text, encoding="ascii"))
def test__returns_mismatch_if_attribute_does_not_exist(self):
attribute = factory.make_string(3, prefix="attr")
matcher = HasAttribute(attribute)
result = matcher.match(self)
self.assertMismatch(result,
" does not have a %r attribute" % attribute)
def test_atomic_write_overwrites_dest_file(self):
content = factory.make_bytes()
filename = self.make_file(contents=factory.make_string())
atomic_write(content, filename)
self.assertThat(filename, FileContains(content))
def test_matches_equal_strings(self):
contents = factory.make_string()
self.assertThat(contents, TextEquals(contents))
def test_atomic_write_writes_file_if_no_file_present(self):
filename = os.path.join(self.make_dir(), factory.make_string())
content = factory.make_bytes()
atomic_write(content, filename, overwrite=False)
self.assertThat(filename, FileContains(content))
def test_deletes_maas_id_file(self):
self.useFixture(MAASIDFixture(factory.make_string()))
url = factory.make_simple_http_url()
secret = factory.make_bytes()
register_command.run(self.make_args(url=url, secret=to_hex(secret)))
self.assertIsNone(get_maas_id())
def test_Redirect_produces_redirect_to_given_URL(self):
target = factory.make_string()
exception = Redirect(target)
response = exception.make_http_response()
self.assertEqual(target, extract_redirect(response))