ControllerTest.java

/*******************************************************************************
 * Copyright (c) 2013 EclipseSource and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    EclipseSource - initial API and implementation
 ******************************************************************************/
package com.eclipsesource.tabris.internal.ui;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.eclipse.rap.rwt.RWT;
import org.eclipse.rap.rwt.remote.RemoteObject;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import com.eclipsesource.tabris.internal.ZIndexStackLayout;
import com.eclipsesource.tabris.internal.ui.rendering.ActionRenderer;
import com.eclipsesource.tabris.internal.ui.rendering.PageRenderer;
import com.eclipsesource.tabris.internal.ui.rendering.RendererFactory;
import com.eclipsesource.tabris.internal.ui.rendering.UIRenderer;
import com.eclipsesource.tabris.test.util.TabrisEnvironment;
import com.eclipsesource.tabris.ui.Action;
import com.eclipsesource.tabris.ui.ActionConfiguration;
import com.eclipsesource.tabris.ui.Page;
import com.eclipsesource.tabris.ui.PageConfiguration;
import com.eclipsesource.tabris.ui.PageData;
import com.eclipsesource.tabris.ui.TransitionListener;
import com.eclipsesource.tabris.ui.UI;
import com.eclipsesource.tabris.ui.UIConfiguration;


public class ControllerTest {

  @Rule
  public TabrisEnvironment environment = new TabrisEnvironment();

  private Shell shell;
  private UIDescriptor uiDescriptor;
  private UIImpl ui;
  private RemoteObject remoteObject;
  private ZIndexStackLayout layout;
  private TransitionListener listener;

  @Before
  public void setUp() {
    Display display = new Display();
    shell = new Shell( display );
    layout = mock( ZIndexStackLayout.class );
    shell.setLayout( layout );
    uiDescriptor = spy( new UIDescriptor() );
    ui = mock( UIImpl.class );
    mockUI();
    remoteObject = environment.getRemoteObject();
  }

  private void mockUI() {
    UIConfiguration configuration = mock( UIConfiguration.class );
    listener = mock( TransitionListener.class );
    when( configuration.getAdapter( UIDescriptor.class ) ).thenReturn( uiDescriptor );
    uiDescriptor.addTransitionListener( listener );
    when( ui.getConfiguration() ).thenReturn( configuration );
  }

  @Test
  public void testIsSerializable() {
    assertTrue( Serializable.class.isAssignableFrom( Controller.class ) );
  }


  @Test
  public void testRegistersItselfAsUpdater() {
    PageDescriptor descriptor = createRootPage( "foo" );
    doReturn( TestPage.class ).when( descriptor ).getPageType();
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );

    Controller controller = new Controller( remoteUI, uiDescriptor );

    Object attribute = RWT.getUISession().getAttribute( UpdateUtil.UPDATER_PROPERTY );
    assertSame( controller, attribute );
  }

  @Test
  public void testCreatesRootPagesFailsNotWithoutRootPages() {
    PageDescriptor descriptor = mock( PageDescriptor.class );
    doReturn( TestPage.class ).when( descriptor ).getPageType();
    doReturn( Boolean.FALSE ).when( descriptor ).isTopLevel();
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );

    try {
      controller.createRootPages( ui );
    } catch( Exception shouldNotHappen ) {
      fail();
    }
  }

  @Test
  public void testCreatesRootPages() {
    PageDescriptor descriptor = createRootPage( "foo" );
    doReturn( TestPage.class ).when( descriptor ).getPageType();

    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );

    controller.createRootPages( ui );

    assertEquals( 1, shell.getChildren().length );
  }

  @Test
  public void testUpdateCreatesNewRootPages() {
    PageDescriptor descriptor = createRootPage( "foo" );
    doReturn( TestPage.class ).when( descriptor ).getPageType();
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    UIConfiguration configuration = mock( UIConfiguration.class );
    PageDescriptor descriptor2 = createRootPage( "fooBar" );
    when( configuration.getAdapter( UIDescriptor.class ) ).thenReturn( uiDescriptor );

    controller.update( configuration );

    Map<PageDescriptor, PageRenderer> rootPages = controller.getRootPages();
    assertNotNull( rootPages.get( descriptor2 ) );
  }

  @Test
  public void testUpdateCreatesUIElementForNewRootPages() {
    PageDescriptor descriptor = createRootPage( "foo" );
    doReturn( TestPage.class ).when( descriptor ).getPageType();
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    UIConfiguration configuration = mock( UIConfiguration.class );
    createRootPage( "fooBar" );
    when( configuration.getAdapter( UIDescriptor.class ) ).thenReturn( uiDescriptor );

    controller.update( configuration );

    assertEquals( 2, shell.getChildren().length );
  }

  @Test
  public void testCreatesGlobalActions() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getTitle() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );

    controller.createGlobalActions( ui );

    verify( remoteObject ).set( "title", "foo" );
  }

  @Test
  public void testUpdateCreatesNewGlobalActions() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getTitle() ).thenReturn( "foo" );
    when( descriptor.getId() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );
    ActionDescriptor descriptor2 = mock( ActionDescriptor.class );
    when( descriptor2.getTitle() ).thenReturn( "foo2" );
    when( descriptor2.getId() ).thenReturn( "foo2" );
    uiDescriptor.add( descriptor2 );
    UIConfiguration configuration = mock( UIConfiguration.class );
    when( configuration.getAdapter( UIDescriptor.class ) ).thenReturn( uiDescriptor );

    controller.update( configuration );

    verify( remoteObject ).set( "title", "foo2" );
  }

  @Test
  public void testUpdateRemovesDestroyedGlobalActions() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getTitle() ).thenReturn( "foo" );
    when( descriptor.getId() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );
    when( uiDescriptor.getGlobalActions() ).thenReturn( new ArrayList<ActionDescriptor>() );
    UIConfiguration configuration = mock( UIConfiguration.class );
    when( configuration.getAdapter( UIDescriptor.class ) ).thenReturn( uiDescriptor );

    controller.update( configuration );

    verify( remoteObject ).destroy();
  }

  @Test
  public void testCreatesGlobalActionsWithUI() {
    ActionRenderer renderer = mock( ActionRenderer.class );
    RemoteRendererFactory factory = mock( RemoteRendererFactory.class );
    when( factory.createActionRenderer( any( UI.class ), any( UIRenderer.class ), any( ActionDescriptor.class ) ) ).thenReturn( renderer );
    when( uiDescriptor.getRendererFactory() ).thenReturn( factory );
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getTitle() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );

    controller.createGlobalActions( ui );

    verify( renderer ).createUi( shell );
  }

  @Test
  public void testShowRootPageCreatesControl() {
    createRootPage( "foo" );
    PageDescriptor root2 = createRootPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showRoot( ui, root2, mock( PageData.class ) );

    assertEquals( 2, shell.getChildren().length );
  }

  @Test
  public void testShowRootPageActivatesPage() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor root2 = createRootPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    PageData data = mock( PageData.class );

    controller.showRoot( ui, root2, data );

    assertTrue( getTestPage( controller, root1 ).wasDeactivated() );
    assertTrue( getTestPage( controller, root2 ).wasActivated() );
  }

  private TestPage getTestPage( Controller controller, PageDescriptor descriptor ) {
    PageRenderer remotePage = controller.getRootPages().get( descriptor );
    return ( TestPage )remotePage.getPage();
  }

  @Test
  public void testShowRootPageActivatesPageWithPageData() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor root2 = createRootPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    PageData data = mock( PageData.class );

    controller.showRoot( ui, root2, data );

    assertTrue( getTestPage( controller, root1 ).wasDeactivated() );
    assertTrue( getTestPage( controller, root2 ).wasActivated() );
  }

  @Test
  public void testShowRootPageActivateRemotePage() {
    createRootPage( "foo" );
    PageDescriptor root2 = createRootPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showRoot( ui, root2, mock( PageData.class ) );

    PageRenderer pageRenderer = controller.getRootPages().get( root2 );
    verify( remoteUI ).activate( pageRenderer );
  }

  @Test
  public void testShowRootPageMakesControlVisible() {
    createRootPage( "foo" );
    PageDescriptor root2 = createRootPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showRoot( ui, root2, mock( PageData.class ) );

    verify( layout, times( 2 ) ).setOnTopControl( any( Composite.class ) );
  }

  @Test
  public void testShowRootPageCallsListener() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor root2 = createRootPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showRoot( ui, root2, mock( PageData.class ) );

    InOrder order = inOrder( listener );
    order.verify( listener ).before( ui, getTestPage( controller, root1 ), getTestPage( controller, root2 ) );
    order.verify( listener ).after( ui, getTestPage( controller, root1 ), getTestPage( controller, root2 ) );
  }

  @Test( expected = IllegalStateException.class )
  public void testFailsToRemovePageFromCurrentFlow() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    controller.showPage( ui, page, mock( PageData.class ) ).getPage();
    PageConfiguration configuration = mock( PageConfiguration.class );
    when( configuration.getAdapter( PageDescriptor.class ) ).thenReturn( page );

    controller.remove( configuration );
  }

  @Test( expected = IllegalStateException.class )
  public void testFailsToRemoveRootPageFromCurrentFlow() {
    PageDescriptor rootPage = createRootPage( "foo" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    controller.showRoot( ui, rootPage, new PageData() );
    PageConfiguration configuration = mock( PageConfiguration.class );
    when( configuration.getAdapter( PageDescriptor.class ) ).thenReturn( rootPage );

    controller.remove( configuration );
  }

  @Test
  public void testRemovesRootPageCallsDestroyOnRenderer() {
    PageDescriptor rootPage = createRootPage( "foo" );
    PageDescriptor rootPage2 = createRootPage( "foo1" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    controller.showRoot( ui, rootPage, new PageData() );
    PageConfiguration configuration = mock( PageConfiguration.class );
    when( configuration.getAdapter( PageDescriptor.class ) ).thenReturn( rootPage2 );

    controller.remove( configuration );

    verify( remoteObject ).destroy();
  }

  @Test
  public void testShowPageCreatesControl() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    TestPage testPage = ( TestPage )controller.showPage( ui, page, mock( PageData.class ) ).getPage();

    assertTrue( getTestPage( controller, root1 ).wasCreated() );
    assertTrue( testPage.wasCreated() );
  }

  @Test
  public void testUpdatePageConfigurationTriggersPageUpdate() {
    RendererFactory factory = mockRendererFactory();
    when( uiDescriptor.getRendererFactory() ).thenReturn( factory );
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    controller.showPage( ui, page, mock( PageData.class ) ).getPage();
    PageConfiguration configuration = mock( PageConfiguration.class );
    when( configuration.getAdapter( PageDescriptor.class ) ).thenReturn( page );

    controller.update( configuration );

    PageRenderer renderer = controller.getAllPages().get( 2 );
    verify( renderer ).update( page, factory, shell );
  }

  private RendererFactory mockRendererFactory() {
    RendererFactory factory = mock( RendererFactory.class );
    doAnswer( new Answer<PageRenderer>() {

      @Override
      public PageRenderer answer( InvocationOnMock invocation ) throws Throwable {
        PageRenderer renderer = mock( PageRenderer.class );
        when( renderer.getData() ).thenReturn( ( PageData )invocation.getArguments()[ 3 ] );
        when( renderer.getPage() ).thenReturn( mock( Page.class ) );
        when( renderer.getDescriptor() ).thenReturn( ( PageDescriptor )invocation.getArguments()[ 2 ] );
        return renderer;
      }
    } ).when( factory ).createPageRenderer( any( UI.class ),
                                            any( UIRenderer.class ),
                                            any( PageDescriptor.class ),
                                            any( PageData.class ) );
    return factory;
  }

  @Test
  public void testShowPageTwiceCreatesControls() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    TestPage testPage1 = ( TestPage )controller.showPage( ui, page, mock( PageData.class ) ).getPage();
    TestPage testPage2 = ( TestPage )controller.showPage( ui, page, mock( PageData.class ) ).getPage();

    assertTrue( getTestPage( controller, root1 ).wasCreated() );
    assertTrue( testPage1.wasCreated() );
    assertTrue( testPage2.wasCreated() );
  }

  @Test
  public void testShowPageActivatesPage() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor page2 = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    PageData data = mock( PageData.class );

    TestPage page = ( TestPage )controller.showPage( ui, page2, data ).getPage();

    assertTrue( getTestPage( controller, root1 ).wasDeactivated() );
    assertTrue( page.wasActivated() );
    assertSame( data, controller.getCurrentData() );
  }

  @Test
  public void testShowPageActivatesPageWithDelegatedPageData() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor page2 = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    PageData data = mock( PageData.class );

    TestPage page = ( TestPage )controller.showPage( ui, page2, data ).getPage();

    assertTrue( getTestPage( controller, root1 ).wasDeactivated() );
    assertTrue( page.wasActivated() );
    assertSame( data, controller.getCurrentData() );
  }

  @Test
  public void testShowPageActivatesRemotePage() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, page, mock( PageData.class ) );

    ArgumentCaptor<PageRenderer> captor = ArgumentCaptor.forClass( PageRenderer.class );
    verify( remoteUI, times( 2 ) ).activate( captor.capture() );
    assertSame( page, captor.getAllValues().get( 1 ).getDescriptor() );
  }

  @Test
  public void testShowPageMakesControlVisible() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, page, mock( PageData.class ) );

    verify( layout, times( 2 ) ).setOnTopControl( any( Control.class ) );
  }

  @Test
  public void testShowPageNotifiesListener() {
    PageDescriptor root1 = createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    TestPage testPage = ( TestPage )controller.showPage( ui, page, mock( PageData.class ) ).getPage();

    InOrder order = inOrder( listener );
    order.verify( listener ).before( ui, getTestPage( controller, root1 ), testPage );
    order.verify( listener ).after( ui, getTestPage( controller, root1 ), testPage );
  }

  @Test
  public void testShowPreviousIsFalseOnRoot() {
    createRootPage( "foo" );
    PageDescriptor page = createRootPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showRoot( ui, page, mock( PageData.class ) );
    boolean success = controller.closeCurrentPage( ui );

    assertFalse( success );
  }

  @Test
  public void testShowPreviousCreatesActionsBeforeActive() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    PageDescriptor rootPage = createRootPage( "foo" );
    List<ActionDescriptor> actions = new ArrayList<ActionDescriptor>();
    actions.add( descriptor );
    when( rootPage.getActions() ).thenReturn( actions );
    RendererFactory factory = spy( RemoteRendererFactory.getInstance() );
    when( uiDescriptor.getRendererFactory() ).thenReturn( factory );
    PageDescriptor pageDescriptor = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, pageDescriptor, mock( PageData.class ) );
    controller.closeCurrentPage( ui );

    InOrder order = inOrder( factory, remoteUI );
    order.verify( factory ).createActionRenderer( ui, remoteUI, descriptor );
    order.verify( factory ).createActionRenderer( ui, remoteUI, descriptor );
    order.verify( remoteUI ).activate( any( PageRenderer.class ) );
  }

  @Test
  public void testShowPageCreatesActionsBeforeActive() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    createRootPage( "foo" );
    List<ActionDescriptor> actions = new ArrayList<ActionDescriptor>();
    actions.add( descriptor );
    RendererFactory factory = spy( RemoteRendererFactory.getInstance() );
    when( uiDescriptor.getRendererFactory() ).thenReturn( factory );
    PageDescriptor pageDescriptor = createPage( "bar" );
    when( pageDescriptor.getActions() ).thenReturn( actions );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, pageDescriptor, mock( PageData.class ) );

    InOrder order = inOrder( factory, remoteUI );
    order.verify( factory ).createActionRenderer( ui, remoteUI, descriptor );
    order.verify( remoteUI ).activate( any( PageRenderer.class ) );
  }

  @Test
  public void testShowRootCreatesActionsBeforeActive() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    PageDescriptor rootPage = createRootPage( "foo" );
    List<ActionDescriptor> actions = new ArrayList<ActionDescriptor>();
    actions.add( descriptor );
    RendererFactory factory = spy( RemoteRendererFactory.getInstance() );
    when( uiDescriptor.getRendererFactory() ).thenReturn( factory );
    when( rootPage.getActions() ).thenReturn( actions );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showRoot( ui, rootPage, mock( PageData.class ) );

    InOrder order = inOrder( factory, remoteUI );
    order.verify( factory ).createActionRenderer( ui, remoteUI, descriptor );
    order.verify( factory ).createActionRenderer( ui, remoteUI, descriptor );
    order.verify( remoteUI ).activate( any( PageRenderer.class ) );
  }

  @Test
  public void testShowPreviousIsTrueOnPage() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, page, mock( PageData.class ) );
    boolean success = controller.closeCurrentPage( ui );

    assertTrue( success );
  }

  @Test
  public void testShowPreviousCallsDeactivateWithOldCurrentPage() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    when( ui.getPageOperator() ).thenReturn( new PageOperatorImpl( controller, ui ) );
    controller.createRootPages( ui );
    PageRenderer renderer = controller.showPage( ui, page, mock( PageData.class ) );
    TestPage testPage = ( TestPage )renderer.getPage();

    controller.closeCurrentPage( ui );

    Page pageAtDeactivate = testPage.getPageAtDeactivate();
    assertSame( testPage, pageAtDeactivate );
  }

  @Test
  public void testShowPreviousisNotifiesListeners() {
    PageDescriptor rootPage = createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    TestPage testPage = ( TestPage )controller.showPage( ui, page, mock( PageData.class ) ).getPage();
    controller.closeCurrentPage( ui );

    InOrder order = inOrder( listener );
    order.verify( listener ).before( ui, testPage, getTestPage( controller, rootPage ) );
    order.verify( listener ).after( ui, testPage, getTestPage( controller, rootPage ) );
  }

  @Test
  public void testShowPreviousMakesControlVisible() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, page, mock( PageData.class ) );
    controller.closeCurrentPage( ui );

    verify( layout, times( 3 ) ).setOnTopControl( any( Composite.class ) );
  }

  @Test
  public void testShowPreviousDestroysRemotePage() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, page, mock( PageData.class ) );
    controller.closeCurrentPage( ui );

    verify( remoteObject ).destroy();
  }

  @Test
  public void testShowPreviousDeactivatesBeforeDistroy() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    PageDescriptor page2 = createPage( "bar2" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    controller.showPage( ui, page, mock( PageData.class ) );
    controller.showPage( ui, page2, mock( PageData.class ) );
    TestPage testPage = ( TestPage )controller.getCurrentPage();

    controller.closeCurrentPage( ui );

    List<String> callStack = testPage.getCallStack();
    assertEquals( "create", callStack.get( 0 ) );
    assertEquals( "activate", callStack.get( 1 ) );
    assertEquals( "deactivate", callStack.get( 2 ) );
    assertEquals( "destroy", callStack.get( 3 ) );
    assertEquals( "dispose", callStack.get( 4 ) );
  }

  @Test
  public void testShowPreviousCallsListenerBeforeDestroy() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    PageDescriptor page2 = createPage( "bar2" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    controller.showPage( ui, page, mock( PageData.class ) );
    controller.showPage( ui, page2, mock( PageData.class ) );

    controller.closeCurrentPage( ui );

    InOrder order = inOrder( listener, remoteObject );
    order.verify( listener ).before( any( UI.class ), any( Page.class ), any( Page.class ) );
    order.verify( remoteObject ).destroy();
    order.verify( listener ).after( any( UI.class ), any( Page.class ), any( Page.class ) );
  }

  @Test
  public void testShowPreviousDoesNotEffectPagePageData() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    PageDescriptor page2 = createPage( "bar2" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    PageData pagePageData = mock( PageData.class );

    controller.showPage( ui, page, pagePageData );
    controller.showPage( ui, page2, mock( PageData.class ) );
    controller.closeCurrentPage( ui );

    assertSame( pagePageData, controller.getCurrentData() );
  }

  @Test
  public void testShowDeactivatesOldPage() {
    PageDescriptor rootPage = createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    PageData data = mock( PageData.class );

    TestPage testPage = ( TestPage )controller.showPage( ui, page, data ).getPage();
    controller.closeCurrentPage( ui );

    assertTrue( testPage.wasDeactivated() );
    assertTrue( getTestPage( controller, rootPage ).wasActivated() );
  }

  @Test
  public void testGetCurrentPage() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.showPage( ui, page, mock( PageData.class ) );

    assertTrue( controller.getCurrentPage() instanceof TestPage );
  }

  @Test
  public void testGetCurrentPageId() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    controller.showPage( ui, page, mock( PageData.class ) );

    String currentPageId = controller.getCurrentPageId();

    assertEquals( "bar", currentPageId );
  }

  @Test
  public void testGetCurrentPageData() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );
    PageData data = mock( PageData.class );

    controller.showPage( ui, page, data );

    assertSame( data, controller.getCurrentData() );
  }

  @Test
  public void testSetTitle() {
    createRootPage( "foo" );
    PageDescriptor page = createPage( "bar" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    PageRenderer remotePage = controller.showPage( ui, page, mock( PageData.class ) );
    controller.setTitle( remotePage.getPage(), "foobar" );

    verify( remoteObject ).set( "title", "foobar" );
  }

  @Test( expected = IllegalStateException.class )
  public void testSetTitleFailsWithNonExistingPage() {
    createRootPage( "foo" );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.setTitle( mock( Page.class ), "foobar" );
  }

  @Test
  public void testSetVisibleFindsGlobalAction() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getId() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );

    controller.setActionVisible( "foo", true );

    verify( remoteObject ).set( "visibility", true );
  }

  @Test( expected = IllegalStateException.class )
  public void testSetVisibleGlobalActionFailsWithoutAction() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getId() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );

    controller.setActionVisible( "foo2", true );
  }

  @Test
  public void testSetEnabledFindsGlobalAction() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getId() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );

    controller.setActionEnabled( "foo", true );

    verify( remoteObject ).set( "enabled", true );
  }

  @Test( expected = IllegalStateException.class )
  public void testSetEnabledGlobalActionFailsWithoutAction() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getId() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );

    controller.setActionEnabled( "foo2", true );
  }

  @Test
  public void testSetVisibleFindsPageAction() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getId() ).thenReturn( "foo" );
    PageDescriptor rootPage = createRootPage( "foo" );
    List<ActionDescriptor> actions = new ArrayList<ActionDescriptor>();
    actions.add( descriptor );
    when( rootPage.getActions() ).thenReturn( actions );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.setActionVisible( "foo", true );

    verify( remoteObject ).set( "visibility", true );
  }

  @Test
  public void testSetEnabledFindsPageAction() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getId() ).thenReturn( "foo" );
    PageDescriptor rootPage = createRootPage( "foo" );
    List<ActionDescriptor> actions = new ArrayList<ActionDescriptor>();
    actions.add( descriptor );
    when( rootPage.getActions() ).thenReturn( actions );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createRootPages( ui );

    controller.setActionEnabled( "foo", true );

    verify( remoteObject ).set( "enabled", true );
  }

  private PageDescriptor createRootPage( String id ) {
    PageDescriptor descriptor = mock( PageDescriptor.class );
    when( descriptor.getId() ).thenReturn( id );
    doReturn( TestPage.class ).when( descriptor ).getPageType();
    doReturn( Boolean.TRUE ).when( descriptor ).isTopLevel();
    uiDescriptor.add( descriptor );
    return descriptor;
  }

  private PageDescriptor createPage( String id ) {
    PageDescriptor descriptor = mock( PageDescriptor.class );
    when( descriptor.getId() ).thenReturn( id );
    doReturn( TestPage.class ).when( descriptor ).getPageType();
    doReturn( Boolean.FALSE ).when( descriptor ).isTopLevel();
    uiDescriptor.add( descriptor );
    return descriptor;
  }

  @Test
  public void testHasGlobalAction() {
    ActionDescriptor descriptor = mock( ActionDescriptor.class );
    when( descriptor.getId() ).thenReturn( "foo" );
    uiDescriptor.add( descriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );

    boolean hasAction = controller.hasAction( "foo" );

    assertTrue( hasAction );
  }

  @Test
  public void testHasPageAction() {
    PageDescriptor pageDescriptor = new PageDescriptor( "bar", TestPage.class );
    pageDescriptor.setTopLevel( true );
    pageDescriptor.addAction( new ActionConfiguration( "foo", TestAction.class ) );
    uiDescriptor.add( pageDescriptor );
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.createGlobalActions( ui );
    controller.createRootPages( ui );
    controller.showPage( ui, pageDescriptor, mock( PageData.class ) );

    boolean hasAction = controller.hasAction( "foo" );

    assertTrue( hasAction );
  }

  @Test
  public void testCanGetPageConfigurationForTopLevelPage() {
    UIConfiguration configuration = new UIConfiguration();
    PageConfiguration pageConfiguration = new PageConfiguration( "foo", TestPage.class ).setTopLevel( true );
    configuration.addPageConfiguration( pageConfiguration );
    Controller controller = new Controller( new RemoteUI( shell ), configuration.getAdapter( UIDescriptor.class ) );
    UIImpl ui = new UIImpl( shell.getDisplay(), controller, configuration );
    controller.setUI( ui );
    controller.createRootPages( ui );

    PageConfiguration actualConfiguration = controller.getPageConfiguration( controller.getAllPages().get( 0 ).getPage() );

    assertSame( pageConfiguration, actualConfiguration );
  }

  @Test
  public void testCanGetPageConfigurationForPage() {
    UIConfiguration configuration = new UIConfiguration();
    PageConfiguration pageConfiguration = new PageConfiguration( "foo", TestPage.class ).setTopLevel( true );
    PageConfiguration pageConfiguration2 = new PageConfiguration( "foo2", TestPage.class );
    configuration.addPageConfiguration( pageConfiguration );
    configuration.addPageConfiguration( pageConfiguration2 );
    Controller controller = new Controller( new RemoteUI( shell ), configuration.getAdapter( UIDescriptor.class ) );
    UIImpl ui = new UIImpl( shell.getDisplay(), controller, configuration );
    controller.setUI( ui );
    controller.createRootPages( ui );
    PageRenderer page = controller.showPage( ui, pageConfiguration2.getAdapter( PageDescriptor.class ), new PageData() );

    PageConfiguration actualConfiguration = controller.getPageConfiguration( page.getPage() );

    assertSame( pageConfiguration2, actualConfiguration );
  }

  @Test
  public void testCanGetActionConfigurationForGlobalAction() {
    UIConfiguration configuration = new UIConfiguration();
    PageConfiguration pageConfiguration = new PageConfiguration( "foo", TestPage.class ).setTopLevel( true );
    configuration.addPageConfiguration( pageConfiguration );
    ActionConfiguration actionConfiguration = new ActionConfiguration( "bar", TestAction.class );
    configuration.addActionConfiguration( actionConfiguration );
    UIDescriptor uiDescriptor = configuration.getAdapter( UIDescriptor.class );
    Controller controller = new Controller( new RemoteUI( shell ), uiDescriptor );
    UIImpl ui = new UIImpl( shell.getDisplay(), controller, configuration );
    controller.setUI( ui );
    controller.createRootPages( ui );
    controller.createGlobalActions( ui );

    ActionConfiguration actualConfiguration = controller.getActionConfiguration( uiDescriptor.getActionDescriptor( "bar" ).getAction() );

    assertSame( actionConfiguration, actualConfiguration );
  }

  @Test
  public void testCanGetActionConfigurationForPageAction() {
    UIConfiguration configuration = new UIConfiguration();
    PageConfiguration pageConfiguration = new PageConfiguration( "foo", TestPage.class ).setTopLevel( true );
    PageConfiguration pageConfiguration2 = new PageConfiguration( "foo2", TestPage.class );
    configuration.addPageConfiguration( pageConfiguration );
    configuration.addPageConfiguration( pageConfiguration2 );
    ActionConfiguration actionConfiguration = new ActionConfiguration( "bar", TestAction.class );
    pageConfiguration2.addActionConfiguration( actionConfiguration );
    UIDescriptor uiDescriptor = configuration.getAdapter( UIDescriptor.class );
    Controller controller = new Controller( new RemoteUI( shell ), uiDescriptor );
    UIImpl ui = new UIImpl( shell.getDisplay(), controller, configuration );
    controller.setUI( ui );
    controller.createRootPages( ui );
    controller.createGlobalActions( ui );
    PageRenderer page = controller.showPage( ui, pageConfiguration2.getAdapter( PageDescriptor.class ), new PageData() );
    Action action = page.getActionRenderers().get( 0 ).getDescriptor().getAction();

    ActionConfiguration actualConfiguration = controller.getActionConfiguration( action );

    assertSame( actionConfiguration, actualConfiguration );
  }

  @Test
  public void testGetActionConfigurationIsNullForNonExistentAction() {
    UIConfiguration configuration = new UIConfiguration();
    PageConfiguration pageConfiguration = new PageConfiguration( "foo", TestPage.class ).setTopLevel( true );
    configuration.addPageConfiguration( pageConfiguration );
    UIDescriptor uiDescriptor = configuration.getAdapter( UIDescriptor.class );
    Controller controller = new Controller( new RemoteUI( shell ), uiDescriptor );
    UIImpl ui = new UIImpl( shell.getDisplay(), controller, configuration );
    controller.setUI( ui );
    controller.createRootPages( ui );
    controller.createGlobalActions( ui );

    ActionConfiguration actualConfiguration = controller.getActionConfiguration( mock( Action.class ) );

    assertNull( actualConfiguration );
  }

  @Test
  public void testGetPageConfigurationIsNullForNonExistentPage() {
    UIConfiguration configuration = new UIConfiguration();
    PageConfiguration pageConfiguration = new PageConfiguration( "foo", TestPage.class ).setTopLevel( true );
    configuration.addPageConfiguration( pageConfiguration );
    UIDescriptor uiDescriptor = configuration.getAdapter( UIDescriptor.class );
    Controller controller = new Controller( new RemoteUI( shell ), uiDescriptor );
    UIImpl ui = new UIImpl( shell.getDisplay(), controller, configuration );
    controller.setUI( ui );
    controller.createRootPages( ui );
    controller.createGlobalActions( ui );

    PageConfiguration actualConfiguration = controller.getPageConfiguration( mock( Page.class ) );

    assertNull( actualConfiguration );
  }

  @Test
  public void testUpdateSetsBackground() {
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.setUI( ui );
    UIConfiguration configuration = mock( UIConfiguration.class );
    when( configuration.getBackground() ).thenReturn( new RGB( 100, 100, 100 ) );
    when( configuration.getAdapter( UIDescriptor.class ) ).thenReturn( uiDescriptor );

    controller.update( configuration );

    verify( remoteUI ).setBackground( eq( new Color( ui.getDisplay(), 100, 100, 100 ) ) );
  }

  @Test
  public void testUpdateSetsForeground() {
    RemoteUI remoteUI = mock( RemoteUI.class );
    when( remoteUI.getPageParent() ).thenReturn( shell );
    when( remoteUI.getActionsParent() ).thenReturn( shell );
    Controller controller = new Controller( remoteUI, uiDescriptor );
    controller.setUI( ui );
    UIConfiguration configuration = mock( UIConfiguration.class );
    when( configuration.getForeground() ).thenReturn( new RGB( 100, 100, 100 ) );
    when( configuration.getAdapter( UIDescriptor.class ) ).thenReturn( uiDescriptor );

    controller.update( configuration );

    verify( remoteUI ).setForeground( eq( new Color( ui.getDisplay(), 100, 100, 100 ) ) );
  }

}