Coverage for src/tests/test

1import grpc

2import pytest

3from google.protobuf import wrappers_pb2

5from couchers import errors

6from couchers.crypto import random_hex

7from couchers.db import session_scope

8from couchers.models import Cluster, ClusterRole, ClusterSubscription, Node, Page, PageType, PageVersion, Thread, Upload

9from couchers.utils import create_polygon_lat_lng, now, to_aware_datetime, to_multi

10from proto import pages_pb2

11from tests.test_communities import create_community

12from tests.test_fixtures import db, generate_user, pages_session, testconfig # noqa

15@pytest.fixture(autouse=True)

16def _(testconfig):

17 pass

20def test_create_place_errors(db):

21 user, token = generate_user()

22 with session_scope() as session:

23 create_community(session, 0, 2, "Root node", [user], [], None)

25 with pages_session(token) as api:

26 with pytest.raises(grpc.RpcError) as e:

27 api.CreatePlace(

28 pages_pb2.CreatePlaceReq(

29 title=None,

30 content="dummy content",

31 address="dummy address",

32 location=pages_pb2.Coordinate(

33 lat=1,

34 lng=1,

35 ),

36 )

37 )

38 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

39 assert e.value.details() == errors.MISSING_PAGE_TITLE

41 with pages_session(token) as api:

42 with pytest.raises(grpc.RpcError) as e:

43 api.CreatePlace(

44 pages_pb2.CreatePlaceReq(

45 title="dummy title",

46 content=None,

47 address="dummy address",

48 location=pages_pb2.Coordinate(

49 lat=1,

50 lng=1,

51 ),

52 )

53 )

54 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

55 assert e.value.details() == errors.MISSING_PAGE_CONTENT

57 with pages_session(token) as api:

58 with pytest.raises(grpc.RpcError) as e:

59 api.CreatePlace(

60 pages_pb2.CreatePlaceReq(

61 title="dummy title",

62 content="dummy content",

63 address=None,

64 location=pages_pb2.Coordinate(

65 lat=1,

66 lng=1,

67 ),

68 )

69 )

70 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

71 assert e.value.details() == errors.MISSING_PAGE_ADDRESS

73 with pages_session(token) as api:

74 with pytest.raises(grpc.RpcError) as e:

75 api.CreatePlace(

76 pages_pb2.CreatePlaceReq(

77 title="dummy title",

78 content="dummy content",

79 address="dummy address",

80 )

81 )

82 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

83 assert e.value.details() == errors.MISSING_PAGE_LOCATION

86def test_create_guide_errors(db):

87 user, token = generate_user()

88 with session_scope() as session:

89 c_id = create_community(session, 0, 2, "Root node", [user], [], None).id

91 with pages_session(token) as api:

92 with pytest.raises(grpc.RpcError) as e:

93 api.CreateGuide(

94 pages_pb2.CreateGuideReq(

95 title=None,

96 content="dummy content",

97 parent_community_id=c_id,

98 )

99 )

100 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

101 assert e.value.details() == errors.MISSING_PAGE_TITLE

102

103 with pages_session(token) as api:

104 with pytest.raises(grpc.RpcError) as e:

105 api.CreateGuide(

106 pages_pb2.CreateGuideReq(

107 title="dummy title",

108 content=None,

109 parent_community_id=c_id,

110 )

111 )

112 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

113 assert e.value.details() == errors.MISSING_PAGE_CONTENT

114

115 with pages_session(token) as api:

116 with pytest.raises(grpc.RpcError) as e:

117 api.CreateGuide(

118 pages_pb2.CreateGuideReq(

119 title="dummy title",

120 content="dummy content",

121 )

122 )

123 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

124 assert e.value.details() == errors.MISSING_PAGE_PARENT

125

126 with pages_session(token) as api:

127 with pytest.raises(grpc.RpcError) as e:

128 api.CreateGuide(

129 pages_pb2.CreateGuideReq(

130 title="dummy title",

131 content="dummy content",

132 parent_community_id=9999,

133 )

134 )

135 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

136 assert e.value.details() == errors.COMMUNITY_NOT_FOUND

137

138 with pages_session(token) as api:

139 with pytest.raises(grpc.RpcError) as e:

140 api.CreateGuide(

141 pages_pb2.CreateGuideReq(

142 title="dummy title",

143 content="dummy content",

144 address="dummy address",

145 parent_community_id=c_id,

146 )

147 )

148 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

149 assert e.value.details() == errors.INVALID_GUIDE_LOCATION

150

151 with pages_session(token) as api:

152 with pytest.raises(grpc.RpcError) as e:

153 api.CreateGuide(

154 pages_pb2.CreateGuideReq(

155 title="dummy title",

156 content="dummy content",

157 location=pages_pb2.Coordinate(

158 lat=1,

159 lng=1,

160 ),

161 parent_community_id=c_id,

162 )

163 )

164 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

165 assert e.value.details() == errors.INVALID_GUIDE_LOCATION

166

167

168def test_create_page_place(db):

169 user, token = generate_user()

170 with session_scope() as session:

171 c_id = create_community(session, 0, 2, "Root node", [user], [], None).id

172

173 with pages_session(token) as api:

174 time_before = now()

175 res = api.CreatePlace(

176 pages_pb2.CreatePlaceReq(

177 title="dummy !#¤%&/-*' title",

178 content="dummy content",

179 address="dummy address",

180 location=pages_pb2.Coordinate(

181 lat=1,

182 lng=1,

183 ),

184 )

185 )

186

187 assert res.title == "dummy !#¤%&/-*' title"

188 assert res.type == pages_pb2.PAGE_TYPE_PLACE

189 assert res.content == "dummy content"

190 assert res.address == "dummy address"

191 assert res.location.lat == 1

192 assert res.location.lng == 1

193 assert res.slug == "dummy-title"

194 assert time_before <= to_aware_datetime(res.created) <= now()

195 assert time_before <= to_aware_datetime(res.last_edited) <= now()

196 assert res.last_editor_user_id == user.id

197 assert res.creator_user_id == user.id

198 assert res.owner_user_id == user.id

199 assert not res.owner_community_id

200 assert not res.owner_group_id

201 assert res.editor_user_ids == [user.id]

202 assert res.can_edit

203 assert res.can_moderate

204

205

206def test_create_page_guide(db):

207 user, token = generate_user()

208 with session_scope() as session:

209 c_id = create_community(session, 0, 2, "Root node", [user], [], None).id

210

211 with pages_session(token) as api:

212 time_before = now()

213 res = api.CreateGuide(

214 pages_pb2.CreateGuideReq(

215 title="dummy title",

216 content="dummy content",

217 address="dummy address",

218 location=pages_pb2.Coordinate(

219 lat=1,

220 lng=1,

221 ),

222 parent_community_id=c_id,

223 )

224 )

225

226 assert res.title == "dummy title"

227 assert res.type == pages_pb2.PAGE_TYPE_GUIDE

228 assert res.content == "dummy content"

229 assert res.address == "dummy address"

230 assert res.location.lat == 1

231 assert res.location.lng == 1

232 assert res.slug == "dummy-title"

233 assert time_before <= to_aware_datetime(res.created) <= now()

234 assert time_before <= to_aware_datetime(res.last_edited) <= now()

235 assert res.last_editor_user_id == user.id

236 assert res.creator_user_id == user.id

237 assert res.owner_user_id == user.id

238 assert not res.owner_community_id

239 assert not res.owner_group_id

240 assert res.editor_user_ids == [user.id]

241 assert res.can_edit

242 assert res.can_moderate

243

244 with pages_session(token) as api:

245 time_before = now()

246 res = api.CreateGuide(

247 pages_pb2.CreateGuideReq(

248 title="dummy title",

249 content="dummy content",

250 parent_community_id=c_id,

251 )

252 )

253

254 assert res.title == "dummy title"

255 assert res.type == pages_pb2.PAGE_TYPE_GUIDE

256 assert res.content == "dummy content"

257 assert not res.address

258 assert not res.HasField("location")

259 assert res.slug == "dummy-title"

260 assert time_before <= to_aware_datetime(res.created) <= now()

261 assert time_before <= to_aware_datetime(res.last_edited) <= now()

262 assert res.last_editor_user_id == user.id

263 assert res.creator_user_id == user.id

264 assert res.owner_user_id == user.id

265 assert not res.owner_community_id

266 assert not res.owner_group_id

267 assert res.editor_user_ids == [user.id]

268 assert res.can_edit

269 assert res.can_moderate

270

271

272def test_get_page(db):

273 user1, token1 = generate_user()

274 user2, token2 = generate_user()

275 with session_scope() as session:

276 c_id = create_community(session, 0, 2, "Root node", [user1], [], None).id

277

278 with pages_session(token1) as api:

279 time_before_create = now()

280 page_id = api.CreatePlace(

281 pages_pb2.CreatePlaceReq(

282 title="dummy title",

283 content="dummy content",

284 address="dummy address",

285 location=pages_pb2.Coordinate(

286 lat=1,

287 lng=1,

288 ),

289 )

290 ).page_id

291

292 with pages_session(token2) as api:

293 time_before_get = now()

294 res = api.GetPage(pages_pb2.GetPageReq(page_id=page_id))

295 assert res.title == "dummy title"

296 assert res.content == "dummy content"

297 assert res.address == "dummy address"

298 assert res.location.lat == 1

299 assert res.location.lng == 1

300 assert res.slug == "dummy-title"

301 assert time_before_create <= to_aware_datetime(res.created) <= time_before_get

302 assert time_before_create <= to_aware_datetime(res.last_edited) <= time_before_get

303 assert res.last_editor_user_id == user1.id

304 assert res.creator_user_id == user1.id

305 assert res.owner_user_id == user1.id

306 assert not res.owner_community_id

307 assert not res.owner_group_id

308 assert res.editor_user_ids == [user1.id]

309 assert not res.can_edit

310 assert not res.can_moderate

311 assert res.thread.thread_id > 0

312 assert res.thread.num_responses == 0

313

314

315def test_update_page(db):

316 user, token = generate_user()

317 with session_scope() as session:

318 c_id = create_community(session, 0, 2, "Root node", [user], [], None).id

319

320 with pages_session(token) as api:

321 time_before_create = now()

322 page_id = api.CreatePlace(

323 pages_pb2.CreatePlaceReq(

324 title="dummy title",

325 content="dummy content",

326 address="dummy address",

327 location=pages_pb2.Coordinate(

328 lat=1,

329 lng=1,

330 ),

331 )

332 ).page_id

333

334 time_before_update = now()

335 api.UpdatePage(

336 pages_pb2.UpdatePageReq(

337 page_id=page_id,

338 title=wrappers_pb2.StringValue(value="test title"),

339 )

340 )

341

342 time_before_get = now()

343 res = api.GetPage(pages_pb2.GetPageReq(page_id=page_id))

344 assert res.title == "test title"

345 assert res.content == "dummy content"

346 assert res.address == "dummy address"

347 assert res.location.lat == 1

348 assert res.location.lng == 1

349 assert res.slug == "test-title"

350 assert time_before_create <= to_aware_datetime(res.created) <= time_before_update

351 assert time_before_update <= to_aware_datetime(res.last_edited) <= time_before_get

352 assert to_aware_datetime(res.created) <= to_aware_datetime(res.last_edited)

353 assert res.last_editor_user_id == user.id

354 assert res.creator_user_id == user.id

355 assert res.owner_user_id == user.id

356 assert not res.owner_community_id

357 assert not res.owner_group_id

358 assert res.editor_user_ids == [user.id]

359 assert res.can_edit

360 assert res.can_moderate

361

362 time_before_second_update = now()

363 api.UpdatePage(

364 pages_pb2.UpdatePageReq(

365 page_id=page_id,

366 content=wrappers_pb2.StringValue(value="test content"),

367 )

368 )

369

370 time_before_second_get = now()

371 res = api.GetPage(pages_pb2.GetPageReq(page_id=page_id))

372 assert res.title == "test title"

373 assert res.content == "test content"

374 assert res.address == "dummy address"

375 assert res.location.lat == 1

376 assert res.location.lng == 1

377 assert res.slug == "test-title"

378 assert time_before_create <= to_aware_datetime(res.created) <= time_before_update

379 assert time_before_second_update <= to_aware_datetime(res.last_edited) <= time_before_second_get

380 assert to_aware_datetime(res.created) <= to_aware_datetime(res.last_edited)

381 assert res.last_editor_user_id == user.id

382 assert res.creator_user_id == user.id

383 assert res.owner_user_id == user.id

384 assert not res.owner_community_id

385 assert not res.owner_group_id

386 assert res.editor_user_ids == [user.id]

387 assert res.can_edit

388 assert res.can_moderate

389 assert res.thread.thread_id > 0

390 assert res.thread.num_responses == 0

391

392 time_before_third_update = now()

393 api.UpdatePage(

394 pages_pb2.UpdatePageReq(

395 page_id=page_id,

396 address=wrappers_pb2.StringValue(value="test address"),

397 )

398 )

399

400 time_before_third_get = now()

401 res = api.GetPage(pages_pb2.GetPageReq(page_id=page_id))

402 assert res.title == "test title"

403 assert res.content == "test content"

404 assert res.address == "test address"

405 assert res.location.lat == 1

406 assert res.location.lng == 1

407 assert res.slug == "test-title"

408 assert time_before_create <= to_aware_datetime(res.created) <= time_before_update

409 assert time_before_third_update <= to_aware_datetime(res.last_edited) <= time_before_third_get

410 assert to_aware_datetime(res.created) <= to_aware_datetime(res.last_edited)

411 assert res.last_editor_user_id == user.id

412 assert res.creator_user_id == user.id

413 assert res.owner_user_id == user.id

414 assert not res.owner_community_id

415 assert not res.owner_group_id

416 assert res.editor_user_ids == [user.id]

417 assert res.can_edit

418 assert res.can_moderate

419 assert res.thread.thread_id > 0

420 assert res.thread.num_responses == 0

421

422 time_before_fourth_update = now()

423 api.UpdatePage(

424 pages_pb2.UpdatePageReq(

425 page_id=page_id,

426 location=pages_pb2.Coordinate(

427 lat=3,

428 lng=1.222,

429 ),

430 )

431 )

432

433 time_before_fourth_get = now()

434 res = api.GetPage(pages_pb2.GetPageReq(page_id=page_id))

435 assert res.title == "test title"

436 assert res.content == "test content"

437 assert res.address == "test address"

438 assert res.location.lat == 3

439 assert res.location.lng == 1.222

440 assert res.slug == "test-title"

441 assert time_before_create <= to_aware_datetime(res.created) <= time_before_update

442 assert time_before_fourth_update <= to_aware_datetime(res.last_edited) <= time_before_fourth_get

443 assert to_aware_datetime(res.created) <= to_aware_datetime(res.last_edited)

444 assert res.last_editor_user_id == user.id

445 assert res.creator_user_id == user.id

446 assert res.owner_user_id == user.id

447 assert not res.owner_community_id

448 assert not res.owner_group_id

449 assert res.editor_user_ids == [user.id]

450 assert res.can_edit

451 assert res.can_moderate

452 assert res.thread.thread_id > 0

453 assert res.thread.num_responses == 0

454

455

456def test_owner_not_moderator(db):

457 """

458 You can be the owner of content yet not have moderation rights

459 """

460 user1, token1 = generate_user()

461 user2, token2 = generate_user()

462 with session_scope() as session:

463 c_id = create_community(session, 0, 2, "Root node", [user1], [], None).id

464

465 # user2 makes page, is owner but not moderator, so can edit, not moderate

466 with pages_session(token2) as api:

467 res = api.CreatePlace(

468 pages_pb2.CreatePlaceReq(

469 title="dummy title",

470 content="dummy content",

471 address="dummy address",

472 location=pages_pb2.Coordinate(

473 lat=1,

474 lng=1,

475 ),

476 )

477 )

478 assert res.title == "dummy title"

479 assert res.content == "dummy content"

480 assert res.address == "dummy address"

481 assert res.location.lat == 1

482 assert res.location.lng == 1

483 assert res.slug == "dummy-title"

484 assert res.last_editor_user_id == user2.id

485 assert res.creator_user_id == user2.id

486 assert res.owner_user_id == user2.id

487 assert not res.owner_community_id

488 assert not res.owner_group_id

489 assert res.editor_user_ids == [user2.id]

490 assert res.can_edit

491 assert not res.can_moderate

492

493 page_id = res.page_id

494

495 # user1 is not owner so can't edit but can moderate

496 with pages_session(token1) as api:

497 res = api.GetPage(pages_pb2.GetPageReq(page_id=page_id))

498 assert res.title == "dummy title"

499 assert res.content == "dummy content"

500 assert res.address == "dummy address"

501 assert res.location.lat == 1

502 assert res.location.lng == 1

503 assert res.slug == "dummy-title"

504 assert res.last_editor_user_id == user2.id

505 assert res.creator_user_id == user2.id

506 assert res.owner_user_id == user2.id

507 assert not res.owner_community_id

508 assert not res.owner_group_id

509 assert res.editor_user_ids == [user2.id]

510 assert not res.can_edit

511 assert res.can_moderate

512 assert res.thread.thread_id > 0

513 assert res.thread.num_responses == 0

514

515

516def test_update_page_errors(db):

517 user, token = generate_user()

518 with session_scope() as session:

519 c_id = create_community(session, 0, 2, "Root node", [user], [], None).id

520

521 with pages_session(token) as api:

522 page_id = api.CreatePlace(

523 pages_pb2.CreatePlaceReq(

524 title="dummy title",

525 content="dummy content",

526 address="dummy address",

527 location=pages_pb2.Coordinate(

528 lat=1,

529 lng=1,

530 ),

531 )

532 ).page_id

533

534 with pytest.raises(grpc.RpcError) as e:

535 api.UpdatePage(

536 pages_pb2.UpdatePageReq(

537 page_id=page_id,

538 title=wrappers_pb2.StringValue(value=""),

539 )

540 )

541 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

542 assert e.value.details() == errors.MISSING_PAGE_TITLE

543

544 with pytest.raises(grpc.RpcError) as e:

545 api.UpdatePage(

546 pages_pb2.UpdatePageReq(

547 page_id=page_id,

548 content=wrappers_pb2.StringValue(value=""),

549 )

550 )

551 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

552 assert e.value.details() == errors.MISSING_PAGE_CONTENT

553

554 with pytest.raises(grpc.RpcError) as e:

555 api.UpdatePage(

556 pages_pb2.UpdatePageReq(

557 page_id=page_id,

558 address=wrappers_pb2.StringValue(value=""),

559 )

560 )

561 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

562 assert e.value.details() == errors.MISSING_PAGE_ADDRESS

563

564

565def test_page_transfer(db):

566 # transfers the pages

567 user1, token1 = generate_user()

568 # admin of the community/group

569 user2, token2 = generate_user()

570 # member of the community/group, shouldn't ever have edit access to anything

571 user3, token3 = generate_user()

572 with session_scope() as session:

573 # create a community

574 node = Node(geom=to_multi(create_polygon_lat_lng([[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]])))

575 session.add(node)

576 community_cluster = Cluster(

577 name=f"Testing Community",

578 description=f"Description for testing community",

579 parent_node=node,

580 is_official_cluster=True,

581 )

582 session.add(community_cluster)

583 main_page = Page(

584 parent_node=community_cluster.parent_node,

585 creator_user_id=user2.id,

586 owner_cluster=community_cluster,

587 type=PageType.main_page,

588 thread=Thread(),

589 )

590 session.add(main_page)

591 session.add(

592 PageVersion(

593 page=main_page,

594 editor_user_id=user2.id,

595 title=f"Main page for the testing community",

596 content="Empty.",

597 )

598 )

599 community_cluster.cluster_subscriptions.append(

600 ClusterSubscription(

601 user_id=user2.id,

602 role=ClusterRole.admin,

603 )

604 )

605 community_cluster.cluster_subscriptions.append(

606 ClusterSubscription(

607 user_id=user3.id,

608 role=ClusterRole.member,

609 )

610 )

611

612 # create a group

613 group_cluster = Cluster(

614 name=f"Testing Group",

615 description=f"Description for testing group",

616 parent_node=node,

617 )

618 session.add(group_cluster)

619 main_page = Page(

620 parent_node=group_cluster.parent_node,

621 creator_user_id=user2.id,

622 owner_cluster=group_cluster,

623 type=PageType.main_page,

624 thread=Thread(),

625 )

626 session.add(main_page)

627 session.add(

628 PageVersion(

629 page=main_page,

630 editor_user_id=user2.id,

631 title=f"Main page for the testing community",

632 content="Empty.",

633 )

634 )

635 group_cluster.cluster_subscriptions.append(

636 ClusterSubscription(

637 user_id=user2.id,

638 role=ClusterRole.admin,

639 )

640 )

641 group_cluster.cluster_subscriptions.append(

642 ClusterSubscription(

643 user_id=user3.id,

644 role=ClusterRole.member,

645 )

646 )

647 session.flush()

648

649 community_id = node.id

650 community_cluster_id = community_cluster.id

651 group_id = group_cluster.id

652

653 with pages_session(token1) as api:

654 create_page_req = pages_pb2.CreatePlaceReq(

655 title="title",

656 content="content",

657 address="address",

658 location=pages_pb2.Coordinate(

659 lat=1,

660 lng=1,

661 ),

662 )

663

664 # transfer should work fine to a community

665 page1 = api.CreatePlace(create_page_req)

666 assert page1.owner_user_id == user1.id

667 assert page1.can_edit

668 assert not page1.can_moderate

669

670 with pages_session(token2) as api:

671 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_edit

672 assert api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_moderate

673

674 with pages_session(token3) as api:

675 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_edit

676 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_moderate

677

678 with pages_session(token1) as api:

679 page1 = api.TransferPage(

680 pages_pb2.TransferPageReq(

681 page_id=page1.page_id,

682 new_owner_community_id=community_id,

683 )

684 )

685 assert page1.owner_community_id == community_id

686 assert not page1.can_edit

687 assert not page1.can_moderate

688

689 with pages_session(token2) as api:

690 assert api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_edit

691 assert api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_moderate

692

693 with pages_session(token3) as api:

694 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_edit

695 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_moderate

696

697 with pages_session(token1) as api:

698 # now we're no longer the owner, can't transfer

699 page1 = api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id))

700 with pytest.raises(grpc.RpcError) as e:

701 api.TransferPage(

702 pages_pb2.TransferPageReq(

703 page_id=page1.page_id,

704 new_owner_group_id=group_id,

705 )

706 )

707 assert e.value.code() == grpc.StatusCode.PERMISSION_DENIED

708 assert e.value.details() == errors.PAGE_TRANSFER_PERMISSION_DENIED

709 page1 = api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id))

710 assert page1.owner_community_id == community_id

711 assert not page1.can_edit

712 assert not page1.can_moderate

713

714 with pages_session(token2) as api:

715 assert api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_edit

716 assert api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_moderate

717

718 with pages_session(token3) as api:

719 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_edit

720 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page1.page_id)).can_moderate

721

722 with pages_session(token1) as api:

723 # try a new page, just for fun

724 page2 = api.CreatePlace(create_page_req)

725 assert page2.owner_user_id == user1.id

726

727 page2 = api.TransferPage(

728 pages_pb2.TransferPageReq(

729 page_id=page2.page_id,

730 new_owner_community_id=community_id,

731 )

732 )

733 assert page2.owner_community_id == community_id

734

735 with pages_session(token2) as api:

736 assert api.GetPage(pages_pb2.GetPageReq(page_id=page2.page_id)).can_edit

737 assert api.GetPage(pages_pb2.GetPageReq(page_id=page2.page_id)).can_moderate

738

739 with pages_session(token3) as api:

740 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page2.page_id)).can_edit

741 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page2.page_id)).can_moderate

742

743 with pages_session(token1) as api:

744 # can't transfer a page to an official cluster, only through community

745 page3 = api.CreatePlace(create_page_req)

746 assert page3.owner_user_id == user1.id

747

748 with pytest.raises(grpc.RpcError) as e:

749 api.TransferPage(

750 pages_pb2.TransferPageReq(

751 page_id=page3.page_id,

752 new_owner_community_id=community_cluster_id,

753 )

754 )

755 assert e.value.code() == grpc.StatusCode.NOT_FOUND

756 assert e.value.details() == errors.GROUP_OR_COMMUNITY_NOT_FOUND

757 page3 = api.GetPage(pages_pb2.GetPageReq(page_id=page3.page_id))

758 assert page3.owner_user_id == user1.id

759

760 # can transfer to group

761 page4 = api.CreatePlace(create_page_req)

762 assert page4.owner_user_id == user1.id

763 assert page4.can_edit

764 assert not page4.can_moderate

765

766 with pages_session(token2) as api:

767 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_edit

768 assert api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_moderate

769

770 with pages_session(token3) as api:

771 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_edit

772 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_moderate

773

774 with pages_session(token1) as api:

775 page4 = api.TransferPage(

776 pages_pb2.TransferPageReq(

777 page_id=page4.page_id,

778 new_owner_group_id=group_id,

779 )

780 )

781 assert page4.owner_group_id == group_id

782 assert not page4.can_edit

783 assert not page4.can_moderate

784

785 with pages_session(token2) as api:

786 assert api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_edit

787 assert api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_moderate

788

789 with pages_session(token3) as api:

790 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_edit

791 assert not api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id)).can_moderate

792

793 with pages_session(token1) as api:

794 # now we're no longer the owner, can't transfer

795 with pytest.raises(grpc.RpcError) as e:

796 api.TransferPage(

797 pages_pb2.TransferPageReq(

798 page_id=page4.page_id,

799 new_owner_community_id=community_id,

800 )

801 )

802 assert e.value.code() == grpc.StatusCode.PERMISSION_DENIED

803 assert e.value.details() == errors.PAGE_TRANSFER_PERMISSION_DENIED

804 page4 = api.GetPage(pages_pb2.GetPageReq(page_id=page4.page_id))

805 assert page4.owner_group_id == group_id

806

807

808def test_page_photo(db):

809 user, token = generate_user()

810 with session_scope() as session:

811 c_id = create_community(session, 0, 2, "Root node", [user], [], None).id

812

813 with pages_session(token) as api:

814 key1 = random_hex(32)

815 filename1 = random_hex(32)

816

817 with session_scope() as session:

818 session.add(

819 Upload(

820 key=key1,

821 filename=filename1,

822 creator_user_id=user.id,

823 )

824 )

825

826 res = api.CreatePlace(

827 pages_pb2.CreatePlaceReq(

828 title="dummy title",

829 content="dummy content",

830 photo_key=key1,

831 address="dummy address",

832 location=pages_pb2.Coordinate(

833 lat=1,

834 lng=1,

835 ),

836 )

837 )

838

839 assert filename1 in res.photo_url

840

841 # can't create with non-existent photo

842 with pytest.raises(grpc.RpcError) as e:

843 api.CreatePlace(

844 pages_pb2.CreatePlaceReq(

845 title="dummy title",

846 content="dummy content",

847 photo_key="nonexisten",

848 address="dummy address",

849 location=pages_pb2.Coordinate(

850 lat=1,

851 lng=1,

852 ),

853 )

854 )

855 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

856 assert e.value.details() == errors.PHOTO_NOT_FOUND

857

858 # can create page with no photo

859 res = api.CreatePlace(

860 pages_pb2.CreatePlaceReq(

861 title="dummy title",

862 content="dummy content",

863 address="dummy address",

864 location=pages_pb2.Coordinate(

865 lat=1,

866 lng=1,

867 ),

868 )

869 )

870

871 assert res.photo_url == ""

872

873 page_id = res.page_id

874

875 # can't set it to non-existent stuff

876 with pytest.raises(grpc.RpcError) as e:

877 api.UpdatePage(

878 pages_pb2.UpdatePageReq(

879 page_id=page_id,

880 photo_key=wrappers_pb2.StringValue(value="non-existent id"),

881 )

882 )

883 assert e.value.code() == grpc.StatusCode.INVALID_ARGUMENT

884 assert e.value.details() == errors.PHOTO_NOT_FOUND

885

886 key2 = random_hex(32)

887 filename2 = random_hex(32)

888

889 with session_scope() as session:

890 session.add(

891 Upload(

892 key=key2,

893 filename=filename2,

894 creator_user_id=user.id,

895 )

896 )

897

898 res = api.UpdatePage(

899 pages_pb2.UpdatePageReq(

900 page_id=page_id,

901 photo_key=wrappers_pb2.StringValue(value=key2),

902 )

903 )

904

905 assert filename2 in res.photo_url

906

907 # can unset it

908

909 res = api.UpdatePage(

910 pages_pb2.UpdatePageReq(

911 page_id=page_id,

912 photo_key=wrappers_pb2.StringValue(value=""),

913 )

914 )

915

916 assert res.photo_url == ""

917

918

919def test_list_user_places(db):

920 user1, token1 = generate_user()

921 with session_scope() as session:

922 c_id = create_community(session, 0, 2, "Root node", [user1], [], None).id

923

924 with pages_session(token1) as api:

925 place1_id = api.CreatePlace(

926 pages_pb2.CreatePlaceReq(

927 title="dummy title",

928 content="dummy content",

929 address="dummy address",

930 location=pages_pb2.Coordinate(

931 lat=1,

932 lng=1,

933 ),

934 )

935 ).page_id

936

937 place2_id = api.CreatePlace(

938 pages_pb2.CreatePlaceReq(

939 title="dummy title 2",

940 content="dummy content 2",

941 address="dummy address 2",

942 location=pages_pb2.Coordinate(

943 lat=1,

944 lng=1,

945 ),

946 )

947 ).page_id

948

949 with pages_session(token1) as api:

950 res = api.ListUserPlaces(pages_pb2.ListUserPlacesReq())

951 assert [p.page_id for p in res.places] == [place1_id, place2_id]

952

953

954def test_list_other_user_places(db):

955 user1, token1 = generate_user()

956 user2, token2 = generate_user()

957 with session_scope() as session:

958 c_id = create_community(session, 0, 2, "Root node", [user1], [], None).id

959

960 with pages_session(token1) as api:

961 place1_id = api.CreatePlace(

962 pages_pb2.CreatePlaceReq(

963 title="dummy title",

964 content="dummy content",

965 address="dummy address",

966 location=pages_pb2.Coordinate(

967 lat=1,

968 lng=1,

969 ),

970 )

971 ).page_id

972

973 place2_id = api.CreatePlace(

974 pages_pb2.CreatePlaceReq(

975 title="dummy title 2",

976 content="dummy content 2",

977 address="dummy address 2",

978 location=pages_pb2.Coordinate(

979 lat=1,

980 lng=1,

981 ),

982 )

983 ).page_id

984

985 with pages_session(token2) as api:

986 res = api.ListUserPlaces(pages_pb2.ListUserPlacesReq(user_id=user1.id))

987 assert [p.page_id for p in res.places] == [place1_id, place2_id]

988

989

990def test_list_user_guides(db):

991 user1, token1 = generate_user()

992 with session_scope() as session:

993 c_id = create_community(session, 0, 2, "Root node", [user1], [], None).id

994

995 with pages_session(token1) as api:

996 guide1_id = api.CreateGuide(

997 pages_pb2.CreateGuideReq(

998 title="dummy title",

999 content="dummy content",

1000 address="dummy address",

1001 location=pages_pb2.Coordinate(

1002 lat=1,

1003 lng=1,

1004 ),

1005 parent_community_id=c_id,

1006 )

1007 ).page_id

1008

1009 guide2_id = api.CreateGuide(

1010 pages_pb2.CreateGuideReq(

1011 title="dummy title 2",

1012 content="dummy content 2",

1013 address="dummy address 2",

1014 location=pages_pb2.Coordinate(

1015 lat=1,

1016 lng=1,

1017 ),

1018 parent_community_id=c_id,

1019 )

1020 ).page_id

1021

1022 with pages_session(token1) as api:

1023 res = api.ListUserGuides(pages_pb2.ListUserGuidesReq())

1024 assert [p.page_id for p in res.guides] == [guide1_id, guide2_id]

1025

1026

1027def test_list_other_user_guides(db):

1028 user1, token1 = generate_user()

1029 user2, token2 = generate_user()

1030 with session_scope() as session:

1031 c_id = create_community(session, 0, 2, "Root node", [user1], [], None).id

1032

1033 with pages_session(token1) as api:

1034 guide1_id = api.CreateGuide(

1035 pages_pb2.CreateGuideReq(

1036 title="dummy title",

1037 content="dummy content",

1038 address="dummy address",

1039 location=pages_pb2.Coordinate(

1040 lat=1,

1041 lng=1,

1042 ),

1043 parent_community_id=c_id,

1044 )

1045 ).page_id

1046

1047 guide2_id = api.CreateGuide(

1048 pages_pb2.CreateGuideReq(

1049 title="dummy title 2",

1050 content="dummy content 2",

1051 address="dummy address 2",

1052 location=pages_pb2.Coordinate(

1053 lat=1,

1054 lng=1,

1055 ),

1056 parent_community_id=c_id,

1057 )

1058 ).page_id

1059

1060 with pages_session(token2) as api:

1061 res = api.ListUserGuides(pages_pb2.ListUserGuidesReq(user_id=user1.id))

1062 assert [p.page_id for p in res.guides] == [guide1_id, guide2_id]

Coverage for src/tests/test_pages.py: 100%

507 statements