Spring Framework example source code file (JRubyScriptFactoryTests.java)

This example Spring Framework source code file (JRubyScriptFactoryTests.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Spring Framework tags/keywords

applicationcontext, classpathxmlapplicationcontext, exception, exception, hello, integer, integer, messenger, messenger, refreshable, short, string, util, world, world

The Spring Framework JRubyScriptFactoryTests.java source code

/*
 * Copyright 2002-2007 the original author or authors.
 *
 * 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 org.springframework.scripting.jruby;

import java.util.Map;

import junit.framework.TestCase;

import org.springframework.aop.support.AopUtils;
import org.springframework.aop.target.dynamic.Refreshable;
import org.springframework.beans.TestBean;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.scripting.Calculator;
import org.springframework.scripting.ConfigurableMessenger;
import org.springframework.scripting.Messenger;
import org.springframework.scripting.ScriptCompilationException;
import org.springframework.scripting.TestBeanAwareMessenger;

/**
 * @author Rob Harrop
 * @author Rick Evans
 * @author Juergen Hoeller
 */
public class JRubyScriptFactoryTests extends TestCase {

	private static final String RUBY_SCRIPT_SOURCE_LOCATOR =
			"inline:require 'java'\n" +
					"class RubyBar\n" +
					"end\n" +
					"RubyBar.new";


	public void testStaticScript() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyContext.xml", getClass());
		Calculator calc = (Calculator) ctx.getBean("calculator");
		Messenger messenger = (Messenger) ctx.getBean("messenger");

		assertFalse("Scripted object should not be instance of Refreshable", calc instanceof Refreshable);
		assertFalse("Scripted object should not be instance of Refreshable", messenger instanceof Refreshable);

		assertEquals(calc, calc);
		assertEquals(messenger, messenger);
		assertTrue(!messenger.equals(calc));
		assertTrue(messenger.hashCode() != calc.hashCode());
		assertTrue(!messenger.toString().equals(calc.toString()));

		String desiredMessage = "Hello World!";
		assertEquals("Message is incorrect", desiredMessage, messenger.getMessage());
	}

	public void testNonStaticScript() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyRefreshableContext.xml", getClass());
		Messenger messenger = (Messenger) ctx.getBean("messenger");

		assertTrue("Should be a proxy for refreshable scripts", AopUtils.isAopProxy(messenger));
		assertTrue("Should be an instance of Refreshable", messenger instanceof Refreshable);

		String desiredMessage = "Hello World!";
		assertEquals("Message is incorrect.", desiredMessage, messenger.getMessage());

		Refreshable refreshable = (Refreshable) messenger;
		refreshable.refresh();

		assertEquals("Message is incorrect after refresh.", desiredMessage, messenger.getMessage());
		assertEquals("Incorrect refresh count", 2, refreshable.getRefreshCount());
	}

	public void testScriptCompilationException() throws Exception {
		try {
			new ClassPathXmlApplicationContext("jrubyBrokenContext.xml", getClass());
			fail("Should throw exception for broken script file");
		}
		catch (BeanCreationException ex) {
			assertTrue(ex.contains(ScriptCompilationException.class));
		}
	}

	public void testCtorWithNullScriptSourceLocator() throws Exception {
		try {
			new JRubyScriptFactory(null, new Class[]{Messenger.class});
			fail("Must have thrown exception by this point.");
		}
		catch (IllegalArgumentException expected) {
		}
	}

	public void testCtorWithEmptyScriptSourceLocator() throws Exception {
		try {
			new JRubyScriptFactory("", new Class[]{Messenger.class});
			fail("Must have thrown exception by this point.");
		}
		catch (IllegalArgumentException expected) {
		}
	}

	public void testCtorWithWhitespacedScriptSourceLocator() throws Exception {
		try {
			new JRubyScriptFactory("\n   ", new Class[]{Messenger.class});
			fail("Must have thrown exception by this point.");
		}
		catch (IllegalArgumentException expected) {
		}
	}

	public void testCtorWithNullScriptInterfacesArray() throws Exception {
		try {
			new JRubyScriptFactory(RUBY_SCRIPT_SOURCE_LOCATOR, null);
			fail("Must have thrown exception by this point.");
		}
		catch (IllegalArgumentException expected) {
		}
	}

	public void testCtorWithEmptyScriptInterfacesArray() throws Exception {
		try {
			new JRubyScriptFactory(RUBY_SCRIPT_SOURCE_LOCATOR, new Class[]{});
			fail("Must have thrown exception by this point.");
		}
		catch (IllegalArgumentException expected) {
		}
	}

	public void testResourceScriptFromTag() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd.xml", getClass());
		TestBean testBean = (TestBean) ctx.getBean("testBean");

		Messenger messenger = (Messenger) ctx.getBean("messenger");
		assertEquals("Hello World!", messenger.getMessage());
		assertFalse(messenger instanceof Refreshable);

		TestBeanAwareMessenger messengerByType = (TestBeanAwareMessenger) ctx.getBean("messengerByType");
		assertEquals(testBean, messengerByType.getTestBean());

		TestBeanAwareMessenger messengerByName = (TestBeanAwareMessenger) ctx.getBean("messengerByName");
		assertEquals(testBean, messengerByName.getTestBean());
	}

	public void testPrototypeScriptFromTag() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd.xml", getClass());
		ConfigurableMessenger messenger = (ConfigurableMessenger) ctx.getBean("messengerPrototype");
		ConfigurableMessenger messenger2 = (ConfigurableMessenger) ctx.getBean("messengerPrototype");

		assertNotSame(messenger, messenger2);
		assertSame(messenger.getClass(), messenger2.getClass());
		assertEquals("Hello World!", messenger.getMessage());
		assertEquals("Hello World!", messenger2.getMessage());
		messenger.setMessage("Bye World!");
		messenger2.setMessage("Byebye World!");
		assertEquals("Bye World!", messenger.getMessage());
		assertEquals("Byebye World!", messenger2.getMessage());
	}

	public void testInlineScriptFromTag() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd.xml", getClass());
		Calculator calculator = (Calculator) ctx.getBean("calculator");
		assertNotNull(calculator);
		assertFalse(calculator instanceof Refreshable);
	}

	public void testRefreshableFromTag() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd.xml", getClass());
		Messenger messenger = (Messenger) ctx.getBean("refreshableMessenger");
		assertEquals("Hello World!", messenger.getMessage());
		assertTrue("Messenger should be Refreshable", messenger instanceof Refreshable);
	}

	public void testThatMultipleScriptInterfacesAreSupported() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-with-xsd.xml", getClass());
		Messenger messenger = (Messenger) ctx.getBean("calculatingMessenger");
		assertEquals("Hello World!", messenger.getMessage());

		// cool, now check that the Calculator interface is also exposed
		Calculator calc = (Calculator) messenger;
		assertEquals(0, calc.add(2, -2));
	}

	public void testWithComplexArg() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyContext.xml", getClass());
		Printer printer = (Printer) ctx.getBean("printer");
		CountingPrintable printable = new CountingPrintable();
		printer.print(printable);
		assertEquals(1, printable.count);
	}

	public void testWithPrimitiveArgsInReturnTypeAndParameters() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyContextForPrimitives.xml", getClass());
		PrimitiveAdder adder = (PrimitiveAdder) ctx.getBean("adder");
		assertEquals(2, adder.addInts(1, 1));
		assertEquals(4, adder.addShorts((short) 1, (short) 3));
		assertEquals(5, adder.addLongs(2L, 3L));
		assertEquals(5, new Float(adder.addFloats(2.0F, 3.1F)).intValue());
		assertEquals(5, new Double(adder.addDoubles(2.0, 3.1)).intValue());
		assertFalse(adder.resultIsPositive(-200, 1));
		assertEquals("ri", adder.concatenate('r', 'i'));
		assertEquals('c', adder.echo('c'));
	}

	public void testWithWrapperArgsInReturnTypeAndParameters() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jrubyContextForWrappers.xml", getClass());
		WrapperAdder adder = (WrapperAdder) ctx.getBean("adder");

		assertEquals(new Integer(2), adder.addInts(new Integer(1), new Integer(1)));
		assertEquals(Integer.class, adder.addInts(new Integer(1), new Integer(1)).getClass());
		assertEquals(new Short((short) 4), adder.addShorts(new Short((short) 1), new Short((short) 3)));
		assertEquals(Short.class, adder.addShorts(new Short((short) 1), new Short((short) 3)).getClass());
		assertEquals(new Long(5L), adder.addLongs(new Long(2L), new Long(3L)));
		assertEquals(Long.class, adder.addLongs(new Long(2L), new Long(3L)).getClass());
		assertEquals(5, adder.addFloats(new Float(2.0F), new Float(3.1F)).intValue());
		assertEquals(Float.class, adder.addFloats(new Float(2.0F), new Float(3.1F)).getClass());
		assertEquals(5, new Double(adder.addDoubles(new Double(2.0), new Double(3.1)).intValue()).intValue());
		assertEquals(Double.class, adder.addDoubles(new Double(2.0), new Double(3.1)).getClass());
		assertFalse(adder.resultIsPositive(new Integer(-200), new Integer(1)).booleanValue());
		assertEquals(Boolean.class, adder.resultIsPositive(new Integer(-200), new Integer(1)).getClass());
		assertEquals("ri", adder.concatenate(new Character('r'), new Character('i')));
		assertEquals(String.class, adder.concatenate(new Character('r'), new Character('i')).getClass());
		assertEquals(new Character('c'), adder.echo(new Character('c')));
		assertEquals(Character.class, adder.echo(new Character('c')).getClass());
		Integer[] numbers = new Integer[]{new Integer(1), new Integer(2), new Integer(3), new Integer(4), new Integer(5)};
		assertEquals("12345", adder.concatArrayOfIntegerWrappers(numbers));
		assertEquals(String.class, adder.concatArrayOfIntegerWrappers(numbers).getClass());

		Short[] shorts = adder.populate(new Short((short) 1), new Short((short) 2));
		assertEquals(2, shorts.length);
		assertNotNull(shorts[0]);
		assertEquals(new Short((short) 1), shorts[0]);
		assertNotNull(shorts[1]);
		assertEquals(new Short((short) 2), shorts[1]);

		String[][] lol = adder.createListOfLists("1", "2", "3");
		assertNotNull(lol);
		assertEquals(3, lol.length);
		assertEquals("1", lol[0][0]);
		assertEquals("2", lol[1][0]);
		assertEquals("3", lol[2][0]);

		Map singleValueMap = adder.toMap("key", "value");
		assertNotNull(singleValueMap);
		assertEquals(1, singleValueMap.size());
		assertEquals("key", singleValueMap.keySet().iterator().next());
		assertEquals("value", singleValueMap.values().iterator().next());

		String[] expectedStrings = new String[]{"1", "2", "3"};
		Map map = adder.toMap("key", expectedStrings);
		assertNotNull(map);
		assertEquals(1, map.size());
		assertEquals("key", map.keySet().iterator().next());
		String[] strings = (String[]) map.values().iterator().next();
		for (int i = 0; i < expectedStrings.length; ++i) {
			assertEquals(expectedStrings[i], strings[i]);
		}
	}

	public void testAOP() throws Exception {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("jruby-aop.xml", getClass());
		Messenger messenger = (Messenger) ctx.getBean("messenger");
		assertEquals(new StringBuffer("Hello World!").reverse().toString(), messenger.getMessage());
	}


	private static final class CountingPrintable implements Printable {

		public int count;

		public String getContent() {
			this.count++;
			return "Hello World!";
		}
	}

}