Coverage for test\unittest.py: 85%

125 statements  

« prev     ^ index     » next       coverage.py v6.4.4, created at 2022-09-11 22:38 -0700

1from datetime import datetime 

2import json 

3import sys 

4import unittest 

5import pprint 

6 

7from benedict import benedict 

8 

9import responses 

10from responses import matchers 

11 

12import requests 

13 

14import logging 

15 

16# from os import environ 

17 

18# from src.tempstick_py import _helpers, tempstick 

19 

20from src.tempstick_py.tempstick import ( 

21 TempStickSensor, 

22 make_request, 

23 GET_SENSORS, 

24 GET_SENSOR, 

25 GET_READINGS, 

26 REQUEST_TYPES, 

27) 

28from src.tempstick_py._helpers import format_mac, format_datetime 

29from src.tempstick_py.exceptions import FilterRemovesRange, InvalidApiKeyError 

30 

31from .data import ( 

32 INVALID_KEY_RESPONSE, 

33 SENSOR, 

34 GENERATED_API_KEY, 

35 GET_SENSORS_DICT, 

36 GET_SENSOR_READING_DICT, 

37 GET_SENSORS_MULTIPLE, 

38 SENSOR_3_CHANGES, 

39) 

40 

41GET_SENSORS_JSON = json.dumps(GET_SENSORS_DICT) 

42GET_SENSOR_READINGS_JSON = json.dumps(GET_SENSOR_READING_DICT) 

43INVALID_KEY_RESPONSE_JSON = json.dumps(INVALID_KEY_RESPONSE) 

44GET_SENSORS_MULTIPLE_JSON = json.dumps(GET_SENSORS_MULTIPLE) 

45 

46SENSOR_ID = SENSOR.get("sensor_id", None) 

47 

48API_KEY = GENERATED_API_KEY 

49 

50 

51class TestNonApiFunctions(unittest.TestCase): 

52 def test_format_mac(self): 

53 self.assertEqual(format_mac("A4:E5:7C:02:11:12"), "a4:e5:7c:02:11:12") 

54 

55 def test_mac_wrong_length(self): 

56 self.assertRaises(AssertionError, format_mac, "A4:E5:7C:02:11:1") 

57 # self.failUnlessRaises(AssertionError, format_mac, "A4:E5:7C:02:11:1") 

58 

59 def test_mac_invalid_chars(self): 

60 self.assertRaises(AssertionError, format_mac, "A4:E5:7C:02:11:1°") 

61 

62 

63class TestSensorApi(unittest.TestCase): 

64 def setUp(self): 

65 self.r_mock = responses.RequestsMock(assert_all_requests_are_fired=False) 

66 self.r_mock.start() 

67 

68 self.headers = {"X-API-KEY": API_KEY} 

69 

70 # valid for get_sensors 

71 self.r_mock.get( 

72 url="https://tempstickapi.com/api/v1/sensors/all", 

73 headers=self.headers, 

74 json=GET_SENSORS_JSON, 

75 match=[matchers.header_matcher({"X-API-KEY": API_KEY})], 

76 ) 

77 # valid for get_sensors, multiple sensors 

78 self.r_mock.get( 

79 url="https://tempstickapi.com/api/v1/sensors/all", 

80 headers=self.headers, 

81 json=GET_SENSORS_MULTIPLE_JSON, 

82 match=[matchers.header_matcher({"X-API-KEY": API_KEY.replace("P", "a")})], 

83 ) 

84 # valid for get_sensor_readings 

85 self.r_mock.get( 

86 url="https://tempstickapi.com/api/v1/sensors/{sensor_id}/readings".format( 

87 sensor_id=SENSOR_ID 

88 ), 

89 headers=self.headers, 

90 json=GET_SENSOR_READINGS_JSON, 

91 match=[matchers.header_matcher({"X-API-KEY": API_KEY})], 

92 ) 

93 # valid for get_sensors, but with response for invalid API key 

94 self.r_mock.get( 

95 url="https://tempstickapi.com/api/v1/sensors/all", 

96 headers=self.headers, 

97 json=INVALID_KEY_RESPONSE_JSON, 

98 ) 

99 # valid for get_sensor (singular) 

100 self.r_mock.get( 

101 url="https://tempstickapi.com/api/v1/sensors/{}".format(SENSOR_ID), 

102 headers=self.headers, 

103 json=SENSOR, 

104 match=[matchers.header_matcher({"X-API-KEY": API_KEY})], 

105 ) 

106 

107 sensor = TempStickSensor(SENSOR.get("id"), SENSOR_ID, SENSOR.get("sensor_name")) 

108 self.simple_sensor = sensor 

109 

110 print("{} | setup -> id: {}".format(logger_name(self), sensor.id)) 

111 print("") 

112 # print("GET_SENSORS_MULTIPLE_JSON:\n{}".format(GET_SENSORS_MULTIPLE_JSON)) 

113 # responses.add( 

114 # method='GET', 

115 # url='https://tempstickapi.com/api/v1/sensors/all', 

116 # headers={'X-API-KEY': API_KEY}, 

117 # json=GET_SENSORS_JSON, 

118 # ) 

119 

120 def tearDown(self) -> None: 

121 self.r_mock.stop() 

122 self.r_mock.reset() 

123 

124 @unittest.skip("used to test testing") 

125 def test_simple(self): 

126 name = logger_name(self) 

127 log = logging.getLogger(name) 

128 print("Log name: {}".format(log.name)) 

129 log.debug("Log Name: {}".format(log.name)) 

130 self.assertEqual(1, 1) 

131 

132 # @responses.activate 

133 def test_make_request_get_sensors(self): 

134 print("") 

135 log = logging.getLogger(logger_name(self)) 

136 log.debug("API Key: {key}".format(key=API_KEY)) 

137 

138 data = make_request(GET_SENSORS, API_KEY) 

139 

140 log.debug("data: {}".format(data)) 

141 

142 self.assertEqual(data.get("message"), "get sensors") 

143 

144 @unittest.skip("use multiple instead") 

145 def test_get_sensors(self): 

146 print("") 

147 log = logging.getLogger(logger_name(self)) 

148 sensors = TempStickSensor.get_sensors(API_KEY) 

149 if len(sensors) > 0: 

150 print("{} | First sensor id: {}".format(log.name, sensors[0].sensor_id)) 

151 print("{} | Last Checkin: {}".format(log.name, sensors[0].last_checkin)) 

152 log.debug("First sensor: {}".format(sensors[0])) 

153 else: 

154 print("{} | No sensors found.".format(log.name)) 

155 log.debug("No sensors found.") 

156 

157 self.assertEqual(sensors[0].sensor_id, SENSOR_ID) 

158 

159 def test_get_sensors_multiple(self): 

160 print("") 

161 log = logging.getLogger(logger_name(self)) 

162 sensors = TempStickSensor.get_sensors(API_KEY.replace("P", "a")) 

163 if len(sensors) > 0: 163 ↛ 168line 163 didn't jump to line 168, because the condition on line 163 was never false

164 print("{} | First sensor id: {}".format(log.name, sensors[0].sensor_id)) 

165 print("{} | Last Checkin: {}".format(log.name, sensors[0].last_checkin)) 

166 log.debug("First sensor: {}".format(sensors[0])) 

167 else: 

168 print("{} | No sensors found.".format(log.name)) 

169 log.debug("No sensors found.") 

170 

171 self.assertEqual(sensors[-1].sensor_id, SENSOR_3_CHANGES.get("sensor_id")) 

172 

173 def test_get_readings(self): 

174 print("") 

175 # log = logging.getLogger(logger_name(self)) 

176 # log.debug("sensor_id: {}".format(SENSOR_ID)) 

177 print("sensor_id: {}".format(SENSOR_ID)) 

178 

179 response = make_request(GET_READINGS, API_KEY, SENSOR_ID) 

180 response_b = benedict(response) 

181 readings = response_b.get_list("data.readings") 

182 

183 first_reading_sensor_time = readings[0].get("sensor_time") 

184 

185 print( 

186 "{} | First reading sensor time: {}".format( 

187 logger_name(self), first_reading_sensor_time 

188 ) 

189 ) 

190 logging.info("First reading sensor time: {}".format(first_reading_sensor_time)) 

191 

192 self.assertEqual(first_reading_sensor_time, "2022-09-04 07:00:36Z") 

193 

194 def test_get_readings_class(self): 

195 print("") 

196 

197 logger = {"log_name": logger_name(self)} 

198 log_print(("sensor_id", self.simple_sensor.sensor_id), **logger) 

199 

200 readings = self.simple_sensor.get_readings(API_KEY) 

201 

202 log_print(("readings[0]", readings[0]), **logger) 

203 

204 self.assertEqual(readings[0].get("temperature"), 24.72) 

205 

206 def test_get_readings_filter(self): 

207 print("") 

208 

209 logger = {"log_name": logger_name(self)} 

210 

211 # split range which goes from 2022-09-04 07:00:00Z - 2022-09-05 06:59:59Z 

212 filter_cutoff = format_datetime("2022-09-04 19:00:00Z") 

213 

214 log_print(("filter_cutoff", filter_cutoff), **logger) 

215 

216 readings = self.simple_sensor.get_readings(API_KEY, filter_cutoff) 

217 

218 log_print(("readings[0]", readings[0]), **logger) 

219 

220 self.assertGreater( 

221 format_datetime(readings[0].get("sensor_time")), filter_cutoff 

222 ) 

223 

224 def test_get_readings_filter_all(self): 

225 print("") 

226 

227 logger = logging.getLogger(__name__) 

228 log_print(("log_name", logger.name), logger_name(self)) 

229 

230 # logger = {'log_name': logger_name(self)} 

231 

232 # current range goes from 2022-09-04 07:00:00Z - 2022-09-05 06:59:59Z 

233 filter_cutoff = format_datetime("2022-09-06 07:00:00Z") 

234 

235 logger.debug("{}: {}".format("filter_cutoff", filter_cutoff)) 

236 

237 # log_print(('filter_cutoff', filter_cutoff), **logger) 

238 

239 self.assertRaises( 

240 FilterRemovesRange, self.simple_sensor.get_readings, API_KEY, filter_cutoff 

241 ) 

242 

243 def test_invalid_api_key(self): 

244 print("") 

245 

246 logger = {"log_name": logger_name(self)} 

247 

248 # sensors = TempStickSensor.get_sensors('invalid_api_key') 

249 

250 # log_print(('sensors[0].get("last_checkin")', sensors[0].get("last_checkin")), **logger) 

251 

252 self.assertRaises( 

253 InvalidApiKeyError, TempStickSensor.get_sensors, "invalid_api_key" 

254 ) 

255 

256 # def test_get_sensor(self): 

257 # print("") 

258 

259 # logger = logging.getLogger(__name__) 

260 # log_print(("log_name", logger.name), logger_name(self)) 

261 

262 # sensor = self.simple_sensor 

263 

264 # sensor = sensor.get_sensor(API_KEY) 

265 

266 # self.assertEqual(sensor.last_temp, SENSOR.get("last_temp")) 

267 

268 

269def logger_name(test): 

270 logger_name = "{function}".format(class_name=test.__class__.__name__, function=test) 

271 return logger_name 

272 

273 

274def log_print(variable: dict, obj=None, log_name=None): 

275 logger = log_name if log_name else logger_name(obj) 

276 name, value = variable 

277 value = "{log_name} | {variable_name}: {value}".format( 

278 log_name=logger, variable_name=name, value=value 

279 ) 

280 print(value) 

281 

282 

283if __name__ == "__main__": 

284 logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) 

285 # log = logging.getLogger(__name__) 

286 # print("hello") 

287 # logging.getLogger("TestSensorApi.test_make_request_get_sensors").setLevel(logging.DEBUG) 

288 # logging.getLogger("TestSensorApi.test_simple").setLevel(logging.DEBUG) 

289 runner = unittest.TextTestRunner(verbosity=2) 

290 unittest.main(testRunner=runner)