g13gui: Tests for BindingProfile and a bunch of code cleanups

The BindingProfile class had a bunch of untested code that was assigning to
things by the wrong name, or making logic errors all throughout. With the added
unit tests, that cleans it up considerably.

g13gui/g13gui/bindingprofile.py

@@ -2,29 +2,29 @@
 
 import bindings
 
+from observer import Subject
+from observer import ChangeType
 
-class BindingProfile(object):
+
+class BindingProfile(Subject):
     def __init__(self, dict=None):
+        self.initDefaults()
         if dict:
-            self._stickMode = dict['stickMode']
+            self.loadFromDict(dict)
-            self._stickRegions = dict['stickRegions']
+
-            self._stickRegionBindings = dict['stickRegionBindings']
+    def initDefaults(self):
-            self._keyBindings = dict['keyBindings']
+        self._stickMode = bindings.StickMode.KEYS
-        else:
-            self._stickMode = bindings.GetStickModeNum('KEYS')
         self._stickRegions = bindings.DEFAULT_STICK_REGIONS
         self._stickRegionBindings = bindings.DEFAULT_STICK_REGION_BINDINGS
         self._keyBindings = bindings.DEFAULT_KEY_BINDINGS
 
-        self._observers = []
+    def stickMode(self):
+        return self._stickMode
 
-    def registerObserver(self, observer):
+    def stickRegions(self):
-        self._observers.append(observer)
-
-    def getStickRegions(self):
         return self._stickRegions
 
-    def getBoundKey(self, gkey):
+    def keyBinding(self, gkey):
         gkey = gkey.upper()
 
         if gkey in self._stickRegions.keys():
@@ -36,38 +36,56 @@ class BindingProfile(object):
 
         return []
 
-    def bindKey(self, gkey, keybinding):
+    def _bindKey(self, gkey, keybinding):
         if gkey in self._stickRegions.keys():
             self._stickRegionBindings[gkey] = keybinding
-            return
+        else:
-
             self._keyBindings[gkey] = keybinding
-        self._notify()
+        self.addChange(ChangeType.MODIFY, gkey, keybinding)
 
-    def _notify(self):
+    def bindKey(self, gkey, keybinding):
-        for observer in self._observers:
+        self._bindKey(gkey, keybinding)
-            observer.on_changed(self)
+        self.notifyChanged()
 
-    def generateConfigString(self):
+    def _setStickMode(self, stickmode):
+        if stickmode not in bindings.ALL_STICK_MODES:
+            raise ValueError('stickmode must be one of %s' %
+                             (bindings.ALL_STICK_MODES))
+
+        self._stickMode = stickmode
+        self.addChange(ChangeType.MODIFY, 'stickmode', stickmode)
+
+    def setStickMode(self, stickmode):
+        self._setStickMode(stickmode)
+        self.notifyChanged()
+
+    def toCommandString(self):
         commands = []
 
         for gkey, kbdkey in self._keyBindings.items():
             if len(kbdkey) > 0:
-                keys = ' '.join(['KEY_' + key for key in kbdkey])
+                keys = '+'.join(['KEY_' + key for key in kbdkey])
                 commands.append("bind %s %s" % (gkey, keys))
             else:
                 commands.append("unbind %s" % (gkey))
 
-        if self._stickMode == bindings.GetStickModeNum('KEYS'):
+        if self._stickMode == bindings.StickMode.KEYS:
             for region, bounds in self._stickRegions.items():
                 commands.append("stickzone add %s" % (region))
-                commands.append("stickzone bounds %s %0.1f %0.1f %0.1f %0.1f" % (region, bounds[0], bounds[1], bounds[2], bounds[3]))
+                commands.append("stickzone bounds %s %0.1f %0.1f %0.1f %0.1f" %
+                                (region, *bounds))
                 keys = ' '.join(['KEY_' + key for key in self._stickRegionBindings[region]])
                 commands.append("stickzone action %s %s" % (region, keys))
 
         return '\n'.join(commands)
 
-    def toDict(self):
+    def loadFromDict(self, dict):
+        self._stickMode = dict['stickMode']
+        self._stickRegions = dict['stickRegions']
+        self._stickRegionBindings = dict['stickRegionBindings']
+        self._keyBindings = dict['keyBindings']
+
+    def saveToDict(self):
         return {
             'stickMode': self._stickMode,
             'stickRegions': self._stickRegions,

g13gui/g13gui/bindingprofile_tests.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python
+
+import unittest
+
+import bindings
+from bindingprofile import BindingProfile
+from observer import ChangeType
+from observer import ObserverTestCase
+
+
+class PrefsTestCase(ObserverTestCase):
+    def setUp(self):
+        pass
+
+    def testInitialSetup(self):
+        bp = BindingProfile()
+        self.assertEqual(bp.stickMode(), bindings.StickMode.KEYS)
+        self.assertEqual(bp.stickRegions(), bindings.DEFAULT_STICK_REGIONS)
+        self.assertEqual(bp._stickRegionBindings, bindings.DEFAULT_STICK_REGION_BINDINGS)
+        self.assertEqual(bp._keyBindings, bindings.DEFAULT_KEY_BINDINGS)
+
+    def testInvalidDict(self):
+        bp = BindingProfile({})
+        self.assertEqual(bp.stickMode(), bindings.StickMode.KEYS)
+        self.assertEqual(bp.stickRegions(), bindings.DEFAULT_STICK_REGIONS)
+        self.assertEqual(bp._stickRegionBindings, bindings.DEFAULT_STICK_REGION_BINDINGS)
+        self.assertEqual(bp._keyBindings, bindings.DEFAULT_KEY_BINDINGS)
+
+    def testDictLoadSave(self):
+        bp = BindingProfile()
+        initial_d = bp.saveToDict()
+        self.assertIsNotNone(initial_d)
+
+        bp = BindingProfile(initial_d)
+        new_d = bp.saveToDict()
+        self.assertEqual(initial_d, new_d)
+
+    def testBindKey(self):
+        bp = BindingProfile()
+        bp.registerObserver(self)
+
+        bp.bindKey('G22', 'A')
+        self.assertEqual(bp._keyBindings['G22'], 'A')
+        self.assertEqual(bp.keyBinding('G22'), 'A')
+        self.assertChangeCount(1)
+        self.assertChangeNotified(bp, ChangeType.MODIFY, 'G22')
+        self.assertChangeDataEquals('A')
+        self.nextChange()
+
+        bp.bindKey('STICK_UP', 'A')
+        self.assertEqual(bp._stickRegionBindings['STICK_UP'], 'A')
+        self.assertEqual(bp.keyBinding('STICK_UP'), 'A')
+        self.assertChangeCount(1)
+        self.assertChangeNotified(bp, ChangeType.MODIFY, 'STICK_UP')
+        self.assertChangeDataEquals('A')
+        self.nextChange()
+
+    def testSetStickMode(self):
+        bp = BindingProfile()
+        bp.registerObserver(self)
+        bp.setStickMode(bindings.StickMode.ABSOLUTE)
+        self.assertEqual(bp._stickMode, bindings.StickMode.ABSOLUTE)
+        self.assertEqual(bp.stickMode(), bindings.StickMode.ABSOLUTE)
+        self.assertChangeCount(1)
+        self.assertChangeNotified(bp, ChangeType.MODIFY, 'stickmode')
+        self.assertChangeDataEquals(bindings.StickMode.ABSOLUTE)
+
+        try:
+            bp.setStickMode('zorch')
+        except ValueError:
+            pass
+        else:
+            self.fail('Expected ValueError from setStickMode')
+
+
+if __name__ == '__main__':
+    unittest.main()