Coverage for app/backend/src/tests/test_search_bfc.py: 100%

148 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-16 22:03 +0000

1import time 

2from collections.abc import Generator 

3from concurrent import futures 

4from typing import Any 

5 

6import grpc 

7import pytest 

8from google.protobuf import empty_pb2, wrappers_pb2 

9from sqlalchemy import func, select, update 

10 

11from couchers import bfc 

12from couchers.config import config 

13from couchers.db import session_scope 

14from couchers.materialized_views import refresh_materialized_views, refresh_materialized_views_rapid 

15from couchers.models import User 

16from couchers.models.logging import EventLog 

17from couchers.proto import api_pb2, search_pb2 

18from couchers.proto.bfc import bfc_pb2, bfc_pb2_grpc 

19from couchers.servicers import search 

20from tests.fixtures.db import generate_user, make_user_block 

21from tests.fixtures.feature_flags import Flags 

22from tests.fixtures.rpc_errors import expect_rpc_error 

23from tests.fixtures.sessions import search_session 

24 

25 

26class FakeBfc(bfc_pb2_grpc.BFCServicer): 

27 def __init__(self) -> None: 

28 self.requests: list[bfc_pb2.UserSearchReq] = [] 

29 self.response = bfc_pb2.UserSearchRes() 

30 self.fail_with: grpc.StatusCode | None = None 

31 self.delay_seconds = 0.0 

32 

33 def UserSearch(self, request: bfc_pb2.UserSearchReq, context: grpc.ServicerContext) -> bfc_pb2.UserSearchRes: 

34 self.requests.append(request) 

35 time.sleep(self.delay_seconds) 

36 if self.fail_with: 

37 context.abort(self.fail_with, "bfc is down") 

38 return self.response 

39 

40 

41@pytest.fixture 

42def fake_bfc(monkeypatch, flags: Flags) -> Generator[FakeBfc]: 

43 fake = FakeBfc() 

44 with futures.ThreadPoolExecutor(1) as executor: 

45 server = grpc.server(executor) 

46 bfc_pb2_grpc.add_BFCServicer_to_server(fake, server) 

47 port = server.add_insecure_port("localhost:0") 

48 server.start() 

49 monkeypatch.setitem(config, "BFC_ADDRESS", f"localhost:{port}") 

50 flags.set_boolean("bfc_user_search_enabled", True) 

51 try: 

52 yield fake 

53 finally: 

54 server.stop(None).wait() 

55 

56 

57@pytest.fixture 

58def reported_errors(monkeypatch) -> list[Exception]: 

59 errors: list[Exception] = [] 

60 monkeypatch.setattr(search, "report_error", errors.append) 

61 return errors 

62 

63 

64def _refresh() -> None: 

65 refresh_materialized_views_rapid(empty_pb2.Empty()) 

66 refresh_materialized_views(empty_pb2.Empty()) 

67 

68 

69def _search_event() -> dict[str, Any]: 

70 with session_scope() as session: 

71 [event] = session.execute(select(EventLog).where(EventLog.event_type == "search.performed")).scalars().all() 

72 return dict(event.properties) 

73 

74 

75def test_request(db, fake_bfc: FakeBfc): 

76 user, token = generate_user(strong_verification=True) 

77 blocked, _ = generate_user() 

78 blocker, _ = generate_user() 

79 make_user_block(user, blocked) 

80 make_user_block(blocker, user) 

81 

82 with search_session(token) as api: 

83 api.UserSearchV2( 

84 search_pb2.UserSearchReq( 

85 search_in_rectangle=search_pb2.RectArea(lat_min=1, lat_max=2, lng_min=3, lng_max=4), 

86 hosting_status_filter=[api_pb2.HOSTING_STATUS_CAN_HOST, api_pb2.HOSTING_STATUS_MAYBE], 

87 language_ability_filter=[ 

88 api_pb2.LanguageAbility(code="fin", fluency=api_pb2.LanguageAbility.Fluency.FLUENCY_FLUENT) 

89 ], 

90 age_max=wrappers_pb2.UInt32Value(value=40), 

91 has_pets=wrappers_pb2.BoolValue(value=False), 

92 only_with_references=True, 

93 same_gender_only=True, 

94 page_size=10, 

95 page_token="token", 

96 ) 

97 ) 

98 

99 [req] = fake_bfc.requests 

100 assert req.viewer_id == user.id 

101 assert sorted(req.blocked_user_ids) == sorted([blocked.id, blocker.id]) 

102 assert req.rectangle == bfc_pb2.Rectangle(lat_min=1, lng_min=3, lat_max=2, lng_max=4) 

103 assert req.page_size == 10 

104 assert req.page_token == "token" 

105 assert list(req.filters.hosting_status) == [api_pb2.HOSTING_STATUS_CAN_HOST, api_pb2.HOSTING_STATUS_MAYBE] 

106 assert [(a.code, a.fluency) for a in req.filters.language_ability] == [ 

107 ("fin", api_pb2.LanguageAbility.Fluency.FLUENCY_FLUENT) 

108 ] 

109 assert req.filters.age_min.value == 18 

110 assert req.filters.age_max.value == 40 

111 assert req.filters.HasField("has_pets") and not req.filters.has_pets.value 

112 assert not req.filters.HasField("accepts_pets") 

113 assert not req.filters.HasField("last_active") 

114 assert req.filters.only_with_references 

115 assert list(req.filters.genders) == [user.gender] 

116 

117 

118def test_serves_bfc_results(db, fake_bfc: FakeBfc): 

119 user, token = generate_user() 

120 others = [generate_user()[0] for _ in range(4)] 

121 _refresh() 

122 

123 fake_bfc.response = bfc_pb2.UserSearchRes( 

124 search_id="search", 

125 results=[bfc_pb2.UserSearchResult(user_id=other.id) for other in reversed(others)], 

126 page_size=3, 

127 next_page_token="next", 

128 total=17, 

129 ) 

130 with search_session(token) as api: 

131 res = api.UserSearchV2(search_pb2.UserSearchReq()) 

132 

133 assert [result.user_id for result in res.results] == [other.id for other in reversed(others)][:3] 

134 assert res.next_page_token == "next" 

135 assert res.total_items == 17 

136 event = _search_event() 

137 assert event["source"] == "bfc" 

138 assert event["bfc_search_id"] == "search" 

139 

140 

141def test_falls_back_when_bfc_fails(db, fake_bfc: FakeBfc, reported_errors: list[Exception]): 

142 fake_bfc.fail_with = grpc.StatusCode.UNAVAILABLE 

143 user, token = generate_user() 

144 _refresh() 

145 

146 with search_session(token) as api: 

147 res = api.UserSearchV2(search_pb2.UserSearchReq()) 

148 

149 assert user.id in [result.user_id for result in res.results] 

150 assert len(fake_bfc.requests) == 1 

151 assert len(reported_errors) == 1 

152 event = _search_event() 

153 assert event["source"] == "fallback" 

154 assert event["bfc_search_id"] is None 

155 

156 

157def test_falls_back_when_bfc_is_too_slow(db, fake_bfc: FakeBfc, reported_errors: list[Exception], monkeypatch): 

158 monkeypatch.setattr(bfc, "TIMEOUT_SECONDS", 0.1) 

159 fake_bfc.delay_seconds = 0.5 

160 user, token = generate_user() 

161 _refresh() 

162 

163 with search_session(token) as api: 

164 res = api.UserSearchV2(search_pb2.UserSearchReq()) 

165 

166 assert user.id in [result.user_id for result in res.results] 

167 assert len(reported_errors) == 1 

168 assert _search_event()["source"] == "fallback" 

169 

170 

171def test_same_gender_needs_strong_verification(db, fake_bfc: FakeBfc): 

172 user, token = generate_user() 

173 

174 with search_session(token) as api: 

175 with expect_rpc_error(grpc.StatusCode.FAILED_PRECONDITION): 

176 api.UserSearchV2(search_pb2.UserSearchReq(same_gender_only=True)) 

177 

178 assert fake_bfc.requests == [] 

179 

180 

181def test_keywords_and_selections_stay_in_the_backend(db, fake_bfc: FakeBfc): 

182 user, token = generate_user() 

183 

184 with search_session(token) as api: 

185 api.UserSearchV2(search_pb2.UserSearchReq(query=wrappers_pb2.StringValue(value="anything"))) 

186 api.UserSearchV2(search_pb2.UserSearchReq(exactly_user_ids=[user.id])) 

187 

188 assert fake_bfc.requests == [] 

189 

190 

191def test_flag_off(db, fake_bfc: FakeBfc, flags: Flags): 

192 flags.set_boolean("bfc_user_search_enabled", False) 

193 user, token = generate_user() 

194 

195 with search_session(token) as api: 

196 api.UserSearchV2(search_pb2.UserSearchReq()) 

197 

198 assert fake_bfc.requests == [] 

199 assert _search_event()["source"] == "backend" 

200 

201 

202def test_skips_users_the_viewer_cannot_see(db, fake_bfc: FakeBfc): 

203 user, token = generate_user() 

204 visible, _ = generate_user() 

205 deleted, _ = generate_user() 

206 blocked, _ = generate_user() 

207 _refresh() 

208 make_user_block(user, blocked) 

209 with session_scope() as session: 

210 session.execute(update(User).where(User.id == deleted.id).values(deleted_at=func.now())) 

211 

212 fake_bfc.response = bfc_pb2.UserSearchRes( 

213 results=[bfc_pb2.UserSearchResult(user_id=u.id) for u in [deleted, visible, blocked]], 

214 page_size=3, 

215 total=3, 

216 ) 

217 with search_session(token) as api: 

218 res = api.UserSearchV2(search_pb2.UserSearchReq()) 

219 

220 assert [result.user_id for result in res.results] == [visible.id]