path: root/sandbox/wjaniszewski/binding-erlang-runtime/src/test/java/org/apache/tuscany/sca/binding/erlang/testing/ReferenceServiceTestCase.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.apache.tuscany.sca.binding.erlang.testing;

import static org.junit.Assert.assertEquals;

import java.io.IOException;

import org.apache.tuscany.sca.binding.erlang.impl.TypeMismatchException;
import org.apache.tuscany.sca.binding.erlang.impl.exceptions.ErlangException;
import org.apache.tuscany.sca.binding.erlang.testing.dynaignore.IgnorableRunner;
import org.apache.tuscany.sca.binding.erlang.testing.dynaignore.IgnoreTest;
import org.apache.tuscany.sca.host.embedded.SCADomain;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.osoa.sca.ServiceRuntimeException;

import com.ericsson.otp.erlang.OtpErlangAtom;
import com.ericsson.otp.erlang.OtpErlangDouble;
import com.ericsson.otp.erlang.OtpErlangList;
import com.ericsson.otp.erlang.OtpErlangLong;
import com.ericsson.otp.erlang.OtpErlangString;
import com.ericsson.otp.erlang.OtpErlangTuple;
import com.ericsson.otp.erlang.OtpMbox;
import com.ericsson.otp.erlang.OtpNode;

//this test runner will ignore tests if epmd is not available
@RunWith(IgnorableRunner.class)
public class ReferenceServiceTestCase {

	private static final String EPMD_COMMAND = "epmd";

	private static MboxInterface mboxReference;
	private static ServiceInterface moduleReference;
	private static ServiceInterface clonedModuleReference;
	private static OtpNode node;
	private static OtpMbox mbox;
	private static Process epmdProcess;

	@BeforeClass
	public static void init() throws IOException {
		try {
			epmdProcess = Runtime.getRuntime().exec(EPMD_COMMAND);
			SCADomain domain = SCADomain
					.newInstance("ErlangReference.composite");
			SCADomain.newInstance("ErlangService.composite");
			ReferenceTestComponentImpl component = domain.getService(
					ReferenceTestComponentImpl.class, "ReferenceTest");
			mboxReference = component.getMboxReference();
			moduleReference = component.getModuleReference();
			clonedModuleReference = component.getClonedModuleReference();
			node = new OtpNode("MboxServer");
			mbox = node.createMbox("sendArgs");
		} catch (IOException e) {
			System.out.println("Problem executing " + EPMD_COMMAND + ": "
					+ e.getLocalizedMessage() + ". Tests will be IGNORED.");
		}
	}

	@AfterClass
	public static void clean() {
		if (epmdProcess != null) {
			epmdProcess.destroy();
		}
	}

	@Before
	public void before() {
		if (epmdProcess == null) {
			throw new IgnoreTest();
		}
	}

	/**
	 * Tests passing strings
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testStrings() throws Exception {
		String strArg = "Test message";
		String strResult = "OK";
		MboxListener mboxListener = new MboxListener(mbox, strResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		String testResult = mboxReference.sendArgs(strArg);
		assertEquals(strArg, ((OtpErlangString) mboxListener.getMsg().getMsg())
				.stringValue());
		assertEquals(strResult, testResult);
	}

	/**
	 * Tests passing booleans
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testBooleans() throws Exception {
		boolean booleanArg = true;
		boolean booleanResult = false;
		MboxListener mboxListener = new MboxListener(mbox, booleanResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		boolean testResult = mboxReference.sendArgs(booleanArg);
		assertEquals(booleanArg, ((OtpErlangAtom) mboxListener.getMsg()
				.getMsg()).booleanValue());
		assertEquals(booleanResult, testResult);
	}

	/**
	 * Tests passing floats
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testFloats() throws Exception {
		float floatArg = 1.0f;
		float floatResult = 2.0f;
		MboxListener mboxListener = new MboxListener(mbox, floatResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		float testResult = mboxReference.sendArgs(floatArg);
		assertEquals(floatArg, ((OtpErlangDouble) mboxListener.getMsg()
				.getMsg()).doubleValue(), 0);
		assertEquals(floatResult, testResult, 0);
	}

	/**
	 * Tests passing doubles
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testDoubles() throws Exception {
		double doubleArg = 1.0f;
		double doubleResult = 2.0f;
		MboxListener mboxListener = new MboxListener(mbox, doubleResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		double testResult = mboxReference.sendArgs(doubleArg);
		assertEquals(doubleArg, ((OtpErlangDouble) mboxListener.getMsg()
				.getMsg()).doubleValue(), 0);
		assertEquals(doubleResult, testResult, 0);
	}

	/**
	 * Tests passing long values
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testLongs() throws Exception {
		long longArg = 1;
		long longResult = 2;
		MboxListener mboxListener = new MboxListener(mbox, longResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		long testResult = mboxReference.sendArgs(longArg);
		assertEquals(longArg, ((OtpErlangLong) mboxListener.getMsg().getMsg())
				.longValue(), 0);
		assertEquals(longResult, testResult, 0);
	}

	/**
	 * Tests passing integers
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testInts() throws Exception {
		int intArg = 1;
		int intResult = 2;
		MboxListener mboxListener = new MboxListener(mbox, intResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		int testResult = mboxReference.sendArgs(intArg);
		assertEquals(intArg, ((OtpErlangLong) mboxListener.getMsg().getMsg())
				.intValue(), 0);
		assertEquals(intResult, testResult, 0);
	}

	/**
	 * Tests passing chars
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testChars() throws Exception {
		char charArg = 1;
		char charResult = 2;
		MboxListener mboxListener = new MboxListener(mbox, charResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		char testResult = mboxReference.sendArgs(charArg);
		assertEquals(charArg, ((OtpErlangLong) mboxListener.getMsg().getMsg())
				.charValue(), 0);
		assertEquals(charResult, testResult, 0);
	}

	/**
	 * Tests passing shorts
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testShorts() throws Exception {
		short shortArg = 1;
		short shortResult = 2;
		MboxListener mboxListener = new MboxListener(mbox, shortResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		short testResult = mboxReference.sendArgs(shortArg);
		assertEquals(shortArg, ((OtpErlangLong) mboxListener.getMsg().getMsg())
				.shortValue(), 0);
		assertEquals(shortResult, testResult, 0);
	}

	/**
	 * Tests passing bytes
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testBytes() throws Exception {
		byte byteArg = 1;
		byte byteResult = 2;
		MboxListener mboxListener = new MboxListener(mbox, byteResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		byte testResult = mboxReference.sendArgs(byteArg);
		assertEquals(byteArg, ((OtpErlangLong) mboxListener.getMsg().getMsg())
				.byteValue(), 0);
		assertEquals(byteResult, testResult, 0);
	}

	/**
	 * Tests passing multiple arguments
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testMultipleArguments() throws Exception {
		MboxListener mboxListener = new MboxListener(mbox, true);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		String testString = "TupleString";
		int testInt = 10;
		mboxReference.sendArgs(testInt, testString);
		assertEquals(testInt, ((OtpErlangLong) ((OtpErlangTuple) mboxListener
				.getMsg().getMsg()).elementAt(0)).longValue());
		assertEquals(testString,
				((OtpErlangString) ((OtpErlangTuple) mboxListener.getMsg()
						.getMsg()).elementAt(1)).stringValue());
	}

	/**
	 * Tests passing tuples
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testTuples() throws Exception {
		StructuredTuple tupleResult = new StructuredTuple();
		tupleResult.arg1.arg1 = 1;
		tupleResult.arg1.arg2 = "Tuple inside tuple";
		tupleResult.arg2 = "Tuple!";
		tupleResult.arg3 = true;
		MboxListener mboxListener = new MboxListener(mbox, tupleResult);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		StructuredTuple testArg = new StructuredTuple();
		testArg.arg2 = "Arg2a";
		testArg.arg3 = true;
		testArg.arg1.arg1 = 10;
		testArg.arg1.arg2 = "Arg2b";
		StructuredTuple testResult = mboxReference.sendArgs(testArg);
		assertEquals(tupleResult, testResult);
		OtpErlangTuple received = (OtpErlangTuple) mboxListener.getMsg()
				.getMsg();
		assertEquals(testArg.arg1.arg1,
				((OtpErlangLong) ((OtpErlangTuple) received.elementAt(0))
						.elementAt(0)).longValue());
		assertEquals(testArg.arg1.arg2,
				((OtpErlangString) ((OtpErlangTuple) received.elementAt(0))
						.elementAt(1)).stringValue());
		assertEquals(testArg.arg2, ((OtpErlangString) received.elementAt(1))
				.stringValue());
		assertEquals(testArg.arg3, ((OtpErlangAtom) received.elementAt(2))
				.booleanValue());
	}

	/**
	 * Tests passing lists
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testLists() throws Exception {
		String[] testArg = new String[] { "One", "Two", "Three" };
		MboxListener mboxListener = new MboxListener(mbox, testArg);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		String[] testResult = mboxReference.sendArgs(testArg);
		assertEquals(testArg.length, testResult.length);
		for (int i = 0; i < testArg.length; i++) {
			assertEquals(testArg[i], testResult[i]);
		}
		OtpErlangList received = (OtpErlangList) mboxListener.getMsg().getMsg();
		assertEquals(testArg.length, received.arity());
		for (int i = 0; i < testArg.length; i++) {
			assertEquals(testArg[i], ((OtpErlangString) received.elementAt(i))
					.stringValue());
		}
	}

	/**
	 * Tests passing multidimensional lists
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testMultiDimLists() throws Exception {
		String[][] testArg = new String[][] { { "One", "Two" },
				{ "Three", "Four", "Five" }, { "Six" } };
		MboxListener mboxListener = new MboxListener(mbox, testArg);
		Thread mboxThread = new Thread(mboxListener);
		mboxThread.start();
		String[][] testResult = mboxReference.sendArgs(testArg);
		assertEquals(testArg.length, testResult.length);
		for (int i = 0; i < testArg.length; i++) {
			for (int j = 0; j < testArg[i].length; j++) {
				assertEquals(testArg[i][j], testResult[i][j]);
			}
		}
		OtpErlangList received = (OtpErlangList) mboxListener.getMsg().getMsg();
		assertEquals(testArg.length, received.arity());
		for (int i = 0; i < testArg.length; i++) {
			for (int j = 0; j < testArg[i].length; j++) {
				assertEquals(testArg[i][j],
						(((OtpErlangString) ((OtpErlangList) received
								.elementAt(i)).elementAt(j)).stringValue()));
			}
		}
	}

	/**
	 * Tests mismatched interface
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void typeMismatch() throws Exception {
		try {
			StructuredTuple arg = new StructuredTuple();
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			String[] arg = new String[] { "test" };
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			long arg = 1;
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			int arg = 1;
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			short arg = 1;
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			char arg = 1;
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			byte arg = 1;
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			double arg = 1;
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			float arg = 1;
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			String arg = "1";
			MboxListener mboxListener = new MboxListener(mbox, true);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}

		try {
			boolean arg = true;
			MboxListener mboxListener = new MboxListener(mbox, 1);
			Thread mboxThread = new Thread(mboxListener);
			mboxThread.start();
			mboxReference.sendArgs(arg);
		} catch (Exception e) {
			assertEquals(TypeMismatchException.class, e.getClass());
			System.out.println(e.getMessage());
		}
	}

	/**
	 * Basic RPC test, without arguments
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testRPC() throws Exception {
		String[] result = moduleReference.sayHellos();
		assertEquals(2, result.length);
		assertEquals("1", result[0]);
		assertEquals("2", result[1]);
	}

	/**
	 * Tests RPC with arguments
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testRPCWithArgs() throws Exception {
		String arg1 = "One";
		String arg2 = "Two";
		String testResult = moduleReference.sayHello(arg1, arg2);
		assertEquals("Hello " + arg1 + " " + arg2, testResult);
	}

	/**
	 * Tests RPC with structured arguments
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testRPCWithComplexArgs() throws Exception {
		StructuredTuple arg = new StructuredTuple();
		arg.arg1.arg2 = "Not empty";
		arg.arg2 = "Not empty";
		StructuredTuple testResult = moduleReference.passComplexArgs(arg,
				new String[] { "some", "array" });
		assertEquals(arg, testResult);
	}

	/**
	 * Tests handling requests pointing to unknown functions
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testUnknownFunction() throws Exception {

		// following functions differs by parameters

		try {
			moduleReference.sayHello();
		} catch (Exception e) {
			assertEquals(ErlangException.class, e.getClass());
		}

		try {
			moduleReference.sayHello("1");
		} catch (Exception e) {
			assertEquals(ErlangException.class, e.getClass());
		}

		try {
			moduleReference.sayHello(1, 2);
		} catch (Exception e) {
			assertEquals(ErlangException.class, e.getClass());
		}

		// for following ones name not exists

		moduleReference.notExist();

		try {
			moduleReference.notExistWithException();
		} catch (Exception e) {
			assertEquals(ErlangException.class, e.getClass());
		}
	}

	/**
	 * Tests using multiple Erlang modules on one SCA Erlang node
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testMultipleModulesOnNode() throws Exception {
		String[] mr = moduleReference.sayHellos();
		String[] cmr = clonedModuleReference.sayHellos();
		assertEquals("1", mr[0]);
		assertEquals("2", mr[1]);

		assertEquals("-1", cmr[0]);
		assertEquals("-2", cmr[1]);
	}

	/**
	 * Tests nodes with duplcated components (the same node and module
	 * parameters)
	 * 
	 * @throws Exception
	 */
	@Test(timeout = 1000)
	public void testModuleDuplicatedOnNode() throws Exception {
		try {
			SCADomain.newInstance("ErlangServiceModuleDuplicate.composite");
		} catch (ServiceRuntimeException e) {
			assertEquals(ErlangException.class, e.getCause().getClass());
		}
	}

}