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.lang.reflect.Field;

import java.util.Map;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.junit.BeforeClass;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

import org.springframework.security.core.Authentication;

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

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.CdmServiceCachingProxy;

import eu.etaxonomy.cdm.cache.CdmRemoteCacheManager;

import eu.etaxonomy.cdm.model.permission.User;

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

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

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

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;

import net.sf.ehcache.CacheManager;

/**

 * 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 {

    @SuppressWarnings("unused")

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

    private static ICdmRemoteSource cdmRemoteSource;

    private static CdmPersistentRemoteSource remotePersistentSource;

    protected static ICdmEntitySessionManager cdmEntitySessionManager;

    @BeforeClass

    public static void initializeBaseRemotingTest() {

        DatabaseUnitils.disableConstraints();

        try {

            initializeController(sourceName,

                    host,

                    httpPort,

                    contextPath,

                    user,

                    password);

        } catch (Exception e) {

            System.err.println("user: " + user + " password: " + password);

            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, String username, String password) {

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

            return;

        }

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

        CdmApplicationRemoteController remoteApplicationController =

                CdmApplicationRemoteController.NewInstance(cdmRemoteSource,

                        null,

                        null);

        CdmApplicationState.setCurrentAppConfig(remoteApplicationController);

        CdmApplicationState.setTermProxy(new CdmServiceCachingProxy());

        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();

        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, password);

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

        User user = (User) authentication.getPrincipal();

        /* circumventing problem with hibernate not refreshing the transient collection authorities in this case,

         * see http://dev.e-taxonomy.eu/trac/ticket/4053 */

        user.initAuthorities();

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

        SecurityContextHolder.getContext().setAuthentication(authentication);

        CdmApplicationState.setCurrentSecurityContext(SecurityContextHolder.getContext());

//        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 ConversationalTransientEntityCacher getCacher(ICdmEntitySessionEnabled sessionOwner) {

        return (ConversationalTransientEntityCacher) 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 | SecurityException |

                IllegalArgumentException | IllegalAccessException e) {

            e.printStackTrace();

        }

        return null;

    }

    protected static void authenticateDefaultUser() {

        authenticate(user, password);

    }

}