JabberTransport_ConnectionTest.java

/*
 * Copyright 2000-2006 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package jetbrains.communicator.jabber.impl;

import jetbrains.communicator.AbstractTransportTestCase;
import jetbrains.communicator.core.IDEtalkEvent;
import jetbrains.communicator.core.Pico;
import jetbrains.communicator.core.impl.users.UserImpl;
import jetbrains.communicator.core.transport.MessageEvent;
import jetbrains.communicator.core.transport.TextXmlMessage;
import jetbrains.communicator.core.transport.Transport;
import jetbrains.communicator.core.users.PresenceMode;
import jetbrains.communicator.core.users.User;
import jetbrains.communicator.core.users.UserEvent;
import jetbrains.communicator.core.users.UserPresence;
import jetbrains.communicator.ide.ProgressIndicator;
import jetbrains.communicator.jabber.JabberUI;
import jetbrains.communicator.jabber.JabberUserFinder;
import jetbrains.communicator.util.WaitFor;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.jivesoftware.smack.*;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.RosterPacket;
import org.jmock.Mock;
import org.jmock.core.Invocation;
import org.jmock.core.stub.ReturnStub;
import org.picocontainer.Disposable;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;

/**
 * @author Kir
 */
@SuppressWarnings({"SSBasedInspection"})
public class JabberTransport_ConnectionTest extends AbstractTransportTestCase {
  private JabberFacadeImpl myFacade;

  public static final String USER = "someuser";
  public static final String PASSWORD = "somePassword";
  public static final String LOCALHOST = "localhost";
  private String myUser;
  private JabberTransport myTransport;
  public static final String FRED = "fred@localhost";
  private MockUserFinder myUserFinder;
  public static final int TIMEOUT = 6000;
  private boolean myUsersSynchronized;

  public static Test suite() {
    TestSuite testSuite = new TestSuite();
    XMPPConnection ourConnection;
    try {
      ourConnection = new XMPPConnection(LOCALHOST);
    } catch (XMPPException e) {
      return testSuite;
    }
    ourConnection.close();

    testSuite.addTestSuite(JabberTransport_ConnectionTest.class);
    return testSuite;
  }

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    //XMPPConnection.DEBUG_ENABLED = true;

    assertEquals("No connection yet", "", myUserFinder.getLog());
    myUser = USER + System.currentTimeMillis();
    addEventListener();

    assertNull(createGoodAccount());

    Thread.sleep(120);
    new WaitFor(500) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 0;
      }
    };

    myTransport.synchronizeRoster(true);
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myUserModel.getAllUsers().length == 0;
      }
    };
    myEvents.clear();
    myUsersSynchronized = false;

    mySelf = createSelf();
  }

  @Override
  protected Transport createTransport() {
    myFacade = new JabberFacadeImpl(myIdeFacade);
    myUserFinder = new MockUserFinder();

    Mock mockUI = createJabberUIMock();
    myTransport = new JabberTransport((JabberUI) mockUI.proxy(), myFacade, myUserModel, myDispatcher, myUserFinder) {
      @Override
      public void synchronizeRoster(boolean removeUsersNotInRoster) {
        super.synchronizeRoster(removeUsersNotInRoster);
        myUsersSynchronized = true;
      }
    };
    Pico.getInstance().registerComponentInstance(myTransport);

    disposeOnTearDown(myFacade);
    disposeOnTearDown(myTransport);

    return myTransport;
  }

  private Mock createJabberUIMock() {
    Mock mockUI = mock(JabberUI.class);
    mockUI.stubs().method("connectAndLogin").will(new ReturnStub(Boolean.TRUE){
      @Override
      public Object invoke(Invocation invocation) throws Throwable {
        myFacade.connect();
        return super.invoke(invocation);
      }
    });
    return mockUI;
  }

  @Override
  protected void tearDown() throws Exception {
//noinspection EmptyCatchBlock
    try {
      myFacade.getConnection().getAccountManager().deleteAccount();
    } catch (Throwable e) {
      // Harmless:
      // e.printStackTrace();
    }

    super.tearDown();
  }

  private String createGoodAccount() {
    return myFacade.createAccountAndConnect(myUser, PASSWORD,
        LOCALHOST, myFacade.getMyAccount().getPort(), false);
  }

  public void testSendProjectIdOnConnect() throws Throwable {
    assertEquals("Should invoke registerForProject", "registerForProject" + myUser + "@" + LOCALHOST,
        myUserFinder.getLog());
  }

  public void testAddUser_NotIdeTalk() throws Throwable {
    addEventListener();
    addUserFred();

    IDEtalkEvent event = checkEvent(false);
    assertTrue(event.toString(), event instanceof UserEvent.Added);
    User user = ((UserEvent.Added) event).getUser();
    assertEquals("Jabber user expected", "Jabber", user.getTransportCode());
    assertEquals("Should add Jabber user", FRED, user.getName());
    assertEquals("Wrong group", "aGroup", user.getGroup());

    assertFalse(user.hasIDEtalkClient());
  }

  public void testAddUser_IdeTalk() throws Throwable {
    XMPPConnection conn = createLocalConnectionWithJabberUser("fred" + System.nanoTime(), JabberFacadeImpl.IDETALK_RESOURCE);

    addEventListener();
    final String fred = getUser(conn);
    addUser(fred);

    IDEtalkEvent event = checkEvent(false);
    assertTrue(event.toString(), event instanceof UserEvent.Added);
    User user = ((UserEvent.Added) event).getUser();
    assertEquals("Jabber user expected", "Jabber", user.getTransportCode());
    assertEquals("Should add Jabber user", fred, user.getName());
    assertEquals("Wrong group", "aGroup", user.getGroup());

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myFacade.getConnection().getRoster().getPresence(fred) != null;
      }
    };
    assertTrue("User with IDEtalk resource", user.hasIDEtalkClient());
  }

  private void addUserFred() {
    addUser(FRED);
  }

  private void addUser(String userId) {
    myFacade.addUsers("aGroup", Arrays.asList(new String[]{userId}));

    waitForEvent();
  }

  private void waitForEvent() {
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 0;
      }
    };
  }

/*
  public void testUserRemovedFromRoster() throws Throwable {
    addEventListener();

    myFacade.addUsers("aGroup", Arrays.asList(new String[]{"jonny@localhost"}));
    waitForEvent();
    myEvents.clear();

    addUserFred();
    myEvents.clear();

    Roster roster = myFacade.getConnection().getRoster();
    roster.removeEntry(roster.getEntry(FRED));

    waitForEvent();
    UserEvent.Removed removedEvent = ((UserEvent.Removed) checkEvent(true));
    assertEquals("Fred should be removed", FRED, removedEvent.getUser().getName());
    assertEquals("Jonny should remain in UserModel", 1, myUserModel.getAllUsers().length);
    assertEquals("jonny@localhost", myUserModel.getAllUsers()[0].getName());
  }
*/

  public void testUserInRosterChangedGroup() throws Throwable {
    addEventListener();
    addUserFred();
    myEvents.clear();

    Roster roster = myFacade.getConnection().getRoster();
    RosterEntry fredEntry = roster.getEntry(FRED);

    UserEvent.Updated updated;
    myEvents.clear();
    roster.getGroup("aGroup").removeEntry(fredEntry);
    RosterGroup group = roster.createGroup("aaasss");
    group.addEntry(fredEntry);
    assertTrue(group.contains(fredEntry.getUser()));

    waitForEvent();
    updated = ((UserEvent.Updated) checkEvent(true));
    assertEquals("group", updated.getPropertyName());
    assertEquals("aGroup", updated.getOldValue());
    assertEquals("aaasss", updated.getNewValue());
  }

  public void testUserInRosterChangedName() throws Throwable {
    addEventListener();
    addUserFred();
    myEvents.clear();

    Roster roster = myFacade.getConnection().getRoster();
    RosterEntry fredEntry = roster.getEntry(FRED);
    fredEntry.setName("Some New Fred Name");

    waitForEvent();
    UserEvent.Updated updated = ((UserEvent.Updated) checkEvent(true));
    assertEquals("displayName", updated.getPropertyName());
    assertEquals(FRED, updated.getOldValue());
    assertEquals("Some New Fred Name", updated.getNewValue());
  }

  public void testLocalChanges_UpdateRoster() throws Throwable {
    addEventListener();
    addUserFred();

    User user = myUserModel.getAllUsers()[0];
    final Roster roster = myFacade.getConnection().getRoster();

    // Change group:
    user.setGroup("someOtherGroup", myUserModel);
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return roster.getGroupCount() == 1 && roster.getGroup("someOtherGroup") != null;
      }
    };

    assertEquals("One group expected", 1, roster.getGroupCount());
    RosterGroup group = roster.getGroup("someOtherGroup");
    assertNotNull(group);
    assertEquals(1, group.getEntryCount());
    assertNotNull(group.getEntry(FRED));

    // Change Display name:
    user.setDisplayName("Some new name", myUserModel);
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return "Some new name".equals(roster.getEntry(FRED).getName());
      }
    };
    assertEquals("User name in Roster should have changed", "Some new name", roster.getEntry(FRED).getName());

    // Delete user:
    myUserModel.removeUser(user);
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return roster.getEntryCount() == 0;
      }
    };
    assertEquals("User should be removed from Roster", 0, roster.getEntryCount());
  }

  public void testDisconnectFromJabber() throws Exception {
    String userName = "bob" + System.currentTimeMillis();
    XMPPConnection contact = createLocalConnectionWithJabberUser(userName, null);

    myTransport.getFacade().addUsers("General", Arrays.asList(getUser(contact)));
    new WaitFor(TIMEOUT) {

      @Override
      protected boolean condition() {
        return 1 == myUserModel.getAllUsers().length && myUserModel.getAllUsers()[0].isOnline();
      }
    };
    assertEquals(1, myUserModel.getAllUsers().length);

    assertTrue(myUserModel.getAllUsers()[0].isOnline());

    myTransport.getFacade().disconnect();
    assertFalse("Jabber user should become unavailable", myUserModel.getAllUsers()[0].isOnline());
  }

  public void testUserOnlineOffline() throws Throwable {
    addEventListener();

    String userName = "bob" + System.currentTimeMillis();
    XMPPConnection contact = createLocalConnectionWithJabberUser(userName, null);

    Roster roster = myTransport.getFacade().getConnection().getRoster();
    String jabberUser = getUser(contact);

    final User bob = UserImpl.create(jabberUser, myTransport.getName());

    myEvents.clear();
    roster.createEntry(jabberUser, "Bob", new String[0]);
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() == 2;
      }
    };
    assertTrue("Bob should be online", bob.isOnline());
    assertEquals("/ideTalk/jabber.png", myTransport.getIconPath(bob.getPresence()));

    assertEquals("One user in UserModel expected:" + Arrays.asList(myUserModel.getAllUsers()),
        1, myUserModel.getAllUsers().length);
    UserEvent.Online online = ((UserEvent.Online) myEvents.get(1));
    assertEquals("Online event expected", bob, online.getUser());

    myEvents.clear();

    Presence presence = new Presence(Presence.Type.unavailable);
    contact.sendPacket(presence);

    new WaitFor(TIMEOUT){
      @Override
      protected boolean condition() {
        return  myEvents.size() == 1;
      }
    };
    assertFalse("Should become offline", bob.isOnline());
    assertEquals("/ideTalk/offline.png", myTransport.getIconPath(myTransport.getUserPresence(bob)));
    assertEquals("Bob should go offline", bob, ((UserEvent.Offline) checkEvent(true)).getUser());
  }

  public void testIgnoreList() throws Exception {
    setIgnoreList("erts\r\nsomeId");

    final XMPPConnection conn = createLocalConnectionWithJabberUser("aaasomeId" + System.nanoTime(), null);
    conn.getRoster().createEntry(selfJabberId(), "name", new String[0]);

    new WaitFor(2000) {
      @Override
      protected boolean condition() {
        return conn.getRoster().getEntry(selfJabberId()).getType() == RosterPacket.ItemType.BOTH;
      }
    };
    assertEquals("Should not subscribe user from ignore list", RosterPacket.ItemType.NONE, conn.getRoster().getEntry(selfJabberId()).getType());
  }

  private void setIgnoreList(String contents) throws IOException {
    File configDir = myIdeFacade.getConfigDir();
    File file = new File(configDir, "jabber.ignore.txt");
    FileWriter fw = new FileWriter(file);
    fw.write(contents);
    fw.close();
  }

  public void testSubscriptionConfirmation() throws Throwable {

    // In this test user bob will try to add me to his contact list.
    // This action will require our confirmation

    addEventListener();

    // Create bob
    String userName = "bob" + System.currentTimeMillis();
    final XMPPConnection bob = createLocalConnectionWithJabberUser(userName, null);

    // Set our account to require manual subscription and disconnect:
    myFacade.getConnection().getRoster().setSubscriptionMode(Roster.SubscriptionMode.manual);
    myFacade.getMyAccount().setRememberPassword(true);
    myFacade.saveSettings();
    myFacade.getConnection().close();

    // Bob tries to add me to his contact list
    myEvents.clear();
    final String selfName = myUser + "@" + getUser(bob).substring(userName.length() + 1);
    bob.getRoster().createEntry(selfName, "me", new String[]{"DDD"});

    // Now we connect. Bob should get us in his presence - auto confirmation of the subscription expected.
    // See JabberTransport:mySubscribeListener
    myFacade.connect();
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return  null != bob.getRoster().getPresence(selfName);
      }
    };
    assertTrue("Sanity check", myFacade.isConnectedAndAuthenticated());

    Presence presence = bob.getRoster().getPresence(selfName);
    assertNotNull(presence);
    assertEquals("Should return good presence", Presence.Type.available,
        presence.getType() );

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 1;
      }
    };

    final String bobUserName = getUser(bob);

    assertEquals("We should get bob in our contact list as well", 1, myUserModel.getAllUsers().length);
    assertEquals("We should get bob in our contact list as well", bobUserName, myUserModel.getAllUsers()[0].getName());

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return getBobEntry(bobUserName) != null && getBobEntry(bobUserName).getType() == RosterPacket.ItemType.BOTH;
      }
    };

    assertEquals("Should add bob as a contact too", RosterPacket.ItemType.BOTH, getBobEntry(bobUserName).getType());
  }

  public void testSyncronizeWithRosterWhileWaitingForSubscription() throws Throwable {
    User bob = myUserModel.createUser("bob@localhost", JabberTransport.CODE);
    myUserModel.addUser(bob);

    myTransport.synchronizeRoster(false);

    assertNotNull("Bob should not be deleted",
        myUserModel.findUser(bob.getName(), bob.getTransportCode()));
  }

  private RosterEntry getBobEntry(String bobUserName) {
    return myFacade.getConnection().getRoster().getEntry(bobUserName);
  }

  public void testIsSelf() throws Throwable {
    assertFalse(myTransport.isSelf(UserImpl.create("some@localhost", myTransport.getName())));
    assertTrue(myTransport.isSelf(UserImpl.create(selfJabberId(), myTransport.getName())));
  }

  public void testIsInMyContactList() throws Exception {
    String userName = "bob" + System.currentTimeMillis();
    XMPPConnection bob = createLocalConnectionWithJabberUser(userName, null);

    userName = getUser(bob);

    assertFalse("Not in my contact list", myTransport.isUserInMyContactListAndActive(userName));

    myFacade.addUsers("General", Collections.singletonList(userName));
    final String userName1 = userName;
    new WaitFor(TIMEOUT){
      @Override
      protected boolean condition() {
        return myTransport.isUserInMyContactListAndActive(userName1);
      }
    };

    assertTrue("In my contact list and active",
        myTransport.isUserInMyContactListAndActive(userName));
    assertTrue("In my contact list and active",
        myTransport.isUserInMyContactListAndActive(userName + "/somePath"));

    bob.close();
    assertFalse("In my contact list and not active",
        myTransport.isUserInMyContactListAndActive(userName));
  }

  private static String getUser(XMPPConnection bob) {
    return JabberTransport.getSimpleId(bob.getUser());
  }

  public void testSendMessage2NonExistingUser() throws Throwable {
    myFacade.addUsers("grp", Arrays.asList(new String[]{"some@fake.user"}));
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myUserModel.getAllUsers().length > 0;
      }
    };

    myUserModel.getAllUsers()[0].sendMessage("some text", getBroadcaster());
    myEvents.clear();
    new WaitFor(TIMEOUT){
      @Override
      protected boolean condition() {
        return myEvents.size() > 0;
      }
    };
    assertEquals("No events expected:" + myEvents, 0, myEvents.size());
  }

  public void testSendMessageWhenOffline() throws Throwable {
    myFacade.disconnect();

    // This should work fine. Connection should be reestablished
    addEventListener();
    mySelf.sendMessage("message", getBroadcaster());
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 0;
      }
    };
    assertTrue("Should reestablish connection", myFacade.isConnectedAndAuthenticated());
    checkEvent(true);
  }

  public void testSendMessage_IgnoreList() throws Throwable {

    XMPPConnection conn = createLocalConnectionWithJabberUser("tom" + System.nanoTime(), null);
    conn.getRoster().createEntry(selfJabberId(), "name", new String[0]);
    addEventListener();
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 1;
      }
    };
    myEvents.clear();

    setIgnoreList(getUser(conn));

    conn.createChat(selfJabberId()).sendMessage("hello");
    new WaitFor(2000) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 0;
      }
    };
    assertEquals("Should ignore message (ignore list exists):" + myEvents, 0, myEvents.size());
  }

  public void testSimpleJabberMessage() throws Throwable {
    Message message = new Message(mySelf.getName(), Message.Type.NORMAL);
    String body = "some \u0442\u0435\u043a\u0441\u0442 <>#$%^";
    message.setThread("someThreadId");
    message.setBody(body);

    addEventListener();
    myFacade.getConnection().sendPacket(message);

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 1;
      }
    };

    IDEtalkEvent event = myEvents.get(1);
    assertTrue("Expect message Event", event instanceof MessageEvent);
    assertEquals("Expect message text", body, ((MessageEvent) event).getMessage());
    assertEquals("Should remember threadId for incoming messages", "someThreadId", myTransport.getThreadId(mySelf));
  }

  public void testSendMessageWithNullBody_ResposesHaveNoBody() throws Exception {
    //Thread.sleep(1000);
    myEvents.clear();
    Message baseMessage = myTransport.createBaseMessage(mySelf, null);
    myTransport.getFacade().getConnection().sendPacket(baseMessage);
    Thread.sleep(100);
    assertEquals("No events expected: " + myEvents, 0, myEvents.size());
  }

  public void testSendCustomMessage_WithoutProvider() throws Exception {

    addEventListener();

    myTransport.sendXmlMessage(mySelf, new TextXmlMessage("some text"){
      @Override
      public String getTagNamespace() {
        return "some namespace";
      }
    });

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 1;
      }
    };

    IDEtalkEvent event = myEvents.get(1);
    assertTrue("Expect message Event for unknown provider", event instanceof MessageEvent);
    assertEquals("Expect message text", "some text", ((MessageEvent) event).getMessage());
  }

  public void testTimeIsSetInSimpleMessage() throws Throwable {
    Message baseMessage = myTransport.createBaseMessage(mySelf, "some text");
    myTransport.getFacade().getConnection().sendPacket(baseMessage);

    new WaitFor(TIMEOUT){
      @Override
      protected boolean condition() {
        return myEvents.size() > 0;
      }
    };

    long diff = ((MessageEvent) myEvents.get(1)).getWhen().getTime() - System.currentTimeMillis();
    assertTrue("Time should be set for simple Jabber messages: " + diff, Math.abs(diff) < 150);
  }

  public void testSyncronizeRosterOnConnect() throws Throwable {
    myTransport.authenticated();
    assertTrue("No Jabber users in UserModel - should sync with roster", myUsersSynchronized);
  }

  public void testSyncronizeRosterOnConnect_HasJabberContacts() throws Throwable {
    myUserModel.addUser(UserImpl.create("fff@ddd.cc", JabberTransport.CODE));
    myTransport.authenticated();
    assertFalse("Already has Jabber users in UserModel - no sync with roster", myUsersSynchronized);
  }

  public void testSetOwnPresence_Status() throws Exception {
    String bobName = "bob" + System.currentTimeMillis();
    final XMPPConnection bob = createLocalConnectionWithJabberUser(bobName, null);
    final String user = selfJabberId();
    bob.getRoster().createEntry(user, user, new String[0]);
    myFacade.addUsers("grp", Arrays.asList(getUser(bob)));

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return null != bob.getRoster().getPresence(user);
      }
    };
    assert null != bob.getRoster().getPresence(user);


    // First, change own presence and check it's changed from bob's point of view
    UserPresence presence = new UserPresence(PresenceMode.AWAY);
    assert presence.isOnline();

    myTransport.setOwnPresence(presence);
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return Presence.Mode.away == bob.getRoster().getPresence(user).getMode();
      }
    };
    Presence p = bob.getRoster().getPresence(user);
    assertSame("Own presence should be away", Presence.Mode.away, p.getMode());
    assertEquals("", p.getStatus());

    // Now, change bob's presence
    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return myEvents.size() > 2;
      }
    };
    myEvents.clear();
    bob.sendPacket(new Presence(Presence.Type.available, "", 0, Presence.Mode.dnd));
    final User bobUser = myUserModel.findUser(getUser(bob), myTransport.getName());

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return PresenceMode.DND == bobUser.getPresence().getPresenceMode();
      }
    };

    assertSame("Should take bob's presence", PresenceMode.DND, bobUser.getPresence().getPresenceMode());
    UserEvent.Updated event = (UserEvent.Updated) checkEvent(true);
    assertEquals(bobUser, event.getUser());
    assertEquals("presence", event.getPropertyName());
    assertEquals(PresenceMode.DND, event.getNewValue());
    assertEquals(PresenceMode.AVAILABLE, event.getOldValue());

    // Now, change bob's presence + set time
    bob.sendPacket(new Presence(Presence.Type.available, "some status", 0, Presence.Mode.xa));

    new WaitFor(TIMEOUT) {
      @Override
      protected boolean condition() {
        return PresenceMode.EXTENDED_AWAY == bobUser.getPresence().getPresenceMode();
      }
    };

    assertSame("Should take bob's presence", PresenceMode.EXTENDED_AWAY, bobUser.getPresence().getPresenceMode());
  }

  public void testShouldNotReconnectOnSimpleDisconnect() throws Throwable {

    myTransport.setReconnectTimeout(200);
    myTransport.disconnected(false);
    myFacade.disconnect();

    Thread.sleep(300);
    assertFalse("No reconnect expected", myFacade.isConnectedAndAuthenticated());
  }

  public void testShouldReconnectOnErrorDisconnect() throws Throwable {
    myTransport.setReconnectTimeout(200);
    myTransport.disconnected(true);  // emulate connection failure
    myFacade.disconnect();

    Thread.sleep(300);
    assertTrue("Reconnect expected", myFacade.isConnectedAndAuthenticated());
  }


  @Override
  protected User createSelf() {
    if (myFacade.getConnection() != null) {
      return UserImpl.create(selfJabberId(), myTransport.getName());
    }
    return null;
  }

  private String selfJabberId() {
    return getUser(myFacade.getConnection());
  }

  @Override
  protected User createAnotherOnlineUser() throws Exception {
    String userName = "AnotherUser" + System.currentTimeMillis();
    final XMPPConnection bob = createLocalConnectionWithJabberUser(userName, null);
    return myUserModel.createUser(getUser(bob), myTransport.getName());
  }

  private XMPPConnection createLocalConnectionWithJabberUser(String userName, String resource) throws XMPPException, InterruptedException {
    final XMPPConnection conn = new XMPPConnection("localhost");
    conn.getAccountManager().createAccount(userName, "123456");
    if (resource == null) {
      resource = "test";
    }
    conn.login(userName, "123456", resource);
    conn.getRoster().setSubscriptionMode(Roster.SubscriptionMode.accept_all);
    Presence presence = new Presence(Presence.Type.available);
    conn.sendPacket(presence);
    disposeOnTearDown(new Disposable(){
      @Override
      public void dispose() {
        try {
          if (conn.isConnected()) {
            conn.getAccountManager().deleteAccount();
          }
        } catch (XMPPException e) {
          throw new RuntimeException(e);
        } finally{
          new Thread() {
            @Override
            public void run() {
              conn.close();
            }
          }.start();
        }
      }
    });
    return conn;
  }

  private class MockUserFinder implements JabberUserFinder {
    private String myLog = "";

    @Override
    public User[] findUsers(ProgressIndicator progressIndicator) {
      myLog += "findUsers";
      return new User[0];
    }

    @Override
    public void registerForProject(String jabberUserId) {
      myLog += "registerForProject" + jabberUserId;
    }

    public String getLog() {
      String log = myLog;
      myLog = "";
      return log;
    }
  }
}