EDIT

/**

 * Copyright (C) 2014 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.httpinvoker;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

import java.lang.reflect.Field;

import java.net.URL;

import java.util.Map;

import java.util.Properties;

import net.sf.ehcache.CacheManager;

import org.apache.log4j.Logger;

import org.eclipse.core.runtime.FileLocator;

import org.eclipse.core.runtime.Platform;

import org.junit.Assert;

import org.junit.BeforeClass;

import org.osgi.framework.Bundle;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.security.core.context.SecurityContextImpl;

import org.unitils.database.DatabaseUnitils;

import org.unitils.database.annotations.Transactional;

import org.unitils.database.util.TransactionMode;

import org.unitils.spring.annotation.SpringApplicationContext;

import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteController;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

import eu.etaxonomy.cdm.api.application.CdmDataChangeService;

import eu.etaxonomy.cdm.api.cache.CdmServiceCacher;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

import eu.etaxonomy.taxeditor.remoting.cache.CdmRemoteCacheManager;

import eu.etaxonomy.taxeditor.remoting.cache.CdmTransientEntityCacher;

import eu.etaxonomy.taxeditor.remoting.source.CdmPersistentRemoteSource;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSource;

import eu.etaxonomy.taxeditor.remoting.source.CdmRemoteSourceException;

import eu.etaxonomy.taxeditor.remoting.source.ICdmRemoteSource;

import eu.etaxonomy.taxeditor.session.CdmEntitySession;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionEnabled;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;

/**

 * Base class for remoting tests, responsible for

 * - starting / stop the cdm server

 * - running some basic connection tests

 * - setting up the remote configuration.

 *

 */

@Transactional(TransactionMode.DISABLED)

@SpringApplicationContext("file:./target/classes/eu/etaxonomy/cdm/testRemotingApplicationContext.xml")

public abstract class BaseRemotingTest extends ThreadedTest {

    private static final Logger logger = Logger.getLogger(BaseRemotingTest.class);

    public static final Resource SERVER_PROPERTIES_FILE =

            new ClassPathResource("server.properties");

    private static ICdmRemoteSource cdmRemoteSource;

    private static CdmPersistentRemoteSource remotePersistentSource;

    public static boolean useManagedServer = true;

    protected static ICdmEntitySessionManager cdmEntitySessionManager;

    private final static String DEFAULT_USER = "admin";

    private final static String DEFAULT_PASSWORD = "00000";

    private static String userHomeKey = "user.home";

    private static String user = DEFAULT_USER;

    private static String password = DEFAULT_PASSWORD;

    protected static CDMServer cdmServer;

    @BeforeClass

    public static void initializeBaseRemotingTest() {

        DatabaseUnitils.disableConstraints();

        try {

            String userHomeDirPath;

            Bundle bundle = Platform.getBundle("eu.etaxonomy.taxeditor.test");

            URL userHomeDirURL = bundle.getEntry("src/test/resources");

            File userHomeDir = new File(FileLocator.resolve(userHomeDirURL).toURI());

            userHomeDirPath = userHomeDir.getAbsolutePath();

            URL serverPropertiesURL = bundle.getEntry("src/test/resources/server.properties");

            File serverPropertiesFile = new File(FileLocator.resolve(serverPropertiesURL).toURI());

            InputStream inputStream = new FileInputStream(serverPropertiesFile);

            Properties prop = new Properties();

            if (inputStream != null) {

                prop.load(inputStream);

                inputStream.close();

            }

            logger.info("Setting user.home to " + userHomeDirPath);

            System.setProperty(userHomeKey, userHomeDirPath);

            cdmServer = new CDMServer("cdmTest", serverPropertiesURL);

            if(prop.getProperty("user") != null) {

                user = prop.getProperty("user");

            }

            if(prop.getProperty("password") != null) {

                password = prop.getProperty("password");

            }

            initializeController(cdmServer.getName(),

                    cdmServer.getHost(),

                    cdmServer.getPort(),

                    cdmServer.getContextPath(),

                    NomenclaturalCode.ICNAFP,

                    user,

                    password);

        } catch (Exception e) {

            e.printStackTrace();

           // Assert.fail("Server failed to start. Reason : " + e.getMessage());

        }

    }

    public static void emptyAllCachesExceptModelCache() {

        CacheManager cm = CacheManager.create();

        String[] cacheNames = CacheManager.create().getCacheNames();

        for(String cacheName : cacheNames) {

            if(!cacheName.equals(CdmRemoteCacheManager.CDM_MODEL_CACHE_NAME)) {

                cm.removeCache(cacheName);

            }

        }

    }

    public static void initializeController(String sourceName, String host, int port, String contextPath, NomenclaturalCode ncode, String username, String password) {

        if(CdmApplicationState.getCurrentAppConfig() != null) {

            return;

        }

        cdmRemoteSource = CdmRemoteSource.NewInstance(sourceName, host, port, contextPath, ncode);

        CdmApplicationRemoteController remoteApplicationController =

                CdmApplicationRemoteController.NewInstance(cdmRemoteSource,

                        null,

                        null);

        CdmApplicationState.setCurrentAppConfig(remoteApplicationController);

        CdmApplicationState.setCdmServiceCacher(new CdmServiceCacher());

        try {

            remotePersistentSource = CdmPersistentRemoteSource.NewInstance(sourceName);

        } catch (CdmRemoteSourceException e) {

            Assert.fail("Default Remote Persistent Source failed to load. Reason : " + e.getMessage());

        }

        cdmEntitySessionManager = getRemoteApplicationController().getCdmEntitySessionManager();

        CdmApplicationState.setCurrentDataChangeService(new CdmDataChangeService());

        authenticate(username, password);

    }

    protected static void authenticate(String username, String password) {

        //FIXME:Remoting the authentication code should be replaced by a method call which actually

        // does the authentication in the editor code so that the 'real' authentication can be tested

        SecurityContextHolder.clearContext();

        SecurityContextImpl sc = new SecurityContextImpl();

        Authentication token = new UsernamePasswordAuthenticationToken(username,password);

        Authentication authentication = getRemoteApplicationController().getAuthenticationManager().authenticate(token);

        authentication = new UsernamePasswordAuthenticationToken(username,password, authentication.getAuthorities());

        sc.setAuthentication(authentication);

        SecurityContextHolder.setContext(sc);

        CdmApplicationState.setCurrentSecurityContext(SecurityContextHolder.getContext());

    }

    protected static CdmApplicationRemoteController getRemoteApplicationController() {

        return (CdmApplicationRemoteController) CdmApplicationState.getCurrentAppConfig();

    }

    protected static ICdmRemoteSource getCdmRemoteSource() {

        return cdmRemoteSource;

    }

    protected static CdmPersistentRemoteSource getCdmPersistentRemoteSource() {

        return remotePersistentSource;

    }

    protected static ICdmEntitySessionManager getCdmEntitySessionManager() {

        return cdmEntitySessionManager;

    }

    protected static CdmEntitySession getSession(ICdmEntitySessionEnabled sessionOwner) {

        Map<ICdmEntitySessionEnabled, CdmEntitySession> ownerSessionMap =

                (Map<ICdmEntitySessionEnabled, CdmEntitySession>) getFieldValueViaReflection(cdmEntitySessionManager, "ownerSessionMap");

        return ownerSessionMap.get(sessionOwner);

    }

    protected static CdmEntitySession getActiveSession() {

        return ((InheritableThreadLocal<CdmEntitySession>) getFieldValueViaReflection(cdmEntitySessionManager, "tlActiveSession")).get();

    }

    protected static CdmTransientEntityCacher getCacher(ICdmEntitySessionEnabled sessionOwner) {

        return (CdmTransientEntityCacher) getFieldValueViaReflection(getSession(sessionOwner), "cdmTransientEntityCacher");

    }

    protected static Object getFieldValueViaReflection(Object object, String fieldName) {

        Class<?> clazz = object.getClass();

        try {

            Field field = clazz.getDeclaredField(fieldName);

            field.setAccessible(true);

            return field.get(object);

        } catch (NoSuchFieldException e) {

            e.printStackTrace();

        } catch (SecurityException e) {

            e.printStackTrace();

        } catch (IllegalArgumentException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        }

        return null;

    }

    protected static void authenticateDefaultUser() {

        authenticate(user, password);

    }

}