The test can't find a user interface component with the name "AuctionSniper Main".

java.lang.AssertionError: 
Tried to look for...
    exactly 1 JFrame (with name "Auction Sniper Main" and showing on screen)
    in all top level windows
but...
    all top level windows
    contained 0 JFrame (with name "Auction Sniper Main" and showing on screen)
  [...]
  at auctionsniper.ApplicationRunner.stop()
  at auctionsniper.AuctionSniperEndToEndTest.stopApplication()
  [...]

WindowLicker is verbose in its error reporting to try to make failures easy to understand. In this case, we couldn't even find the top level frame so JUnit failed before even starting the test. This stack trace comes from the @After method that stops the application.

We need a top-level window for our application. We write a auctionsniper.ui.MainWindow class that extends Swing's JFrame, and call it from main(). All it will do is create a window with the right name.

public class Main {
  private MainWindow ui;
  
  public Main() throws Exception {
    startUserInterface();
  }

  public static void main(String... args) throws Exception {
    Main main = new Main();
  }
  
  private void startUserInterface() throws Exception {
    SwingUtilities.invokeAndWait(new Runnable() {
      public void run() {
        ui = new MainWindow();
      }
    });
  }
}

public class MainWindow extends JFrame {
  public MainWindow() {
    super("Auction Sniper");
    setName(MAIN_WINDOW_NAME);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);
  }
}

Unfortunately, this is a little complicated because Swing requires us to create the user interface on its event dispatch thread. We've further complicated the implementation so we can hang on to the main window object in our code; it's not strictly necessary here but we thought we'd get it over with.

The user interface in Figure 7.1, “Just a top-level window” really is minimal. It does not look like much but it confirms that we can start up an application window and connect to it.

Figure 7.1. Just a top-level window

Our test still fails, but we've moved on a step. Now we know that our harness is working, which is one less thing to worry about as we move on to more interesting functionality.

The test finds a top-level window, but no display of the current state of the Sniper. To start with, the Sniper should show Joining while waiting for the Auction to respond.

java.lang.AssertionError: 
Tried to look for...
    exactly 1 JLabel (with name "sniper status")
    in exactly 1 JFrame (with name "Auction Sniper Main" and showing on screen)
    in all top level windows
and check that its label text is "Joining"
but...
    all top level windows
    contained 1 JFrame (with name "Auction Sniper Main" and showing on screen)
    contained 0 JLabel (with name "sniper status")
  at com.objogate.wl.AWTEventQueueProber.check()
  [...]
  at AuctionSniperDriver.showsSniperStatus()
  at ApplicationRunner.startBiddingIn()
  at AuctionSniperEndToEndTest.sniperJoinsAuctionUntilAuctionCloses()
  [...]

We add a label representing the Sniper's state to MainWindow.

public class MainWindow extends JFrame {
  public static final String AUCTION_STATUS_NAME = "auctionStatus";
  private final JLabel auctionStatus = createLabel(STATUS_JOINING);
  
  public MainWindow(){
    super("Auction Sniper");
    setName(MAIN_WINDOW_NAME);
    add(auctionStatus);
    pack();
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);
  }

  private static JLabel createLabel(String initialText) {
    JLabel result = new JLabel(initialText);
    result.setName(AUCTION_STATUS_NAME, );
    result.setBorder(new LineBorder(Color.BLACK));
    return result;
  }
}

Another minimal change, but now we can show some content in our application Figure 7.2, “Showing Joining status”.

Figure 7.2. Showing Joining status

Our user interface is working, but the Auction does not receive a Join request from the Sniper.

java.lang.AssertionError: 
Expected: is not null
     got: null
  at org.junit.Assert.assertThat()
  at SingleMessageListener.receivesAMessage()
  at FakeAuctionServer.receivesJoinRequestFromSniper()
  at AuctionSniperEndToEndTest.sniperJoinsAuctionUntilAuctionCloses()
  [...]

This failure message is a bit cryptic, but the names in the stack trace tell us what's wrong.

We write a simplistic implementation to get us past this failure, it connects to the chat in Main and sends an empty message. We create a null MessageListener to allow us to create a Chat for sending the empty initial message, since we don't yet care about receiving messages.

public class Main {
  public static final String AUCTION_RESOURCE = "Auction";
  public static final String ITEM_ID_AS_LOGIN = "auction-%s";
  public static final String AUCTION_ID_FORMAT = 
                               ITEM_ID_AS_LOGIN + "@%s/" + AUCTION_RESOURCE;

  [...]

  public static void main(String... args) throws Exception {
    Main main = new Main();
    XMPPConnection connection = connect(args[0], args[1], args[2]);
    Chat chat = connection.getChatManager().createChat(
        auctionId(args[3], connection), 
        new MessageListener() {
          public void processMessage(Chat aChat, Message message) {
            // nothing yet
          }
        });
    chat.sendMessage(new Message());
  }

  private static XMPPConnection connect(String hostname, 
                                        String username, 
                                        String password) 
    throws XMPPException 
  {
    XMPPConnection connection = new XMPPConnection(hostname);
    connection.connect();
    connection.login(username, password, AUCTION_RESOURCE);
  
    return connection;
  }

  private static String auctionId(XMPPConnection connection, String itemId) {
    return String.format(AUCTION_ID_FORMAT, itemId, 
                         connection.getServiceName()); 
  }
  [...]
}

This shows that we can establish a connection from the Sniper to the Auction, which means we had to sort out details such as interpreting the item and user credentials from the command-line arguments, and using the Smack library. We're leaving the message contents until later because we only have one message type, so sending an empty value is enough to prove the connection.

This implementation may seem gratuitously naive, after all we should be able to design a structure for something as simple as this, but we've often found it worth writing a small amount of ugly code and seeing how it falls out. It helps us to test our ideas before we've gone too far and sometimes the results can be surprising. The important point is to make sure we don't leave it ugly.

We make a point of keeping the connection code out of the Swing invokeAndWait() call that creates the MainWindow, because we want the user interface to settle before we try anything more complicated.

With a connection established, the Sniper should receive and display the Lost response from the Auction, of course it doesn't.

java.lang.AssertionError: 
Tried to look for...
    exactly 1 JLabel (with name "sniper status")
    in exactly 1 JFrame (with name "Auction Sniper Main" and showing on screen)
    in all top level windows
and check that its label text is "Lost"
but...
    all top level windows
    contained 1 JFrame (with name "Auction Sniper Main" and showing on screen)
    contained 1 JLabel (with name "sniper status")
    label text was "Joining"
  [...]
  at AuctionSniperDriver.showsSniperStatus()
  at ApplicationRunner.showsSniperHasLostAuction()
  at AuctionSniperEndToEndTest.sniperJoinsAuctionUntilAuctionCloses()
  [...]

We need to attach the user interface to the chat so it can receive the response from the Auction, so we create a connection and pass it to Main to create the Chat object. joinAction() creates a MessageListener that sets the status label, using an invokeLater() call to avoid blocking the Smack library. As with the Join message, we don't bother with the contents of the incoming message since there's only one possible response the Auction can send at the moment. While we're at it, we rename connect() to connection() to make the code read better.

public class Main {
  @SuppressWarnings("unused") private Chat notToBeGCd;
  [...]
  public static void main(String... args) throws Exception {
    Main main = new Main();
    main.joinAuction(connection(args[0], args[1], args[2]), args[3]);
  }

  private void joinAuction(XMPPConnection connection, String itemId) 
    throws XMPPException
  {
    final Chat chat = connection.getChatManager().createChat(
        auctionId(itemId, connection), 
        new MessageListener() {
          public void processMessage(Chat aChat, Message message) {
            SwingUtilities.invokeLater(new Runnable() {
              public void run() {
                ui.showStatus(MainWindow.STATUS_LOST);
              }
            });
          }
        });
    this.notToBeGCd = chat;
    
    chat.sendMessage(new Message());
  }

We implement the display method in the user interface and, finally, the whole test passes.

public class MainWindow extends JFrame {
  [...]
  public void showStatus(String status) {
    auctionStatus.setText(status);
  }
}

Here (Figure 7.3, “Showing Lost status”) is visible confirmation that the code works.

Figure 7.3. Showing Lost status

It may not look like much, but it confirms that a Sniper can establish a connection with an Auction, accept a response, and display the result.