package at.asitplus.eidas.specific.modules.msproxyservice.test.protocol;

import static at.asitplus.eidas.specific.core.MsEidasNodeConstants.PROP_CONFIG_SP_NEW_EID_MODE;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;

import java.net.URISyntaxException;
import java.net.URLDecoder;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.apache.commons.lang3.RandomStringUtils;
import org.joda.time.DateTime;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.opensaml.saml.saml2.core.NameIDType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.google.common.collect.ImmutableSortedSet;

import at.asitplus.eidas.specific.core.test.config.dummy.MsConnectorDummyConfigMap;
import at.asitplus.eidas.specific.core.test.config.dummy.MsConnectorDummySpConfiguration;
import at.asitplus.eidas.specific.modules.core.eidas.EidasConstants;
import at.asitplus.eidas.specific.modules.core.eidas.service.EidasAttributeRegistry;
import at.asitplus.eidas.specific.modules.msproxyservice.protocol.ProxyServiceAuthenticationAction;
import at.asitplus.eidas.specific.modules.msproxyservice.protocol.ProxyServicePendingRequest;
import at.gv.egiz.eaaf.core.api.data.EaafConfigConstants;
import at.gv.egiz.eaaf.core.api.data.EaafConstants;
import at.gv.egiz.eaaf.core.api.data.PvpAttributeDefinitions;
import at.gv.egiz.eaaf.core.api.idp.IAuthData;
import at.gv.egiz.eaaf.core.api.idp.slo.SloInformationInterface;
import at.gv.egiz.eaaf.core.exceptions.EaafException;
import at.gv.egiz.eaaf.core.exceptions.EaafStorageException;
import at.gv.egiz.eaaf.core.impl.idp.EidAuthenticationData;
import at.gv.egiz.eaaf.core.impl.idp.module.test.TestRequestImpl;
import eu.eidas.auth.commons.attribute.AttributeDefinition;
import eu.eidas.auth.commons.attribute.ImmutableAttributeMap;
import eu.eidas.auth.commons.light.ILightResponse;
import eu.eidas.auth.commons.light.impl.LightRequest;
import eu.eidas.auth.commons.light.impl.LightRequest.Builder;
import eu.eidas.specificcommunication.SpecificCommunicationDefinitionBeanNames;
import eu.eidas.specificcommunication.exception.SpecificCommunicationException;
import eu.eidas.specificcommunication.protocol.SpecificCommunicationService;
import lombok.SneakyThrows;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {
    "/spring/SpringTest-context_basic_test.xml",
    "/spring/SpringTest-context_basic_mapConfig.xml",
  })
public class ProxyServiceAuthenticationActionTest {

  @Autowired private MsConnectorDummyConfigMap basicConfig;
  @Autowired private ProxyServiceAuthenticationAction action;
  @Autowired private ApplicationContext context;
  @Autowired EidasAttributeRegistry attrRegistry;
  
  private MockHttpServletRequest httpReq;
  private MockHttpServletResponse httpResp;
  private ProxyServicePendingRequest pendingReq;
  private MsConnectorDummySpConfiguration oaParam;
  private SpecificCommunicationService springManagedSpecificConnectorCommunicationService;
  
   
  /**
   * jUnit test set-up.
   * @throws EaafException In case of an error
   */
  @Before
  public void setUp() throws URISyntaxException, EaafException {
    httpReq = new MockHttpServletRequest("POST", "https://localhost/authhandler");
    httpResp = new MockHttpServletResponse();
    RequestContextHolder.resetRequestAttributes();
    RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(httpReq, httpResp));
    
    basicConfig.putConfigValue("eidas.ms.auth.eIDAS.node_v2.proxy.forward.endpoint", 
        "http://eidas.proxy/endpoint");    
    basicConfig.putConfigValue("auth.eIDAS.proxy.workaround.mandates.legalperson", 
        "false");
    
    final Map<String, String> spConfig = new HashMap<>();
    spConfig.put(EaafConfigConstants.SERVICE_UNIQUEIDENTIFIER, "testSp");
    spConfig.put("target", "urn:publicid:gv.at:cdid+XX");
    spConfig.put(PROP_CONFIG_SP_NEW_EID_MODE, "true");
    oaParam = new MsConnectorDummySpConfiguration(spConfig, basicConfig);
    oaParam.setLoa(Arrays.asList(EaafConstants.EIDAS_LOA_HIGH));
        
    pendingReq = new ProxyServicePendingRequest();
    pendingReq.initialize(httpReq, basicConfig);
    pendingReq.setOnlineApplicationConfiguration(oaParam);
    
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    springManagedSpecificConnectorCommunicationService =
        (SpecificCommunicationService) context.getBean(
            SpecificCommunicationDefinitionBeanNames.SPECIFIC_PROXYSERVICE_COMMUNICATION_SERVICE
                .toString());
    
  }
  
  @Test
  public void wrongPendingRequestType() {    
    IAuthData authData = generateDummyAuthData();
    TestRequestImpl internalPendingReq = new TestRequestImpl();
    
    EaafException exception = assertThrows(EaafException.class,
        () ->  action.processRequest(internalPendingReq, httpReq, httpResp, authData));
    Assert.assertEquals("wrong errorCode", "eidas.proxyservice.99", exception.getErrorId());
    
  }

  @Test
  public void missingForwardUrl() {        
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", false);
    basicConfig.removeConfigValue("eidas.ms.auth.eIDAS.node_v2.proxy.forward.endpoint");
        
    EaafException exception = assertThrows(EaafException.class,
        () ->  action.processRequest(pendingReq, httpReq, httpResp, authData));
    Assert.assertEquals("wrong errorCode", "config.08", exception.getErrorId());
    
  }
  
  @Test 
  public void responseWithoutMandate() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, RandomStringUtils.randomAlphanumeric(10));    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", false);
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 4, respAttr.size());    
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH, 
        authData.getDateOfBirth());
        
  }
  
  @Test 
  public void responseWithoutMandatePersistentNameId() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, RandomStringUtils.randomAlphanumeric(10));
    IAuthData authData = generateDummyAuthData(attr, EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18",
        false);

    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.nameIdFormat(NameIDType.PERSISTENT);
    pendingReq.setEidasRequest(eidasRequestBuilder.build());

    // perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);

    // validate state
    Assert.assertNotNull("Result should be not null", result);

    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData,
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME), NameIDType.PERSISTENT);
    assertEquals("wrong attr. size", 4, respAttr.size());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER,
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH,
        authData.getDateOfBirth());

  }

  @Test
  public void responseWithoutMandateAndOptionalAttributesExist() throws EaafException, SpecificCommunicationException {
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_DATEOFBIRTH).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByName("http://eidas.europa.eu/attributes/naturalperson/BirthName"))
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));
    attr.put("ida_birthname", RandomStringUtils.randomAlphanumeric(10));
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", false);
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 5, respAttr.size());    
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH, 
        authData.getDateOfBirth());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_BIRTHNAME, 
        (String) attr.get("ida_birthname"));
    
  }
  
  @Test 
  public void responseWithoutMandateAndOptionalAttributesNotExist() throws EaafException, SpecificCommunicationException {
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_DATEOFBIRTH).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByName("http://eidas.europa.eu/attributes/naturalperson/BirthName"))
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", false);
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 4, respAttr.size());    
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH, 
        authData.getDateOfBirth());
    
  }
  
  
  @Test 
  public void responseWithNatMandate() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));        
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME,
        "1985-11-15");
    
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 8, respAttr.size());    
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_DATEOFBIRTH, authData.getDateOfBirth());

    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME));
           
  }
  
  @Test 
  public void responseWithNatMandatePersistentNameId() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME,
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME,
        "1985-11-15");

    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.nameIdFormat(NameIDType.PERSISTENT);
    pendingReq.setEidasRequest(eidasRequestBuilder.build());

    IAuthData authData = generateDummyAuthData(attr, EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18",
        true);

    // perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);

    // validate state
    Assert.assertNotNull("Result should be not null", result);

    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME), NameIDType.PERSISTENT);
    assertEquals("wrong attr. size", 8, respAttr.size());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_PERSONALIDENTIFIER,
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTFAMILYNAME, authData
        .getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTGIVENNAME, authData
        .getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_DATEOFBIRTH, authData.getDateOfBirth());

    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME));

  }

  @Test
  public void responseWithNatMandateButJurRequested() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));        
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME,
        "1985-11-15");
        
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
    
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 4, respAttr.size());    
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_DATEOFBIRTH, authData.getDateOfBirth());
           
  }
  
  @Test 
  public void responseWithNatMandateOptionalAttribute() throws EaafException, SpecificCommunicationException {    
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_DATEOFBIRTH).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByName("http://eidas.europa.eu/attributes/naturalperson/BirthName"))
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    attr.put("ida_birthName_mandator", RandomStringUtils.randomAlphanumeric(10));
    attr.put("ida_birthName", RandomStringUtils.randomAlphanumeric(10));
    
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME,
        "1985-11-15");
    
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 9, respAttr.size());    
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_DATEOFBIRTH, authData.getDateOfBirth());

    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME));

    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_BIRTHNAME, 
        (String) attr.get("ida_birthName_mandator"));
    
  }
  
  @Test 
  public void responseWithJurMandate() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
   
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
        
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 6, respAttr.size());  
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_DATEOFBIRTH, authData.getDateOfBirth());
   
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_LEGALNAME, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME));
    
    assertNull("find nat. person subject: personalId", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER));
    assertNull("find nat. person subject: familyName", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME));
    assertNull("find nat. person subject: givenName", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME));
    assertNull("find nat. person subject: dateOfBirth", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH));
    
  }
  
  @Test 
  public void responseWithJurMandatePersistentNameId() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME,
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));

    IAuthData authData = generateDummyAuthData(attr, EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18",
        true);

    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.nameIdFormat(NameIDType.PERSISTENT);
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(
            EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME)
            .first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());

    // perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);

    // validate state
    Assert.assertNotNull("Result should be not null", result);

    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME), NameIDType.PERSISTENT);
    assertEquals("wrong attr. size", 6, respAttr.size());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_PERSONALIDENTIFIER,
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTFAMILYNAME, authData
        .getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTGIVENNAME, authData
        .getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_DATEOFBIRTH, authData.getDateOfBirth());

    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_LEGALNAME,
        (String) attr.get(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME));

    assertNull("find nat. person subject: personalId",
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER));
    assertNull("find nat. person subject: familyName",
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME));
    assertNull("find nat. person subject: givenName",
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME));
    assertNull("find nat. person subject: dateOfBirth",
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH));

  }

  @Test
  public void borisModeResponseWithJurMandate() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_TYPE_NAME,
        "MUST_BE_UPDATED");
   
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
    
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName("eJusticeLegalPersonRole").first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 7, respAttr.size());  
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_REPRESENTATIVE_DATEOFBIRTH, authData.getDateOfBirth());
   
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_LEGALNAME, 
        (String) attr.get(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME));
    
    checkAttrValue(respAttr, "eJusticeLegalPersonRole", "VIP1");
    
    assertNull("find nat. person subject: personalId", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER));
    assertNull("find nat. person subject: familyName", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME));
    assertNull("find nat. person subject: givenName", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME));
    assertNull("find nat. person subject: dateOfBirth", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH));
    
  }
  
  @Test 
  public void borisModeResponseWithJurMandate2() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_TYPE_NAME,
        "SECOND");
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
        
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName("eJusticeLegalPersonRole").first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 7, respAttr.size());  
    
    checkAttrValue(respAttr, "eJusticeLegalPersonRole", "VIP2");
   
  }
  
  @Test 
  public void borisModeNatPersonResponse() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    String familyName = RandomStringUtils.randomAlphanumeric(10);
    
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_TYPE_NAME,
        "SECOND");
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        familyName, RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
    
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_DATEOFBIRTH).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName("eJusticeNaturalPersonRole").first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 5, respAttr.size());  
    
    checkAttrValue(respAttr, "eJusticeNaturalPersonRole", "VIP2");    
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, familyName);
   
  }
  
  @Test 
  public void borisModeNoMandateType() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
   
    
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName("eJusticeLegalPersonRole").first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 6, respAttr.size());  
    
  }
  
  @Test 
  public void borisModeEmptyMandateType() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_TYPE_NAME, "");
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);   
    
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName("eJusticeLegalPersonRole").first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 6, respAttr.size());  
    
  }
  
  @Test 
  public void borisModeUnknownMandateType() throws EaafException, SpecificCommunicationException {
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));
    
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_TYPE_NAME, RandomStringUtils.randomAlphanumeric(10));
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
        
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName("eJusticeLegalPersonRole").first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
    
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 6, respAttr.size());  
    
  }
  
  @Test
  public void responseWithNatMandateWithWorkAround() throws EaafException, SpecificCommunicationException {
    basicConfig.putConfigValue("auth.eIDAS.proxy.workaround.mandates.legalperson", 
        "true");
        
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BPK_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_GIVEN_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_FAMILY_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_NAT_PER_BIRTHDATE_NAME,
        "1985-11-15");
        
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 8, respAttr.size());    
            
  }
  
  @Test
  public void responseWithJurMandateWithWorkAround() throws EaafException, SpecificCommunicationException {
    basicConfig.putConfigValue("auth.eIDAS.proxy.workaround.mandates.legalperson", 
        "true");
    
    //request natural person subject only
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
        
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    

    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
        
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 10, respAttr.size());  
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER, 
        (String) attr.get(PvpAttributeDefinitions.BPK_NAME));
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME, authData.getFamilyName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME, authData.getGivenName());
    checkAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH, authData.getDateOfBirth());
   
  }
  
  @Test
  public void responseWithJurMandateWithWorkAroundNoNatSubject() throws EaafException, SpecificCommunicationException {
    basicConfig.putConfigValue("auth.eIDAS.proxy.workaround.mandates.legalperson", 
        "true");
    
    //request natural person subject only
    LightRequest.Builder eidasRequestBuilder = generateBasicLightRequest();
    eidasRequestBuilder.requestedAttributes(ImmutableAttributeMap.builder()
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALPERSONIDENTIFIER).first())
        .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_LEGALNAME).first())
        .build());
    pendingReq.setEidasRequest(eidasRequestBuilder.build());
        
    Map<String, Object> attr = new HashMap<>();
    attr.put(PvpAttributeDefinitions.BPK_NAME, 
        "AT+XX:" + RandomStringUtils.randomAlphanumeric(10));    
    
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_SOURCE_PIN_NAME,
        RandomStringUtils.randomAlphabetic(10));
    attr.put(PvpAttributeDefinitions.MANDATE_LEG_PER_FULL_NAME_NAME,
        RandomStringUtils.randomAlphabetic(10));    
    
    IAuthData authData = generateDummyAuthData(attr , EaafConstants.EIDAS_LOA_HIGH,
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1945-04-18", true);
    
    //perform test
    SloInformationInterface result = action.processRequest(pendingReq, httpReq, httpResp, authData);
    
    //validate state
    Assert.assertNotNull("Result should be not null", result);
    
    ImmutableAttributeMap respAttr = validateBasicEidasResponse(authData);
    assertEquals("wrong attr. size", 6, respAttr.size());     
    assertNull("find nat. person subject: personalId", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER));
    assertNull("find nat. person subject: familyName", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME));
    assertNull("find nat. person subject: givenName", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME));
    assertNull("find nat. person subject: dateOfBirth", 
        getAttrValue(respAttr, EidasConstants.eIDAS_ATTR_DATEOFBIRTH));
    
  }
  
  @Test
  public void checkBasicConstrainsInAction() {
    
    Assert.assertTrue("Wrong NeedAuthentication", action.needAuthentication(pendingReq, httpReq, httpResp));
    Assert.assertNotNull("Missing ActionName", action.getDefaultActionName());
    
    Assert.assertNotNull("missing ActionBean", context.getBean(ProxyServiceAuthenticationAction.class));
    
  }
  
  @SneakyThrows
  private IAuthData generateDummyAuthData() {
    return generateDummyAuthData(new HashMap<>(), EaafConstants.EIDAS_LOA_LOW, 
        RandomStringUtils.randomAlphanumeric(10), RandomStringUtils.randomAlphanumeric(10), "1940-01-01", false);
    
  }
  
  private Object getAttrValue(ImmutableAttributeMap respAttr, String attrName) {
    final AttributeDefinition<?> attrDef = 
        attrRegistry.getCoreAttributeRegistry().getByFriendlyName(attrName).first();
    return respAttr.getFirstValue(attrDef); 
    
  }
  
  private void checkAttrValue(ImmutableAttributeMap respAttr, String attrName, String expected) {
    Object value = getAttrValue(respAttr, attrName);  
    assertNotNull("not attr value: " + attrName, value);
   
    if (value instanceof String) {
      assertEquals("wrong attr. value: " + attrName, expected, value);
     
    } else if ( value instanceof DateTime) {
      assertEquals("wrong attr. value: " + attrName, expected, ((DateTime)value).toString("yyyy-MM-dd"));
          
    }       
  }
  
  private ImmutableAttributeMap validateBasicEidasResponse(IAuthData authData) throws SpecificCommunicationException {
    return validateBasicEidasResponse(authData, null, NameIDType.TRANSIENT);
    
  }
  
  private ImmutableAttributeMap validateBasicEidasResponse(IAuthData authData, String subjectNameId,
      String persistent) throws SpecificCommunicationException {
    assertNotNull("not redirct Header", httpResp.getHeader("Location"));
    assertTrue("wrong redirect URL", httpResp.getHeader("Location").startsWith(
        "http://eidas.proxy/endpoint?token="));
    String token = httpResp.getHeader("Location").substring("http://eidas.proxy/endpoint?token=".length());

    ILightResponse resp = springManagedSpecificConnectorCommunicationService.getAndRemoveResponse(URLDecoder
        .decode(token),
        ImmutableSortedSet.copyOf(attrRegistry.getCoreAttributeRegistry().getAttributes()));

    assertNotNull("responseId", resp.getId());
    assertEquals("inResponseTo", pendingReq.getEidasRequest().getId(), resp.getInResponseToId());
    assertEquals("relayState", pendingReq.getEidasRequest().getRelayState(), resp.getRelayState());
    assertEquals("LoA", authData.getEidasQaaLevel(), resp.getLevelOfAssurance());

    assertNotNull("subjectNameId", resp.getSubject());
    if (subjectNameId != null) {
      assertEquals("subjectNameId", subjectNameId, resp.getSubject());
    }
    assertEquals("subjectNameIdFormat", persistent, resp.getSubjectNameIdFormat());

    assertFalse("not attributes", resp.getAttributes().isEmpty());
    return resp.getAttributes();

  }

  private Builder generateBasicLightRequest() {
    return LightRequest.builder()
        .id(UUID.randomUUID().toString())
        .issuer(RandomStringUtils.randomAlphabetic(10))
        .citizenCountryCode(RandomStringUtils.randomAlphabetic(2).toUpperCase())
        .levelOfAssurance(EaafConstants.EIDAS_LOA_HIGH)
        .spCountryCode(RandomStringUtils.randomAlphabetic(2).toUpperCase())
        .spType("public")
        .requesterId(RandomStringUtils.randomAlphanumeric(10))
        .providerName(RandomStringUtils.randomAlphanumeric(10))
        .requestedAttributes(ImmutableAttributeMap.builder()    
            .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_PERSONALIDENTIFIER).first())
            .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTGIVENNAME).first())
            .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_CURRENTFAMILYNAME).first())
            .put(attrRegistry.getCoreAttributeRegistry().getByFriendlyName(EidasConstants.eIDAS_ATTR_DATEOFBIRTH).first())
            .build()
         );
  }
  
  @SneakyThrows
  private IAuthData generateDummyAuthData(Map<String, Object> attrs, String loa, String familyName, String givenName, String dateOfBirth, 
      boolean useMandates) {
    attrs.put(PvpAttributeDefinitions.BIRTHDATE_NAME, dateOfBirth);
    attrs.put(PvpAttributeDefinitions.GIVEN_NAME_NAME, givenName);
    attrs.put(PvpAttributeDefinitions.PRINCIPAL_NAME_NAME, familyName);
            
    EidAuthenticationData dummyIdaData = new EidAuthenticationData();      
    dummyIdaData.setUseMandate(useMandates); 
    dummyIdaData.setEidasLoa(loa);
    dummyIdaData.setGivenName(givenName);    
    dummyIdaData.setFamilyName(familyName);
    dummyIdaData.setDateOfBirth(dateOfBirth);   
    attrs.entrySet().forEach(el -> {
      try {
        dummyIdaData.setGenericData(el.getKey(), el.getValue());
   
      } catch (EaafStorageException e) {
        e.printStackTrace();
        
      }
    });
    
    return dummyIdaData;
    
  }
}