1import unittest 

2import database 

3import time 

4import http 

5import flask_unittest 

6import flask.globals 

7from api import app, connect_db 

8 

9db = database.Database(True) 

10 

11 

12class ADatabaseTests(unittest.TestCase): 

13 def test_a_check_user_exists_one(self): 

14 self.assertFalse(db.check_user_exists("test")) 

15 def test_b_register(self): 

16 self.assertTrue(db.create_user("test", "testpassword", "tech"), "user creation failed") 

17 def test_c_check_user_exists_two(self): 

18 self.assertTrue(db.check_user_exists("test")) 

19 def test_d_login(self): 

20 result, id = db.check_password("test", "testpassword") 

21 self.assertTrue(result, "failed to login") 

22 self.assertIsNotNone(id, "id was none") 

23 result, id = db.check_password("test", "wrongpassword") 

24 self.assertFalse(result, "logged in with wrong password") 

25 self.assertIsNone(id, "id was given for wrong password") 

26 result, id = (db.check_password("userDoesntExist", "whocares")) 

27 self.assertFalse(result) 

28 self.assertIsNone(id) 

29 def test_e_create_token(self): 

30 result, id = db.check_password("test", "testpassword") 

31 if result is False: 

32 self.skipTest("failed to login") 

33 token = db.create_token(60, id) 

34 self.assertIsNotNone(token, "token was none") 

35 def test_f_check_token(self): 

36 result, user0 = db.check_password("test", "testpassword") 

37 if result is False: 

38 self.skipTest("failed to login") 

39 token = db.create_token(2, user0["id"]) 

40 if token is None: 

41 self.skipTest("failed to create token") 

42 user = db.check_token(token) 

43 self.assertIsNotNone(user, "user was None") 

44 self.assertEqual(user["name"], "test", "user name was wrong") 

45 self.assertEqual(user["id"], user0["id"], "user id was wrong") 

46 self.assertEqual(user["role"], "tech", "user role was wrong") 

47 user = db.check_token("0000a1") 

48 self.assertIsNone(user, "user was returned for bad Token") 

49 time.sleep(2) 

50 user = db.check_token(token) 

51 self.assertIsNone(user, "Token worked after timeout") 

52 def test_g_get_templates_one(self): 

53 self.assertEqual(db.get_templates(), []) 

54 def test_h_create_template(self): 

55 template = db.create_template("test", [{"title":"test1", "type":"string", "role":"tech"}, {"title":"test2", "type":"string", "role":"doc"}]) 

56 self.assertEqual(template["name"], "test") 

57 self.assertEqual(template["headers"], {"test1": ["string", "tech"], "test2": ["string", "doc"]}) 

58 def test_i_get_templates_two(self): 

59 self.assertIsNot(db.get_templates(), []) 

60 templates = db.get_templates() 

61 self.assertEqual(templates[0]["name"], "test") 

62 self.assertEqual(templates[0]["headers"], {"test1": ["string", "tech"], "test2": ["string", "doc"]}) 

63 def test_j_get_tests_one(self): 

64 self.assertEqual(db.get_tests(), []) 

65 def test_k_create_test(self): 

66 templates = db.get_templates() 

67 if not templates: 

68 self.skipTest("failed to get template") 

69 self.assertTrue(db.create_test("test", 

70 templates[0]["id"], 

71 [{"name":"test1", "value":"blue"}, {"name":"test2", "value":"green"}] 

72 )) 

73 def test_l_get_tests_two(self): 

74 self.assertIsNot(db.get_tests(), []) 

75 tests = db.get_tests() 

76 self.assertEqual(tests[0]["name"], "test") 

77 self.assertEqual(tests[0]["fields"], [{"name":"test1", "value":"blue"}, {"name":"test2", "value":"green"}]) 

78 def test_m_get_logs_one(self): 

79 self.assertEqual(db.get_logs(), []) 

80 def test_n_create_and_get_log(self): 

81 templates = db.get_templates() 

82 if not templates: 

83 self.skipTest("failed to get template") 

84 tests = db.get_tests() 

85 if not tests: 

86 self.skipTest("failed to get tests") 

87 template_id = templates[0]["id"] 

88 test_id = tests[0]["id"] 

89 result = db.create_log(template_id, test_id, None)["id"] 

90 self.assertIsNotNone(result) 

91 log = db.get_log(result) 

92 self.assertEqual(log["id"], result) 

93 self.assertEqual(log["template"], template_id) 

94 self.assertEqual(log["test"], test_id) 

95 self.assertEqual(log["name"], "test") 

96 self.assertEqual(log["slides"], []) 

97 result = db.create_log(template_id, test_id, "test2")["id"] 

98 self.assertIsNotNone(result) 

99 log = db.get_log(result) 

100 self.assertEqual(log["id"], result) 

101 self.assertEqual(log["template"], template_id) 

102 self.assertEqual(log["test"], test_id) 

103 self.assertEqual(log["name"], "test2") 

104 self.assertEqual(log["slides"], []) 

105 def test_o_get_logs_two(self): 

106 self.assertIsNot(db.get_logs(), []) 

107 self.assertEqual(len(db.get_logs()), 2) 

108 def test_pa_post_and_edit_slide(self): 

109 logs = db.get_logs() 

110 if not logs: 

111 self.skipTest("failed to get logs") 

112 log_id = logs[0]["id"] 

113 fields = {"test1": "green"} 

114 result, user0 = db.check_password("test", "testpassword") 

115 if not result: 

116 self.skipTest("failed to login") 

117 token = db.create_token(60, user0["id"]) 

118 user = db.check_token(token) 

119 if user is None: 

120 self.skipTest("failed to get user") 

121 slide_id = db.post_slide(log_id, fields, False, user)["id"] 

122 self.assertIsNotNone(slide_id) 

123 self.assertEqual(db.get_logs()[0]["slides"][0], slide_id) 

124 slide = db.get_slide(slide_id) 

125 self.assertEqual(slide["fields"]["test1"], "green") 

126 self.assertFalse(slide["submitted"]) 

127 self.assertTrue(db.edit_slide(slide_id, {"test1": "blue", "test2": "green"}, True, user)) 

128 slide = db.get_slide(slide_id) 

129 self.assertEqual(slide["fields"]["test1"], "blue") 

130 self.assertRaises(KeyError, lambda: slide["fields"]["test2"]) 

131 def test_pb_get_slides(self): 

132 logs = db.get_logs() 

133 if not logs: 

134 self.skipTest("failed to get logs") 

135 log_id = logs[0]["id"] 

136 slides = db.get_slides(log_id) 

137 self.assertIsNot(slides, []) 

138 self.assertEqual(slides[0]["fields"]["test1"], "blue") 

139 

140class qApiTests(flask_unittest.ClientTestCase): 

141 app = app 

142 

143 def setUp(self, client) -> None: 

144 connect_db(True) 

145 

146 def test_q_register(self, client): 

147 response1 = client.post("/register", json={"name":"test", 'password':'testpass', 'role':'tech'}) 

148 self.assertJsonEqual(response1, {"result": True}) 

149 response2 = client.post("/register", json={'name':'test', 'password':"testpass", 'role':'doc'}) 

150 self.assertJsonEqual(response2, {"result": False}) 

151 response1 = client.put("/login", json={"name":"test", "password":"test"}) 

152 self.assertJsonEqual(response1, {"result": False}) 

153 response = client.put("/login", json={"name":"lol", "password":"bad"}) 

154 self.assertJsonEqual(response, {"result": False}) 

155 response2 = client.put("login", json={"name":"test", "password":"testpass"}) 

156 self.assertIsNotNone(response2.json["user"]["token"]) 

157 self.assertTrue(response2.json["result"]) 

158 token = response2.json["user"]["token"] 

159 

160 templates = client.get(f"/templates/?token=123") 

161 self.assertStatus(templates, 403) 

162 templates = client.get(f"/templates/?token={token}") 

163 self.assertJsonEqual(templates, {"result": []}) 

164 

165 template = client.post("/templates/create", json={"name": "test", 

166 "columns": [ 

167 {"title":"test1", "type":"string", "role":"tech"}, 

168 {"title":"test2", "type":"string", "role":"doc"} 

169 ], 

170 "token": token 

171 }) 

172 self.assertEqual(template.json["name"], "test") 

173 self.assertEqual(template.json["headers"], {"test1": ["string", "tech"], "test2": ["string", "doc"]}) 

174 template = client.post("/templates/create", json={"name": "test", 

175 "columns": [ 

176 {"title":"test1", "type":"string", "role":"tech"}, 

177 {"title":"test2", "type":"string", "role":"doc"} 

178 ], 

179 "token": "123" 

180 }) 

181 self.assertStatus(template, 403) 

182 

183 template = client.post("/templates/create", json={ 

184 "columns": 

185 {"title":"test1", "type":"string", "role":"tech"}, 

186 "token": token 

187 }) 

188 self.assertStatus(template, 400) 

189 

190 templates = client.get(f"/templates/?token={token}").json["result"] 

191 self.assertEqual(templates[0]["name"], "test") 

192 self.assertEqual(templates[0]["headers"], {"test1": ["string", "tech"], "test2": ["string", "doc"]}) 

193 

194 create_test = client.post("/tests/create", json={"name": "test", 

195 "template": templates[0]["id"], 

196 "fields": [{"name": "test1", "value": "blue"}, {"name": "test2", "value": "green"}], 

197 "token": token 

198 }) 

199 self.assertStatus(create_test, 200) 

200 create_test = client.post("/tests/create", json={"name": "test", 

201 "template": templates[0]["id"], 

202 "fieldasdfs": [{"name": "test1", "value": "blue"}, {"name": "test2", "value": "green"}], 

203 "token": token 

204 }) 

205 self.assertStatus(create_test, 400) 

206 tests = client.get(f"/tests/?token={token}").json["result"] 

207 self.assertEqual(tests[0]["name"], "test") 

208 self.assertEqual(tests[0]["fields"], [{"name":"test1", "value":"blue"}, {"name":"test2", "value":"green"}]) 

209 

210 result = client.post("/logs/create", json={"template": templates[0]["id"], "test": tests[0]["id"], "token":token}).json 

211 result = result["result"] 

212 log = client.get(f"/logs/{result['id']}/?token={token}").json["result"] 

213 self.assertEqual(log["template"], templates[0]["id"]) 

214 self.assertEqual(log["test"], tests[0]["id"]) 

215 self.assertEqual(log["name"], "test") 

216 self.assertEqual(log["slides"], []) 

217 

218 logs = client.get(f"/logs/?token={token}").json 

219 self.assertEqual(len(logs), 1) 

220 fields = {"test1": "green"} 

221 slide = client.post(f"/logs/{log['id']}/slides/create", json={"fields": fields, "submit": False, "token":token}).json["result"] 

222 slide = client.put(f"/logs/{log['id']}/slides/edit", json={"slide": slide["id"], "fields":{"test1": "blue", "test2": "green"}, "submit": True, "token": token}) 

223 self.assertStatus(slide, 200) 

224 

225 

226 slides = client.get(f"/logs/{log['id']}/slides/?token={token}").json 

227 self.assertEqual(len(logs), 1) 

228 self.assertEqual(slides[0]["fields"], {"test1": "blue"}) 

229 

230if __name__ == '__main__': 

231 unittest.main()