Coverage for tests/tests_unit/test_data_grabber.py: 45%

1import copy 

2import datetime 

3import json 

4import uuid 

5 

6import pytest 

7import pytest_cases 

8from bson import ObjectId 

9from fastapi import HTTPException 

10from pydantic import BaseModel 

11from sotrans_models.models._base import BaseOIDModel, BaseUUIDModel 

12from sotrans_models.models.orders.order import OrderDBModel 

13from utils.data_grabber import MongoDataGrabber, adjust_search_query 

14 

15from ..tests_unit.cases_test_data_grabber import ( 

16 AdjustSearchQueryCases, 

17 ParseSortRaise, 

18) 

19from ..tests_unit.data_grabber_fixtures import ( 

20 initial_key_allowed, 

21 params_mock_one, 

22 params_mocks_full, 

23 params_mocks_raise, 

24) 

25from ..tests_unit.get_params_fixtures import ( 

26 mock_get_list_params, 

27 mock_get_one_params, 

28) 

29from ..tests_unit.model_fixtures import model_out 

30 

31 

32@pytest.mark.asyncio 

33async def test_get_list_full(params_mocks_full, mongo_table_engine, model_out): 

34 mongo_data_grabber = MongoDataGrabber(type(model_out), mongo_table_engine) 

35 got = await mongo_data_grabber.get_list(params_mocks_full) 

36 assert got.total == 1 

37 

38 

39@pytest.mark.asyncio 

40async def test_get_really_one(mongo_table_engine, model_out, params_mock_one): 

41 mongo_data_grabber = MongoDataGrabber(type(model_out), mongo_table_engine) 

42 got = await mongo_data_grabber.get_one(model_out.id, params_mock_one) 

43 assert got 

44 

45 

46@pytest.mark.asyncio 

47async def test_get_list_raises( 

48 params_mocks_raise, mongo_table_engine, model_out 

49): 

50 mongo_data_grabber = MongoDataGrabber(type(model_out), mongo_table_engine) 

51 with pytest.raises(HTTPException): 

52 await mongo_data_grabber.get_list(params_mocks_raise) 

53 

54 

55@pytest_cases.parametrize_with_cases("r", cases=ParseSortRaise) 

56@pytest.mark.asyncio 

57async def test_parse_sort_raise(r): 

58 with pytest.raises(HTTPException): 

59 MongoDataGrabber.parse_sort(r) 

60 

61 

62@pytest.mark.asyncio 

63async def test_raises_get_one_no_id(mock_get_one_params, mongo_table_engine): 

64 mongo_data_grabber = MongoDataGrabber(BaseModel, mongo_table_engine) 

65 with pytest.raises(HTTPException): 

66 await mongo_data_grabber.get_one(str(ObjectId()), mock_get_one_params) 

67 

68 

69@pytest.mark.asyncio 

70async def test_where_conversion_oid(): 

71 pattern = {"id": str(ObjectId()), "x": 2} 

72 MongoDataGrabber.where_conversion(pattern, BaseOIDModel) 

73 assert type(pattern["id"]) is ObjectId 

74 

75 

76def test_where_conversion_datetime(): 

77 pattern_simple = {"auction_end_time": "2024-04-20T00:00:00"} 

78 MongoDataGrabber.where_conversion(pattern_simple, OrderDBModel) 

79 assert type(pattern_simple["auction_end_time"]) is datetime.datetime 

80 pattern = { 

81 "auction_end_time": { 

82 "$gte": "2024-04-20T00:00:00", 

83 "$lte": "2024-04-24T00:00:00", 

84 } 

85 } 

86 MongoDataGrabber.where_conversion(pattern, OrderDBModel) 

87 assert type(pattern["auction_end_time"]["$gte"]) is datetime.datetime 

88 

89 

90def test_where_conversion_in_operator(): 

91 pattern = {"id": {"$in": [str(uuid.uuid4()) for _ in range(4)]}} 

92 MongoDataGrabber.where_conversion(pattern, BaseUUIDModel) 

93 assert all(type(u) is uuid.UUID for u in pattern["id"]["$in"]) 

94 

95 

96@pytest.mark.asyncio 

97async def test_where_conversion_raises(): 

98 pattern = {"id": {"$in": "x"}} 

99 with pytest.raises(HTTPException): 

100 MongoDataGrabber.where_conversion(pattern, BaseUUIDModel) 

101 

102 

103@pytest_cases.parametrize_with_cases( 

104 "initial,field,allowed,result", cases=AdjustSearchQueryCases 

105) 

106def test_adjust_search_query(initial, field, allowed, result): 

107 adjusted = adjust_search_query(json.dumps(initial), field, allowed) 

108 assert adjusted == json.dumps(result) 

109 

110 

111def test_adjust_search_query_raises_on_single_mismatch(initial_key_allowed): 

112 initial, key, allowed = initial_key_allowed 

113 with pytest.raises(HTTPException): 

114 adjust_search_query(json.dumps(initial), key, allowed) 

115 

116 

117def test_data_grabber_comparison_query(): 

118 pattern = {"client_price": {"$gte": 1000}, "id": {"$in": []}} 

119 convertable = copy.deepcopy(pattern) 

120 MongoDataGrabber.where_conversion(convertable, OrderDBModel) 

121 assert convertable == pattern 

122 

123 

124@pytest.mark.asyncio 

125async def test_data_grabber_comparison_raises(mongo_table_engine): 

126 pattern = {"client_price": {"$gte": {"$regex": "22"}}} 

127 with pytest.raises(HTTPException): 

128 MongoDataGrabber.where_conversion(pattern, OrderDBModel) 

129 

130 

131@pytest.mark.asyncio 

132async def test_data_grabber_raises_wrong_parameters(mongo_table_engine): 

133 pattern = {"client_price": "abc"} 

134 with pytest.raises(HTTPException): 

135 MongoDataGrabber.where_conversion(pattern, OrderDBModel) 

136 

137 

138def test_or_conversion(): 

139 pattern = {"$or": [{"id": str(uuid.uuid4())}]} 

140 MongoDataGrabber.where_conversion(pattern, BaseUUIDModel) 

141 assert type(pattern["$or"][0]["id"]) is uuid.UUID 

142 

143 

144def test_or_conversion_with_in(mongo_table_engine): 

145 pattern = {"$or": [{"id": {"$in": [str(uuid.uuid4()) for _ in range(3)]}}]} 

146 MongoDataGrabber.where_conversion(pattern, BaseUUIDModel) 

147 assert all(type(u) is uuid.UUID for u in pattern["$or"][0]["id"]["$in"]) 

148 

149 

150def test_conversion_with_list(mongo_table_engine): 

151 pattern = { 

152 OrderDBModel.assigned.company.employee.id: { 

153 "$in": [str(uuid.uuid4()) for _ in range(3)] 

154 } 

155 } 

156 MongoDataGrabber.where_conversion(pattern, OrderDBModel) 

157 assert all( 

158 type(u) is uuid.UUID 

159 for u in pattern[OrderDBModel.assigned.company.employee.id]["$in"] 

160 )