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

1import pytest 

2from sqlalchemy.exc import IntegrityError 

3from sqlalchemy.sql import func 

4 

5from couchers.db import session_scope 

6from couchers.models import ActivenessProbe, ActivenessProbeStatus, Cluster, Node, Page, PageType, PageVersion, Thread 

7from couchers.utils import create_polygon_lat_lng, to_multi 

8from tests.test_communities import create_1d_polygon, create_community 

9from tests.test_fixtures import db, generate_user, testconfig # noqa 

10 

11 

12@pytest.fixture(autouse=True) 

13def _(testconfig): 

14 pass 

15 

16 

17def test_node_constraints(db): 

18 # check we can't have two official clusters for a given node 

19 with pytest.raises(IntegrityError) as e: 

20 with session_scope() as session: 

21 node = Node(geom=to_multi(create_1d_polygon(0, 2))) 

22 session.add(node) 

23 cluster1 = Cluster( 

24 name="Testing community, cluster 1", 

25 description="Testing community description", 

26 parent_node=node, 

27 is_official_cluster=True, 

28 ) 

29 session.add(cluster1) 

30 cluster2 = Cluster( 

31 name="Testing community, cluster 2", 

32 description="Testing community description", 

33 parent_node=node, 

34 is_official_cluster=True, 

35 ) 

36 session.add(cluster2) 

37 assert "violates unique constraint" in str(e.value) 

38 assert "ix_clusters_owner_parent_node_id_is_official_cluster" in str(e.value) 

39 

40 

41def test_page_constraints(db): 

42 user, token = generate_user() 

43 

44 with session_scope() as session: 

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

46 

47 # check we can't create a page without an owner 

48 with pytest.raises(IntegrityError) as e: 

49 with session_scope() as session: 

50 page = Page( 

51 parent_node_id=c_id, 

52 # note no owner 

53 creator_user_id=user.id, 

54 type=PageType.guide, 

55 thread=Thread(), 

56 ) 

57 session.add(page) 

58 session.add( 

59 PageVersion( 

60 page=page, 

61 editor_user_id=user.id, 

62 title="Title", 

63 content="Content", 

64 ) 

65 ) 

66 assert "violates check constraint" in str(e.value) 

67 assert "one_owner" in str(e.value) 

68 

69 with session_scope() as session: 

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

71 session.add(node) 

72 cluster = Cluster( 

73 name="Testing Community", 

74 description="Description for testing community", 

75 parent_node=node, 

76 ) 

77 session.add(cluster) 

78 session.flush() 

79 cluster_parent_id = cluster.parent_node_id 

80 cluster_id = cluster.id 

81 

82 # check we can't create a page with two owners 

83 with pytest.raises(IntegrityError) as e: 

84 with session_scope() as session: 

85 page = Page( 

86 parent_node_id=cluster_parent_id, 

87 creator_user_id=user.id, 

88 owner_cluster_id=cluster_id, 

89 owner_user_id=user.id, 

90 type=PageType.guide, 

91 thread=Thread(), 

92 ) 

93 session.add(page) 

94 session.add( 

95 PageVersion( 

96 page=page, 

97 editor_user_id=user.id, 

98 title="Title", 

99 content="Content", 

100 ) 

101 ) 

102 assert "violates check constraint" in str(e.value) 

103 assert "one_owner" in str(e.value) 

104 

105 # main page must be owned by the right cluster 

106 with pytest.raises(IntegrityError) as e: 

107 with session_scope() as session: 

108 main_page = Page( 

109 parent_node_id=cluster_parent_id, 

110 # note owner is not cluster 

111 creator_user_id=user.id, 

112 owner_user_id=user.id, 

113 type=PageType.main_page, 

114 thread=Thread(), 

115 ) 

116 session.add(main_page) 

117 session.add( 

118 PageVersion( 

119 page=main_page, 

120 editor_user_id=user.id, 

121 title="Main page for the testing community", 

122 content="Empty.", 

123 ) 

124 ) 

125 assert "violates check constraint" in str(e.value) 

126 assert "main_page_owned_by_cluster" in str(e.value) 

127 

128 # can only have one main page 

129 with pytest.raises(IntegrityError) as e: 

130 with session_scope() as session: 

131 main_page1 = Page( 

132 parent_node_id=cluster_parent_id, 

133 creator_user_id=user.id, 

134 owner_cluster_id=cluster_id, 

135 type=PageType.main_page, 

136 thread=Thread(), 

137 ) 

138 session.add(main_page1) 

139 session.add( 

140 PageVersion( 

141 page=main_page1, 

142 editor_user_id=user.id, 

143 title="Main page 1 for the testing community", 

144 content="Empty.", 

145 ) 

146 ) 

147 main_page2 = Page( 

148 parent_node_id=cluster_parent_id, 

149 creator_user_id=user.id, 

150 owner_cluster_id=cluster_id, 

151 type=PageType.main_page, 

152 thread=Thread(), 

153 ) 

154 session.add(main_page2) 

155 session.add( 

156 PageVersion( 

157 page=main_page2, 

158 editor_user_id=user.id, 

159 title="Main page 2 for the testing community", 

160 content="Empty.", 

161 ) 

162 ) 

163 assert "violates unique constraint" in str(e.value) 

164 assert "ix_pages_owner_cluster_id_type" in str(e.value) 

165 

166 

167def test_activeness_probes_cant_have_multiple(db): 

168 # can't have two active activeness probes for a given user 

169 user, token = generate_user() 

170 

171 with session_scope() as session: 

172 # we can create one 

173 first_probe = ActivenessProbe(user_id=user.id) 

174 session.add(first_probe) 

175 session.commit() 

176 

177 # change it to expired 

178 first_probe.response = ActivenessProbeStatus.expired 

179 first_probe.responded = func.now() 

180 session.commit() 

181 

182 # can create another one 

183 session.add(ActivenessProbe(user_id=user.id)) 

184 session.commit() 

185 

186 # can't create one more 

187 with pytest.raises(IntegrityError) as e: 

188 with session_scope() as session: 

189 session.add(ActivenessProbe(user_id=user.id)) 

190 session.commit() 

191 assert "violates unique constraint" in str(e.value)