def test_main_streams(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}, {
'logGroupName': 'BBB'
}, {
'logGroupName': 'CCC'
}]
},
]
streams = [{'logStreams': [self._stream('DDD'), self._stream('EEE')]}]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
main("awslogs streams AAA".split())
self.assertEqual(mock_stdout.getvalue(), ("DDD\n" "EEE\n"))
def test_main_streams(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
awslogs = AWSLogs()
groups = [
{'logGroups': [{'logGroupName': 'AAA'},
{'logGroupName': 'BBB'},
{'logGroupName': 'CCC'}]},
]
streams = [
{'logStreams': [self._stream('DDD'),
self._stream('EEE')]}
]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
main("awslogs streams AAA".split())
self.assertEqual(
mock_stdout.getvalue(),
("DDD\n"
"EEE\n")
)
def test_main_get(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
logs = [{
'events': [{
'timestamp': 1,
'message': 'Hello 1'
}, {
'timestamp': 2,
'message': 'Hello 2'
}, {
'timestamp': 3,
'message': 'Hello 3'
}],
'nextForwardToken':
'token'
}, {
'events': [{
'timestamp': 4,
'message': 'Hello 4'
}, {
'timestamp': 5,
'message': 'Hello 5'
}, {
'timestamp': 6,
'message': 'Hello 6'
}],
'nextForwardToken':
'token'
}, {
'events': []
}]
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}, {
'logGroupName': 'BBB'
}, {
'logGroupName': 'CCC'
}]
},
]
streams = [{'logStreams': [self._stream('DDD'), self._stream('EEE')]}]
instance.get_log_events.side_effect = logs
instance.describe_log_groups.side_effect = groups
instance.describe_log_streams.side_effect = streams
main("awslogs get AAA DDD --no-color".split())
self.assertEqual(mock_stdout.getvalue(), ("AAA DDD Hello 1\n"
"AAA DDD Hello 2\n"
"AAA DDD Hello 3\n"
"AAA DDD Hello 4\n"
"AAA DDD Hello 5\n"
"AAA DDD Hello 6\n"))
def test_get_nogroup_nostream_short_forms(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get -GS AAA DDD --no-color".split())
self.assertEqual(mock_stdout.getvalue(), ("Hello 1\n"
"Hello 2\n"
"Hello 3\n"
"Hello 4\n"
"Hello 5\n"
"Hello 6\n"))
def test_get_nogroup(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get --no-group AAA DDD --color=never".split())
self.assertEqual(mock_stdout.getvalue(), ("DDD Hello 1\n"
"EEE Hello 2\n"
"DDD Hello 3\n"
"EEE Hello 4\n"
"DDD Hello 5\n"
"EEE Hello 6\n"))
def test_main_groups(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
groups = [{"logGroups": [{"logGroupName": "AAA"}, {"logGroupName": "BBB"}, {"logGroupName": "CCC"}]}]
instance.describe_log_groups.side_effect = groups
main("awslogs groups".split())
self.assertEqual(mock_stdout.getvalue(), ("AAA\n" "BBB\n" "CCC\n"))
def test_get_nostream(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get --no-stream AAA DDD --no-color".split())
self.assertEqual(mock_stdout.getvalue(), ("AAA Hello 1\n"
"AAA Hello 2\n"
"AAA Hello 3\n"
"AAA Hello 4\n"
"AAA Hello 5\n"
"AAA Hello 6\n"))
def test_main_get_query(self, mock_stdout, botoclient):
self.set_json_logs(botoclient)
main("awslogs get AAA DDD --query foo".split())
output = mock_stdout.getvalue()
expected = (
"\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m bar\n"
"\x1b[32mAAA\x1b[0m \x1b[36mEEE\x1b[0m {\"bar\": \"baz\"}\n"
"\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m Hello 3\n")
assert output == expected
def test_main_get_deduplication(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
event_keys = [
"eventId", "timestamp", "ingestionTime", "message", "logStreamName"
]
logs = [{
'events':
mapkeys(event_keys,
[[1, 0, 0, 'Hello 1', 'DDD'], [2, 0, 0, 'Hello 2', 'EEE'],
[3, 0, 0, 'Hello 3', 'DDD']]),
'nextToken':
'token'
}, {
'events':
mapkeys(event_keys,
[[1, 0, 0, 'Hello 1', 'EEE'], [2, 0, 0, 'Hello 2', 'DDD'],
[3, 0, 0, 'Hello 3', 'EEE']]),
'nextToken':
'token'
}, {
'events': []
}]
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}, {
'logGroupName': 'BBB'
}, {
'logGroupName': 'CCC'
}]
},
]
streams = [{'logStreams': [self._stream('DDD'), self._stream('EEE')]}]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
client.filter_log_events.side_effect = logs
main("awslogs get AAA DDD --no-color".split())
self.assertEqual(mock_stdout.getvalue(), ("AAA DDD Hello 1\n"
"AAA EEE Hello 2\n"
"AAA DDD Hello 3\n"))
def test_main_get(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get AAA DDD --no-color".split())
output = mock_stdout.getvalue()
expected = ("AAA DDD Hello 1\n"
"AAA EEE Hello 2\n"
"AAA DDD Hello 3\n"
"AAA EEE Hello 4\n"
"AAA DDD Hello 5\n"
"AAA EEE Hello 6\n")
assert output == expected
def test_main_get(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get AAA DDD --no-color".split())
output = mock_stdout.getvalue()
expected = ("AAA DDD Hello 1\n"
"AAA EEE Hello 2\n"
"AAA DDD Hello 3\n"
"AAA EEE Hello 4\n"
"AAA DDD Hello 5\n"
"AAA EEE Hello 6\n"
)
assert output == expected
def test_main_get_with_color(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get AAA DDD".split())
output = mock_stdout.getvalue()
expected = ("\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m Hello 1\n"
"\x1b[32mAAA\x1b[0m \x1b[36mEEE\x1b[0m Hello 2\n"
"\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m Hello 3\n"
"\x1b[32mAAA\x1b[0m \x1b[36mEEE\x1b[0m Hello 4\n"
"\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m Hello 5\n"
"\x1b[32mAAA\x1b[0m \x1b[36mEEE\x1b[0m Hello 6\n")
assert output == expected
def test_main_streams(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
groups = [{"logGroups": [{"logGroupName": "AAA"}, {"logGroupName": "BBB"}, {"logGroupName": "CCC"}]}]
streams = [{"logStreams": [self._stream("DDD"), self._stream("EEE")]}]
instance.describe_log_groups.side_effect = groups
instance.describe_log_streams.side_effect = streams
main("awslogs streams AAA".split())
self.assertEqual(mock_stdout.getvalue(), ("DDD\n" "EEE\n"))
def test_get_nogroup_nostream(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get --no-group --no-stream AAA DDD --no-color".split())
self.assertEqual(
mock_stdout.getvalue(),
("Hello 1\n"
"Hello 2\n"
"Hello 3\n"
"Hello 4\n"
"Hello 5\n"
"Hello 6\n")
)
def test_main_get_with_color(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get AAA DDD".split())
output = mock_stdout.getvalue()
expected = ("\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m Hello 1\n"
"\x1b[32mAAA\x1b[0m \x1b[36mEEE\x1b[0m Hello 2\n"
"\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m Hello 3\n"
"\x1b[32mAAA\x1b[0m \x1b[36mEEE\x1b[0m Hello 4\n"
"\x1b[32mAAA\x1b[0m \x1b[36mDDD\x1b[0m Hello 5\n"
"\x1b[32mAAA\x1b[0m \x1b[36mEEE\x1b[0m Hello 6\n"
)
assert output == expected
def test_get_ingestion_time(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get "
"--ingestion-time --no-group --no-stream "
"AAA DDD --no-color".split())
self.assertEqual(mock_stdout.getvalue(),
("1970-01-01T00:00:05.000Z Hello 1\n"
"1970-01-01T00:00:05.000Z Hello 2\n"
"1970-01-01T00:00:05.006Z Hello 3\n"
"1970-01-01T00:00:05.000Z Hello 4\n"
"1970-01-01T00:00:05.000Z Hello 5\n"
"1970-01-01T00:00:05.009Z Hello 6\n"))
def test_main_get(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
awslogs = AWSLogs()
logs = [
{'events': [{'eventId': 1, 'message': 'Hello 1', 'logStreamName': 'DDD'},
{'eventId': 2, 'message': 'Hello 2', 'logStreamName': 'EEE'},
{'eventId': 3, 'message': 'Hello 3', 'logStreamName': 'DDD'}],
'nextToken': 'token'},
{'events': [{'eventId': 4, 'message': 'Hello 4', 'logStreamName': 'EEE'},
{'eventId': 5, 'message': 'Hello 5', 'logStreamName': 'DDD'},
{'eventId': 6, 'message': 'Hello 6', 'logStreamName': 'EEE'}],
'nextToken': 'token'},
{'events': []}
]
groups = [
{'logGroups': [{'logGroupName': 'AAA'},
{'logGroupName': 'BBB'},
{'logGroupName': 'CCC'}]},
]
streams = [
{'logStreams': [self._stream('DDD'),
self._stream('EEE')]}
]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
client.filter_log_events.side_effect = logs
main("awslogs get AAA DDD --no-color".split())
self.assertEqual(
mock_stdout.getvalue(),
("AAA DDD Hello 1\n"
"AAA EEE Hello 2\n"
"AAA DDD Hello 3\n"
"AAA EEE Hello 4\n"
"AAA DDD Hello 5\n"
"AAA EEE Hello 6\n")
)
def test_main_get_deduplication(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
event_keys = ["eventId", "timestamp", "ingestionTime",
"message", "logStreamName"]
logs = [
{'events': mapkeys(event_keys,
[[1, 0, 0, 'Hello 1', 'DDD'],
[2, 0, 0, 'Hello 2', 'EEE'],
[3, 0, 0, 'Hello 3', 'DDD']]),
'nextToken': 'token'},
{'events': mapkeys(event_keys,
[[1, 0, 0, 'Hello 1', 'EEE'],
[2, 0, 0, 'Hello 2', 'DDD'],
[3, 0, 0, 'Hello 3', 'EEE']]),
'nextToken': 'token'},
{'events': []}
]
groups = [
{'logGroups': [{'logGroupName': 'AAA'},
{'logGroupName': 'BBB'},
{'logGroupName': 'CCC'}]},
]
streams = [
{'logStreams': [self._stream('DDD'),
self._stream('EEE')]}
]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
client.filter_log_events.side_effect = logs
main("awslogs get AAA DDD --no-color".split())
self.assertEqual(
mock_stdout.getvalue(),
("AAA DDD Hello 1\n"
"AAA EEE Hello 2\n"
"AAA DDD Hello 3\n")
)
def test_get_timestamp_and_ingestion_time(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get "
"--timestamp --ingestion-time --no-group --no-stream "
"AAA DDD --no-color".split())
self.assertEqual(
mock_stdout.getvalue(),
("1970-01-01T00:00:00.000Z 1970-01-01T00:00:05.000Z Hello 1\n"
"1970-01-01T00:00:00.000Z 1970-01-01T00:00:05.000Z Hello 2\n"
"1970-01-01T00:00:00.000Z 1970-01-01T00:00:05.006Z Hello 3\n"
"1970-01-01T00:00:00.000Z 1970-01-01T00:00:05.000Z Hello 4\n"
"1970-01-01T00:00:00.000Z 1970-01-01T00:00:05.000Z Hello 5\n"
"1970-01-01T00:00:00.000Z 1970-01-01T00:00:05.009Z Hello 6\n")
)
def test_connection_error(self, mock_stderr, mock_awslogs):
mock_awslogs.side_effect = ConnectionError("Error!")
code = main("awslogs get AAA BBB".split())
self.assertEqual(code, 2)
output = mock_stderr.getvalue()
self.assertEqual(mock_stderr.getvalue(),
colored("awslogs can't connecto to AWS.\n", "red"))
def test_main_get_no_matching_streams(self, mock_stderr, botoclient):
client = Mock()
botoclient.return_value = client
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}]
},
]
# None of these match the pattern below: "foo.*"
streams = [{'logStreams': [self._stream('DDD'), self._stream('EEE')]}]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
exit_code = main("awslogs get AAA foo.*".split())
self.assertEqual(
mock_stderr.getvalue(),
colored(
"No streams match your pattern 'foo.*' "
"for the given time period.\n", "red"))
assert exit_code == 7
def test_connection_error(self, mock_stderr, mock_awslogs):
mock_awslogs.side_effect = ConnectionError("Error!")
code = main("awslogs get AAA BBB".split())
self.assertEqual(code, 2)
output = mock_stderr.getvalue()
self.assertEqual(mock_stderr.getvalue(),
colored("awslogs can't connecto to AWS.\n", "red"))
def test_unknown_error(self, mock_stderr, mock_awslogs):
mock_awslogs.side_effect = Exception("Error!")
exit_code = main("awslogs get AAA BBB".split())
output = mock_stderr.getvalue()
self.assertTrue("You've found a bug!" in output)
self.assertTrue("Exception: Error!" in output)
assert exit_code == 1
def test_unknown_error(self, mock_stderr, mock_awslogs):
mock_awslogs.side_effect = Exception("Error!")
code = main("awslogs get AAA BBB".split())
output = mock_stderr.getvalue()
self.assertEqual(code, 1)
self.assertTrue("You've found a bug!" in output)
self.assertTrue("Exception: Error!" in output)
def test_main_get_no_matching_streams(self, mock_stderr, botoclient):
client = Mock()
botoclient.return_value = client
groups = [
{'logGroups': [{'logGroupName': 'AAA'}]},
]
# None of these match the pattern below: "foo.*"
streams = [
{'logStreams': [self._stream('DDD'),
self._stream('EEE')]}
]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
code = main("awslogs get AAA foo.*".split())
self.assertEqual(code, 7)
self.assertEqual(mock_stderr.getvalue(),
colored("No streams match your pattern 'foo.*'.\n",
"red"))
def test_no_handler_was_ready_to_authenticate(self, mock_stderr, connect_to_region):
instance = Mock()
connect_to_region.side_effect = boto.exception.NoAuthHandlerFound("No handler was ready to authenticate")
code = main("awslogs groups --aws-region=eu-west-1".split())
self.assertEqual(code, 5)
self.assertTrue("No handler was ready to authenticate" in mock_stderr.getvalue())
def test_empty_aws_region(self, mock_stderr):
code = main("awslogs groups".split())
self.assertEqual(code, 6)
self.assertEqual(
mock_stderr.getvalue(),
colored(
"You need to provide a valid AWS region name using --aws-region\n",
"red"))
def test_no_handler_was_ready_to_authenticate(self, mock_stderr,
connect_to_region):
instance = Mock()
connect_to_region.side_effect = boto.exception.NoAuthHandlerFound(
"No handler was ready to authenticate")
code = main("awslogs groups --aws-region=eu-west-1".split())
self.assertEqual(code, 5)
self.assertTrue(
"No handler was ready to authenticate" in mock_stderr.getvalue())
def test_main_groups(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
groups = [
{'logGroups': [{'logGroupName': 'AAA'},
{'logGroupName': 'BBB'},
{'logGroupName': 'CCC'}]},
]
client.get_paginator.return_value.paginate.return_value = groups
main("awslogs groups".split())
self.assertEqual(
mock_stdout.getvalue(),
("AAA\n"
"BBB\n"
"CCC\n")
)
def test_main_get(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
logs = [
{
"events": [
{"timestamp": 1, "message": "Hello 1"},
{"timestamp": 2, "message": "Hello 2"},
{"timestamp": 3, "message": "Hello 3"},
],
"nextForwardToken": "token",
},
{
"events": [
{"timestamp": 4, "message": "Hello 4"},
{"timestamp": 5, "message": "Hello 5"},
{"timestamp": 6, "message": "Hello 6"},
],
"nextForwardToken": "token",
},
{"events": []},
]
groups = [{"logGroups": [{"logGroupName": "AAA"}, {"logGroupName": "BBB"}, {"logGroupName": "CCC"}]}]
streams = [{"logStreams": [self._stream("DDD"), self._stream("EEE")]}]
instance.get_log_events.side_effect = logs
instance.describe_log_groups.side_effect = groups
instance.describe_log_streams.side_effect = streams
main("awslogs get AAA DDD --no-color".split())
self.assertEqual(
mock_stdout.getvalue(),
(
"AAA DDD Hello 1\n"
"AAA DDD Hello 2\n"
"AAA DDD Hello 3\n"
"AAA DDD Hello 4\n"
"AAA DDD Hello 5\n"
"AAA DDD Hello 6\n"
),
)
def test_access_denied_error(self, mock_stderr, connect_to_region):
instance = Mock()
connect_to_region.return_value = instance
exc = boto.exception.JSONResponseError(
status=400, reason="Bad Request", body={u"Message": u"User XXX...", "__type": "AccessDeniedException"}
)
instance.describe_log_groups.side_effect = exc
code = main("awslogs groups --aws-region=eu-west-1".split())
self.assertEqual(code, 4)
self.assertEqual(mock_stderr.getvalue(), colored("User XXX...\n", "red"))
def test_main_groups(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}, {
'logGroupName': 'BBB'
}, {
'logGroupName': 'CCC'
}]
},
]
client.get_paginator.return_value.paginate.return_value = groups
main("awslogs groups".split())
self.assertEqual(mock_stdout.getvalue(), ("AAA\n" "BBB\n" "CCC\n"))
def test_main_groups(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}, {
'logGroupName': 'BBB'
}, {
'logGroupName': 'CCC'
}]
},
]
instance.describe_log_groups.side_effect = groups
main("awslogs groups".split())
self.assertEqual(mock_stdout.getvalue(), ("AAA\n" "BBB\n" "CCC\n"))
def test_get_nogroup_nostream(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
exit_code = main(
"awslogs get --no-group --no-stream AAA DDD --color=never".split())
self.assertEqual(mock_stdout.getvalue(), ("Hello 1\n"
"Hello 2\n"
"Hello 3\n"
"Hello 4\n"
"Hello 5\n"
"Hello 6\n"))
assert exit_code == 0
def test_main_get(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
logs = [
{'events': [{'timestamp': 1, 'message': 'Hello 1'},
{'timestamp': 2, 'message': 'Hello 2'},
{'timestamp': 3, 'message': 'Hello 3'}],
'nextForwardToken': 'token'},
{'events': [{'timestamp': 4, 'message': 'Hello 4'},
{'timestamp': 5, 'message': 'Hello 5'},
{'timestamp': 6, 'message': 'Hello 6'}],
'nextForwardToken': 'token'},
{'events': []}
]
groups = [
{'logGroups': [{'logGroupName': 'AAA'},
{'logGroupName': 'BBB'},
{'logGroupName': 'CCC'}]},
]
streams = [
{'logStreams': [{'logStreamName': 'DDD'},
{'logStreamName': 'EEE'}]}
]
instance.get_log_events.side_effect = logs
instance.describe_log_groups.side_effect = groups
instance.describe_log_streams.side_effect = streams
main("awslogs get AAA DDD --no-color".split())
self.assertEqual(
mock_stdout.getvalue(),
("AAA DDD Hello 1\n"
"AAA DDD Hello 2\n"
"AAA DDD Hello 3\n"
"AAA DDD Hello 4\n"
"AAA DDD Hello 5\n"
"AAA DDD Hello 6\n")
)
def test_get_timestamp(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
exit_code = main("awslogs get "
"--timestamp --no-group --no-stream "
"AAA DDD --color=never".split())
self.assertEqual(mock_stdout.getvalue(),
("1970-01-01T00:00:00.000Z Hello 1\n"
"1970-01-01T00:00:00.000Z Hello 2\n"
"1970-01-01T00:00:00.000Z Hello 3\n"
"1970-01-01T00:00:00.000Z Hello 4\n"
"1970-01-01T00:00:00.000Z Hello 5\n"
"1970-01-01T00:00:00.000Z Hello 6\n"))
assert exit_code == 0
def test_main_streams(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}, {
'logGroupName': 'BBB'
}, {
'logGroupName': 'CCC'
}]
},
]
streams = [{'logStreams': [self._stream('DDD'), self._stream('EEE')]}]
instance.describe_log_groups.side_effect = groups
instance.describe_log_streams.side_effect = streams
main("awslogs streams AAA".split())
self.assertEqual(mock_stdout.getvalue(), ("DDD\n" "EEE\n"))
def test_main_streams(self, mock_stdout, AWSConnection):
instance = Mock()
AWSConnection.return_value = instance
groups = [
{'logGroups': [{'logGroupName': 'AAA'},
{'logGroupName': 'BBB'},
{'logGroupName': 'CCC'}]},
]
streams = [
{'logStreams': [{'logStreamName': 'DDD'},
{'logStreamName': 'EEE'}]}
]
instance.describe_log_groups.side_effect = groups
instance.describe_log_streams.side_effect = streams
main("awslogs streams AAA".split())
self.assertEqual(
mock_stdout.getvalue(),
("DDD\n"
"EEE\n")
)
def test_access_denied_error(self, mock_stderr, connect_to_region):
instance = Mock()
connect_to_region.return_value = instance
exc = boto.exception.JSONResponseError(status=400,
reason='Bad Request',
body={
u'Message':
u'User XXX...',
'__type':
'AccessDeniedException'
})
instance.describe_log_groups.side_effect = exc
code = main("awslogs groups --aws-region=eu-west-1".split())
self.assertEqual(code, 4)
self.assertEqual(mock_stderr.getvalue(),
colored("User XXX...\n", "red"))
def test_empty_aws_region(self, mock_stderr):
code = main("awslogs groups".split())
self.assertEqual(code, 6)
self.assertEqual(mock_stderr.getvalue(),
colored("You need to provide a valid AWS region name using --aws-region\n", "red"))
def test_invalid_aws_region(self, mock_stderr):
code = main("awslogs groups --aws-region=xxx".split())
self.assertEqual(code, 6)
self.assertEqual(
mock_stderr.getvalue(),
colored("xxx is not a valid AWS region name\n", "red"))
def test_invalid_aws_region(self, mock_stderr):
code = main("awslogs groups --aws-region=xxx".split())
self.assertEqual(code, 6)
self.assertEqual(mock_stderr.getvalue(),
colored("xxx is not a valid AWS region name\n", "red"))
print("No logs found for " + searched)
exit(1)
if len(found) == 1:
group = found[0]
if len(found) > 1:
questions = [
inquirer.List(
'group',
message="%s%s%s (enter to select)" %
("\033[1m", "Which log?", "\033[0m"),
choices=found,
)
]
answers = None
try:
answers = inquirer.prompt(questions, raise_keyboard_interrupt=True)
group = answers['group']
except KeyboardInterrupt:
print("Cancelled by user")
sys.exit(1)
opts = sys.argv[2:]
opts.insert(0, sys.argv[0])
opts.insert(1, "get")
opts.insert(2, group)
opts.insert(3, 'ALL')
exit(AWSLogsBin.main(opts))
def test_unknown_date_error(self, mock_stderr):
code = main("awslogs get AAA BBB -sX".split())
self.assertEqual(code, 3)
self.assertEqual(mock_stderr.getvalue(),
colored("awslogs doesn't understand 'X' as a date.\n", "red"))
def test_main_get_deduplication(self, mock_stdout, botoclient):
client = Mock()
botoclient.return_value = client
awslogs = AWSLogs()
logs = [{
'events': [{
'eventId': 1,
'message': 'Hello 1',
'logStreamName': 'DDD'
}, {
'eventId': 2,
'message': 'Hello 2',
'logStreamName': 'EEE'
}, {
'eventId': 3,
'message': 'Hello 3',
'logStreamName': 'DDD'
}],
'nextToken':
'token'
}, {
'events': [{
'eventId': 1,
'message': 'Hello 1',
'logStreamName': 'DDD'
}, {
'eventId': 2,
'message': 'Hello 2',
'logStreamName': 'EEE'
}, {
'eventId': 3,
'message': 'Hello 3',
'logStreamName': 'DDD'
}],
'nextToken':
'token'
}, {
'events': []
}]
groups = [
{
'logGroups': [{
'logGroupName': 'AAA'
}, {
'logGroupName': 'BBB'
}, {
'logGroupName': 'CCC'
}]
},
]
streams = [{'logStreams': [self._stream('DDD'), self._stream('EEE')]}]
def paginator(value):
mock = Mock()
mock.paginate.return_value = {
'describe_log_groups': groups,
'describe_log_streams': streams
}.get(value)
return mock
client.get_paginator.side_effect = paginator
client.filter_log_events.side_effect = logs
main("awslogs get AAA DDD --no-color".split())
self.assertEqual(mock_stdout.getvalue(), ("AAA DDD Hello 1\n"
"AAA EEE Hello 2\n"
"AAA DDD Hello 3\n"))
def test_unknown_date_error(self, mock_stderr):
exit_code = main("awslogs get AAA BBB -sX".split())
self.assertEqual(
mock_stderr.getvalue(),
colored("awslogs doesn't understand 'X' as a date.\n", "red"))
assert exit_code == 3
def test_main_get(self, mock_stdout, botoclient):
self.set_ABCDE_logs(botoclient)
main("awslogs get AAA DDD --no-color".split())
