reconstructed/tests/test_variables.py

296 lines
10 KiB
Python

"""Tests for the variable storage / cache."""
import pytest
from . import reconstructed
class TestBasics:
"""Test basic access to the store."""
@pytest.fixture
def host_vars(self):
"""A set of fake host vars to use."""
return {
"var1": "value1",
"var2": "value2",
}
@pytest.fixture
def store(self, host_vars):
"""A store initialized with the host variables above."""
return reconstructed.VariableStorage(host_vars)
def test_init(self, host_vars, store):
"""Reference to host vars is copied, cache is initialized, stack is empty."""
assert store._host_vars is host_vars
assert store._cache == host_vars
assert store._cache is not host_vars
assert len(store._script_vars) == 0
assert len(store._script_stack) == 0
def test_read_hostvar(self, host_vars, store):
"""Host vars can be read from the store."""
for k, v in host_vars.items():
assert store[k] == host_vars[k]
def test_del_hostvars(self, host_vars, store):
"""Host variables cannot be deleted."""
for k in host_vars.keys():
with pytest.raises(KeyError):
del store[k]
assert k in store._host_vars
assert k in store._cache
assert store[k] == host_vars[k]
def test_write_local(self, host_vars, store):
"""Variables can be written and read back."""
k, v = "local", "valuel"
assert k not in store
store[k] = v
assert k in store
assert store[k] == v
assert k not in host_vars
assert k in store._script_vars
assert store._script_vars[k] == v
assert k in store._cache
assert store._cache[k] == v
def test_del_local(self, host_vars, store):
"""Local variables can be deleted."""
k, v = "local", "valuel"
assert k not in store
store[k] = v
del store[k]
assert k not in store
assert k not in host_vars
assert k not in store._script_vars
assert k not in store._cache
def test_local_hides_hostvar(self, host_vars, store):
"""Local variables can hide host variables with the same name."""
k = tuple(host_vars.keys())[0]
initial = host_vars[k]
v = initial + "nope"
store[k] = v
assert k in store
assert store[k] == v
assert host_vars[k] == initial
assert k in store._script_vars
assert store._script_vars[k] == v
assert k in store._cache
assert store._cache[k] == v
def test_del_unhides_hostvar(self, host_vars, store):
"""Deleting a local that hides a host vars makes the host var visible again."""
k = tuple(host_vars.keys())[0]
initial = host_vars[k]
v = initial + "nope"
store[k] = v
del store[k]
assert k in store
assert store[k] == initial
assert host_vars[k] == initial
assert k not in store._script_vars
assert k in store._cache
assert store._cache[k] == initial
class TestIterators:
"""Tests for the various iterator methods."""
@pytest.fixture
def host_vars(self):
"""A set of fake host vars to use."""
return {
"var1": "value1",
"var2": "value2",
}
@pytest.fixture
def local_vars(self, host_vars):
"""A set of local vars, one of which overrides a host var."""
k = tuple(host_vars.keys())[0]
return {
k: "not " + host_vars[k],
"varl": "valuel",
}
@pytest.fixture
def store(self, host_vars, local_vars):
"""A store initialized with both host variables and locals."""
store = reconstructed.VariableStorage(host_vars)
for k, v in local_vars.items():
store[k] = v
return store
def test_keys(self, host_vars, local_vars, store):
"""A store's keys are the union of its host and local variable names."""
expected = set(host_vars.keys()) | set(local_vars.keys())
actual = set(store.keys())
assert expected == actual
def test_values(self, host_vars, local_vars, store):
"""A store's values correspond to the ones in host and local variables, \
with the latter taking precedence."""
expected = dict(host_vars)
expected.update(local_vars)
assert tuple(expected.values()) == tuple(store.values())
def test_items(self, host_vars, local_vars, store):
"""A store's items correspond to the ones in host and local variables, \
with the latter taking precedence."""
expected = dict(host_vars)
expected.update(local_vars)
assert tuple(expected.items()) == tuple(store.items())
def test_iter(self, host_vars, local_vars, store):
"""Iterating over a store is equivalent to getting its keys."""
expected = set(host_vars.keys()) | set(local_vars.keys())
actual = set(k for k in store)
assert expected == actual
class TestStack:
"""Tests for the stack features of the variable storage class."""
@pytest.fixture
def host_vars(self):
"""A set of fake host vars to use."""
return {
"var1": ["value1"],
}
@pytest.fixture
def local_vars(self):
"""A set of fake local variables."""
return {
"varl1": ["valuel1"],
}
@pytest.fixture
def store(self, host_vars, local_vars):
"""A store initialized with both host variables and locals."""
store = reconstructed.VariableStorage(host_vars)
for k, v in local_vars.items():
store[k] = v
return store
def test_push_empty(self, store):
"""Test pushing nothing."""
store._script_stack_push(())
assert len(store._script_stack) == 1
assert store._script_stack[0] == {}
def test_push_missing(self, store):
"""Test pushing a variable that is not defined."""
v = "nope"
assert v not in store._script_vars
assert v not in store._host_vars
store._script_stack_push((v,))
assert len(store._script_stack) == 1
assert store._script_stack[0] == {v: (False, None)}
def test_push_host(self, store, host_vars):
"""Test pushing a single, existing host var."""
v = "var1"
assert v in store._host_vars
store._script_stack_push((v,))
assert len(store._script_stack) == 1
assert store._script_stack[0] == {v: (False, None)}
def test_push_local(self, store):
"""Test pushing a single, existing local var."""
v = "varl1"
assert v in store._script_vars
store._script_stack_push((v,))
assert len(store._script_stack) == 1
assert store._script_stack[0] == {v: (True, store._script_vars[v])}
assert store._script_stack[0][v][1] is not store._script_vars[v]
def test_pop_empty(self, store):
"""Test poping an empty stack entry."""
old_cache = store._cache
store._script_stack.append({})
store._script_stack_pop()
assert len(store._script_stack) == 0
assert store._cache is old_cache
def test_pop_missing(self, store):
"""Test poping a variable that is not defined."""
old_cache = store._cache
v = "nope"
assert v not in store._script_vars
assert v not in store._host_vars
store._script_stack.append({v: (False, None)})
store._script_stack_pop()
assert len(store._script_stack) == 0
assert store._cache is old_cache
def test_pop_unchanged_host(self, store):
"""Test poping a host variable that was not overridden."""
old_cache = store._cache
v = "var1"
assert v in store._host_vars
assert v not in store._script_vars
store._script_stack.append({v: (False, None)})
store._script_stack_pop()
assert len(store._script_stack) == 0
assert store._cache is old_cache
def test_pop_overridden_host(self, store):
"""Test poping a host variable that was overridden."""
old_cache = store._cache
v_name = "var1"
v_value = "test"
assert v_name in store._host_vars
assert v_name not in store._script_vars
store._script_stack.append({v_name: (False, None)})
store._script_vars[v_name] = v_value
store._cache[v_name] = v_value
assert store[v_name] == v_value
store._script_stack_pop()
assert len(store._script_stack) == 0
assert store._cache is not old_cache
assert store._cache[v_name] == store._host_vars[v_name]
assert v_name not in store._script_vars
def test_pop_unchanged_local(self, store):
"""Test poping a script variable that was not changed."""
old_cache = store._cache
v_name = "varl1"
assert v_name not in store._host_vars
assert v_name in store._script_vars
v_initial = store._script_vars[v_name]
store._script_stack.append({v_name: (True, v_initial)})
store._script_stack_pop()
assert len(store._script_stack) == 0
assert store._cache is not old_cache
assert v_name in store._cache
assert store._cache[v_name] is v_initial
assert v_name in store._script_vars
assert store._script_vars[v_name] is v_initial
def test_pop_modified_local(self, store):
"""Test poping a script variable that was modified."""
old_cache = store._cache
v_name = "varl1"
assert v_name not in store._host_vars
assert v_name in store._script_vars
v_initial = store._script_vars[v_name]
v_new = ["no"]
store._script_vars[v_name] = v_new
store._cache[v_name] = v_new
store._script_stack.append({v_name: (True, v_initial)})
store._script_stack_pop()
assert len(store._script_stack) == 0
assert store._cache is not old_cache
assert v_name in store._cache
assert store._cache[v_name] is v_initial
assert v_name in store._script_vars
assert store._script_vars[v_name] is v_initial