• Home
• org.loadui
• testFx
• 3.0.0-beta1
• source code
• GuiTest.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.loadui.testfx.GuiTest Maven / Gradle / Ivy

/*
 * Copyright 2013 SmartBear Software
 * 
 * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by the European Commission - subsequent
 * versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 * 
 * http://ec.europa.eu/idabc/eupl
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the Licence is
 * distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the Licence for the specific language governing permissions and limitations
 * under the Licence.
 */
package org.loadui.testfx;

import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.*;
import com.google.common.util.concurrent.SettableFuture;
import javafx.application.Application;
import javafx.geometry.*;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.SceneBuilder;
import javafx.scene.control.Labeled;
import javafx.scene.input.KeyCode;
import javafx.scene.input.MouseButton;
import javafx.scene.text.Text;
import javafx.stage.PopupWindow;
import javafx.stage.Stage;
import javafx.stage.Window;
import org.hamcrest.Matcher;
import org.junit.Before;
import org.loadui.testfx.exceptions.NoNodesFoundException;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.*;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.collect.Iterables.*;
import static org.loadui.testfx.Matchers.hasLabel;

public abstract class GuiTest
{
	private static final SettableFuture stageFuture = SettableFuture.create();
	protected static Stage stage;
	private static String stylesheet = null;

	public static class TestFxApp extends Application
	{
		private static Scene scene = null;

		@Override
		public void start( Stage primaryStage ) throws Exception
		{

			primaryStage.show();
			stageFuture.set( primaryStage );
		}

		public static void setRoot( Parent rootNode )
		{
			scene.setRoot( rootNode );
		}
	}

	@Before
	public void setupStage() throws Throwable
	{
		showNodeInStage();
	}

	protected abstract Parent getRootNode();

	/**
	 * Creates and displays a new stage, using {@link getRootNode()} as the root node.
	 */
	public void showNodeInStage()
	{
		showNodeInStage( null );
	}

	public void showNodeInStage( final String stylesheet )
	{
		GuiTest.stylesheet = stylesheet;

		if( stage == null )
		{
			FXTestUtils.launchApp( TestFxApp.class );
			try
			{
				stage = targetWindow( stageFuture.get( 25, TimeUnit.SECONDS ) );
				FXTestUtils.bringToFront( stage );
			}
			catch( Exception e )
			{
				throw new RuntimeException( "Unable to show stage", e );
			}
		}

		try
		{
			FXTestUtils.invokeAndWait( new Runnable()
			{
				@Override
				public void run()
				{
					Scene scene = SceneBuilder
							.create()
							.width( 600 )
							.height( 400 )
							.root( getRootNode() ).build();

					if( stylesheet != null )
						scene.getStylesheets().add( stylesheet );

					stage.setScene( scene );
				}
			}, 5 );
		}
		catch( Exception e )
		{
			e.printStackTrace();
		}


	}

	public static void showNodeInStage2( Parent node, String stylesheet )
	{
		GuiTest.stylesheet = stylesheet;

		if( stage == null )
		{
			FXTestUtils.launchApp( TestFxApp.class );
			try
			{
				stage = targetWindow( stageFuture.get( 25, TimeUnit.SECONDS ) );
				FXTestUtils.bringToFront( stage );
			}
			catch( Exception e )
			{
				throw new RuntimeException( "Unable to show stage", e );
			}
		}
		TestFxApp.setRoot( node );
	}

	private static Window lastSeenWindow = null;

	public static  T targetWindow( T window )
	{
		if( window instanceof Stage )
		{
			Stage stage = ( Stage )window;
			//stage.toFront();
		}
		lastSeenWindow = window;
		return window;
	}

	public static OffsetTarget offset( Object target, double offsetX, double offsetY )
	{
		return new OffsetTarget( target, offsetX, offsetY );
	}

	@SuppressWarnings( "deprecation" )
	public static List getWindows()
	{
		return Lists.reverse( Lists.newArrayList( Window.impl_getWindows() ) );
	}

	public static Window getWindowByIndex( int index )
	{
		return getWindows().get( index );
	}

	public static Stage findStageByTitle( final String titleRegex )
	{
		return Iterables.find( Iterables.filter( getWindows(), Stage.class ), new Predicate()
		{
			@Override
			public boolean apply( Stage input )
			{
				return input.getTitle().matches( titleRegex );
			}
		} );
	}

	public static Set findAll( String query, Object parent )
	{
		try
		{
			if( parent instanceof String )
			{
				final String titleRegex = ( String )parent;
				return findAll( query, targetWindow( findStageByTitle( titleRegex ) ).getScene() );
			}
			else if( parent instanceof Node )
			{
				Node node = ( Node )parent;
				targetWindow( node.getScene().getWindow() );
				return findAll( query, node );
			}
			else if( parent instanceof Scene )
			{
				Scene scene = ( Scene )parent;
				targetWindow( scene.getWindow() );
				return findAll( query, scene.getRoot() );
			}
			else if( parent instanceof Window )
			{
				return findAll( query, targetWindow( ( Window )parent ).getScene() );
			}
		}
		catch( Exception e )
		{
			//Ignore, something went wrong with checking a window, so return an empty set.
		}

		return Collections.emptySet();
	}

	public static Set findAll( String query, Node node )
	{
		if( query.startsWith( "." ) || query.startsWith( "#" ) )
		{
			return node.lookupAll( query );
		}
		else
		{
			return findAll( hasLabel( query ), node );
		}
	}

	public static Set findAll( String query )
	{
		Set results = Sets.newLinkedHashSet();
		results.addAll( findAll( query, lastSeenWindow ) );
		final Predicate isDescendant = new Predicate()
		{
			@Override
			public boolean apply( Window input )
			{
				Window parent = null;
				if( input instanceof Stage )
				{
					parent = ( ( Stage )input ).getOwner();
				}
				else if( input instanceof PopupWindow )
				{
					parent = ( ( PopupWindow )input ).getOwnerWindow();
				}

				return parent == lastSeenWindow || parent != null && apply( parent );
			}
		};
		Iterable descendants = Iterables.filter( getWindows(), isDescendant );
		Iterable rest = Iterables.filter( getWindows(), Predicates.not( isDescendant ) );
		for( Window descendant : ImmutableList.copyOf( concat( descendants, rest ) ) )
		{
			results.addAll( findAll( query, descendant ) );
		}

		return results;
	}

	@SuppressWarnings( "unchecked" )
	public static  T find( String selector, Object parent )
	{
		return checkNotNull( ( T )getFirst( findAll( selector, parent ), null ),
				"Query [%s] select [%s] resulted in no nodes found!", parent, selector );
	}

	@SuppressWarnings( "unchecked" )
	public static  T find( final String query )
	{
		T foundNode = null;
		boolean isCssQuery = query.startsWith( "." ) || query.startsWith( "#" );

		if( isCssQuery )
		{
			foundNode = findByCssSelector( query );
			if( foundNode == null )
				throw new NoNodesFoundException( "No nodes matched the CSS query '" + query + "'! Screenshot saved as " + captureScreenshot().getAbsolutePath() );
		}
		else
		{
			foundNode = ( T )find( new HasLabel( query ) );
			if( foundNode == null )
				throw new NoNodesFoundException( "No nodes found with label '" + query + "'! Screenshot saved as " + captureScreenshot().getAbsolutePath() );
		}

		return foundNode;
	}


	public static boolean exists( final String query )
	{
		return selectorExists( query ) || labelExists( query );
	}

	private static boolean labelExists( String query )
	{
		return find( hasLabel( query ) ) != null;
	}

	private static boolean selectorExists( String query )
	{
		return findByCssSelector( query ) != null;
	}

	/**
	 * Returns a Callable that calculates the number of nodes that matches the given query.
	 *
	 * @param nodeQuery a CSS query or the label of a node.
	 * @return
	 */
	public static Callable numberOf( final String nodeQuery )
	{
		return new Callable()
		{
			@Override
			public Integer call() throws Exception
			{
				return findAll( nodeQuery ).size();
			}
		};
	}

	public static File captureScreenshot()
	{
		File screenshot = new File( "screenshot" + new Date().getTime() + ".png" );
		try
		{
			BufferedImage image = new Robot().createScreenCapture( new Rectangle( Toolkit.getDefaultToolkit().getScreenSize() ) );
			ImageIO.write( image, "png", screenshot );
		}
		catch( Exception e )
		{
			e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
		}
		return screenshot;
	}

	private static class HasLabel implements Predicate
	{
		private final String label;

		HasLabel( String label )
		{
			this.label = label;
		}

		@Override
		public boolean apply( Node node )
		{
			if( node instanceof Labeled )
				return label.equals( ( ( Labeled )node ).getText() );
			if( node instanceof Text )
				return label.equals( ( ( Text )node ).getText() );
			return false;
		}
	}

	public static void waitUntil( final Node node, final Matcher