Switch to UserInfoRequestedEvent in qauth.

qauth/src/com/dmdirc/addons/qauth/QAuthManager.java

 import com.dmdirc.events.ServerConnectedEvent;
 import com.dmdirc.events.ServerInviteReceivedEvent;
 import com.dmdirc.events.ServerNoticeEvent;
-import com.dmdirc.events.ServerNumericEvent;
+import com.dmdirc.events.UserInfoResponseEvent;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.User;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
+import com.dmdirc.parser.events.UserInfoEvent;
 import com.dmdirc.plugins.PluginDomain;
 import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.util.validators.NotEmptyValidator;
     private boolean autoInvite;
     private boolean acceptInvites;
     private boolean waitingWhois;
-    private boolean authed;
 
     @Inject
     public QAuthManager(
         connection.getLocalUser().ifPresent(u -> {
             connection.requestUserInfo(u);
             waitingWhois = true;
-            authed = false;
         });
     }
 
     }
 
     @Handler
-    void handleServerNumericEvent(final ServerNumericEvent event) {
+    void handleUserInfoResponse(final UserInfoResponseEvent event) {
         if (!waitingWhois) {
             return;
         }
-        if(event.getNumeric() == 330 && event.getConnection().getLocalUser().map(User::getNickname)
-                .orElse("").equalsIgnoreCase(event.getArgs()[3])) {
-            // TODO: Check account matches? (param arg 4)
-            authed = true;
-        }
-        if (event.getNumeric() == 318 && event.getConnection().getLocalUser().map(User::getNickname)
-                .orElse("").equalsIgnoreCase(event.getArgs()[3])) {
-            waitingWhois = false;
-            if (!authed) {
-                auth(event.getConnection());
+        event.getConnection().getLocalUser().ifPresent(u -> {
+            if (u.equals(event.getUser())) {
+                // TODO: Check account matches?
+                if (!event.getInfo(UserInfoEvent.UserInfoType.ACCOUNT_NAME).isPresent()) {
+                    auth(event.getConnection());
+                }
+                waitingWhois = false;
             }
-        }
+        });
     }
 
     @Handler

qauth/test/com/dmdirc/addons/qauth/QAuthManagerTest.java

 import com.dmdirc.events.ServerConnectedEvent;
 import com.dmdirc.events.ServerInviteReceivedEvent;
 import com.dmdirc.events.ServerNoticeEvent;
+import com.dmdirc.events.UserInfoResponseEvent;
 import com.dmdirc.interfaces.Connection;
 import com.dmdirc.interfaces.User;
 import com.dmdirc.interfaces.config.AggregateConfigProvider;
 import com.dmdirc.interfaces.config.ConfigProvider;
+import com.dmdirc.parser.events.UserInfoEvent;
 import com.dmdirc.plugins.PluginInfo;
 import com.dmdirc.plugins.PluginMetaData;
 
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.when;
 
     @Mock private Invite invite;
     @Mock private Connection connection;
     @Mock private PreferencesCategory preferencesCategory;
+    @Mock private UserInfoResponseEvent userInfoResponseEvent;
     @Captor private ArgumentCaptor<PreferencesCategory> preferencesCategoryArgumentCaptor;
     private QAuthManager instance;
 
         when(preferencesDialogModel.getConfigManager()).thenReturn(aggregateConfigProvider);
         when(preferencesDialogModel.getIdentity()).thenReturn(configProvider);
         when(preferencesDialogModel.getCategory("Plugins")).thenReturn(preferencesCategory);
+        when(userInfoResponseEvent.getConnection()).thenReturn(connection);
         instance = new QAuthManager("pluginDomain", pluginInfo, config, eventBus);
 
         instance.handleUsername("username");
         assertTrue(preferencesCategoryArgumentCaptor.getValue().getSettings().size() > 1);
     }
 
-    // TODO: Test ServerNumericEvent method
+    @Test
+    public void testWhoisReply_NotWaiting() throws Exception {
+        instance.handleUserInfoResponse(userInfoResponseEvent);
+        verifyNoMoreInteractions(connection);
+    }
+
+    @Test
+    public void testWhoisReply_Waiting_Authed() throws Exception {
+        when(userInfoResponseEvent.getInfo(UserInfoEvent.UserInfoType.ACCOUNT_NAME))
+                .thenReturn(Optional.of("RAR"));
+        when(userInfoResponseEvent.getUser()).thenReturn(localUser);
+        instance.handleWhois(true);
+        instance.handleConnect(serverConnectedEvent);
+        instance.handleUserInfoResponse(userInfoResponseEvent);
+        verify(connection, never()).sendMessage(anyString(), anyString());
+    }
+
+    @Test
+    public void testWhoisReply_Waiting_NotAuthed() throws Exception {
+        when(userInfoResponseEvent.getInfo(UserInfoEvent.UserInfoType.ACCOUNT_NAME))
+                .thenReturn(Optional.empty());
+        when(userInfoResponseEvent.getUser()).thenReturn(localUser);
+        instance.handleWhois(true);
+        instance.handleConnect(serverConnectedEvent);
+        instance.handleUserInfoResponse(userInfoResponseEvent);
+        verify(connection).sendMessage(anyString(), anyString());
+    }
 }