Debian Codegraph @

pylib/tests/integration_tests/test_device_manager.py

raw
1 #!/usr/bin/python3
2 # SPDX-License-Identifier: GPL-2.0-or-later
3
4 import multiprocessing
5 import os
6 import signal
7 import tempfile
8 import time
9 import unittest
10 import shutil
11 import openrazer.client
12 import openrazer_daemon.daemon
13 import openrazer._fake_driver as fake_driver
14
15
16 def run_daemon(daemon_dir, driver_dir):
17 # TODO console_log false
18 daemon = openrazer_daemon.daemon.RazerDaemon(verbose=True, console_log=False, test_dir=driver_dir)
19 daemon.run()
20
21
22 class DeviceManagerTest(unittest.TestCase):
23 @classmethod
24 def setUpClass(cls):
25 cls._daemon_dir = tempfile.mkdtemp(prefix='tmp_', suffix='_daemondata')
26 cls._tmp_dir = tempfile.mkdtemp(prefix='tmp_', suffix='_daemontest')
27
28 cls._bw_serial = 'IO0000000000001'
29 cls._bw_chroma = fake_driver.FakeDevice('razerblackwidowchroma', serial=cls._bw_serial, tmp_dir=cls._tmp_dir)
30 print("Created BlackWidow Chroma endpoints")
31
32 cls._daemon_proc = multiprocessing.Process(target=run_daemon, args=(cls._daemon_dir, cls._tmp_dir))
33 cls._daemon_proc.start()
34 print("Started daemon")
35 time.sleep(5)
36
37 @classmethod
38 def tearDownClass(cls):
39 print("Stopping daemon")
40 os.kill(cls._daemon_proc.pid, signal.SIGINT)
41 time.sleep(3)
42 if cls._daemon_proc.is_alive():
43 print("Daemon still alive...")
44 time.sleep(8)
45 if cls._daemon_proc.is_alive():
46 cls._daemon_proc.terminate()
47
48 if cls._daemon_proc.is_alive():
49 print("Failed to kill daemon")
50
51 cls._bw_chroma.close()
52
53 shutil.rmtree(cls._tmp_dir)
54 shutil.rmtree(cls._daemon_dir)
55
56 time.sleep(5)
57
58 def setUp(self):
59 self._bw_chroma.create_endpoints()
60
61 self.device_manager = openrazer.client.DeviceManager()
62
63 def test_device_list(self):
64 self.assertEqual(len(self.device_manager.devices), 1)
65
66 def test_serial(self):
67 device = self.device_manager.devices[0]
68
69 self.assertEqual(device.serial, self._bw_chroma.get('device_serial'))
70
71 def test_name(self):
72 device = self.device_manager.devices[0]
73
74 self.assertEqual(device.name, self._bw_chroma.get('device_type'))
75
76 def test_type(self):
77 device = self.device_manager.devices[0]
78
79 self.assertEqual(device.type, 'keyboard')
80
81 def test_fw_version(self):
82 device = self.device_manager.devices[0]
83
84 self.assertEqual(device.firmware_version, self._bw_chroma.get('firmware_version'))
85
86 def test_brightness(self):
87 device = self.device_manager.devices[0]
88
89 # Test 100%
90 device.brightness = 100.0
91
92 self.assertEqual('255', self._bw_chroma.get('matrix_brightness'))
93
94 self.assertEqual(100.0, device.brightness)
95
96 device.brightness = 50.0
97
98 self.assertEqual('127', self._bw_chroma.get('matrix_brightness'))
99
100 self.assertAlmostEqual(50.0, device.brightness, delta=0.4)
101
102 device.brightness = 0.0
103
104 self.assertEqual('0', self._bw_chroma.get('matrix_brightness'))
105
106 self.assertEqual(0, device.brightness)
107
108 def test_capabilities(self):
109 device = self.device_manager.devices[0]
110
111 self.assertEqual(device.capabilities, device._capabilities)
112
113 def test_device_keyboard_game_mode(self):
114 device = self.device_manager.devices[0]
115
116 self._bw_chroma.set('mode_game', '1')
117 self.assertTrue(device.game_mode_led)
118 device.game_mode_led = False
119 self.assertEqual(self._bw_chroma.get('mode_game'), '0')
120 device.game_mode_led = True
121 self.assertEqual(self._bw_chroma.get('mode_game'), '1')
122
123 def test_device_keyboard_macro_mode(self):
124 device = self.device_manager.devices[0]
125
126 self._bw_chroma.set('mode_macro', '1')
127 self.assertTrue(device.macro_mode_led)
128 device.macro_mode_led = False
129 self.assertEqual(self._bw_chroma.get('mode_macro'), '0')
130 device.macro_mode_led = True
131 self.assertEqual(self._bw_chroma.get('mode_macro'), '1')
132
133 self._bw_chroma.set('mode_macro_effect', '0')
134 self.assertEqual(device.macro_mode_led_effect, openrazer.client.constants.MACRO_LED_STATIC)
135 device.macro_mode_led_effect = openrazer.client.constants.MACRO_LED_BLINK
136 self.assertEqual(self._bw_chroma.get('mode_macro'), str(openrazer.client.constants.MACRO_LED_BLINK))
137
138 def test_device_keyboard_effect_none(self):
139 device = self.device_manager.devices[0]
140
141 device.fx.none()
142
143 self.assertEqual(self._bw_chroma.get('matrix_effect_none'), '1')
144
145 def test_device_keyboard_effect_spectrum(self):
146 device = self.device_manager.devices[0]
147
148 device.fx.spectrum()
149
150 self.assertEqual(self._bw_chroma.get('matrix_effect_spectrum'), '1')
151
152 def test_device_keyboard_effect_wave(self):
153 device = self.device_manager.devices[0]
154
155 device.fx.wave(openrazer.client.constants.WAVE_LEFT)
156 self.assertEqual(self._bw_chroma.get('matrix_effect_wave'), str(openrazer.client.constants.WAVE_LEFT))
157 device.fx.wave(openrazer.client.constants.WAVE_RIGHT)
158 self.assertEqual(self._bw_chroma.get('matrix_effect_wave'), str(openrazer.client.constants.WAVE_RIGHT))
159
160 with self.assertRaises(ValueError):
161 device.fx.wave('lalala')
162
163 def test_device_keyboard_effect_wheel(self):
164 device = self.device_manager.devices[0]
165
166 device.fx.wheel(openrazer.client.constants.WHEEL_LEFT)
167 self.assertEqual(self._bw_chroma.get('matrix_effect_wheel'), str(openrazer.client.constants.WHEEL_LEFT))
168 device.fx.wheel(openrazer.client.constants.WHEEL_RIGHT)
169 self.assertEqual(self._bw_chroma.get('matrix_effect_wheel'), str(openrazer.client.constants.WHEEL_RIGHT))
170
171 with self.assertRaises(ValueError):
172 device.fx.wheel('lalala')
173
174 def test_device_keyboard_effect_static(self):
175 device = self.device_manager.devices[0]
176
177 device.fx.static(255, 0, 255)
178 self.assertEqual(b'\xFF\x00\xFF', self._bw_chroma.get('matrix_effect_static', binary=True))
179
180 for red, green, blue in ((256.0, 0, 0), (0, 256.0, 0), (0, 0, 256.0)):
181 with self.assertRaises(ValueError):
182 device.fx.static(red, green, blue)
183
184 device.fx.static(256, 0, 700)
185 self.assertEqual(b'\xFF\x00\xFF', self._bw_chroma.get('matrix_effect_static', binary=True))
186
187 def test_device_keyboard_effect_reactive(self):
188 device = self.device_manager.devices[0]
189
190 time = openrazer.client.constants.REACTIVE_500MS
191 device.fx.reactive(255, 0, 255, time)
192 self.assertEqual(b'\x01\xFF\x00\xFF', self._bw_chroma.get('matrix_effect_reactive', binary=True))
193
194 for red, green, blue in ((256.0, 0, 0), (0, 256.0, 0), (0, 0, 256.0)):
195 with self.assertRaises(ValueError):
196 device.fx.reactive(red, green, blue, time)
197
198 device.fx.reactive(256, 0, 700, time)
199 self.assertEqual(b'\x01\xFF\x00\xFF', self._bw_chroma.get('matrix_effect_reactive', binary=True))
200
201 with self.assertRaises(ValueError):
202 device.fx.reactive(255, 0, 255, 'lalala')
203
204 def test_device_keyboard_effect_breath_single(self):
205 device = self.device_manager.devices[0]
206
207 device.fx.breath_single(255, 0, 255)
208 self.assertEqual(b'\xFF\x00\xFF', self._bw_chroma.get('matrix_effect_breath', binary=True))
209
210 for red, green, blue in ((256.0, 0, 0), (0, 256.0, 0), (0, 0, 256.0)):
211 with self.assertRaises(ValueError):
212 device.fx.breath_single(red, green, blue)
213
214 device.fx.breath_single(256, 0, 700)
215 self.assertEqual(b'\xFF\x00\xFF', self._bw_chroma.get('matrix_effect_breath', binary=True))
216
217 def test_device_keyboard_effect_breath_dual(self):
218 device = self.device_manager.devices[0]
219
220 device.fx.breath_dual(255, 0, 255, 255, 0, 0)
221 self.assertEqual(b'\xFF\x00\xFF\xFF\x00\x00', self._bw_chroma.get('matrix_effect_breath', binary=True))
222
223 for r1, g1, b1, r2, g2, b2 in ((256.0, 0, 0, 0, 0, 0), (0, 256.0, 0, 0, 0, 0), (0, 0, 256.0, 0, 0, 0),
224 (0, 0, 0, 256.0, 0, 0), (0, 0, 0, 0, 256.0, 0), (0, 0, 0, 0, 0, 256.0)):
225 with self.assertRaises(ValueError):
226 device.fx.breath_dual(r1, g1, b1, r2, g2, b2)
227
228 device.fx.breath_dual(256, 0, 700, 255, 0, 0)
229 self.assertEqual(b'\xFF\x00\xFF\xFF\x00\x00', self._bw_chroma.get('matrix_effect_breath', binary=True))
230
231 def test_device_keyboard_effect_breath_random(self):
232 device = self.device_manager.devices[0]
233
234 device.fx.breath_random()
235
236 self.assertEqual(self._bw_chroma.get('matrix_effect_breath'), '1')
237
238 def test_device_keyboard_effect_ripple(self):
239 device = self.device_manager.devices[0]
240
241 refresh_rate = 0.01
242 device.fx.ripple(255, 0, 255, refresh_rate)
243 time.sleep(0.1)
244
245 custom_effect_payload = self._bw_chroma.get('matrix_custom_frame', binary=True)
246 self.assertGreater(len(custom_effect_payload), 1)
247 self.assertEqual(self._bw_chroma.get('matrix_effect_custom'), '1')
248
249 for red, green, blue in ((256.0, 0, 0), (0, 256.0, 0), (0, 0, 256.0)):
250 with self.assertRaises(ValueError):
251 device.fx.reactive(red, green, blue, refresh_rate)
252
253 with self.assertRaises(ValueError):
254 device.fx.reactive(255, 0, 255, 'lalala')
255
256 device.fx.none()
257
258 def test_device_keyboard_effect_random_ripple(self):
259 device = self.device_manager.devices[0]
260
261 refresh_rate = 0.01
262 device.fx.ripple_random(refresh_rate)
263 time.sleep(0.1)
264
265 custom_effect_payload = self._bw_chroma.get('matrix_custom_frame', binary=True)
266 self.assertGreater(len(custom_effect_payload), 1)
267 self.assertEqual(self._bw_chroma.get('matrix_effect_custom'), '1')
268
269 with self.assertRaises(ValueError):
270 device.fx.ripple_random('lalala')
271
272 device.fx.none()
273
274 def test_device_keyboard_effect_framebuffer(self):
275 device = self.device_manager.devices[0]
276
277 device.fx.advanced.matrix.set(0, 0, (255, 0, 255))
278
279 self.assertEqual(device.fx.advanced.matrix.get(0, 0), (255, 0, 255))
280
281 device.fx.advanced.draw()
282 custom_effect_payload = self._bw_chroma.get('matrix_custom_frame', binary=True)
283 self.assertEqual(custom_effect_payload[:4], b'\x00\xFF\x00\xFF')
284
285 device.fx.advanced.matrix.to_framebuffer() # Save 255, 0, 255
286 device.fx.advanced.matrix.reset() # Clear FB
287
288 device.fx.advanced.matrix.set(0, 0, (0, 255, 0))
289
290 device.fx.advanced.draw_fb_or() # Draw FB or'd with Matrix
291 custom_effect_payload = self._bw_chroma.get('matrix_custom_frame', binary=True)
292 self.assertEqual(custom_effect_payload[:4], b'\x00\xFF\xFF\xFF')
293
294 # Append that to FB
295 device.fx.advanced.matrix.to_framebuffer_or()
296 device.fx.advanced.draw()
297 custom_effect_payload = self._bw_chroma.get('matrix_custom_frame', binary=True)
298
299 binary = device.fx.advanced.matrix.to_binary()
300
301 self.assertEqual(binary, custom_effect_payload)
302
303 def test_device_keyboard_macro_enable(self):
304 device = self.device_manager.devices[0]
305
306 device.macro.enable_macros()
307
308 self.assertEqual(self._bw_chroma.get('macro_keys'), '1')
309
310 def test_device_keyboard_macro_add(self):
311 device = self.device_manager.devices[0]
312
313 url_macro = device.macro.create_url_macro_item('http://example.org')
314 device.macro.add_macro('M1', [url_macro])
315
316 macros = device.macro.get_macros()
317 self.assertIn('M1', macros)
318
319 with self.assertRaises(ValueError):
320 device.macro.add_macro('M6', url_macro) # Unknown key
321
322 with self.assertRaises(ValueError):
323 device.macro.add_macro('M1', 'lalala') # Not a sequnce
324
325 with self.assertRaises(ValueError):
326 device.macro.add_macro('M1', ['lalala']) # Bad element in sequence
327
328 def test_device_keyboard_macro_del(self):
329 device = self.device_manager.devices[0]
330
331 url_macro = device.macro.create_url_macro_item('http://example.org')
332 device.macro.add_macro('M2', [url_macro])
333
334 macros = device.macro.get_macros()
335 self.assertIn('M2', macros)
336
337 device.macro.del_macro('M2')
338 macros = device.macro.get_macros()
339 self.assertNotIn('M2', macros)
340
341 with self.assertRaises(ValueError):
342 device.macro.del_macro('M6') # Unknown key
343
344
345 if __name__ == "__main__":
346 unittest.main()