/*
package eu.dnetlib.oauth;

import eu.dnetlib.oauth.config.SpringConfiguration;
import org.apache.log4j.BasicConfigurator;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.surfnet.oaaas.auth.OAuth2ValidatorImpl;
import org.surfnet.oaaas.config.SpringConfigTest;
import org.surfnet.oaaas.model.AuthorizationRequest;
import org.surfnet.oaaas.model.Client;
import org.surfnet.oaaas.repository.AccessTokenRepository;
import org.surfnet.oaaas.repository.ClientRepository;

import javax.inject.Inject;
import java.sql.SQLException;
import java.util.Arrays;

import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.when;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class OauthValidatorTest extends SpringConfigTest {

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    @Mock
    private ClientRepository clientRepository;

    @Mock
    private AccessTokenRepository accessTokenRepository;
    @Inject
    //public LocalContainerEntityManagerFactoryBean entityManagerFactory;

    // @Inject
    // private org.surfnet.oaaas.auth.OAuth2ValidatorImpl validator = new
    // OAuth2ValidatorImpl();

    private AuthorizationRequest request;
    private Client client;
    @Inject
    JpaTransactionManager transactionManager;

    @Before
    public void wire() {
        MockitoAnnotations.initMocks(this);
        BasicConfigurator.configure();

        assertNotNull(clientRepository);
        assertNotNull(entityManagerFactory);
        // assertNotNull(validator);
        assertNotNull(accessTokenRepository);

    }

    @Test
    public void simpleTest() throws SQLException {

        this.client = createClient("client-app");

        when(clientRepository.findByClientId(client.getClientId())).thenReturn(client);
        this.request = getAuthorizationRequest(client);
        log.info("Request is  " + request.toString());

    }

    //
    @Test
    public void testValidateValidRedirectUri() {
        request.setRedirectUri("http://not-registered.nl");
        validate(ValidationResponse.REDIRECT_URI_NOT_VALID);
    }

    @Test
    public void testInvalidRedirectUriFragment() {
        request.setRedirectUri(request.getRedirectUri() + "#fragment");
        validate(ValidationResponse.REDIRECT_URI_FRAGMENT_COMPONENT);
    }

    @Test
    public void testClientNotPermittedImplicitGrant() {
        request.setResponseType(OAuth2ValidatorImpl.IMPLICIT_GRANT_RESPONSE_TYPE);
        validate(ValidationResponse.IMPLICIT_GRANT_NOT_PERMITTED);
    }

    @Test
    public void testHappyFlow() {
        validate(ValidationResponse.VALID);
    }

    @Test
    public void testRedirectUriWithQueryParameter() {
        request.setRedirectUri(request.getRedirectUri() + "?param=example&param2=test");
        validate(ValidationResponse.VALID);
    }

    @Test
    public void testValidateClientId() {
        request.setClientId("unknown_client");
        validate(ValidationResponse.UNKNOWN_CLIENT_ID);
    }

    @Test
    public void testValidateImplicitGrant() {
        reset(clientRepository);
        Client client = createClient("client-app");
        client.setAllowedImplicitGrant(true);
        when(clientRepository.findByClientId(client.getClientId())).thenReturn(client);

        request.setResponseType(OAuth2ValidatorImpl.IMPLICIT_GRANT_RESPONSE_TYPE);
        request.setRedirectUri(" ");
        validate(ValidationResponse.IMPLICIT_GRANT_REDIRECT_URI);
    }

    @Test
    public void partOfRedirectUrimatching() {
        request.setRedirectUri("http://gothere.nl.subdomain/extra_path");
        validate(ValidationResponse.VALID);
    }

    @Test
    public void testValidateResponseType() {
        request.setResponseType("not-existing-response-type");
        validate(ValidationResponse.UNSUPPORTED_RESPONSE_TYPE);
    }

    @Test
    public void testValidateScope() {
        request.setRequestedScopes(Arrays.asList("no-existing-scope"));
        validate(ValidationResponse.SCOPE_NOT_VALID);
    }

    @Test
    public void testValidateRedirectUri() {
        request.setRedirectUri("qwert://no-valid-url");
        validate(ValidationResponse.REDIRECT_URI_NOT_URI);
    }

    @Test
    public void determineRedirectUri() {
        request.setRedirectUri("http://gothere.nl");
        validator.determineRedirectUri(request, "code", createClient("clientId"));
        validate(ValidationResponse.VALID);

    }

    @Test
    public void implicitGrantNoRedirectGivenShouldUseDefault() {
        Client client = createClient("any");
        final String uri = "http://implicit-grant-uri/";
        request.setRedirectUri("");
        client.setRedirectUris(Arrays.asList(uri));
        try {
            final String determinedUri = validator.determineRedirectUri(request, OAuth2ValidatorImpl.IMPLICIT_GRANT_RESPONSE_TYPE, client);
            fail();
        } catch (ValidationResponseException e) {
            assertEquals(ValidationResponse.IMPLICIT_GRANT_REDIRECT_URI, e.v);
        }
    }

    @Test
    public void determineUrlValidImplicitGrant() {
        Client client = createClient("any");
        final String uri = "http://implicit-grant-uri/";
        request.setRedirectUri(uri);
        client.setRedirectUris(Arrays.asList(uri));
        final String determinedUri = validator.determineRedirectUri(request, OAuth2ValidatorImpl.IMPLICIT_GRANT_RESPONSE_TYPE, client);
        assertEquals(uri, determinedUri);
    }

    @Test
    public void testClientCredentialsTokenRequest() {
        AccessTokenRequest accessTokenRequest = new AccessTokenRequest();
        accessTokenRequest.setGrantType(OAuth2Validator.GRANT_TYPE_CLIENT_CREDENTIALS);
        accessTokenRequest.setClientId(client.getClientId());
        ValidationResponse response = validator.validate(accessTokenRequest, BasicAuthCredentials.createCredentialsFromHeader(null));
        assertEquals(ValidationResponse.CLIENT_CREDENTIALS_NOT_PERMITTED, response);
        assertNull(accessTokenRequest.getClient());

        client.setAllowedClientCredentials(true);
        response = validator.validate(accessTokenRequest, BasicAuthCredentials.createCredentialsFromHeader(null));
        assertEquals(ValidationResponse.VALID, response);
        assertEquals(client, accessTokenRequest.getClient());
    }

    private Client createClient(String clientId) {
        Client client = new Client();
        client.setName("Client App");
        client.setClientId(clientId);
        client.setRedirectUris(Arrays.asList("http://gothere.nl", "http://gohere.nl"));
        client.setScopes(Arrays.asList("read", "update"));
        return client;
    }

    //
    // // // TODO look here for validation
    private void validate(ValidationResponse expected) {
        ValidationResponse response = validator.validate(request);
        assertEquals(expected, response);
    }


    private AuthorizationRequest getAuthorizationRequest(Client client) {
        AuthorizationRequest request = new AuthorizationRequest();
        request.setClientId(client.getClientId());
        request.setRedirectUri("http://gothere.nl");
        request.setRequestedScopes(Arrays.asList("read", "update"));
        request.setResponseType(OAuth2ValidatorImpl.AUTHORIZATION_CODE_GRANT_RESPONSE_TYPE);
        return request;
    }

}
*/