Coverage for fake_kubernetes_client/resource_manager.py: 31%

1"""FakeResourceManager implementation for fake Kubernetes client""" 

2 

3from typing import TYPE_CHECKING, Any, Union 

4 

5from fake_kubernetes_client.exceptions import ResourceNotFoundError 

6from fake_kubernetes_client.resource_field import FakeResourceField 

7from fake_kubernetes_client.resource_instance import FakeResourceInstance 

8 

9if TYPE_CHECKING: 

10 from fake_kubernetes_client.dynamic_client import FakeDynamicClient 

11 

12 

13class FakeResourceManager: 

14 """Manager for resource discovery and access""" 

15 

16 def __init__(self, client: "FakeDynamicClient") -> None: 

17 self.client = client 

18 self.registry = client.registry 

19 self.storage = client.storage 

20 

21 def get( 

22 self, 

23 api_version: Union[str, None] = None, 

24 kind: Union[str, None] = None, 

25 name: Union[str, None] = None, 

26 singular_name: Union[str, None] = None, 

27 namespaced: Union[bool, None] = None, 

28 group: Union[str, None] = None, 

29 version: Union[str, None] = None, 

30 preferred: Union[bool, None] = None, 

31 prefix: Union[str, None] = None, 

32 **kwargs: Any, 

33 ) -> FakeResourceInstance: 

34 """Get resource instance for performing operations""" 

35 # Construct API version if group and version provided 

36 if group is not None and version is not None: 

37 # Explicitly check if group is not empty string 

38 if group != "": 

39 api_version = f"{group}/{version}" 

40 else: 

41 # If group is empty string, use version alone (core API group) 

42 api_version = version 

43 

44 # Find resource definition 

45 resource_def = None 

46 

47 if kind and api_version: 

48 resource_def = self.registry.get_resource_definition(kind=kind, api_version=api_version) 

49 elif name and api_version: # 'name' is the plural 

50 resource_def = self.registry.get_resource_definition_by_plural(plural=name, api_version=api_version) 

51 elif kind: 

52 # Get all definitions for this kind 

53 definitions = self.registry.get_resource_definitions(kind=kind) 

54 if definitions: 

55 # If preferred is True, try to find preferred version 

56 if preferred: 

57 # Simple logic: prefer stable versions (v1 > v1beta1 > v1alpha1) 

58 for def_ in definitions: 

59 if def_["version"] == "v1": 

60 resource_def = def_ 

61 break 

62 if not resource_def: 

63 resource_def = definitions[0] 

64 else: 

65 resource_def = definitions[0] 

66 

67 if not resource_def: 

68 raise ResourceNotFoundError(f"Resource not found: api_version={api_version}, kind={kind}, name={name}") 

69 

70 return FakeResourceInstance(resource_def=resource_def, storage=self.storage, client=self.client) 

71 

72 def search( 

73 self, group: Union[str, None] = None, kind: Union[str, None] = None, **kwargs: Any 

74 ) -> list[FakeResourceField]: 

75 """Search for resource definitions""" 

76 # Delegate to registry's search method 

77 return self.registry.search(kind=kind, group=group, **kwargs)