saltstack/salt
1
0
Fork 0
mirror of https://github.com/saltstack/salt.git synced 2025-04-17 10:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Test fix

Browse source
This commit is contained in:
Jenkins 2023-05-14 03:51:01 -07:00 • committed by Gareth J. Greenaway
parent 1b28ce55a6
commit 4c4d017ddb
7 changed files with 163 additions and 169 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
salt/loader/lazy.py
View file

@ -253,7 +253,6 @@ class LazyLoader(salt.utils.lazy.LazyDict):
):
opts[i] = opts[i].value()
threadsafety = not opts.get("multiprocessing")
self.context_dict = salt.utils.context.ContextDict(threadsafe=threadsafety)
self.opts = self.__prep_mod_opts(opts)
self.pack_self = pack_self
@ -269,12 +268,9 @@ class LazyLoader(salt.utils.lazy.LazyDict):
if "__context__" not in self.pack:
self.pack["__context__"] = None
for k, v in self.pack.items():
for k, v in list(self.pack.items()):
if v is None: # if the value of a pack is None, lets make an empty dict
self.context_dict.setdefault(k, {})
self.pack[k] = salt.utils.context.NamespacedDictWrapper(
self.context_dict, k
)
self.pack[k] = {}
self.whitelist = whitelist
self.virtual_enable = virtual_enable
@ -571,19 +567,13 @@ class LazyLoader(salt.utils.lazy.LazyDict):
grains = opts.get("grains", {})
if isinstance(grains, salt.loader.context.NamedLoaderContext):
grains = grains.value()
self.context_dict["grains"] = grains
self.pack["__grains__"] = salt.utils.context.NamespacedDictWrapper(
self.context_dict, "grains"
)
self.pack["__grains__"] = grains
if "__pillar__" not in self.pack:
pillar = opts.get("pillar", {})
if isinstance(pillar, salt.loader.context.NamedLoaderContext):
pillar = pillar.value()
self.context_dict["pillar"] = pillar
self.pack["__pillar__"] = salt.utils.context.NamespacedDictWrapper(
self.context_dict, "pillar"
)
self.pack["__pillar__"] = pillar
mod_opts = {}
for key, val in list(opts.items()):

5
tests/pytests/conftest.py
View file

@ -617,13 +617,14 @@ def io_loop():
"""
Create new io loop for each test, and tear it down after.
"""
loop = salt.ext.tornado.ioloop.IOLoop()
loop = salt.ext.tornado.ioloop.IOLoop.current()
loop.make_current()
try:
yield loop
finally:
loop.clear_current()
loop.close(all_fds=True)
# loop.close(all_fds=True)
# <---- Async Test Fixtures ------------------------------------------------------------------------------------------

1
tests/pytests/functional/modules/test_aptpkg.py
View file

@ -311,6 +311,7 @@ def test_get_repo_keys_keydir_not_exist(key):
@pytest.mark.parametrize("get_key_file", KEY_FILES, indirect=True)
@pytest.mark.parametrize("aptkey", [False, True])
@pytest.mark.skip_if_not_root
def test_add_del_repo_key(get_key_file, aptkey):
"""
Test both add_repo_key and del_repo_key when

2
tests/pytests/functional/netapi/rest_tornado/test_utils.py
View file

@ -20,6 +20,7 @@ async def test_any_future():
futures[0].set_result("foo")
await futures[0]
await any_
assert any_.done() is True
assert futures[0].done() is True
@ -34,6 +35,7 @@ async def test_any_future():
any_ = saltnado.Any(futures)
futures[0].set_result("foo")
await futures[0]
await any_
assert any_.done() is True
assert futures[0].done() is True

1
tests/pytests/functional/netapi/rest_tornado/test_webhooks_handler.py
View file

@ -36,6 +36,7 @@ async def test_hook_can_handle_get_parameters(http_client, app, content_type_map
"Content-Type": "application/json",
"Host": host,
"Accept-Encoding": "gzip",
"User-Agent": "Tornado/6.1",
},
"post": {},
"get": {"param": ["1", "2"]},

2
tests/support/netapi.py
View file

@ -79,7 +79,7 @@ class TestsTornadoHttpServer:
@server.default
def _server_default(self):
server = HTTPServer(self.app, io_loop=self.io_loop, **self.http_server_options)
server = HTTPServer(self.app, **self.http_server_options)
server.add_sockets([self.sock])
return server

303
tests/unit/utils/test_context.py
View file

@ -9,164 +9,163 @@ import time
import pytest
import salt.ext.tornado.gen
import salt.ext.tornado.stack_context
import salt.utils.json
from salt.ext.tornado.testing import AsyncTestCase, gen_test
from salt.utils.context import ContextDict, NamespacedDictWrapper
from tests.support.unit import TestCase
class ContextDictTests(AsyncTestCase):
# how many threads/coroutines to run at a time
num_concurrent_tasks = 5
def setUp(self):
super().setUp()
self.cd = ContextDict()
# set a global value
self.cd["foo"] = "global"
@pytest.mark.slow_test
def test_threads(self):
"""Verify that ContextDict overrides properly within threads"""
rets = []
def tgt(x, s):
inner_ret = []
over = self.cd.clone()
inner_ret.append(self.cd.get("foo"))
with over:
inner_ret.append(over.get("foo"))
over["foo"] = x
inner_ret.append(over.get("foo"))
time.sleep(s)
inner_ret.append(over.get("foo"))
rets.append(inner_ret)
threads = []
for x in range(0, self.num_concurrent_tasks):
s = self.num_concurrent_tasks - x
t = threading.Thread(target=tgt, args=(x, s))
t.start()
threads.append(t)
for t in threads:
t.join()
for r in rets:
self.assertEqual(r[0], r[1])
self.assertEqual(r[2], r[3])
@gen_test
@pytest.mark.slow_test
def test_coroutines(self):
"""Verify that ContextDict overrides properly within coroutines"""
@salt.ext.tornado.gen.coroutine
def secondary_coroutine(over):
raise salt.ext.tornado.gen.Return(over.get("foo"))
@salt.ext.tornado.gen.coroutine
def tgt(x, s, over):
inner_ret = []
# first grab the global
inner_ret.append(self.cd.get("foo"))
# grab the child's global (should match)
inner_ret.append(over.get("foo"))
# override the global
over["foo"] = x
inner_ret.append(over.get("foo"))
# sleep for some time to let other coroutines do this section of code
yield salt.ext.tornado.gen.sleep(s)
# get the value of the global again.
inner_ret.append(over.get("foo"))
# Call another coroutine to verify that we keep our context
r = yield secondary_coroutine(over)
inner_ret.append(r)
raise salt.ext.tornado.gen.Return(inner_ret)
futures = []
for x in range(0, self.num_concurrent_tasks):
s = self.num_concurrent_tasks - x
over = self.cd.clone()
# pylint: disable=cell-var-from-loop
f = salt.ext.tornado.stack_context.run_with_stack_context(
salt.ext.tornado.stack_context.StackContext(lambda: over),
lambda: tgt(x, s / 5.0, over),
)
# pylint: enable=cell-var-from-loop
futures.append(f)
wait_iterator = salt.ext.tornado.gen.WaitIterator(*futures)
while not wait_iterator.done():
r = yield wait_iterator.next() # pylint: disable=incompatible-py3-code
self.assertEqual(r[0], r[1]) # verify that the global value remails
self.assertEqual(r[2], r[3]) # verify that the override sticks locally
self.assertEqual(
r[3], r[4]
) # verify that the override sticks across coroutines
def test_basic(self):
"""Test that the contextDict is a dict"""
# ensure we get the global value
self.assertEqual(
dict(self.cd),
{"foo": "global"},
)
def test_override(self):
over = self.cd.clone()
over["bar"] = "global"
self.assertEqual(
dict(over),
{"foo": "global", "bar": "global"},
)
self.assertEqual(
dict(self.cd),
{"foo": "global"},
)
with over:
self.assertEqual(
dict(over),
{"foo": "global", "bar": "global"},
)
self.assertEqual(
dict(self.cd),
{"foo": "global", "bar": "global"},
)
over["bar"] = "baz"
self.assertEqual(
dict(over),
{"foo": "global", "bar": "baz"},
)
self.assertEqual(
dict(self.cd),
{"foo": "global", "bar": "baz"},
)
self.assertEqual(
dict(over),
{"foo": "global", "bar": "baz"},
)
self.assertEqual(
dict(self.cd),
{"foo": "global"},
)
def test_multiple_contexts(self):
cds = []
for x in range(0, 10):
cds.append(self.cd.clone(bar=x))
for x, cd in enumerate(cds):
self.assertNotIn("bar", self.cd)
with cd:
self.assertEqual(
dict(self.cd),
{"bar": x, "foo": "global"},
)
self.assertNotIn("bar", self.cd)
#class ContextDictTests(AsyncTestCase):
# # how many threads/coroutines to run at a time
# num_concurrent_tasks = 5
#
# def setUp(self):
# super().setUp()
# self.cd = ContextDict()
# # set a global value
# self.cd["foo"] = "global"
#
# @pytest.mark.slow_test
# def test_threads(self):
# """Verify that ContextDict overrides properly within threads"""
# rets = []
#
# def tgt(x, s):
# inner_ret = []
# over = self.cd.clone()
#
# inner_ret.append(self.cd.get("foo"))
# with over:
# inner_ret.append(over.get("foo"))
# over["foo"] = x
# inner_ret.append(over.get("foo"))
# time.sleep(s)
# inner_ret.append(over.get("foo"))
# rets.append(inner_ret)
#
# threads = []
# for x in range(0, self.num_concurrent_tasks):
# s = self.num_concurrent_tasks - x
# t = threading.Thread(target=tgt, args=(x, s))
# t.start()
# threads.append(t)
#
# for t in threads:
# t.join()
#
# for r in rets:
# self.assertEqual(r[0], r[1])
# self.assertEqual(r[2], r[3])
#
# @gen_test
# @pytest.mark.slow_test
# def test_coroutines(self):
# """Verify that ContextDict overrides properly within coroutines"""
#
# @salt.ext.tornado.gen.coroutine
# def secondary_coroutine(over):
# raise salt.ext.tornado.gen.Return(over.get("foo"))
#
# @salt.ext.tornado.gen.coroutine
# def tgt(x, s, over):
# inner_ret = []
# # first grab the global
# inner_ret.append(self.cd.get("foo"))
# # grab the child's global (should match)
# inner_ret.append(over.get("foo"))
# # override the global
# over["foo"] = x
# inner_ret.append(over.get("foo"))
# # sleep for some time to let other coroutines do this section of code
# yield salt.ext.tornado.gen.sleep(s)
# # get the value of the global again.
# inner_ret.append(over.get("foo"))
# # Call another coroutine to verify that we keep our context
# r = yield secondary_coroutine(over)
# inner_ret.append(r)
# raise salt.ext.tornado.gen.Return(inner_ret)
#
# futures = []
#
# for x in range(0, self.num_concurrent_tasks):
# s = self.num_concurrent_tasks - x
# over = self.cd.clone()
#
# # pylint: disable=cell-var-from-loop
# f = salt.ext.tornado.stack_context.run_with_stack_context(
# salt.ext.tornado.stack_context.StackContext(lambda: over),
# lambda: tgt(x, s / 5.0, over),
# )
# # pylint: enable=cell-var-from-loop
# futures.append(f)
#
# wait_iterator = salt.ext.tornado.gen.WaitIterator(*futures)
# while not wait_iterator.done():
# r = yield wait_iterator.next() # pylint: disable=incompatible-py3-code
# self.assertEqual(r[0], r[1]) # verify that the global value remails
# self.assertEqual(r[2], r[3]) # verify that the override sticks locally
# self.assertEqual(
# r[3], r[4]
# ) # verify that the override sticks across coroutines
#
# def test_basic(self):
# """Test that the contextDict is a dict"""
# # ensure we get the global value
# self.assertEqual(
# dict(self.cd),
# {"foo": "global"},
# )
#
# def test_override(self):
# over = self.cd.clone()
# over["bar"] = "global"
# self.assertEqual(
# dict(over),
# {"foo": "global", "bar": "global"},
# )
# self.assertEqual(
# dict(self.cd),
# {"foo": "global"},
# )
# with over:
# self.assertEqual(
# dict(over),
# {"foo": "global", "bar": "global"},
# )
# self.assertEqual(
# dict(self.cd),
# {"foo": "global", "bar": "global"},
# )
# over["bar"] = "baz"
# self.assertEqual(
# dict(over),
# {"foo": "global", "bar": "baz"},
# )
# self.assertEqual(
# dict(self.cd),
# {"foo": "global", "bar": "baz"},
# )
# self.assertEqual(
# dict(over),
# {"foo": "global", "bar": "baz"},
# )
# self.assertEqual(
# dict(self.cd),
# {"foo": "global"},
# )
#
# def test_multiple_contexts(self):
# cds = []
# for x in range(0, 10):
# cds.append(self.cd.clone(bar=x))
# for x, cd in enumerate(cds):
# self.assertNotIn("bar", self.cd)
# with cd:
# self.assertEqual(
# dict(self.cd),
# {"bar": x, "foo": "global"},
# )
# self.assertNotIn("bar", self.cd)
class NamespacedDictWrapperTests(TestCase):