def creates_container_from_docker_client():
expected_image = 'test_img'
expected_host_config = {}
expected_name = 'test_name'
expected_env = {}
expected_cmd = '/bin/sh -c "while true; do sleep 1000; done"'
expected_cn_id = '12345'
docker_mock = create_autospec(DockerClient, spec_set=True)
docker_mock.create_container.return_value = {'Id': expected_cn_id}
subject = Container(expected_image,
expected_host_config,
docker_mock,
name=expected_name,
env=expected_env)
docker_mock.create_container\
.assert_called_once_with(image=expected_image,
host_config=expected_host_config,
name=expected_name,
environment=expected_env,
command=expected_cmd)
assert_that(subject.id).is_equal_to(expected_cn_id)
def test_create_gallery(graphene_client: Client):
result = graphene_client.execute('''
mutation {
createGallery(name: "galleryName", public: true, position: 78) {
gallery {
galleryId
name
public
position
}
}
}
''')
assert_that(json.dumps(result)).is_equal_to_ignoring_whitespace('''
{
"data": {
"createGallery": {
"gallery": {
"galleryId": 1,
"name": "galleryName",
"public": true,
"position": 78
}
}
}
}''')
gallery = Gallery.query.get(1)
assert_that(gallery.id).is_equal_to(1)
assert_that(gallery.name).is_equal_to('galleryName')
assert_that(gallery.public).is_true()
assert_that(gallery.position).is_equal_to(78)
def test_is_after_failure(self):
try:
d2 = datetime.datetime.today()
assert_that(self.d1).is_after(d2)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}> to be after <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}>, but was not.')
def test_valid(self):
msg = CommandMessage(original_text='.count ham',
text='ham',
sender='123_homer@localhost/Oklahomer')
assert_that(hipchat_count(msg, {})) \
.described_as(".count command increments count") \
.is_equal_to('1')
def test_is_equal_to_ignoring_milliseconds_failure(self):
try:
d2 = datetime.datetime.today() + datetime.timedelta(days=1)
assert_that(self.d1).is_equal_to_ignoring_milliseconds(d2)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}> to be equal to <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}>, but was not.')
def test_is_close_to_failure(self):
try:
d2 = self.d1 + datetime.timedelta(minutes=5)
assert_that(self.d1).is_close_to(d2, datetime.timedelta(minutes=1))
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}> to be close to <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}> within tolerance <\d+:\d{2}:\d{2}>, but was not.')
def test_is_close_to_bad_tolerance_arg_type_failure(self):
try:
d2 = datetime.datetime.today()
assert_that(self.d1).is_close_to(d2, 123)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given tolerance arg must be timedelta, but was <int>')
def test_is_less_than_or_equal_to_failure(self):
try:
d2 = datetime.datetime.today()
assert_that(d2).is_less_than_or_equal_to(self.d1)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}> to be less than or equal to <\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}>, but was not.')
def test_is_between_bad_arg2_type_failure(self):
try:
d2 = datetime.datetime.today()
assert_that(self.d1).is_between(d2, 123)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given high arg must be datetime, but was <int>')
def test_contents_of_return_type_ascii(self):
if sys.version_info[0] == 3:
contents = contents_of(self.tmp.name, 'ascii')
assert_that(contents).is_type_of(str)
else:
contents = contents_of(self.tmp.name, 'ascii')
assert_that(contents).is_type_of(str)
def devices_do_not_contain_places(self, device_id: str) -> list:
""" The opposite of `device_and_place_contain_each_other`."""
device, _ = self.get(self.DEVICES, '', device_id)
assert_that(device).does_not_contain('place')
for component_id in device.get('components', []):
component, _ = self.get(self.DEVICES, '', component_id)
assert_that(component).does_not_contain('place')
def test_is_instance_of(self):
assert_that(self.fred).is_instance_of(Person)
assert_that(self.fred).is_instance_of(object)
assert_that(self.joe).is_instance_of(Developer)
assert_that(self.joe).is_instance_of(Person)
assert_that(self.joe).is_instance_of(object)
def test_is_file_directory_failure(self):
try:
dirname = os.path.dirname(self.tmp.name)
assert_that(dirname).is_file()
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <.*> to be a file, but was not.')
def test_is_not_same_as_failure():
for obj in [object(), 1, 'foo', True, None, 123.456]:
try:
assert_that(obj).is_not_same_as(obj)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <.+> to be not identical to <.+>, but was.')
def test_extracting_dict_missing_key_failure(self):
people_as_dicts = [{'first_name': p.first_name, 'last_name': p.last_name} for p in self.people]
try:
assert_that(people_as_dicts).extracting('foo')
fail('should have raised error')
except ValueError as ex:
assert_that(str(ex)).matches(r'item keys \[.*\] did not contain key <foo>')
def step_impl(context):
for row in context.input:
assert_that(bucket.head_object(row["name"]).status_code
).is_equal_to(404)
assert_that(os.path.isfile("tmp/" + row["name"])).is_equal_to(True)
sh.rm("-rf", "tmp").wait()
def step_impl(context):
ok = True
for row in context.table:
if row["name"] not in context.output:
ok = False
break
assert_that(ok).is_equal_to(True)
def test_create_image(graphene_client: Client):
result = graphene_client.execute('''
mutation {
createImage(name: "myImage") {
image {
imageId
name
public
keywords
}
}
}
''')
assert_that(json.dumps(result)).is_equal_to_ignoring_whitespace('''
{
"data": {
"createImage": {
"image": {
"imageId": 1,
"name": "myImage",
"public": false,
"keywords": []
}
}
}
}
''')
image = Image.query.get(1)
assert_that(image.id).is_equal_to(1)
assert_that(image.name).is_equal_to('myImage')
assert_that(image.public).is_false()
assert_that(image.keywords).is_empty()
def test_create_image_with_keywords(graphene_client: Client):
result = graphene_client.execute('''
mutation {
createImage(name: "myImage", keywords: ["foo", "bar", "baz"]) {
image {
keywords
}
}
}
''')
assert_that(json.dumps(result)).is_equal_to_ignoring_whitespace('''
{
"data": {
"createImage": {
"image": {
"keywords": [
"foo",
"bar",
"baz"
]
}
}
}
}
''')
image = Image.query.get(1)
assert_that([keyword.keyword for keyword in image.keywords]).contains_sequence("foo", "bar", "baz")
def test_expected_exception_all_failure():
try:
assert_that(func_noop).raises(RuntimeError).when_called_with('a', 'b', 3, 4, foo=1, bar=2, baz='dog')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <func_noop> to raise <RuntimeError> when called with ('a', 'b', 3, 4, 'bar': 2, 'baz': 'dog', 'foo': 1).")
def test_expected_exception_one_arg_failure():
try:
assert_that(func_noop).raises(RuntimeError).when_called_with('foo')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <func_noop> to raise <RuntimeError> when called with ('foo').")
def step_impl(context):
resp = bucket.list_objects()
assert_that(sorted([i["key"] for i in resp["keys"]])
).is_equal_to(sorted([row["name"] for row in context.table]))
for row in context.table:
bucket.delete_object(row["name"])
def test_is_less_than_or_equal_to_failure(self):
try:
t2 = datetime.timedelta(seconds=90)
assert_that(t2).is_less_than_or_equal_to(self.t1)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <\d{1,2}:\d{2}:\d{2}> to be less than or equal to <\d{1,2}:\d{2}:\d{2}>, but was not.')
def test_expected_exceptions(self):
def some_func(arg):
raise RuntimeError('some err')
assert_that(some_func).raises(RuntimeError).when_called_with('foo')
assert_that(some_func).raises(RuntimeError).when_called_with('foo')\
.is_length(8).starts_with('some').is_equal_to('some err')
def test_is_greater_than_failure(self):
try:
t2 = datetime.timedelta(seconds=90)
assert_that(self.t1).is_greater_than(t2)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).matches('Expected <\d{1,2}:\d{2}:\d{2}> to be greater than <\d{1,2}:\d{2}:\d{2}>, but was not.')
def test__init(self):
msg = CommandMessage(original_text='.hello',
text='',
sender='spam@localhost/ham')
response = hipchat_hello(msg, {})
assert_that(response) \
.described_as(".hello initiates conversation.") \
.is_instance_of(UserContext) \
.has_message("Hello. How are you feeling today?")
assert_that(response.input_options) \
.described_as("User has two options to respond.") \
.is_length(2)
assert_that([o.next_step.__name__ for o in response.input_options]) \
.described_as("Those options include 'Good' and 'Bad'") \
.contains(hipchat_user_feeling_good.__name__,
hipchat_user_feeling_bad.__name__)
assert_that(response.input_options[0].next_step("Good", {})) \
.described_as("When 'Good,' just return text.") \
.is_equal_to("Good to hear that.")
assert_that(response.input_options[1].next_step("Bad", {})) \
.described_as("When 'Bad,' continue to ask health status") \
.is_instance_of(UserContext)
def wait_future_finish(self, future):
sleep(.5) # Why would I need this line?? Check later.
ret = concurrent.futures.wait([future], 5, return_when=ALL_COMPLETED)
if len(ret.not_done) > 0:
logging.error("Jobs are not finished.")
assert_that(ret.done).contains(future)
def step_impl(context):
for row in context.table:
assert_that(bucket.head_object(row["name"]).status_code
).is_equal_to(404 if row["deleted"] == "1" else 200)
for row in context.table:
bucket.delete_object(row["name"])
def test_multiple_calls_with_same_word(self):
msg = CommandMessage(original_text='.count ham',
text='ham',
sender='123_homer@localhost/Oklahomer')
assert_that(hipchat_count(msg, {})) \
.described_as("First count returns 1") \
.is_equal_to('1')
other_msg = CommandMessage(original_text='.count ham',
text='ham',
sender='other@localhost/Oklahomer')
assert_that(hipchat_count(other_msg, {})) \
.described_as("Different counter for different message") \
.is_equal_to('1')
assert_that(hipchat_count(msg, {})) \
.described_as("Same message results in incremented count") \
.is_equal_to('2')
reset_msg = CommandMessage(original_text='.reset_count',
text='',
sender='123_homer@localhost/Oklahomer')
assert_that(hipchat_reset_count(reset_msg, {})) \
.described_as(".reset_count command resets current count") \
.is_equal_to("restart counting")
assert_that(hipchat_count(msg, {})) \
.described_as("Count restarts") \
.is_equal_to('1')
def test_parsing_of_dependency_list_output(self):
with open(os.path.join(os.path.dirname(__file__), 'mvn_dependency_list_output.txt'), 'r') as output_file:
output = output_file.read()
dependencies = self.dependency_list.parse_dependencies(output)
assert_that(dependencies).is_length(22)
def test_is_equal_ignoring_case_bad_value_type_failure():
try:
assert_that(123).is_equal_to_ignoring_case(12)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('val is not a string')
def test_starts_with_bad_arg_empty_failure():
try:
assert_that('fred').starts_with('')
fail('should have raised error')
except ValueError as ex:
assert_that(str(ex)).is_equal_to('given prefix arg must not be empty')
def test_starts_with_bad_arg_type_failure():
try:
assert_that('fred').starts_with(123)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given prefix arg must be a string')
def test_starts_with_bad_value_type_failure():
try:
assert_that(123).starts_with(12)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('val is not a string or iterable')
def test_starts_with_failure():
try:
assert_that('fred').starts_with('bar')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to('Expected <fred> to start with <bar>, but did not.')
def test_starts_with():
assert_that('fred').starts_with('f')
assert_that('fred').starts_with('fr')
assert_that('fred').starts_with('fred')
def test_is_equal_ignoring_case_bad_arg_type_failure():
try:
assert_that('fred').is_equal_to_ignoring_case(12)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given arg must be a string')
def test_is_equal_ignoring_case():
assert_that('FOO').is_equal_to_ignoring_case('foo')
assert_that('foo').is_equal_to_ignoring_case('FOO')
assert_that('fOO').is_equal_to_ignoring_case('foo')
def test_is_not_empty():
assert_that('foo').is_not_empty()
def test_is_equal_ignoring_case_failure():
try:
assert_that('foo').is_equal_to_ignoring_case('bar')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to('Expected <foo> to be case-insensitive equal to <bar>, but was not.')
def test_does_not_contain_list_multi_item_failure():
try:
assert_that('foo').does_not_contain('x','f','o')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to("Expected <foo> to not contain items <'x', 'f', 'o'>, but did contain <'f', 'o'>.")
def test_is_not_empty_failure():
try:
assert_that('').is_not_empty()
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to('Expected not empty string, but was empty.')
def test_does_not_contain():
assert_that('foo').does_not_contain('x')
assert_that('foo').does_not_contain('x','y')
def test_is_empty():
assert_that('').is_empty()
def test_contains_ignoring_case_list_multi_item_failure():
try:
assert_that(['foo','bar']).contains_ignoring_case('Foo','X','Y')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to("Expected <['foo', 'bar']> to case-insensitive contain items <'Foo', 'X', 'Y'>, but did not contain <'X', 'Y'>.")
def test_does_not_contain_single_item_failure():
try:
assert_that('foo').does_not_contain('f')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to('Expected <foo> to not contain item <f>, but did.')
def test_contains_ignoring_case_list_multi_elem_type_failure():
try:
assert_that(['foo', 123]).contains_ignoring_case('f')
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('val items must all be strings')
def test_contains_ignoring_case_list_multi_item_type_failure():
try:
assert_that(['foo','bar']).contains_ignoring_case('F', 12)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given args must all be strings')
def test_contains_ignoring_case_single_item_type_failure():
try:
assert_that('foo').contains_ignoring_case(12)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given arg must be a string')
def test_contains_ignoring_case_list_missinge_item_failure():
try:
assert_that(['foo']).contains_ignoring_case()
fail('should have raised error')
except ValueError as ex:
assert_that(str(ex)).is_equal_to('one or more args must be given')
def test_is_subset_of_single_item_superset():
assert_that(['a']).is_subset_of(['a'])
assert_that((1, )).is_subset_of((1, ))
assert_that('ab').is_subset_of('ab')
assert_that(set([1])).is_subset_of(set([1]))
assert_that({'a': 1}).is_subset_of({'a': 1})
def test_contains_ignoring_case_list():
assert_that(['foo']).contains_ignoring_case('Foo')
assert_that(['foo', 'bar', 'baz']).contains_ignoring_case('Foo')
assert_that(['foo', 'bar', 'baz']).contains_ignoring_case('Foo', 'bAr')
assert_that(['foo', 'bar', 'baz']).contains_ignoring_case('Foo', 'bAr', 'baZ')
def test_is_not_iterable_failure():
try:
assert_that(['a', 'b', 'c']).is_not_iterable()
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to('Expected not iterable, but was.')
def test_is_subset_of_failure_empty_superset():
try:
assert_that(['a', 'b', 'c']).is_subset_of([])
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).contains('to be subset of <>')
def test_is_iterable_failure():
try:
assert_that(123).is_iterable()
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to('Expected iterable, but was not.')
def test_is_subset_of():
assert_that(['a', 'b', 'c']).is_subset_of(['a', 'b', 'c'])
assert_that(['a', 'b', 'c']).is_subset_of(['a', 'b', 'c', 'd'])
assert_that(['a', 'b', 'c']).is_subset_of(['a'], ['b'], ['c'])
assert_that(['a', 'b', 'c']).is_subset_of('a', 'b', 'c')
assert_that(['a', 'b', 'a']).is_subset_of(['a', 'a', 'b'])
assert_that((1, 2, 3)).is_subset_of((1, 2, 3))
assert_that((1, 2, 3)).is_subset_of((1, 2, 3, 4))
assert_that((1, 2, 3)).is_subset_of((1, ), (2, ), (3, ))
assert_that((1, 2, 3)).is_subset_of(1, 2, 3)
assert_that((1, 2, 1)).is_subset_of(1, 1, 2)
assert_that('foo').is_subset_of('abcdefghijklmnopqrstuvwxyz')
assert_that('foo').is_subset_of('abcdef', set(['m', 'n', 'o']), ['x', 'y'])
assert_that(set([1, 2, 3])).is_subset_of(set([1, 2, 3, 4]))
assert_that({'a': 1, 'b': 2}).is_subset_of({'a': 1, 'b': 2, 'c': 3})
assert_that({'a': 1, 'b': 2}).is_subset_of({'a': 3}, {'b': 2}, {'a': 1})
def test_chaining():
assert_that(['a', 'b',
'c']).is_iterable().is_type_of(list).is_sorted().is_length(3)
def test_is_not_iterable():
assert_that(123).is_not_iterable()
assert_that({'a': 1, 'b': 2, 'c': 3}).is_iterable()
def test_is_sorted_failure_bad_val():
try:
assert_that(123).is_sorted()
fail("should have raised error")
except TypeError as ex:
assert_that(str(ex)).is_equal_to('val is not iterable')
def test_is_iterable():
assert_that(['a', 'b', 'c']).is_iterable()
assert_that((1, 2, 3)).is_iterable()
assert_that('foo').is_iterable()
assert_that({'a': 1, 'b': 2, 'c': 3}.keys()).is_iterable()
assert_that({'a': 1, 'b': 2, 'c': 3}.values()).is_iterable()
assert_that({'a': 1, 'b': 2, 'c': 3}.items()).is_iterable()
