Coverage for tests/unit/test_utils.py: 100%

44 statements  

« prev     ^ index     » next       coverage.py v7.5.0, created at 2024-04-23 13:14 -0600

1"""Test functions in es_testbed.helpers.utils""" 

2# pylint: disable=missing-function-docstring,redefined-outer-name 

3import typing as t 

4import pytest 

5from es_testbed import defaults as dft 

6from es_testbed.helpers import utils as u 

7 

8FMAP: t.Dict[str, t.Dict] = { 

9 'hot': dft.ilmhot(), 

10 'warm': dft.ilmwarm(), 

11 'cold': dft.ilmcold(), 

12 'frozen': dft.ilmfrozen(), 

13 'delete': dft.ilmdelete(), 

14} 

15REPO: str = 'repo' 

16TIERS: t.Sequence[str] = ['hot', 'warm', 'cold', 'frozen', 'delete'] 

17TREPO: t.Dict[str, t.Union[str, None]] = { 

18 'hot': None, 

19 'warm': None, 

20 'cold': REPO, 

21 'frozen': REPO, 

22 'delete': None, 

23} 

24 

25def searchable(repo: str=None) -> t.Union[t.Dict[str, t.Dict[str, str]], None]: 

26 if repo: 

27 return {'searchable_snapshot': {'snapshot_repository': repo}} 

28 return {} 

29 

30def forcemerge(fm: bool=False, mns: int=1) -> t.Union[t.Dict[str, t.Dict[str, str]], None]: 

31 if fm: 

32 return {'forcemerge': {'max_num_segments': mns}} 

33 return {} 

34 

35@pytest.fixture 

36def tiertestval(): 

37 def _tiertestval(tier: str, repo: str=None, fm: bool=False, mns: int=1): 

38 retval = {tier: FMAP[tier]} 

39 retval[tier]['actions'].update(searchable(repo)) 

40 retval[tier]['actions'].update(forcemerge(fm=fm, mns=mns)) 

41 return retval 

42 return _tiertestval 

43 

44@pytest.fixture 

45def builtphase(): 

46 def _builtphase(tier: str, repo: str=None, fm: bool=False, mns: int=1): 

47 return u.build_ilm_phase(tier, actions=forcemerge(fm=fm, mns=mns), repository=repo) 

48 return _builtphase 

49 

50def test_build_ilm_phase_defaults(builtphase, tiertestval): 

51 for tier in TIERS: 

52 assert builtphase(tier, repo=TREPO[tier]) == tiertestval(tier, repo=TREPO[tier]) 

53 

54# This allows me to run multiple testing scenarios in the same test space 

55def test_build_ilm_policy(tiertestval): 

56 # 3 tests building different ILM policies with different tiers 

57 tgroups = [['hot', 'delete'], ['hot', 'frozen', 'delete'], ['hot', 'cold', 'delete']] 

58 # Each tier group corresponds to a forcemerge plan by list index, with each index a tuple for 

59 # forcemerge True/False and max_num_segment count 

60 fmerge = [(False, 0), (False, 0), (True, 3)] 

61 for idx, tgrp in enumerate(tgroups): # Iterate over testing scenarios 

62 phases = {} # Build out the phase dict for each scenario 

63 fm, mns = fmerge[idx] # Extract whether to use forcemerge by index/tuple 

64 for tier in tgrp: # Iterate over each tier in the testing scenario 

65 phases.update(tiertestval(tier, repo=TREPO[tier])) # Update with values per tier 

66 if fm: # If we're doing forcemerge 

67 phases['hot']['actions'].update(forcemerge(fm=fm, mns=mns)) # Update the hot tier 

68 # To keep the line more readable, build the kwargs as a dict first 

69 kwargs = {'repository': REPO, 'forcemerge': fm, 'max_num_segments': mns} 

70 # Then pass it as **kwargs 

71 assert u.build_ilm_policy(tgrp, **kwargs) == {'phases': phases} 

72 # Our policy is easier to build at the last minute rather than constantly passing 

73 # dict['phases']['tier']