source: java/main/src/test/java/com/framsticks/hosting/ServerTest.java @ 97

package com.framsticks.hosting;

// import org.apache.log4j.Logger;
import org.testng.annotations.Test;

import com.framsticks.core.Mode;
import com.framsticks.core.ObjectTree;
import com.framsticks.core.Path;
import com.framsticks.core.XmlBasedTest;
import com.framsticks.remote.RemoteTree;

import com.framsticks.test.TestClass;
import com.framsticks.core.Tree;
import com.framsticks.params.FramsClass;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.params.AccessInterface;
import com.framsticks.params.PrimitiveParam;
import com.framsticks.params.PropertiesAccess;
import com.framsticks.params.types.ProcedureParam;
import com.framsticks.util.dispatching.Dispatching.Waiter;
import com.framsticks.util.dispatching.FutureHandler;
import com.framsticks.util.dispatching.RunAt;

import static com.framsticks.core.TreeOperations.*;

import static org.fest.assertions.Assertions.*;

@Test
public class ServerTest extends XmlBasedTest {

        protected RemoteTree remote;
        protected FramsClass remoteTestFramsClass;
        protected Path remotePath;

        protected Server server;
        protected ObjectTree hosted;
        protected TestClass hostedObject;

        @Override
        protected String getConfigurationName() {
                return "ServerTest.xml";
        }

        @Test
        public void runServer() {
                assertThat(framsticks.size()).isEqualTo(2);
                assertThat(framsticks.get("test")).isInstanceOf(Server.class);
                assertThat(framsticks.get("remote")).isInstanceOf(RemoteTree.class);

                server = (Server) framsticks.get("test");
                remote = (RemoteTree) framsticks.get("remote");
                assertThat(server.getHosted()).isInstanceOf(ObjectTree.class);
                hosted = (ObjectTree) server.getHosted();
                assertThat(hosted.getRootObject()).isInstanceOf(TestClass.class);
                hostedObject = hosted.getRootObject(TestClass.class);
        }

        @Test(dependsOnMethods = "runServer")
        public void fetchInfo() {
                remote.dispatch(new RunAt<Tree>(failOnException) {
                        @Override
                        protected void runAt() {
                                remote.info(Path.to(remote, "/"), new FutureHandler<FramsClass>(failOnException) {
                                        @Override
                                        protected void result(FramsClass result) {
                                                remoteTestFramsClass = result;
                                                assertThat(result.getId()).isEqualTo("TestClass");
                                        }
                                });
                        }
                });

                Dispatching.synchronize(remote, 1.0);
        }

        @Test(dependsOnMethods = "fetchInfo")
        public void resolveAndfetchRootObject() {
                final Waiter waiter = produceWaiter(1.0);

                remote.dispatch(new RunAt<Tree>(failOnException) {
                        @Override
                        protected void runAt() {
                                final Path path = Path.to(remote, "/");
                                assertThat(path.isResolved()).isFalse();

                                remote.resolve(path, new FutureHandler<Path>(failOnException) {
                                        @Override
                                        protected void result(final Path result) {
                                                assertThat(result.isResolved()).isTrue();
                                                remotePath = result;
                                                remote.get(result, Mode.FETCH, new FutureHandler<Object>(failOnException) {
                                                        @Override
                                                        protected void result(Object object) {
                                                                AccessInterface access = bindAccess(result);
                                                                assertThat(access).isInstanceOf(PropertiesAccess.class);
                                                                assertThat(access.get("name", String.class)).isEqualTo("a test name");
                                                                waiter.pass();
                                                        }
                                                });
                                        }
                                });
                        }
                });
        }

        @Test(dependsOnMethods = "resolveAndfetchRootObject")
        public void setValueName() {
                final Waiter waiter = produceWaiter(2.0);

                set(remotePath, remoteTestFramsClass.getParamEntry("name", PrimitiveParam.class), "new name", new FutureHandler<Integer>(failOnException) {
                        @Override
                        protected void result(Integer flags) {
                                // assertThat(flags).isEqualTo(0);
                                /** And now check directly whether it was really set. */
                                hosted.dispatch(new RunAt<Tree>(failOnException) {
                                        @Override
                                        protected void runAt() {
                                                assertThat(hostedObject.getName()).isEqualTo("new name");
                                                waiter.pass();
                                        }
                                });
                        }
                });
        }

        @Test(dependsOnMethods = "setValueName")
        public void callMethod() {
                final Waiter firstWaiter = produceWaiter(2.0);
                final Waiter waiter = produceWaiter(2.0);

                call(remotePath, remoteTestFramsClass.getParamEntry("resetHistory", ProcedureParam.class), new Object[] {}, new FutureHandler<Object>(failOnException) {
                        @Override
                        protected void result(Object result) {
                                firstWaiter.pass();
                        }
                });

                call(remotePath, remoteTestFramsClass.getParamEntry("appendHistory", ProcedureParam.class), new Object[] {"next word"}, new FutureHandler<Object>(failOnException) {
                        @Override
                        protected void result(Object result) {
                                hosted.dispatch(new RunAt<Tree>(failOnException) {
                                        @Override
                                        protected void runAt() {
                                                assertThat(hostedObject.getHistory()).isEqualTo("next word|");
                                                waiter.pass();
                                        }
                                });
                        }
                });

        }

        @Test(dependsOnMethods = "callMethod")
        public void endWait() {
                monitor.useFor(1.0);
        }
}