def test_SetArgsBasic_sets_the_args_to_the_plugin(self):
plugin = self._get_plugin_example()
args = {"arg1": "val1", "arg2": "val2"}
self.plugin_params.Args = args
assert_that(self.plugin_params.SetArgsBasic(args, plugin), equal_to([args]))
assert_that(plugin["Args"], matches_regexp(".*arg1=val1.*"))
assert_that(plugin["Args"], matches_regexp(".*arg2=val2.*"))
def test_RunCommandList_runs_more_than_one_command_in_a_shell(self):
output = self.interactive_shell.RunCommandList(['pwd', "echo 1234"])
pwd_expected = self.get_abs_path(".")
echo_expected = "1234"
assert_that(output, matches_regexp(pwd_expected))
assert_that(output, matches_regexp(echo_expected))
def test_SetArgsBasic_sets_the_args_to_the_plugin(self):
plugin = self._get_plugin_example()
args = {"arg1": "val1", "arg2": "val2"}
self.plugin_params.Args = args
assert_that(self.plugin_params.SetArgsBasic(args, plugin),
equal_to([args]))
assert_that(plugin["Args"], matches_regexp(".*arg1=val1.*"))
assert_that(plugin["Args"], matches_regexp(".*arg2=val2.*"))
def test_shell_exec_monitor_runs_a_command_logging_the_output(self):
stream = StreamMock()
self.redirect_logging_to_stream(stream)
command = 'pwd'
expected_command_output = self.get_abs_path(".")
expected_time_logging_message = "Execution Start Date/Time"
command_output = self.shell.shell_exec_monitor(command)
assert_that(command_output, matches_regexp(expected_command_output))
assert_that(stream.get_content(), matches_regexp(expected_time_logging_message))
assert_that(stream.get_content(), matches_regexp(expected_command_output))
def test_get_image_info(self):
datastore = self._find_configured_datastore_in_host_config()
request = ImageInfoRequest(image_id="ttylinux",
datastore_id=datastore.id)
response = self.host_client.get_image_info(request)
assert_that(response.result, is_(ImageInfoResultCode.OK))
assert_that(response.image_info.tombstone, is_(False))
if response.image_info.last_updated_time != NEVER_UPDATED:
assert_that(response.image_info.last_updated_time, matches_regexp(
self.REGEX_TIME)
)
assert_that(response.image_info.created_time, matches_regexp(
self.REGEX_TIME)
)
assert_that(response.image_info.vm_ids, has_length(
response.image_info.ref_count))
assert_that(response.image_info.type, is_(ImageType.CLOUD))
assert_that(response.image_info.replication, is_(
ImageReplication.EAGER))
vm_wrapper = VmWrapper(self.host_client)
image = DiskImage("ttylinux", CloneType.COPY_ON_WRITE)
disks = [
Disk(new_id(), self.DEFAULT_DISK_FLAVOR.name, False, True,
image=image,
capacity_gb=0, flavor_info=self.DEFAULT_DISK_FLAVOR),
]
reservation = \
vm_wrapper.place_and_reserve(vm_disks=disks).reservation
request = vm_wrapper.create_request(res_id=reservation)
response = vm_wrapper.create(request=request)
assert_that(response.vm, not_none())
request = ImageInfoRequest(image_id="ttylinux",
datastore_id=datastore.id)
response = self.host_client.get_image_info(request)
assert_that(response.result, is_(ImageInfoResultCode.OK))
assert_that(response.image_info.tombstone, is_(False))
assert_that(len(response.image_info.vm_ids),
is_(response.image_info.ref_count))
assert_that(response.image_info.vm_ids, has_length(
response.image_info.ref_count))
vm_wrapper.delete(request=vm_wrapper.delete_request(disk_ids=[]))
def _validate_datastore_id(self, datastore_id):
""" Check if id is in one of the expected formats. """
# standard uuids are 36 chars
# vmfs volume uuids are 35 chars
# nfs volume uuids are 17 chars
assert_that(datastore_id, matches_regexp("^[0-9a-f-]+$"))
assert_that(len(datastore_id),
any_of(equal_to(17), equal_to(35), equal_to(36)))
def correctly_ordered(ordering, docs_by_name):
seen = set()
elems = []
is_rev = matches_regexp(r"(\d+)-[a-fA-F0-9]{32}")
for name in ordering:
if name not in seen:
docid = docs_by_name[name]["_id"]
elems.append(has_entries({"id": docid, "rev": is_rev}))
seen.add(name)
else:
elems.append(has_entry("error", "conflict"))
return contains(*tuple(elems))
def test_get_vm_path(self):
vm_wrapper = VmWrapper(self.host_client)
# create a vm without disk
reservation = vm_wrapper.place_and_reserve().reservation
request = vm_wrapper.create_request(res_id=reservation)
vm_wrapper.create(request=request)
find_response = vm_wrapper.find()
vm_id = vm_wrapper.id
assert_that(find_response.path,
matches_regexp("\[.*\] vms/%s/%s/%s\.vmx" %
(vm_id[0:2], vm_id, vm_id)))
def test_get_host_config(self):
"""Test that the agent responds with Host configuration"""
request = Host.GetConfigRequest()
response = self.host_client.get_host_config(request)
assert_that(response.hostConfig.agent_id,
matches_regexp("[0-9a-f-]{36}"))
datastores = response.hostConfig.datastores
assert_that(datastores, has_length(len(self.get_all_datastores())))
for datastore in datastores:
assert_that(self.get_all_datastores(), has_item(datastore.name))
assert_that(datastore.type, not_none())
self._validate_datastore_id(datastores[0].id)
assert_that(response.hostConfig.networks, not_none())
vm_networks = [network for network in response.hostConfig.networks
if NetworkType.VM in network.types]
assert_that(len(vm_networks), greater_than_or_equal_to(1))
def test_Run_command_in_a_shell(self):
output = self.interactive_shell.Run('pwd')
expected = self.get_abs_path(".")
assert_that(output, matches_regexp(expected))
def test_get_abs_path(self):
relative_path = "test_cases/resources" # Relative to owtf/tests directory
abs_path = self.get_abs_path(relative_path)
assert_that(abs_path, matches_regexp("/(.+/)*" + relative_path + "/?"))
def assert_that_output_matches_more_than(self, regex, times):
"""Assert that the output matches a given regular expression a specified number of times."""
assert_that(self.owtf_output, matches_regexp(regex))
if times is not None:
times_replaced = self._get_number_of_occurences_for(regex)
assert_that(times_replaced, greater_than_or_equal_to(times))
def is_timestamp():
return match_equality(matches_regexp(TIMESTAMP_PATTERN))
def assert_that_output_matches_more_than(self, regex, times):
"""Assert that the output matches a given regular expression a specified number of times."""
assert_that(self.owtf_output, matches_regexp(regex))
if times is not None:
times_replaced = self._get_number_of_occurences_for(regex)
assert_that(times_replaced, greater_than_or_equal_to(times))
def test_get_abs_path(self):
relative_path = "test_cases/resources" # Relative to owtf/tests directory
abs_path = self.get_abs_path(relative_path)
assert_that(abs_path, matches_regexp("/(.+/)*" + relative_path + "/?"))
def test_streaming_different_file_types(self):
dir = self._new_tempdir()
input = iter(WriteFilesTest.SIMPLE_COLLECTION)
ts = (TestStream().advance_watermark_to(0).add_elements(
[next(input), next(input)]).advance_watermark_to(10).add_elements(
[next(input),
next(input)]).advance_watermark_to(20).add_elements([
next(input), next(input)
]).advance_watermark_to(30).add_elements([
next(input), next(input)
]).advance_watermark_to(40).advance_watermark_to_infinity())
def no_colon_file_naming(*args):
file_name = fileio.destination_prefix_naming()(*args)
return file_name.replace(':', '_')
with TestPipeline() as p:
_ = (p
| ts
| beam.WindowInto(FixedWindows(10))
| beam.io.fileio.WriteToFiles(
path=dir,
destination=lambda record: record['foundation'],
sink=lambda dest:
(WriteFilesTest.CsvSink(WriteFilesTest.CSV_HEADERS)
if dest == 'apache' else WriteFilesTest.JsonSink()),
file_naming=no_colon_file_naming,
max_writers_per_bundle=0,
))
with TestPipeline() as p:
cncf_files = (p
| fileio.MatchFiles(FileSystems.join(dir, 'cncf*'))
| "CncfFileNames" >> beam.Map(lambda fm: fm.path))
apache_files = (p
| "MatchApache" >> fileio.MatchFiles(
FileSystems.join(dir, 'apache*'))
|
"ApacheFileNames" >> beam.Map(lambda fm: fm.path))
assert_that(
cncf_files,
matches_all([
stringmatches.matches_regexp(
'.*cncf-1970-01-01T00_00_00-1970-01-01T00_00_10--.*'),
stringmatches.matches_regexp(
'.*cncf-1970-01-01T00_00_10-1970-01-01T00_00_20--.*'),
stringmatches.matches_regexp(
'.*cncf-1970-01-01T00_00_20-1970-01-01T00_00_30--.*'),
stringmatches.matches_regexp(
'.*cncf-1970-01-01T00_00_30-1970-01-01T00_00_40--.*')
]),
label='verifyCNCFFiles')
assert_that(
apache_files,
matches_all([
stringmatches.matches_regexp(
'.*apache-1970-01-01T00_00_00-1970-01-01T00_00_10--.*'
),
stringmatches.matches_regexp(
'.*apache-1970-01-01T00_00_10-1970-01-01T00_00_20--.*'
),
stringmatches.matches_regexp(
'.*apache-1970-01-01T00_00_20-1970-01-01T00_00_30--.*'
),
stringmatches.matches_regexp(
'.*apache-1970-01-01T00_00_30-1970-01-01T00_00_40--.*')
]),
label='verifyApacheFiles')
import sys
sys.path.insert(0, "..")
sys.path.insert(0, "../..")
import re
import unittest
from hamcrest.library.text.stringmatches import matches_regexp
from hamcrest_unit_test.matcher_test import MatcherTest
__author__ = "Chris Rose"
__copyright__ = "Copyright 2011 hamcrest.org"
__license__ = "BSD, see License.txt"
string_matcher = matches_regexp(r"--[a-z]+--")
compiled_matcher = matches_regexp(re.compile(r"--[a-z]+--"))
class StringMatchesTest(MatcherTest):
def testMatchesWhenPatternIsFoundAtBeginning(self):
self.assert_matches("pattern at beginning", string_matcher, "--a-----")
def testMatchesWhenPatternIsFoundAtEnd(self):
self.assert_matches("pattern at end", string_matcher, "-----a--")
def testMatchesWhenPatternIsFoundInMiddle(self):
self.assert_matches("pattern in the middle", string_matcher,
"-----a-----")
def testMismatchesWhenPatternIsNotPresent(self):