BrowserOperationHandler_Test.java example

Explorer
rap-master
/*******************************************************************************
 * Copyright (c) 2013, 2014 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 org.eclipse.swt.internal.browser.browserkit;

import static org.eclipse.swt.internal.browser.browserkit.BrowserOperationHandler.javaToJson;
import static org.eclipse.swt.internal.browser.browserkit.BrowserOperationHandler.jsonToJava;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.HashMap;
import java.util.concurrent.atomic.AtomicInteger;

import org.eclipse.rap.json.JsonArray;
import org.eclipse.rap.json.JsonObject;
import org.eclipse.rap.json.JsonValue;
import org.eclipse.rap.rwt.internal.lifecycle.PhaseId;
import org.eclipse.rap.rwt.testfixture.internal.Fixture;
import org.eclipse.rap.rwt.widgets.BrowserCallback;
import org.eclipse.rap.rwt.widgets.BrowserUtil;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTError;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.browser.BrowserFunction;
import org.eclipse.swt.browser.ProgressEvent;
import org.eclipse.swt.browser.ProgressListener;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;


public class BrowserOperationHandler_Test {

  private Browser browser;
  private BrowserOperationHandler handler;

  @Before
  public void setUp() {
    Fixture.setUp();
    Fixture.fakePhase( PhaseId.PROCESS_ACTION );
    Display display = new Display();
    Shell shell = new Shell( display, SWT.NONE );
    browser = new Browser( shell, SWT.NONE );
    handler = new BrowserOperationHandler( browser );
  }

  @After
  public void tearDown() {
    Fixture.tearDown();
  }

  @Test
  public void testHandleNotifyProgress() {
    ProgressListener listener = mock( ProgressListener.class );
    browser.addProgressListener( listener );

    handler.handleNotify( "Progress", new JsonObject() );

    InOrder order = inOrder( listener );
    order.verify( listener ).changed( any( ProgressEvent.class ) );
    order.verify( listener ).completed( any( ProgressEvent.class ) );
    order.verifyNoMoreInteractions();
  }

  @Test
  public void testHandleNotifyProgress_invisibleBrowser() {
    ProgressListener listener = mock( ProgressListener.class );
    browser.addProgressListener( listener );
    browser.setVisible( false );

    handler.handleNotify( "Progress", new JsonObject() );

    verify( listener ).changed( any( ProgressEvent.class ) );
    verify( listener ).completed( any( ProgressEvent.class ) );
  }

  @Test
  public void testHandleNotifyProgress_disabledBrowser() {
    ProgressListener listener = mock( ProgressListener.class );
    browser.addProgressListener( listener );
    browser.setEnabled( false );

    handler.handleNotify( "Progress", new JsonObject() );

    verify( listener ).changed( any( ProgressEvent.class ) );
    verify( listener ).completed( any( ProgressEvent.class ) );
  }

  @Test
  public void testHandleCallExecuteFunction() {
    BrowserFunction browserFunction = mockBrowserFunction();

    JsonObject parameters = new JsonObject()
      .add( "name", "func" )
      .add( "arguments", new JsonArray().add( "eclipse" ).add( 3.6 ) );
    handler.handleCall( "executeFunction", parameters );

    Object[] expected = new Object[] { "eclipse", Double.valueOf( 3.6 ) };
    verify( browserFunction ).function( expected );
  }

  @Test
  public void testHandleCallExecuteFunction_withoutArguments() {
    BrowserFunction browserFunction = mockBrowserFunction();

    JsonObject parameters = new JsonObject()
      .add( "name", "func" )
      .add( "arguments", new JsonArray() );
    handler.handleCall( "executeFunction", parameters );

    verify( browserFunction ).function( new Object[0] );
  }

  @Test
  public void testHandleCallExecuteFunction_withInvalidReturnValue() {
    BrowserFunction browserFunction = mockBrowserFunction();
    when( browserFunction.function( any( Object[].class ) ) )
      .thenReturn( new HashMap<String, Object>() );

    JsonObject parameters = new JsonObject()
      .add( "name", "func" )
      .add( "arguments", new JsonArray() );

    try {
      handler.handleCall( "executeFunction", parameters );
    } catch( SWTError error ) {
      assertEquals( SWT.ERROR_INVALID_RETURN_VALUE, error.code );
    }
  }

  @Test
  public void testHandleCallEvaluationSucceeded() {
    BrowserCallback browserCallback = mock( BrowserCallback.class );
    BrowserUtil.evaluate( browser, "alert('33');", browserCallback );

    JsonObject parameters = new JsonObject().add( "result", new JsonArray().add( 27 ) );
    handler.handleCall( "evaluationSucceeded", parameters );

    verify( browserCallback ).evaluationSucceeded( Double.valueOf( 27 ) );
  }

  @Test
  public void testHandleCallEvaluationSucceeded_nullResult() {
    BrowserCallback browserCallback = mock( BrowserCallback.class );
    BrowserUtil.evaluate( browser, "alert('33');", browserCallback );

    JsonObject parameters = new JsonObject().add( "result", JsonObject.NULL );
    handler.handleCall( "evaluationSucceeded", parameters );

    verify( browserCallback ).evaluationSucceeded( null );
  }

  @Test
  public void testHandleCallEvaluationFailed() {
    BrowserCallback browserCallback = mock( BrowserCallback.class );
    BrowserUtil.evaluate( browser, "alert('33');", browserCallback );

    handler.handleCall( "evaluationFailed", new JsonObject() );

    verify( browserCallback ).evaluationFailed( any( Exception.class ) );
  }

  @Test
  public void testJsonToJava_null() {
    assertNull( jsonToJava( JsonObject.NULL ) );
  }

  @Test
  public void testJsonToJava_boolean() {
    assertEquals( Boolean.TRUE, jsonToJava( JsonObject.TRUE ) );
  }

  @Test
  public void testJsonToJava_number() {
    assertEquals( Double.valueOf( 5 ), jsonToJava( JsonValue.valueOf( 5 ) ) );
  }

  @Test
  public void testJsonToJava_string() {
    assertEquals( "foo", jsonToJava( JsonValue.valueOf( "foo" ) ) );
  }

  @Test
  public void testJsonToJava_array() {
    JsonArray array = new JsonArray().add( true ).add( JsonObject.NULL ).add( 5 ).add( "foo" );

    Object[] result = ( Object[] )jsonToJava( array );

    Object[] expected = new Object[] { Boolean.TRUE, null, Double.valueOf( 5 ), "foo" };
    assertArrayEquals( expected, result );
  }

  @Test
  public void testJsonToJava_nestedArray() {
    JsonArray array = new JsonArray().add( true ).add( new JsonArray().add( 5 ).add( "foo" ) );

    Object[] result = ( Object[] )jsonToJava( array );

    Object[] expected = new Object[] { Boolean.TRUE, new Object[] { Double.valueOf( 5 ), "foo" } };
    assertArrayEquals( expected, result );
  }

  @Test( expected = RuntimeException.class )
  public void testJsonToJava_object() {
    jsonToJava( new JsonObject() );
  }

  @Test
  public void testJavaToJson_null() {
    assertEquals( JsonValue.NULL, javaToJson( null ) );
  }

  @Test
  public void testJavaToJson_boolean() {
    assertEquals( JsonValue.TRUE, javaToJson( Boolean.TRUE ) );
  }

  @Test
  public void testJavaToJson_number() {
    // According to the contract of BrowserFunction, all subtypes of number are supported
    assertEquals( JsonValue.valueOf( 23d ), javaToJson( Double.valueOf( 23 ) ) );
    assertEquals( JsonValue.valueOf( 23d ), javaToJson( new AtomicInteger( 23 ) ) );
  }

  @Test
  public void testJavaToJson_string() {
    assertEquals( JsonValue.valueOf( "foo" ), javaToJson( "foo" ) );
  }

  @Test
  public void testJavaToJson_array() {
    Object[] array = new Object[] { Boolean.TRUE, null, Double.valueOf( 5 ), "foo" };

    JsonValue result = javaToJson( array );

    JsonArray expected = new JsonArray().add( true ).add( JsonObject.NULL ).add( 5 ).add( "foo" );
    assertEquals( expected, result );
  }

  @Test
  public void testJavaToJson_nestedArray() {
    Object[] array = new Object[] { Boolean.TRUE, new Object[] { Double.valueOf( 5 ), "foo" } };

    JsonValue result = javaToJson( array );

    JsonArray expected = new JsonArray().add( true ).add( new JsonArray().add( 5 ).add( "foo" ) );
    assertEquals( expected, result );
  }

  @Test
  public void testJavaToJson_unsupportedObject() {
    try {
      javaToJson( new HashMap<String, Object>() );
      fail();
    } catch( SWTError error ) {
      assertEquals( SWT.ERROR_INVALID_RETURN_VALUE, error.code );
      assertEquals( "Return value not valid", error.getMessage() );
    }
  }

  private BrowserFunction mockBrowserFunction() {
    final BrowserFunction mock = mock( BrowserFunction.class );
    // Wrap the mock in a delegator BrowserFunction that registers itself in Browser.createFunction
    new BrowserFunction( browser, "func" ) {
      @Override
      public Object function( Object[] arguments ) {
        return mock.function( arguments );
      }
    };
    return mock;
  }

}