494 lines
20 KiB
Python
494 lines
20 KiB
Python
# Copyright 2016 The Kubernetes Authors.
|
||
#
|
||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||
# you may not use this file except in compliance with the License.
|
||
# You may obtain a copy of the License at
|
||
#
|
||
# http://www.apache.org/licenses/LICENSE-2.0
|
||
#
|
||
# Unless required by applicable law or agreed to in writing, software
|
||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
# See the License for the specific language governing permissions and
|
||
# limitations under the License.
|
||
|
||
import unittest
|
||
|
||
from unittest.mock import Mock, call
|
||
|
||
from kubernetes import client
|
||
|
||
from .watch import Watch
|
||
|
||
|
||
class WatchTests(unittest.TestCase):
|
||
def setUp(self):
|
||
# counter for a test that needs test global state
|
||
self.callcount = 0
|
||
|
||
def test_watch_with_decode(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=[
|
||
'{"type": "ADDED", "object": {"metadata": {"name": "test1",'
|
||
'"resourceVersion": "1"}, "spec": {}, "status": {}}}\n',
|
||
'{"type": "ADDED", "object": {"metadata": {"name": "test2",'
|
||
'"resourceVersion": "2"}, "spec": {}, "sta',
|
||
'tus": {}}}\n'
|
||
'{"type": "ADDED", "object": {"metadata": {"name": "test3",'
|
||
'"resourceVersion": "3"}, "spec": {}, "status": {}}}\n',
|
||
'should_not_happened\n'])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_namespaces = Mock(return_value=fake_resp)
|
||
fake_api.get_namespaces.__doc__ = ':return: V1NamespaceList'
|
||
|
||
w = Watch()
|
||
count = 1
|
||
for e in w.stream(fake_api.get_namespaces):
|
||
self.assertEqual("ADDED", e['type'])
|
||
# make sure decoder worked and we got a model with the right name
|
||
self.assertEqual("test%d" % count, e['object'].metadata.name)
|
||
# make sure decoder worked and updated Watch.resource_version
|
||
self.assertEqual(
|
||
"%d" % count, e['object'].metadata.resource_version)
|
||
self.assertEqual("%d" % count, w.resource_version)
|
||
count += 1
|
||
# make sure we can stop the watch and the last event with won't be
|
||
# returned
|
||
if count == 4:
|
||
w.stop()
|
||
|
||
# make sure that all three records were consumed by the stream
|
||
self.assertEqual(4, count)
|
||
|
||
fake_api.get_namespaces.assert_called_once_with(
|
||
_preload_content=False, watch=True)
|
||
fake_resp.stream.assert_called_once_with(
|
||
amt=None, decode_content=False)
|
||
fake_resp.close.assert_called_once()
|
||
fake_resp.release_conn.assert_called_once()
|
||
|
||
def test_watch_with_interspersed_newlines(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=[
|
||
'\n',
|
||
'{"type": "ADDED", "object": {"metadata":',
|
||
'{"name": "test1","resourceVersion": "1"}}}\n{"type": "ADDED", ',
|
||
'"object": {"metadata": {"name": "test2", "resourceVersion": "2"}}}\n',
|
||
'\n',
|
||
'',
|
||
'{"type": "ADDED", "object": {"metadata": {"name": "test3", "resourceVersion": "3"}}}\n',
|
||
'\n\n\n',
|
||
'\n',
|
||
])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_namespaces = Mock(return_value=fake_resp)
|
||
fake_api.get_namespaces.__doc__ = ':return: V1NamespaceList'
|
||
|
||
w = Watch()
|
||
count = 0
|
||
|
||
# Consume all test events from the mock service, stopping when no more data is available.
|
||
# Note that "timeout_seconds" below is not a timeout; rather, it disables retries and is
|
||
# the only way to do so. Without that, the stream will re-read the test data forever.
|
||
for e in w.stream(fake_api.get_namespaces, timeout_seconds=1):
|
||
count += 1
|
||
self.assertEqual("test%d" % count, e['object'].metadata.name)
|
||
self.assertEqual(3, count)
|
||
|
||
def test_watch_with_multibyte_utf8(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=[
|
||
# two-byte utf-8 character
|
||
'{"type":"MODIFIED","object":{"data":{"utf-8":"© 1"},"metadata":{"name":"test1","resourceVersion":"1"}}}\n',
|
||
# same copyright character expressed as bytes
|
||
b'{"type":"MODIFIED","object":{"data":{"utf-8":"\xC2\xA9 2"},"metadata":{"name":"test2","resourceVersion":"2"}}}\n'
|
||
# same copyright character with bytes split across two stream chunks
|
||
b'{"type":"MODIFIED","object":{"data":{"utf-8":"\xC2',
|
||
b'\xA9 3"},"metadata":{"n',
|
||
# more chunks of the same event, sent as a mix of bytes and strings
|
||
'ame":"test3","resourceVersion":"3"',
|
||
'}}}',
|
||
b'\n'
|
||
])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_configmaps = Mock(return_value=fake_resp)
|
||
fake_api.get_configmaps.__doc__ = ':return: V1ConfigMapList'
|
||
|
||
w = Watch()
|
||
count = 0
|
||
|
||
# Consume all test events from the mock service, stopping when no more data is available.
|
||
# Note that "timeout_seconds" below is not a timeout; rather, it disables retries and is
|
||
# the only way to do so. Without that, the stream will re-read the test data forever.
|
||
for event in w.stream(fake_api.get_configmaps, timeout_seconds=1):
|
||
count += 1
|
||
self.assertEqual("MODIFIED", event['type'])
|
||
self.assertEqual("test%d" % count, event['object'].metadata.name)
|
||
self.assertEqual("© %d" % count, event['object'].data["utf-8"])
|
||
self.assertEqual(
|
||
"%d" % count, event['object'].metadata.resource_version)
|
||
self.assertEqual("%d" % count, w.resource_version)
|
||
self.assertEqual(3, count)
|
||
|
||
def test_watch_with_invalid_utf8(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
# test 1 uses 1 invalid utf-8 byte
|
||
# test 2 uses a sequence of 2 invalid utf-8 bytes
|
||
# test 3 uses a sequence of 3 invalid utf-8 bytes
|
||
return_value=[
|
||
# utf-8 sequence for 😄 is \xF0\x9F\x98\x84
|
||
# all other sequences below are invalid
|
||
# ref: https://www.w3.org/2001/06/utf-8-wrong/UTF-8-test.html
|
||
b'{"type":"MODIFIED","object":{"data":{"utf-8":"\xF0\x9F\x98\x84 1","invalid":"\x80 1"},"metadata":{"name":"test1"}}}\n',
|
||
b'{"type":"MODIFIED","object":{"data":{"utf-8":"\xF0\x9F\x98\x84 2","invalid":"\xC0\xAF 2"},"metadata":{"name":"test2"}}}\n',
|
||
# mix bytes/strings and split byte sequences across chunks
|
||
b'{"type":"MODIFIED","object":{"data":{"utf-8":"\xF0\x9F\x98',
|
||
b'\x84 ',
|
||
b'',
|
||
b'3","invalid":"\xE0\x80',
|
||
b'\xAF ',
|
||
'3"},"metadata":{"n',
|
||
'ame":"test3"',
|
||
'}}}',
|
||
b'\n'
|
||
])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_configmaps = Mock(return_value=fake_resp)
|
||
fake_api.get_configmaps.__doc__ = ':return: V1ConfigMapList'
|
||
|
||
w = Watch()
|
||
count = 0
|
||
|
||
# Consume all test events from the mock service, stopping when no more data is available.
|
||
# Note that "timeout_seconds" below is not a timeout; rather, it disables retries and is
|
||
# the only way to do so. Without that, the stream will re-read the test data forever.
|
||
for event in w.stream(fake_api.get_configmaps, timeout_seconds=1):
|
||
count += 1
|
||
self.assertEqual("MODIFIED", event['type'])
|
||
self.assertEqual("test%d" % count, event['object'].metadata.name)
|
||
self.assertEqual("😄 %d" % count, event['object'].data["utf-8"])
|
||
# expect N replacement characters in test N
|
||
self.assertEqual("<EFBFBD> %d".replace('<EFBFBD>', '<EFBFBD>'*count) %
|
||
count, event['object'].data["invalid"])
|
||
self.assertEqual(3, count)
|
||
|
||
def test_watch_for_follow(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=[
|
||
'log_line_1\n',
|
||
'log_line_2\n'])
|
||
|
||
fake_api = Mock()
|
||
fake_api.read_namespaced_pod_log = Mock(return_value=fake_resp)
|
||
fake_api.read_namespaced_pod_log.__doc__ = ':param bool follow:\n:return: str'
|
||
|
||
w = Watch()
|
||
count = 1
|
||
for e in w.stream(fake_api.read_namespaced_pod_log):
|
||
self.assertEqual("log_line_1", e)
|
||
count += 1
|
||
# make sure we can stop the watch and the last event with won't be
|
||
# returned
|
||
if count == 2:
|
||
w.stop()
|
||
|
||
fake_api.read_namespaced_pod_log.assert_called_once_with(
|
||
_preload_content=False, follow=True)
|
||
fake_resp.stream.assert_called_once_with(
|
||
amt=None, decode_content=False)
|
||
fake_resp.close.assert_called_once()
|
||
fake_resp.release_conn.assert_called_once()
|
||
|
||
def test_watch_resource_version_set(self):
|
||
# https://github.com/kubernetes-client/python/issues/700
|
||
# ensure watching from a resource version does reset to resource
|
||
# version 0 after k8s resets the watch connection
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
values = [
|
||
'{"type": "ADDED", "object": {"metadata": {"name": "test1",'
|
||
'"resourceVersion": "1"}, "spec": {}, "status": {}}}\n',
|
||
'{"type": "ADDED", "object": {"metadata": {"name": "test2",'
|
||
'"resourceVersion": "2"}, "spec": {}, "sta',
|
||
'tus": {}}}\n'
|
||
'{"type": "ADDED", "object": {"metadata": {"name": "test3",'
|
||
'"resourceVersion": "3"}, "spec": {}, "status": {}}}\n'
|
||
]
|
||
|
||
# return nothing on the first call and values on the second
|
||
# this emulates a watch from a rv that returns nothing in the first k8s
|
||
# watch reset and values later
|
||
|
||
def get_values(*args, **kwargs):
|
||
self.callcount += 1
|
||
if self.callcount == 1:
|
||
return []
|
||
else:
|
||
return values
|
||
|
||
fake_resp.stream = Mock(
|
||
side_effect=get_values)
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_namespaces = Mock(return_value=fake_resp)
|
||
fake_api.get_namespaces.__doc__ = ':return: V1NamespaceList'
|
||
|
||
w = Watch()
|
||
# ensure we keep our requested resource version or the version latest
|
||
# returned version when the existing versions are older than the
|
||
# requested version
|
||
# needed for the list existing objects, then watch from there use case
|
||
calls = []
|
||
|
||
iterations = 2
|
||
# first two calls must use the passed rv, the first call is a
|
||
# "reset" and does not actually return anything
|
||
# the second call must use the same rv but will return values
|
||
# (with a wrong rv but a real cluster would behave correctly)
|
||
# calls following that will use the rv from those returned values
|
||
calls.append(call(_preload_content=False, watch=True,
|
||
resource_version="5"))
|
||
calls.append(call(_preload_content=False, watch=True,
|
||
resource_version="5"))
|
||
for i in range(iterations):
|
||
# ideally we want 5 here but as rv must be treated as an
|
||
# opaque value we cannot interpret it and order it so rely
|
||
# on k8s returning the events completely and in order
|
||
calls.append(call(_preload_content=False, watch=True,
|
||
resource_version="3"))
|
||
|
||
for c, e in enumerate(w.stream(fake_api.get_namespaces,
|
||
resource_version="5")):
|
||
if c == len(values) * iterations:
|
||
w.stop()
|
||
|
||
# check calls are in the list, gives good error output
|
||
fake_api.get_namespaces.assert_has_calls(calls)
|
||
# more strict test with worse error message
|
||
self.assertEqual(fake_api.get_namespaces.mock_calls, calls)
|
||
|
||
def test_watch_stream_twice(self):
|
||
w = Watch(float)
|
||
for step in ['first', 'second']:
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=['{"type": "ADDED", "object": 1}\n'] * 4)
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_namespaces = Mock(return_value=fake_resp)
|
||
fake_api.get_namespaces.__doc__ = ':return: V1NamespaceList'
|
||
|
||
count = 1
|
||
for e in w.stream(fake_api.get_namespaces):
|
||
count += 1
|
||
if count == 3:
|
||
w.stop()
|
||
|
||
self.assertEqual(count, 3)
|
||
fake_api.get_namespaces.assert_called_once_with(
|
||
_preload_content=False, watch=True)
|
||
fake_resp.stream.assert_called_once_with(
|
||
amt=None, decode_content=False)
|
||
fake_resp.close.assert_called_once()
|
||
fake_resp.release_conn.assert_called_once()
|
||
|
||
def test_watch_stream_loop(self):
|
||
w = Watch(float)
|
||
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=['{"type": "ADDED", "object": 1}\n'])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_namespaces = Mock(return_value=fake_resp)
|
||
fake_api.get_namespaces.__doc__ = ':return: V1NamespaceList'
|
||
|
||
count = 0
|
||
|
||
# when timeout_seconds is set, auto-exist when timeout reaches
|
||
for e in w.stream(fake_api.get_namespaces, timeout_seconds=1):
|
||
count = count + 1
|
||
self.assertEqual(count, 1)
|
||
|
||
# when no timeout_seconds, only exist when w.stop() is called
|
||
for e in w.stream(fake_api.get_namespaces):
|
||
count = count + 1
|
||
if count == 2:
|
||
w.stop()
|
||
|
||
self.assertEqual(count, 2)
|
||
self.assertEqual(fake_api.get_namespaces.call_count, 2)
|
||
self.assertEqual(fake_resp.stream.call_count, 2)
|
||
self.assertEqual(fake_resp.close.call_count, 2)
|
||
self.assertEqual(fake_resp.release_conn.call_count, 2)
|
||
|
||
def test_unmarshal_with_float_object(self):
|
||
w = Watch()
|
||
event = w.unmarshal_event('{"type": "ADDED", "object": 1}', 'float')
|
||
self.assertEqual("ADDED", event['type'])
|
||
self.assertEqual(1.0, event['object'])
|
||
self.assertTrue(isinstance(event['object'], float))
|
||
self.assertEqual(1, event['raw_object'])
|
||
|
||
def test_unmarshal_with_no_return_type(self):
|
||
w = Watch()
|
||
event = w.unmarshal_event('{"type": "ADDED", "object": ["test1"]}',
|
||
None)
|
||
self.assertEqual("ADDED", event['type'])
|
||
self.assertEqual(["test1"], event['object'])
|
||
self.assertEqual(["test1"], event['raw_object'])
|
||
|
||
def test_unmarshal_with_custom_object(self):
|
||
w = Watch()
|
||
event = w.unmarshal_event('{"type": "ADDED", "object": {"apiVersion":'
|
||
'"test.com/v1beta1","kind":"foo","metadata":'
|
||
'{"name": "bar", "resourceVersion": "1"}}}',
|
||
'object')
|
||
self.assertEqual("ADDED", event['type'])
|
||
# make sure decoder deserialized json into dictionary and updated
|
||
# Watch.resource_version
|
||
self.assertTrue(isinstance(event['object'], dict))
|
||
self.assertEqual("1", event['object']['metadata']['resourceVersion'])
|
||
self.assertEqual("1", w.resource_version)
|
||
|
||
def test_unmarshal_with_bookmark(self):
|
||
w = Watch()
|
||
event = w.unmarshal_event(
|
||
'{"type":"BOOKMARK","object":{"kind":"Job","apiVersion":"batch/v1"'
|
||
',"metadata":{"resourceVersion":"1"},"spec":{"template":{'
|
||
'"metadata":{},"spec":{"containers":null}}},"status":{}}}',
|
||
'V1Job')
|
||
self.assertEqual("BOOKMARK", event['type'])
|
||
# Watch.resource_version is *not* updated, as BOOKMARK is treated the
|
||
# same as ERROR for a quick fix of decoding exception,
|
||
# resource_version in BOOKMARK is *not* used at all.
|
||
self.assertEqual(None, w.resource_version)
|
||
|
||
def test_watch_with_exception(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(side_effect=KeyError('expected'))
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_thing = Mock(return_value=fake_resp)
|
||
|
||
w = Watch()
|
||
try:
|
||
for _ in w.stream(fake_api.get_thing):
|
||
self.fail(self, "Should fail on exception.")
|
||
except KeyError:
|
||
pass
|
||
# expected
|
||
|
||
fake_api.get_thing.assert_called_once_with(
|
||
_preload_content=False, watch=True)
|
||
fake_resp.stream.assert_called_once_with(
|
||
amt=None, decode_content=False)
|
||
fake_resp.close.assert_called_once()
|
||
fake_resp.release_conn.assert_called_once()
|
||
|
||
def test_watch_with_error_event(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=[
|
||
'{"type": "ERROR", "object": {"code": 410, '
|
||
'"reason": "Gone", "message": "error message"}}\n'])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_thing = Mock(return_value=fake_resp)
|
||
|
||
w = Watch()
|
||
# No events are generated when no initial resourceVersion is passed
|
||
# No retry is attempted either, preventing an ApiException
|
||
assert not list(w.stream(fake_api.get_thing))
|
||
|
||
fake_api.get_thing.assert_called_once_with(
|
||
_preload_content=False, watch=True)
|
||
fake_resp.stream.assert_called_once_with(
|
||
amt=None, decode_content=False)
|
||
fake_resp.close.assert_called_once()
|
||
fake_resp.release_conn.assert_called_once()
|
||
|
||
def test_watch_retries_on_error_event(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=[
|
||
'{"type": "ERROR", "object": {"code": 410, '
|
||
'"reason": "Gone", "message": "error message"}}\n'])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_thing = Mock(return_value=fake_resp)
|
||
|
||
w = Watch()
|
||
try:
|
||
for _ in w.stream(fake_api.get_thing, resource_version=0):
|
||
self.fail(self, "Should fail with ApiException.")
|
||
except client.rest.ApiException:
|
||
pass
|
||
|
||
# Two calls should be expected during a retry
|
||
fake_api.get_thing.assert_has_calls(
|
||
[call(resource_version=0, _preload_content=False, watch=True)] * 2)
|
||
fake_resp.stream.assert_has_calls(
|
||
[call(amt=None, decode_content=False)] * 2)
|
||
assert fake_resp.close.call_count == 2
|
||
assert fake_resp.release_conn.call_count == 2
|
||
|
||
def test_watch_with_error_event_and_timeout_param(self):
|
||
fake_resp = Mock()
|
||
fake_resp.close = Mock()
|
||
fake_resp.release_conn = Mock()
|
||
fake_resp.stream = Mock(
|
||
return_value=[
|
||
'{"type": "ERROR", "object": {"code": 410, '
|
||
'"reason": "Gone", "message": "error message"}}\n'])
|
||
|
||
fake_api = Mock()
|
||
fake_api.get_thing = Mock(return_value=fake_resp)
|
||
|
||
w = Watch()
|
||
try:
|
||
for _ in w.stream(fake_api.get_thing, timeout_seconds=10):
|
||
self.fail(self, "Should fail with ApiException.")
|
||
except client.rest.ApiException:
|
||
pass
|
||
|
||
fake_api.get_thing.assert_called_once_with(
|
||
_preload_content=False, watch=True, timeout_seconds=10)
|
||
fake_resp.stream.assert_called_once_with(
|
||
amt=None, decode_content=False)
|
||
fake_resp.close.assert_called_once()
|
||
fake_resp.release_conn.assert_called_once()
|
||
|
||
|
||
if __name__ == '__main__':
|
||
unittest.main()
|