Fix bugs in process_cfg_account + tests

res/ui/account_cfg.ui

@@ -57,33 +57,6 @@
             </item>
            </layout>
           </item>
-          <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_7">
-            <property name="topMargin">
-             <number>6</number>
-            </property>
-            <item>
-             <widget class="QLabel" name="label_2">
-              <property name="text">
-               <string>Wallets</string>
-              </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QSpinBox" name="spinbox_wallets">
-              <property name="minimum">
-               <number>1</number>
-              </property>
-              <property name="maximum">
-               <number>100</number>
-              </property>
-              <property name="value">
-               <number>1</number>
-              </property>
-             </widget>
-            </item>
-           </layout>
-          </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_8">
             <property name="topMargin">
@@ -475,22 +448,6 @@
     </hint>
    </hints>
   </connection>
-  <connection>
-   <sender>spinbox_wallets</sender>
-   <signal>valueChanged(int)</signal>
-   <receiver>AccountConfigurationDialog</receiver>
-   <slot>action_edit_account_parameters()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>285</x>
-     <y>127</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>199</x>
-     <y>118</y>
-    </hint>
-   </hints>
-  </connection>
   <connection>
    <sender>button_delete</sender>
    <signal>clicked()</signal>

src/cutecoin/gui/process_cfg_account.py

@@ -4,8 +4,7 @@ Created on 6 mars 2014
 @author: inso
 """
 import logging
-import requests
-from ucoinpy.documents.peer import Peer
+import asyncio
 from ucoinpy.key import SigningKey
 from ..gen_resources.account_cfg_uic import Ui_AccountConfigurationDialog
 from ..gui.process_cfg_community import ProcessConfigureCommunity
@@ -122,12 +121,9 @@ class StepPageCommunities(Step):
         if self.config_dialog.password_asker.result() == QDialog.Rejected:
             return
 
-        nb_wallets = self.config_dialog.spinbox_wallets.value()
-        self.config_dialog.account.set_walletpool_size(nb_wallets, password)
-
         self.config_dialog.app.add_account(self.config_dialog.account)
         if len(self.config_dialog.app.accounts) == 1:
-            self.config_dialog.app.default_account = self.config_dialog.account.name
+            self.config_dialog.app.preferences['account'] = self.config_dialog.account.name
         self.config_dialog.app.save(self.config_dialog.account)
         self.config_dialog.app.current_account = self.config_dialog.account
 
@@ -196,17 +192,14 @@ class ProcessConfigureAccount(QDialog, Ui_AccountConfigurationDialog):
         self.list_communities.setModel(CommunitiesListModel(self.account))
 
     def action_edit_account_key(self):
-        if self.step.is_valid():
-            self.button_next.setEnabled(True)
-        else:
-            self.button_next.setEnabled(False)
+        self.button_generate.setEnabled(self.step.is_valid())
+        self.button_next.setEnabled(self.step.is_valid())
 
     def action_show_pubkey(self):
         salt = self.edit_salt.text()
         password = self.edit_password.text()
         pubkey = SigningKey(salt, password).pubkey
-        QMessageBox.information(self, self.tr("Public key"),
-                                self.tr("These parameters pubkeys are : {0}").format(pubkey))
+        self.label_info.setText(pubkey)
 
     def action_edit_account_parameters(self):
         if self.step.is_valid():
@@ -255,5 +248,11 @@ Are you sure ?"""))
             self.stacked_pages.setCurrentIndex(previous_index)
             self.step.display_page()
 
+    def async_exec(self):
+        future = asyncio.Future()
+        self.finished.connect(lambda r: future.set_result(r))
+        self.open()
+        return future
+
     def accept(self):
         super().accept()

src/cutecoin/tests/process_cfg_account/test_add_account.py

+import sys
+import unittest
+import asyncio
+import quamash
+import logging
+from PyQt5.QtWidgets import QDialog
+from PyQt5.QtCore import QLocale, Qt
+from PyQt5.QtTest import QTest
+from cutecoin.tests.mocks.bma import new_blockchain
+from cutecoin.tests.mocks.access_manager import MockNetworkAccessManager
+from cutecoin.core.registry.identities import IdentitiesRegistry
+from cutecoin.gui.process_cfg_account import ProcessConfigureAccount
+from cutecoin.gui.password_asker import PasswordAskerDialog
+from cutecoin.core.app import Application
+from cutecoin.core.account import Account
+from cutecoin.tests import get_application
+
+
+class ProcessAddCommunity(unittest.TestCase):
+    def setUp(self):
+        self.qapplication = get_application()
+        self.network_manager = MockNetworkAccessManager()
+        QLocale.setDefault(QLocale("en_GB"))
+        self.lp = quamash.QEventLoop(self.qapplication)
+        asyncio.set_event_loop(self.lp)
+        self.identities_registry = IdentitiesRegistry()
+
+        self.application = Application(self.qapplication, self.lp, self.network_manager, self.identities_registry)
+        self.application.preferences['notifications'] = False
+        # Salt/password : "testcutecoin/testcutecoin"
+        # Pubkey : 7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ
+        self.account = Account("testcutecoin", "7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ",
+                               "test", [], [], [], self.identities_registry)
+        self.password_asker = PasswordAskerDialog(self.account)
+        self.password_asker.password = "testcutecoin"
+        self.password_asker.remember = True
+
+    def tearDown(self):
+        try:
+            self.lp.close()
+        finally:
+            asyncio.set_event_loop(None)
+
+    def test_create_account(self):
+        process_account = ProcessConfigureAccount(self.application,
+                                                    None)
+
+        @asyncio.coroutine
+        def open_dialog(process_account):
+            result = yield from process_account.async_exec()
+            self.assertEqual(result, QDialog.Accepted)
+
+        def close_dialog():
+            if process_account.isVisible():
+                process_account.close()
+
+        @asyncio.coroutine
+        def exec_test():
+            QTest.keyClicks(process_account.edit_account_name, "test")
+            self.assertEqual(process_account.stacked_pages.currentWidget(),
+                             process_account.page_init,
+                             msg="Current widget : {0}".format(process_account.stacked_pages.currentWidget().objectName()))
+            QTest.mouseClick(process_account.button_next, Qt.LeftButton)
+
+            self.assertEqual(process_account.stacked_pages.currentWidget(),
+                             process_account.page_gpg,
+                             msg="Current widget : {0}".format(process_account.stacked_pages.currentWidget().objectName()))
+
+            QTest.keyClicks(process_account.edit_salt, "testcutecoin")
+            self.assertFalse(process_account.button_next.isEnabled())
+            self.assertFalse(process_account.button_generate.isEnabled())
+            QTest.keyClicks(process_account.edit_password, "testcutecoin")
+            self.assertFalse(process_account.button_next.isEnabled())
+            self.assertFalse(process_account.button_generate.isEnabled())
+            QTest.keyClicks(process_account.edit_password_repeat, "wrongpassword")
+            self.assertFalse(process_account.button_next.isEnabled())
+            self.assertFalse(process_account.button_generate.isEnabled())
+            process_account.edit_password_repeat.setText("")
+            QTest.keyClicks(process_account.edit_password_repeat, "testcutecoin")
+            self.assertTrue(process_account.button_next.isEnabled())
+            self.assertTrue(process_account.button_generate.isEnabled())
+            QTest.mouseClick(process_account.button_generate, Qt.LeftButton)
+            self.assertEqual(process_account.label_info.text(),
+                             "7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ")
+            QTest.mouseClick(process_account.button_next, Qt.LeftButton)
+
+            self.assertEqual(process_account.stacked_pages.currentWidget(),
+                             process_account.page__communities,
+                             msg="Current widget : {0}".format(process_account.stacked_pages.currentWidget().objectName()))
+            process_account.password_asker.password = "testcutecoin"
+            process_account.password_asker.remember = True
+            yield from asyncio.sleep(1)
+            QTest.mouseClick(process_account.button_next, Qt.LeftButton)
+            self.assertEqual(len(self.application.accounts), 1)
+            self.assertEqual(self.application.current_account.name, "test")
+            self.assertEqual(self.application.preferences['account'], "test")
+
+        self.lp.call_later(10, close_dialog)
+        asyncio.async(exec_test())
+        self.lp.run_until_complete(open_dialog(process_account))
+
+if __name__ == '__main__':
+    logging.basicConfig( stream=sys.stderr )
+    logging.getLogger().setLevel( logging.DEBUG )
+    unittest.main()

src/cutecoin/tests/process_cfg_community/__init__.py

-import sys
-import unittest
-import os
-import asyncio
-import quamash
-from PyQt5.QtWidgets import QMenu
-from PyQt5.QtCore import QLocale
-from cutecoin.gui.mainwindow import MainWindow
-from cutecoin.core.app import Application
-from cutecoin.tests import get_application
-
-class MainWindowMenusTest(unittest.TestCase):
-    def setUp(self):
-        self.qapplication = get_application()
-        QLocale.setDefault(QLocale("en_GB"))
-        self.lp = quamash.QEventLoop(self.qapplication)
-        asyncio.set_event_loop(self.lp)
-
-        self.application = Application(self.qapplication, self.lp, None, None)
-        self.main_window = MainWindow(self.application)
-
-    def tearDown(self):
-        try:
-            self.lp.close()
-        finally:
-            asyncio.set_event_loop(None)
-
-    def test_menubar(self):
-        children = self.main_window.menubar.children()
-        menus = []
-        """:type: list[QMenu]"""
-        for child in children:
-            if isinstance(child, QMenu):
-                menus.append(child)
-        self.assertEqual(len(menus), 3)
-        self.assertEqual(menus[0].objectName(), 'menu_file')
-        self.assertEqual(menus[1].objectName(), 'menu_account')
-        self.assertEqual(menus[2].objectName(), 'menu_help')
-
-    def test_menu_account(self):
-        actions = self.main_window.menu_account.actions()
-        """:type: list[QAction]"""
-        self.assertEqual('action_configure_parameters', actions[1].objectName())
-        self.assertEqual('action_add_account', actions[2].objectName())
-        self.assertEqual('actionCertification', actions[4].objectName())
-        self.assertEqual('actionTransfer_money', actions[5].objectName())
-        self.assertEqual('action_add_a_contact', actions[7].objectName())
-        self.assertEqual(9, len(actions))
-
-    def test_menu_actions(self):
-        actions = self.main_window.menu_help.actions()
-        """:type: list[QAction]"""
-        self.assertEqual(len(actions), 1)
-        self.assertEqual(actions[0].objectName(), 'actionAbout')
-
-if __name__ == '__main__':
-    unittest.main()

src/cutecoin/tests/process_cfg_community/test_add_community.py

@@ -51,6 +51,10 @@ class ProcessAddCommunity(unittest.TestCase):
             result = yield from process_community.async_exec()
             self.assertEqual(result, QDialog.Accepted)
 
+        def close_dialog():
+            if process_community.isVisible():
+                process_community.close()
+
         @asyncio.coroutine
         def exec_test():
             mock = new_blockchain.get_mock()
@@ -88,6 +92,7 @@ class ProcessAddCommunity(unittest.TestCase):
                              msg="Current widget : {0}".format(process_community.stacked_pages.currentWidget().objectName()))
             QTest.mouseClick(process_community.button_next, Qt.LeftButton)
 
+        self.lp.call_later(15, close_dialog)
         asyncio.async(exec_test())
         self.lp.run_until_complete(open_dialog(process_community))