← Back to branch summary

~ubuntuone-control-tower/ubuntuone-control-panel/trunk

« back to all changes in this revision

Viewing changes to ubuntuone/controlpanel/gtk/tests/test_gui.py

  • Committer: Tarmac
  • Author(s): Natalia B. Bidart, natalia.bidart at canonical
  • Date: 2010-12-17 18:16:17 UTC
  • mfrom: (32.2.14 devices)
  • Revision ID: tarmac-20101217181617-ledgaqp08ayhu2cl
* Implemented devices tab (LP: #690649).

* Maximun size is set using geometry hints (LP: #683164).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntuone/controlpanel/gtk/tests/test_gui.py
45
45
    {'volume_id': '2', 'suggested_path': '~/baz', 'subscribed': 'True'},
46
46
]
47
47
 
 
48
FAKE_DEVICE_INFO = {
 
49
    'device_id': '1258-6854', 'device_name': 'Baz', 'device_type': 'Computer',
 
50
    'configurable': 'True', 'limit_bandwidth': 'True',
 
51
    'max_upload_speed': '1000', 'max_download_speed': '72548',
 
52
}
 
53
 
 
54
FAKE_DEVICES_INFO = [
 
55
    {'device_id': '0', 'name': 'Foo', 'type': 'Computer', 'configurable': ''},
 
56
    {'device_id': '1', 'name': 'Bar', 'type': 'Phone', 'configurable': ''},
 
57
    {'device_id': '2', 'name': 'Z', 'type': 'Computer',
 
58
     'configurable': 'True', 'limit_bandwidth': '',
 
59
     'max_upload_speed': '0', 'max_download_speed': '0'},
 
60
    {'device_id': '1258-6854', 'name': 'Baz', 'type': 'Computer',
 
61
     'configurable': 'True', 'limit_bandwidth': 'True',
 
62
     'max_upload_speed': '1000', 'max_download_speed': '72548'},
 
63
]
 
64
 
48
65
 
49
66
class FakedObject(object):
50
67
    """Fake an object, record every call."""
108
125
    bus_name = gui.DBUS_BUS_NAME
109
126
    object_path = gui.DBUS_PREFERENCES_PATH
110
127
    iface = gui.DBUS_PREFERENCES_IFACE
111
 
    exposed_methods = ['account_info', 'devices_info', 'volumes_info',
112
 
                       'file_sync_status', 'change_volume_settings']
 
128
    exposed_methods = [
 
129
        'account_info', 'devices_info', 'change_device_settings',
 
130
        'volumes_info', 'change_volume_settings', 'file_sync_status',
 
131
    ]
113
132
 
114
133
 
115
134
class FakedSessionBus(object):
268
287
        self.assertEqual(self.ui.get_icon_name(), 'ubuntuone')
269
288
 
270
289
    def test_max_size(self):
271
 
        """Max size is not bigger than 966x576 (LP: #645526)."""
272
 
        self.assertTrue(self.ui.get_size_request() <= (966, 576))
 
290
        """Max size is not bigger than 736x525 (LP: #645526, LP: #683164)."""
 
291
        self.assertTrue(self.ui.get_size_request() <= (736, 525))
273
292
 
274
293
 
275
294
class ControlPanelTestCase(ControlPanelMixinTestCase):
801
820
        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
802
821
 
803
822
        self.assertFalse(self.ui.label_alignment.get_visible())
804
 
        self.assertEqual(self.ui.folders_alignment.get_children(),
805
 
                         [self.ui.volumes])
 
823
        self.assertEqual(self.ui.folders.get_children(), [self.ui.volumes])
806
824
 
807
825
        volumes = self.ui.volumes.get_children()
808
826
        volumes.reverse()
828
846
        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
829
847
        self.ui.on_volumes_info_ready(FAKE_VOLUMES_INFO)
830
848
 
831
 
        self.assertEqual(len(self.ui.folders_alignment.get_children()), 1)
832
 
        child = self.ui.folders_alignment.get_children()[0]
 
849
        self.assertEqual(len(self.ui.folders.get_children()), 1)
 
850
        child = self.ui.folders.get_children()[0]
833
851
        self.assertEqual(child, self.ui.volumes)
834
852
 
835
853
        volumes = filter(lambda w: isinstance(w, gui.gtk.CheckButton),
840
858
        """When there are no volumes, a notification is shown."""
841
859
        self.ui.on_volumes_info_ready([])
842
860
        # no volumes table
843
 
        self.assertEqual(len(self.ui.folders_alignment.get_children()), 0)
 
861
        self.assertEqual(len(self.ui.folders.get_children()), 0)
844
862
        self.assertTrue(self.ui.volumes is None)
845
863
 
846
864
    def test_on_subscribed_clicked(self):
852
870
            checkbutton.clicked()
853
871
            fid = checkbutton.get_label()
854
872
 
855
 
            subscribed = 'True' if checkbutton.get_active() else ''
 
873
            subscribed = gui.bool_str(checkbutton.get_active())
856
874
            self.assert_backend_called(method,
857
875
                                       (fid, {'subscribed': subscribed}))
858
876
            # clean backend calls
859
877
            self.ui.backend._called.pop(method)
860
878
 
861
879
            checkbutton.clicked()
862
 
            subscribed = 'True' if checkbutton.get_active() else ''
 
880
            subscribed = gui.bool_str(checkbutton.get_active())
863
881
            self.assert_backend_called('change_volume_settings',
864
882
                                       (fid, {'subscribed': subscribed}))
865
883
 
881
899
        self.test_on_volumes_info_ready_with_no_volumes()
882
900
 
883
901
 
 
902
class DeviceTestCase(ControlPanelMixinTestCase):
 
903
    """The test suite for the device widget."""
 
904
 
 
905
    klass = gui.Device
 
906
    ui_filename = 'device.ui'
 
907
 
 
908
    def assert_device_equal(self, device, expected):
 
909
        """Assert that the device has the values from expected."""
 
910
        self.assertEqual(device.device_id.get_text(),
 
911
                         expected['device_id'])
 
912
        self.assertEqual(device.device_name.get_text(),
 
913
                         expected['device_name'])
 
914
        self.assertEqual(device.device_type.get_icon_name()[0],
 
915
                         expected['device_type'].lower())
 
916
        self.assertEqual(device.configurable,
 
917
                         bool(expected['configurable']))
 
918
        self.assertEqual(device.limit_bandwidth.get_active(),
 
919
                         bool(expected['limit_bandwidth']))
 
920
 
 
921
        value = int(expected['max_upload_speed']) // gui.KILOBYTES
 
922
        self.assertEqual(device.max_upload_speed.get_value_as_int(), value)
 
923
        value = int(expected['max_download_speed']) // gui.KILOBYTES
 
924
        self.assertEqual(device.max_download_speed.get_value_as_int(), value)
 
925
 
 
926
    def assert_device_settings_changed(self):
 
927
        """Changing throttling settings updates the backend properly."""
 
928
        expected = self.ui.__dict__
 
929
        self.assert_backend_called('change_device_settings',
 
930
                                   (self.ui.device_id.get_text(), expected))
 
931
        self.assertEqual(self.ui.warning_label.get_text(), '')
 
932
 
 
933
    def modify_settings(self):
 
934
        """Modify settings so values actually change."""
 
935
        new_val = not self.ui.limit_bandwidth.get_active()
 
936
        self.ui.limit_bandwidth.set_active(new_val)
 
937
 
 
938
        new_val = self.ui.max_upload_speed.get_value_as_int() + 1
 
939
        self.ui.max_upload_speed.set_value(new_val)
 
940
 
 
941
        new_val = self.ui.max_download_speed.get_value_as_int() + 1
 
942
        self.ui.max_download_speed.set_value(new_val)
 
943
 
 
944
    def test_is_a_vbox(self):
 
945
        """Inherits from VBox."""
 
946
        self.assertIsInstance(self.ui, gui.gtk.VBox)
 
947
 
 
948
    def test_inner_widget_is_packed(self):
 
949
        """The 'itself' vbox is packed into the widget."""
 
950
        self.assertIn(self.ui.itself, self.ui.get_children())
 
951
 
 
952
    def test_is_visible(self):
 
953
        """Is visible."""
 
954
        self.assertTrue(self.ui.get_visible())
 
955
 
 
956
    def test_is_sensitive(self):
 
957
        """Is sensitive."""
 
958
        self.assertTrue(self.ui.get_sensitive())
 
959
 
 
960
    def test_warning_label_is_cleared(self):
 
961
        """The warning label is cleared."""
 
962
        self.assertEqual(self.ui.warning_label.get_text(), '')
 
963
 
 
964
    def test_device_id_is_hidden(self):
 
965
        """The device id label is hidden."""
 
966
        self.assertFalse(self.ui.device_id.get_visible())
 
967
 
 
968
    def test_default_values(self):
 
969
        """Default values are correct."""
 
970
        self.assertEqual(self.ui.device_id.get_text(), '')
 
971
        self.assertEqual(self.ui.device_name.get_text(), '')
 
972
        self.assertEqual(self.ui.device_type.get_icon_name()[0],
 
973
                         gui.DEVICE_TYPE_COMPUTER.lower())
 
974
        self.assertEqual(self.ui.configurable, False)
 
975
        self.assertEqual(self.ui.limit_bandwidth.get_active(), False)
 
976
        self.assertEqual(self.ui.max_upload_speed.get_value_as_int(), 0)
 
977
        self.assertEqual(self.ui.max_download_speed.get_value_as_int(), 0)
 
978
 
 
979
    def test_init_does_not_call_backend(self):
 
980
        """When updating, the backend is not called."""
 
981
        self.assertEqual(self.ui.backend._called, {})
 
982
 
 
983
    def test_update_device_id(self):
 
984
        """A device can be updated from a dict."""
 
985
        value = '741-822-963'
 
986
        self.ui.update(device_id=value)
 
987
        self.assertEqual(value, self.ui.device_id.get_text())
 
988
 
 
989
    def test_update_device_name(self):
 
990
        """A device can be updated from a dict."""
 
991
        value = 'The death star'
 
992
        self.ui.update(device_name=value)
 
993
        self.assertEqual(value, self.ui.device_name.get_text())
 
994
 
 
995
    def test_update_unicode_device_name(self):
 
996
        """A device can be updated from a dict."""
 
997
        value = u'Ñoño Ñandú'
 
998
        self.ui.update(device_name=value)
 
999
        self.assertEqual(value, self.ui.device_name.get_text())
 
1000
 
 
1001
    def test_update_device_type_computer(self):
 
1002
        """A device can be updated from a dict."""
 
1003
        dtype = gui.DEVICE_TYPE_COMPUTER
 
1004
        self.ui.update(device_type=dtype)
 
1005
        self.assertEqual((dtype.lower(), gui.gtk.ICON_SIZE_BUTTON),
 
1006
                         self.ui.device_type.get_icon_name())
 
1007
 
 
1008
    def test_update_device_type_phone(self):
 
1009
        """A device can be updated from a dict."""
 
1010
        dtype = gui.DEVICE_TYPE_PHONE
 
1011
        self.ui.update(device_type=dtype)
 
1012
        self.assertEqual((dtype.lower(), gui.gtk.ICON_SIZE_BUTTON),
 
1013
                         self.ui.device_type.get_icon_name())
 
1014
 
 
1015
    def test_update_configurable(self):
 
1016
        """A device can be updated from a dict."""
 
1017
        self.ui.update(configurable='')
 
1018
        self.assertFalse(self.ui.configurable)
 
1019
        self.assertFalse(self.ui.throttling.get_visible())
 
1020
 
 
1021
    def test_update_non_configurable(self):
 
1022
        """A device can be updated from a dict."""
 
1023
        self.ui.update(configurable='True')
 
1024
        self.assertTrue(self.ui.configurable)
 
1025
        self.assertTrue(self.ui.throttling.get_visible())
 
1026
 
 
1027
    def test_update_limit_bandwidth(self):
 
1028
        """A device can be updated from a dict."""
 
1029
        self.ui.update(limit_bandwidth='')
 
1030
        self.assertFalse(self.ui.limit_bandwidth.get_active())
 
1031
 
 
1032
        self.ui.update(limit_bandwidth='True')
 
1033
        self.assertTrue(self.ui.limit_bandwidth.get_active())
 
1034
 
 
1035
    def test_update_upload_speed(self):
 
1036
        """A device can be updated from a dict."""
 
1037
        value = '12345'
 
1038
        self.ui.update(max_upload_speed=value)
 
1039
        self.assertEqual(int(value) // gui.KILOBYTES,
 
1040
                         self.ui.max_upload_speed.get_value_as_int())
 
1041
 
 
1042
    def test_update_download_speed(self):
 
1043
        """A device can be updated from a dict."""
 
1044
        value = '987654'
 
1045
        self.ui.update(max_download_speed=value)
 
1046
        self.assertEqual(int(value) // gui.KILOBYTES,
 
1047
                         self.ui.max_download_speed.get_value_as_int())
 
1048
 
 
1049
    def test_update_does_not_call_backend(self):
 
1050
        """When updating, the backend is not called."""
 
1051
        self.ui.update(**FAKE_DEVICE_INFO)
 
1052
        self.assertEqual(self.ui.backend._called, {})
 
1053
        self.assert_device_equal(self.ui, FAKE_DEVICE_INFO)
 
1054
 
 
1055
    def test_on_limit_bandwidth_toggled(self):
 
1056
        """When toggling limit_bandwidth, backend is updated."""
 
1057
        self.ui.limit_bandwidth.toggled()
 
1058
        self.assert_device_settings_changed()
 
1059
 
 
1060
    def test_on_max_upload_speed_value_changed(self):
 
1061
        """When setting max_upload_speed, backend is updated."""
 
1062
        self.ui.max_upload_speed.set_value(25)
 
1063
        self.assert_device_settings_changed()
 
1064
 
 
1065
    def test_on_max_download_speed_value_changed(self):
 
1066
        """When setting max_download_speed, backend is updated."""
 
1067
        self.ui.max_download_speed.set_value(52)
 
1068
        self.assert_device_settings_changed()
 
1069
 
 
1070
    def test_backend_signals(self):
 
1071
        """The proper signals are connected to the backend."""
 
1072
        self.assertEqual(self.ui.backend._signals['DeviceSettingsChanged'],
 
1073
                         [self.ui.on_device_settings_changed])
 
1074
        self.assertEqual(self.ui.backend._signals['DeviceSettingsChangeError'],
 
1075
                         [self.ui.on_device_settings_change_error])
 
1076
 
 
1077
    def test_on_device_settings_changed(self):
 
1078
        """When settings were changed for this device, enable it."""
 
1079
        self.modify_settings()
 
1080
        did = self.ui.device_id.get_text()
 
1081
        self.ui.on_device_settings_changed(device_id=did)
 
1082
 
 
1083
        self.assertTrue(self.ui.get_sensitive())
 
1084
        self.assertEqual(self.ui.warning_label.get_text(), '')
 
1085
        self.assertEqual(self.ui.__dict__, self.ui._last_settings)
 
1086
 
 
1087
    def test_on_device_settings_change_after_error(self):
 
1088
        """Change success after error."""
 
1089
        self.modify_settings()
 
1090
        did = self.ui.device_id.get_text()
 
1091
        self.ui.on_device_settings_change_error(device_id=did)  # change failed
 
1092
 
 
1093
        self.test_on_device_settings_changed()
 
1094
 
 
1095
    def test_on_device_settings_changed_different_id(self):
 
1096
        """When settings were changed for other device, nothing changes."""
 
1097
        self.modify_settings()
 
1098
        self.ui.on_device_settings_changed(device_id='yadda')
 
1099
 
 
1100
        self.assertEqual(self.ui.warning_label.get_text(), '')
 
1101
 
 
1102
    def test_on_device_settings_change_error(self):
 
1103
        """When settings were not changed for this device, notify the user.
 
1104
 
 
1105
        Also, confirm that old values were restored.
 
1106
 
 
1107
        """
 
1108
        self.ui.update(**FAKE_DEVICE_INFO)  # use known values
 
1109
 
 
1110
        self.modify_settings()
 
1111
 
 
1112
        did = self.ui.device_id.get_text()
 
1113
        self.ui.on_device_settings_change_error(device_id=did)  # change failed
 
1114
 
 
1115
        self.assertTrue(self.ui.get_sensitive())
 
1116
        self.assert_warning_correct(self.ui.warning_label,
 
1117
                                    self.ui.DEVICE_CHANGE_ERROR)
 
1118
        self.assert_device_equal(self.ui, FAKE_DEVICE_INFO)  # restored info
 
1119
 
 
1120
    def test_on_device_settings_change_error_after_success(self):
 
1121
        """Change error after success."""
 
1122
        self.modify_settings()
 
1123
        did = self.ui.device_id.get_text()
 
1124
        self.ui.on_device_settings_changed(device_id=did)
 
1125
 
 
1126
        self.test_on_device_settings_change_error()
 
1127
 
 
1128
    def test_on_device_settings_change_error_different_id(self):
 
1129
        """When settings were not changed for other device, do nothing."""
 
1130
        self.modify_settings()
 
1131
        self.ui.on_device_settings_change_error(device_id='yudo')
 
1132
        self.assertEqual(self.ui.warning_label.get_text(), '')
 
1133
 
 
1134
 
884
1135
class DevicesTestCase(ControlPanelMixinTestCase):
885
1136
    """The test suite for the devices panel."""
886
1137
 
899
1150
        """Is visible."""
900
1151
        self.assertTrue(self.ui.get_visible())
901
1152
 
 
1153
    def test_backend_signals(self):
 
1154
        """The proper signals are connected to the backend."""
 
1155
        self.assertEqual(self.ui.backend._signals['DevicesInfoReady'],
 
1156
                         [self.ui.on_devices_info_ready])
 
1157
        self.assertEqual(self.ui.backend._signals['DevicesInfoError'],
 
1158
                         [self.ui.on_devices_info_error])
 
1159
 
 
1160
    def test_devices_info_is_requested(self):
 
1161
        """The devices info is requested to the backend."""
 
1162
        self.assert_backend_called('devices_info', ())
 
1163
 
 
1164
    def test_on_devices_info_ready(self):
 
1165
        """The devices info is processed when ready."""
 
1166
        self.ui.on_devices_info_ready(FAKE_DEVICES_INFO)
 
1167
 
 
1168
        children = self.ui.devices.get_children()
 
1169
        self.assertEqual(len(children), len(FAKE_DEVICES_INFO))
 
1170
 
 
1171
        for child, device in zip(children, FAKE_DEVICES_INFO):
 
1172
            self.assertIsInstance(child, gui.Device)
 
1173
 
 
1174
            self.assertEqual(device['device_id'],
 
1175
                             child.device_id.get_text())
 
1176
            self.assertEqual(device['device_name'],
 
1177
                             child.device_name.get_text())
 
1178
            self.assertEqual(device['device_type'].lower(),
 
1179
                             child.device_type.get_icon_name()[0])
 
1180
            self.assertEqual(bool(device['configurable']),
 
1181
                             child.configurable)
 
1182
 
 
1183
            if bool(device['configurable']):
 
1184
                self.assertEqual(bool(device['limit_bandwidth']),
 
1185
                                 child.limit_bandwidth.get_active())
 
1186
                value = int(device['max_upload_speed']) // gui.KILOBYTES
 
1187
                self.assertEqual(value,
 
1188
                                 child.max_upload_speed.get_value_as_int())
 
1189
                value = int(device['max_download_speed']) // gui.KILOBYTES
 
1190
                self.assertEqual(value,
 
1191
                                 child.max_download_speed.get_value_as_int())
 
1192
 
 
1193
    def test_on_devices_info_error(self):
 
1194
        """The devices info couldn't be retrieved."""
 
1195
        self.ui.on_devices_info_error()
 
1196
 
902
1197
 
903
1198
class ApplicationsTestCase(ControlPanelMixinTestCase):
904
1199
    """The test suite for the applications panel."""