Coverage for app/backend/src/tests/test_metrics.py: 98%

144 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-20 12:21 +0000

1from datetime import timedelta 

2 

3import pytest 

4from google.protobuf import empty_pb2 

5from sqlalchemy import update 

6 

7from couchers.db import session_scope 

8from couchers.materialized_views import refresh_materialized_views 

9from couchers.metrics import ( 

10 _set_hacky_gauges_funcs, 

11 _set_hacky_labeled_gauges_funcs, 

12 _set_hacky_multi_gauges_funcs, 

13 active_users_by_platform_gauge, 

14 active_users_by_platform_statement, 

15 active_users_by_recency_gauge, 

16 active_users_mobile_fraction_gauge, 

17 sent_request_gauge, 

18 users_gauges, 

19 users_per_community_gauge, 

20) 

21from couchers.models import ClientPlatform, HostingStatus, User, UserActivity 

22from couchers.utils import now, today 

23from tests.fixtures.db import generate_user 

24from tests.test_communities import create_community 

25from tests.test_requests import _create_host_request_via_api, _create_public_trip 

26 

27 

28def _populate(gauge): 

29 for registered_gauge, f in _set_hacky_labeled_gauges_funcs: 29 ↛ 33line 29 didn't jump to line 33 because the loop on line 29 didn't complete

30 if registered_gauge is gauge: 

31 f(registered_gauge) 

32 return 

33 raise AssertionError("gauge is not a registered labeled gauge") 

34 

35 

36def _query_value(gauge): 

37 for registered_gauge, f in _set_hacky_gauges_funcs: 37 ↛ 40line 37 didn't jump to line 40 because the loop on line 37 didn't complete

38 if registered_gauge is gauge: 

39 return f() 

40 raise AssertionError("gauge is not a registered gauge") 

41 

42 

43def _populate_single_pass(): 

44 for f in _set_hacky_multi_gauges_funcs: 

45 f() 

46 

47 

48def _sample_values(gauge): 

49 return { 

50 sample.labels[gauge._labelnames[0]]: sample.value for metric in gauge.collect() for sample in metric.samples 

51 } 

52 

53 

54def _users_gauge_values(): 

55 return { 

56 sample.name: sample.value for gauge in users_gauges for metric in gauge.collect() for sample in metric.samples 

57 } 

58 

59 

60def test_users_per_community_gauge(db): 

61 user1, _ = generate_user() 

62 user2, _ = generate_user() 

63 user3, _ = generate_user() 

64 

65 with session_scope() as session: 

66 world = create_community(session, 0, 100, "World", [user1], [], None) 

67 macroregion = create_community(session, 0, 50, "Macroregion", [user2], [], world) 

68 region = create_community(session, 0, 25, "Region", [user3], [user1], macroregion) 

69 # subregion is below the region level and must be excluded 

70 create_community(session, 0, 10, "Subregion", [user2], [user3], region) 

71 

72 # the gauge reads from the cluster_subscription_counts materialized view 

73 refresh_materialized_views(empty_pb2.Empty()) 

74 

75 _populate(users_per_community_gauge) 

76 values = _sample_values(users_per_community_gauge) 

77 

78 assert values["World"] == 1 

79 assert values["Macroregion"] == 1 

80 assert values["Region"] == 2 

81 assert "Subregion" not in values 

82 

83 

84def test_active_users_by_recency_gauge(db): 

85 ages = { 

86 "<1d": timedelta(hours=2), 

87 "1d-1w": timedelta(days=3), 

88 "1w-1m": timedelta(days=14), 

89 "1m-6m": timedelta(days=60), 

90 "6m-12m": timedelta(days=250), 

91 "12m-24m": timedelta(days=500), 

92 "24m+": timedelta(days=800), 

93 } 

94 user_ids_by_bucket = {} 

95 for bucket in ages: 

96 user, _ = generate_user() 

97 user_ids_by_bucket[bucket] = user.id 

98 

99 with session_scope() as session: 

100 for bucket, age in ages.items(): 

101 session.execute(update(User).where(User.id == user_ids_by_bucket[bucket]).values(last_active=now() - age)) 

102 

103 _populate_single_pass() 

104 values = _sample_values(active_users_by_recency_gauge) 

105 

106 for bucket in ages: 

107 assert values[bucket] == 1 

108 

109 

110def test_active_users_by_recency_gauge_emits_empty_buckets(db): 

111 generate_user() 

112 

113 _populate_single_pass() 

114 values = _sample_values(active_users_by_recency_gauge) 

115 

116 # every bucket is always emitted, even the ones with no users in them 

117 assert set(values) == {"<1d", "1d-1w", "1w-1m", "1m-6m", "6m-12m", "12m-24m", "24m+"} 

118 assert values["<1d"] == 1 

119 assert values["24m+"] == 0 

120 

121 

122def test_users_gauges(db): 

123 generate_user(gender="Man", hosting_status=HostingStatus.can_host) 

124 generate_user(gender="Woman", hosting_status=HostingStatus.cant_host) 

125 generate_user(gender="Non-binary", hosting_status=HostingStatus.maybe) 

126 generate_user(gender="Woman", hosting_status=HostingStatus.can_host, delete_user=True) 

127 

128 _populate_single_pass() 

129 values = _users_gauge_values() 

130 

131 # the deleted user is excluded from every count 

132 assert values["couchers_users"] == 3 

133 assert values["couchers_active_users_5m"] == 3 

134 assert values["couchers_users_man"] == 1 

135 assert values["couchers_users_woman"] == 1 

136 assert values["couchers_users_nonbinary"] == 1 

137 assert values["couchers_users_can_host"] == 1 

138 assert values["couchers_users_cant_host"] == 1 

139 assert values["couchers_users_maybe"] == 1 

140 

141 

142def test_users_completed_profile_gauge(db): 

143 generate_user() 

144 generate_user() 

145 short_about_me, _ = generate_user() 

146 # a long enough about me isn't sufficient on its own, there has to be a photo in the profile gallery too 

147 generate_user(complete_profile=False, about_me="x" * 150) 

148 

149 # ...and neither is a photo without a long enough about me 

150 with session_scope() as session: 

151 session.execute(update(User).where(User.id == short_about_me.id).values(about_me="too short")) 

152 

153 _populate_single_pass() 

154 

155 assert _users_gauge_values()["couchers_users_completed_profile"] == 2 

156 

157 

158def _add_activity(user_id: int, client_platform: ClientPlatform | None, age: timedelta = timedelta(minutes=1)) -> None: 

159 with session_scope() as session: 

160 session.add(UserActivity(user_id=user_id, period=now() - age, client_platform=client_platform, api_calls=1)) 

161 

162 

163def _platform_metrics() -> dict[str, int]: 

164 with session_scope() as session: 

165 return dict(session.execute(active_users_by_platform_statement()).one()._mapping) 

166 

167 

168def _gauge_value(gauge) -> float: 

169 return float(next(sample.value for metric in gauge.collect() for sample in metric.samples)) 

170 

171 

172def test_active_users_by_platform(db): 

173 web_desktop_user, _ = generate_user() 

174 web_mobile_user, _ = generate_user() 

175 ios_user, _ = generate_user() 

176 android_user, _ = generate_user() 

177 other_user, _ = generate_user() 

178 

179 _add_activity(web_desktop_user.id, ClientPlatform.web_desktop) 

180 _add_activity(web_mobile_user.id, ClientPlatform.web_mobile) 

181 _add_activity(ios_user.id, ClientPlatform.app_ios) 

182 _add_activity(android_user.id, ClientPlatform.app_android) 

183 _add_activity(other_user.id, None) 

184 

185 # the "other" (null platform) user is counted in the total but in no platform bucket, and mobile is the union of 

186 # web_mobile + app_ios + app_android 

187 assert _platform_metrics() == { 

188 "total": 5, 

189 "mobile": 3, 

190 "web_desktop": 1, 

191 "web_mobile": 1, 

192 "app_ios": 1, 

193 "app_android": 1, 

194 } 

195 

196 

197def test_active_users_by_platform_excludes_invisible_users(db): 

198 visible_user, _ = generate_user() 

199 deleted_user, _ = generate_user(delete_user=True) 

200 

201 _add_activity(visible_user.id, ClientPlatform.web_desktop) 

202 _add_activity(deleted_user.id, ClientPlatform.web_desktop) 

203 

204 assert _platform_metrics() == { 

205 "total": 1, 

206 "mobile": 0, 

207 "web_desktop": 1, 

208 "web_mobile": 0, 

209 "app_ios": 0, 

210 "app_android": 0, 

211 } 

212 

213 

214def test_active_users_by_platform_counts_user_once_per_platform(db): 

215 user, _ = generate_user() 

216 

217 _add_activity(user.id, ClientPlatform.web_desktop) 

218 _add_activity(user.id, ClientPlatform.app_ios) 

219 

220 # the user is counted once in the total and once in mobile (they had app_ios activity), but appears in both the 

221 # web_desktop and app_ios breakdowns 

222 assert _platform_metrics() == { 

223 "total": 1, 

224 "mobile": 1, 

225 "web_desktop": 1, 

226 "web_mobile": 0, 

227 "app_ios": 1, 

228 "app_android": 0, 

229 } 

230 

231 

232def test_active_users_by_platform_excludes_old_activity(db): 

233 user, _ = generate_user() 

234 

235 _add_activity(user.id, ClientPlatform.app_ios, age=timedelta(days=2)) 

236 

237 assert _platform_metrics() == { 

238 "total": 0, 

239 "mobile": 0, 

240 "web_desktop": 0, 

241 "web_mobile": 0, 

242 "app_ios": 0, 

243 "app_android": 0, 

244 } 

245 

246 

247def test_active_users_mobile_fraction_gauge(db): 

248 desktop_user, _ = generate_user() 

249 mobile_web_user, _ = generate_user() 

250 ios_user, _ = generate_user() 

251 android_user, _ = generate_user() 

252 

253 _add_activity(desktop_user.id, ClientPlatform.web_desktop) 

254 _add_activity(mobile_web_user.id, ClientPlatform.web_mobile) 

255 _add_activity(ios_user.id, ClientPlatform.app_ios) 

256 _add_activity(android_user.id, ClientPlatform.app_android) 

257 

258 # populating the breakdown gauge also sets the mobile fraction gauge: 3 of 4 active users are on mobile 

259 _populate(active_users_by_platform_gauge) 

260 assert _gauge_value(active_users_mobile_fraction_gauge) == pytest.approx(0.75) 

261 

262 

263def test_sent_request_gauge_excludes_public_trip_offers(db, moderator): 

264 _, surfer_token = generate_user() 

265 host, host_token = generate_user() 

266 traveller, _ = generate_user() 

267 

268 _create_host_request_via_api(surfer_token, host.id, moderator) 

269 

270 # the host offering to host a public trip hasn't sent a host request 

271 trip_id = _create_public_trip(traveller.id, today() + timedelta(days=5), today() + timedelta(days=10)) 

272 _create_host_request_via_api(host_token, traveller.id, moderator, public_trip_id=trip_id) 

273 

274 assert _query_value(sent_request_gauge) == 1