Code development platform for open source projects from the European Union institutions :large_blue_circle: EU Login authentication by SMS will be completely phased out by mid-2025. To see alternatives please check here

Skip to content
Snippets Groups Projects
Commit 81e1e9ed authored by Joze RIHTARSIC's avatar Joze RIHTARSIC
Browse files

Cleaning the code

parent fdf70bec
No related branches found
No related tags found
No related merge requests found
Pipeline #72607 passed with warnings
Stage: build-maven
Stage: security-scanning
Stage: build-docker
Stage: test-backend
Stage: visualization
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 54 additions and 1799 deletions
smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupSearchService.java → smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIResourceSearchService.java
+ 2
− 2
View file @ 81e1e9ed
......@@ -21,8 +21,8 @@ import java.util.ArrayList;
import java.util.List;
@Service
public class UIServiceGroupSearchService extends UIServiceBase<DBResource, ServiceGroupSearchRO> {
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(UIServiceGroupSearchService.class);
public class UIResourceSearchService extends UIServiceBase<DBResource, ServiceGroupSearchRO> {
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(UIResourceSearchService.class);
@Autowired
DomainDao domainDao;
......
smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataService.java deleted 100644 → 0
+ 0
− 226
View file @ fdf70bec
package eu.europa.ec.edelivery.smp.services.ui;
import eu.europa.ec.edelivery.smp.conversion.IdentifierService;
import eu.europa.ec.edelivery.smp.data.dao.BaseDao;
import eu.europa.ec.edelivery.smp.data.dao.DomainDao;
import eu.europa.ec.edelivery.smp.data.dao.SubresourceDao;
import eu.europa.ec.edelivery.smp.data.dao.UserDao;
import eu.europa.ec.edelivery.smp.data.model.doc.DBSubresource;
import eu.europa.ec.edelivery.smp.data.ui.ServiceMetadataRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceMetadataValidationRO;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.io.UnsupportedEncodingException;
import java.nio.charset.IllegalCharsetNameException;
import java.security.cert.CertificateException;
/**
* Services for managing the Service metadata
*/
@Service
public class UIServiceMetadataService extends UIServiceBase<DBSubresource, ServiceMetadataRO> {
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(UIServiceMetadataService.class);
protected final DomainDao domainDao;
protected final SubresourceDao serviceMetadataDao;
protected final UserDao userDao;
protected final IdentifierService caseSensitivityNormalizer;
protected final ConfigurationService configurationService;
public UIServiceMetadataService(DomainDao domainDao,
SubresourceDao serviceMetadataDao,
UserDao userDao,
IdentifierService caseSensitivityNormalizer,
ConfigurationService configurationService) {
this.domainDao = domainDao;
this.serviceMetadataDao = serviceMetadataDao;
this.userDao = userDao;
this.caseSensitivityNormalizer = caseSensitivityNormalizer;
this.configurationService = configurationService;
}
@Override
protected BaseDao<DBSubresource> getDatabaseDao() {
return serviceMetadataDao;
}
@Transactional
public ServiceMetadataRO getServiceMetadataXMLById(Long serviceMetadataId) {
LOG.debug("Get service metadata: {}", serviceMetadataId);
DBSubresource dbSubresource = serviceMetadataDao.find(serviceMetadataId);
ServiceMetadataRO serviceMetadataRO = new ServiceMetadataRO();
serviceMetadataRO.setId(dbSubresource.getId());
serviceMetadataRO.setDocumentIdentifier(dbSubresource.getIdentifierValue());
serviceMetadataRO.setDocumentIdentifierScheme(dbSubresource.getIdentifierScheme());
return serviceMetadataRO;
}
private String getConvertServiceMetadataToString(Long id, byte[] extension) {
try {
return new String(extension, "UTF-8");
} catch (UnsupportedEncodingException e) {
LOG.error("Can not convert ServiceMetadata bytearray to 'UTF-8'", e);
throw new IllegalCharsetNameException("UTF-8");
}
}
/**
* Check if service metadata parsers and if data match servicemetadata and service group...
*
* @param serviceMetadataRO
* @return
*/
public ServiceMetadataValidationRO validateServiceMetadata(ServiceMetadataValidationRO serviceMetadataRO) {
/* byte[] buff;
if (serviceMetadataRO == null) {
throw new SMPRuntimeException(INVALID_REQUEST, "Validate service metadata", "Missing servicemetadata parameter");
} else if (StringUtils.isBlank(serviceMetadataRO.getXmlContent())) {
serviceMetadataRO.setErrorMessage("Service metadata xml must not be empty");
} else {
// validate xml - first byte-array is expected to be in utf8 format
// convert to utf-8 byte array
try {
buff = serviceMetadataRO.getXmlContent().getBytes("UTF-8");
serviceMetadataRO.setXmlContent(""); // no need to return back schema
} catch (UnsupportedEncodingException e) {
serviceMetadataRO.setErrorMessage(ExceptionUtils.getRootCauseMessage(e));
serviceMetadataRO.setXmlContent(""); // no need to return back schema
return serviceMetadataRO;
}
Identifier headerDI = caseSensitivityNormalizer.normalizeDocument(
serviceMetadataRO.getDocumentIdentifierScheme(),
serviceMetadataRO.getDocumentIdentifier());
Identifier headerPI = caseSensitivityNormalizer.normalizeParticipant(
serviceMetadataRO.getParticipantScheme(),
serviceMetadataRO.getParticipantIdentifier());
// validate by schema
try {
BdxSmpOasisValidator.validateXSD(buff);
} catch (XmlInvalidAgainstSchemaException e) {
serviceMetadataRO.setErrorMessage(ExceptionUtils.getRootCauseMessage(e));
return serviceMetadataRO;
}
*/
/* TODO
// validate data
ServiceMetadata smd = ServiceMetadataConverter.unmarshal(buff);
if (smd.getRedirect() != null) {
if (StringUtils.isBlank(smd.getRedirect().getHref())) {
serviceMetadataRO.setErrorMessage("Redirect URL must must be empty!");
return serviceMetadataRO;
}
}
if (smd.getServiceInformation() != null) {
Identifier xmlDI = caseSensitivityNormalizer.normalizeDocument(smd.getServiceInformation().getDocumentIdentifier());
ParticipantIdentifierType xmlPI = caseSensitivityNormalizer.normalizeParticipant(smd.getServiceInformation().getParticipantIdentifier());
if (!xmlDI.equals(headerDI)) {
serviceMetadataRO.setErrorMessage("Document identifier and scheme do not match!");
return serviceMetadataRO;
}
if (!xmlPI.equals(headerPI)) {
serviceMetadataRO.setErrorMessage("Participant identifier and scheme do not match!");
return serviceMetadataRO;
}
}
if (serviceMetadataRO.getStatusAction() == EntityROStatus.NEW.getStatusNumber()) {
// check if service metadata already exists
Optional<DBSubresource> exists = serviceMetadataDao.findServiceMetadata(headerPI.getValue(), headerPI.getScheme(),
headerDI.getValue(), headerDI.getScheme());
if (exists.isPresent()) {
serviceMetadataRO.setErrorMessage("Document identifier and scheme already exist in database!");
return serviceMetadataRO;
}
}
try {
validateServiceMetadataCertificates(smd);
} catch (CertificateException e) {
serviceMetadataRO.setErrorMessage(ExceptionUtils.getRootCauseMessage(e));
return serviceMetadataRO;
}
}
*/
//return serviceMetadataRO;
return null;
}
/**
* Method validates certificates in all endpoints.
*
* @param smd ServiceMetadata document
* @throws CertificateException exception if certificate is not valid or the allowed key type
public void validateServiceMetadataCertificates(ServiceMetadata smd) throws CertificateException {
List<EndpointType> endpointTypeList = searchAllEndpoints(smd);
for (EndpointType endpointType : endpointTypeList) {
validateCertificate(endpointType.getCertificate());
}
}
*/
/**
* Method returns all EndpointTypes
*
* @param smd
* @return public List<EndpointType> searchAllEndpoints(ServiceMetadata smd) {
List<ProcessType> processTypeList = smd.getServiceInformation() != null ?
smd.getServiceInformation().getProcessList().getProcesses() : Collections.emptyList();
List<EndpointType> endpointTypeList = new ArrayList<>();
processTypeList.stream().forEach(processType -> endpointTypeList.addAll(processType.getServiceEndpointList() != null ?
processType.getServiceEndpointList().getEndpoints() : Collections.emptyList()));
return endpointTypeList;
}
*/
/**
* Validate the certificate
*
* @param crtData x509 encoded byte array
* @throws CertificateException
public void validateCertificate(byte[] crtData) throws CertificateException {
if (crtData == null || crtData.length == 0) {
LOG.debug("Skip certificate validation: Empty certificate.");
return;
}
X509Certificate cert = X509CertificateUtils.getX509Certificate(crtData);
// validate is certificate is valid
cert.checkValidity();
// validate if certificate has the right key algorithm
PublicKey key = cert.getPublicKey();
List<String> allowedKeyAlgs = configurationService.getAllowedDocumentCertificateTypes();
if (allowedKeyAlgs == null || allowedKeyAlgs.isEmpty()) {
LOG.debug("Ignore the service metadata certificate key type validation (Empty property: [{}]).", DOCUMENT_RESTRICTION_CERT_TYPES.getProperty());
return;
}
if (StringUtils.equalsAnyIgnoreCase(key.getAlgorithm(), allowedKeyAlgs.toArray(new String[]{}))) {
LOG.debug("Certificate has valid key algorithm [{}]. Allowed algorithms: [{}] .", key.getAlgorithm(), allowedKeyAlgs);
return;
}
LOG.debug("Certificate has invalid key algorithm [{}]. Allowed algorithms: [{}] .", key.getAlgorithm(), allowedKeyAlgs);
throw new CertificateException("Certificate does not have allowed key type!");
} */
}
smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIResourceSearchServiceTest.java 0 → 100644
+ 49
− 0
View file @ 81e1e9ed
package eu.europa.ec.edelivery.smp.services.ui;
import eu.europa.ec.edelivery.smp.config.ConversionTestConfig;
import eu.europa.ec.edelivery.smp.data.ui.ServiceGroupSearchRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceResult;
import eu.europa.ec.edelivery.smp.services.AbstractServiceIntegrationTest;
import eu.europa.ec.edelivery.smp.services.ui.filters.ResourceFilter;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
@ContextConfiguration(classes = {UIResourceSearchService.class, ConversionTestConfig.class})
public class UIResourceSearchServiceTest extends AbstractServiceIntegrationTest {
@Autowired
protected UIResourceSearchService testInstance;
@Before
public void prepareDatabase() {
// setup initial data!
testUtilsDao.clearData();
testUtilsDao.createSubresources();
}
@Test
public void testGetTableList() {
ResourceFilter filter = new ResourceFilter();
ServiceResult<ServiceGroupSearchRO> result = testInstance.getTableList(-1, -1, null, null, filter);
assertNotNull(result);
assertEquals(2, result.getCount().intValue());
}
@Test
public void testGetTableListWithFilter() {
ResourceFilter filter = new ResourceFilter();
filter.setIdentifierValueLike(testUtilsDao.getResourceD1G1RD1().getIdentifierValue());
ServiceResult<ServiceGroupSearchRO> result = testInstance.getTableList(-1, -1, null, null, filter);
assertNotNull(result);
assertEquals(1, result.getCount().intValue());
}
}
smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupSearchServiceTest.java deleted 100644 → 0
+ 0
− 101
View file @ fdf70bec
package eu.europa.ec.edelivery.smp.services.ui;
import eu.europa.ec.edelivery.smp.data.model.doc.DBResource;
import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
import eu.europa.ec.edelivery.smp.data.ui.ServiceGroupSearchRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceResult;
import eu.europa.ec.edelivery.smp.services.AbstractServiceIntegrationTest;
import eu.europa.ec.edelivery.smp.testutil.TestConstants;
import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
@ContextConfiguration(classes = {UIServiceGroupSearchService.class, UIServiceMetadataService.class})
@Ignore
public class UIServiceGroupSearchServiceTest extends AbstractServiceIntegrationTest {
@Autowired
protected UIServiceGroupSearchService testInstance;
@Autowired
protected UIServiceMetadataService uiServiceMetadataService;
protected void insertDataObjectsForOwner(int size, DBUser owner) {
for (int i = 0; i < size; i++) {
insertServiceGroup(String.format("%4d", i), true, owner);
}
}
protected void insertDataObjects(int size) {
insertDataObjectsForOwner(size, null);
}
protected DBResource insertServiceGroup(String id, boolean withExtension, DBUser owner) {
DBResource d = TestDBUtils.createDBResource(String.format("0007:%s:utest", id), TestConstants.TEST_SG_SCHEMA_1, withExtension);
if (owner != null) {
// d.getUsers().add(owner);
}
serviceGroupDao.persistFlushDetach(d);
return d;
}
@Test
public void testGetTableListEmpty() {
// given
//when
ServiceResult<ServiceGroupSearchRO> res = testInstance.getTableList(-1, -1, null, null, null);
// then
assertNotNull(res);
assertEquals(0, res.getCount().intValue());
assertEquals(0, res.getPage().intValue());
assertEquals(-1, res.getPageSize().intValue());
assertEquals(0, res.getServiceEntities().size());
assertNull(res.getFilter());
}
@Test
public void testGetTableList15() {
// given
insertDataObjects(15);
//when
ServiceResult<ServiceGroupSearchRO> res = testInstance.getTableList(-1, -1, null, null, null);
// then
assertNotNull(res);
assertEquals(15, res.getCount().intValue());
assertEquals(0, res.getPage().intValue());
assertEquals(-1, res.getPageSize().intValue());
assertEquals(15, res.getServiceEntities().size());
assertNull(res.getFilter());
// all table properties should not be null
assertNotNull(res);
assertNotNull(res.getServiceEntities().get(0).getParticipantIdentifier());
assertNotNull(res.getServiceEntities().get(0).getParticipantScheme());
}
@Test
public void convertToRo() {
// given
DBResource sg = TestDBUtils.createDBResource();
// then when
ServiceGroupSearchRO sgr = testInstance.convertToRo(sg);
// then
assertEquals(sg.getId(), sgr.getId());
assertEquals(sg.getIdentifierScheme(), sgr.getParticipantScheme());
assertEquals(sg.getIdentifierValue(), sgr.getParticipantIdentifier());
}
}
smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupServiceIntegrationTest.java deleted 100644 → 0
+ 0
− 374
View file @ fdf70bec
package eu.europa.ec.edelivery.smp.services.ui;
import eu.europa.ec.edelivery.smp.data.model.doc.DBResource;
import eu.europa.ec.edelivery.smp.data.model.user.DBResourceMember;
import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
import eu.europa.ec.edelivery.smp.data.ui.ServiceGroupRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceResult;
import eu.europa.ec.edelivery.smp.services.AbstractServiceIntegrationTest;
import eu.europa.ec.edelivery.smp.testutil.TestConstants;
import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import static org.hamcrest.text.MatchesPattern.matchesPattern;
import static org.junit.Assert.*;
/**
* Purpose of class is to test ServiceGroupService base methods
*
* @author Joze Rihtarsic
* @since 4.1
*/
@Ignore
@ContextConfiguration(classes = {UIServiceGroupService.class, UIServiceMetadataService.class})
public class UIServiceGroupServiceIntegrationTest extends AbstractServiceIntegrationTest {
@Rule
public ExpectedException expectedExeption = ExpectedException.none();
@Autowired
protected UIServiceGroupService testInstance;
@Autowired
protected UIServiceMetadataService uiServiceMetadataService;
protected void insertDataObjectsForOwner(int size, DBUser owner) {
for (int i = 0; i < size; i++) {
insertServiceGroup(String.format("%4d", i), true, owner);
}
}
protected void insertDataObjects(int size) {
insertDataObjectsForOwner(size, null);
}
protected DBResource insertServiceGroup(String id, boolean withExtension, DBUser owner) {
DBResource d = TestDBUtils.createDBResource(String.format("0007:%s:utest", id), TestConstants.TEST_SG_SCHEMA_1, withExtension);
if (owner!= null) {
d.getMembers().add(new DBResourceMember(d, owner));
}
serviceGroupDao.persistFlushDetach(d);
return d;
}
@Test
public void testGetTableListEmpty() {
// given
//when
ServiceResult<ServiceGroupRO> res = testInstance.getTableList(-1, -1, null, null, null);
// then
assertNotNull(res);
assertEquals(0, res.getCount().intValue());
assertEquals(0, res.getPage().intValue());
assertEquals(-1, res.getPageSize().intValue());
assertEquals(0, res.getServiceEntities().size());
assertNull(res.getFilter());
}
/*
@Test
public void testGetTableList15() {
// given
insertDataObjects(15);
//when
ServiceResult<ServiceGroupRO> res = testInstance.getTableList(-1, -1, null, null, null);
// then
assertNotNull(res);
assertEquals(15, res.getCount().intValue());
assertEquals(0, res.getPage().intValue());
assertEquals(-1, res.getPageSize().intValue());
assertEquals(15, res.getServiceEntities().size());
assertNull(res.getFilter());
// all table properties should not be null
assertNotNull(res);
assertNotNull(res.getServiceEntities().get(0).getParticipantIdentifier());
assertNotNull(res.getServiceEntities().get(0).getParticipantScheme());
}
@Test
public void testAddServiceWithMetadata() {
// given
DBDomain testDomain01 = TestDBUtils.createDBDomain(TestConstants.TEST_DOMAIN_CODE_1);
domainDao.persistFlushDetach(testDomain01);
ServiceGroupRO sgnew = TestROUtils.createROServiceGroupForDomains(testDomain01);
// add service metadata
ServiceMetadataRO mtro = TestROUtils.createServiceMetadataDomain(testDomain01, sgnew, TestConstants.TEST_DOC_ID_1, TestConstants.TEST_DOC_SCHEMA_1);
sgnew.getServiceMetadata().add(mtro);
//when
testInstance.updateServiceGroupList(Collections.singletonList(sgnew), true);
// then
ServiceResult<ServiceGroupRO> res = testInstance.getTableList(-1, -1, null, null, null);
assertNotNull(res);
assertEquals(1, res.getCount().intValue());
ServiceGroupRO sgAdded = res.getServiceEntities().get(0);
ServiceGroupValidationRO sgExt = testInstance.getServiceGroupExtensionById(sgAdded.getId());
// all table properties should not be null
assertNotNull(sgAdded);
assertEquals(sgnew.getParticipantIdentifier(), sgAdded.getParticipantIdentifier());
assertEquals(sgnew.getParticipantScheme(), sgAdded.getParticipantScheme());
assertNull(sgAdded.getExtension()); // with list extension must be empty - extension is retrived by some other call
assertEquals(sgnew.getExtension(), sgExt.getExtension());
assertEquals(1, sgAdded.getServiceGroupDomains().size());
assertEquals(1, sgAdded.getServiceMetadata().size());
}
@Test
public void testUpdateServiceGroupExtensionAndServiceMetadaXML() {
// given
DBDomain testDomain01 = TestDBUtils.createDBDomain(TestConstants.TEST_DOMAIN_CODE_1);
domainDao.persistFlushDetach(testDomain01);
DBResource dbServiceGroup = TestDBUtils.createDBServiceGroup();
dbServiceGroup.addDomain(testDomain01);
DBSubresource DBSubresource = TestDBUtils.createDBSubresource(dbServiceGroup.getIdentifierValue(), dbServiceGroup.getIdentifierScheme());
dbServiceGroup.getResourceDomains().get(0).addServiceMetadata(DBSubresource);
serviceGroupDao.persistFlushDetach(dbServiceGroup);
String newMetadataXML = TestROUtils.generateServiceMetadata(dbServiceGroup.getIdentifierValue(), dbServiceGroup.getIdentifierScheme(),
DBSubresource.getDocumentIdentifier(), DBSubresource.getDocumentIdentifierScheme());
String newExtension = TestROUtils.generateExtension();
ServiceResult<ServiceGroupRO> res = testInstance.getTableList(-1, -1, null, null, null);
assertEquals(1, res.getCount().intValue());
ServiceGroupRO sgChange = res.getServiceEntities().get(0);
ServiceMetadataRO smdXML = uiServiceMetadataService.getServiceMetadataXMLById(res.getServiceEntities().get(0).getServiceMetadata().get(0).getId());
// test new extension
assertNotEquals(newExtension, sgChange.getExtension());
assertNotEquals(newMetadataXML, smdXML.getXmlContent());
// set new extension
sgChange.setStatus(EntityROStatus.UPDATED.getStatusNumber());
sgChange.setExtension(newExtension);
sgChange.setExtensionStatus(EntityROStatus.UPDATED.getStatusNumber());
// set new XMLContent
sgChange.getServiceMetadata().get(0).setStatus(EntityROStatus.UPDATED.getStatusNumber());
sgChange.getServiceMetadata().get(0).setXmlContentStatus(EntityROStatus.UPDATED.getStatusNumber());
sgChange.getServiceMetadata().get(0).setXmlContent(newMetadataXML);
//when
testInstance.updateServiceGroupList(Collections.singletonList(sgChange), true);
// then
res = testInstance.getTableList(-1, -1, null, null, null);
assertNotNull(res);
assertEquals(1, res.getCount().intValue());
ServiceGroupRO sgUpdated = res.getServiceEntities().get(0);
ServiceGroupValidationRO sgExt = testInstance.getServiceGroupExtensionById(sgUpdated.getId());
assertEquals(1, sgChange.getServiceMetadata().size());
// retrive service metadata xml with special service - it is not retrieve by browsing list
ServiceMetadataRO smdXMLNew = uiServiceMetadataService.getServiceMetadataXMLById(sgUpdated.getServiceMetadata().get(0).getId());
// all table properties should not be null
assertNotNull(sgUpdated);
assertEquals(sgUpdated.getParticipantIdentifier(), sgUpdated.getParticipantIdentifier());
assertEquals(sgUpdated.getParticipantScheme(), sgUpdated.getParticipantScheme());
assertEquals(newExtension, sgExt.getExtension());
assertEquals(1, sgChange.getServiceGroupDomains().size());
assertNotNull(smdXMLNew.getXmlContent());
assertEquals(newMetadataXML, smdXMLNew.getXmlContent());
}
@Test
public void testUpdateServiceMatadataChangeDomain() {
// given
DBDomain testDomain01 = TestDBUtils.createDBDomain(TestConstants.TEST_DOMAIN_CODE_1);
domainDao.persistFlushDetach(testDomain01);
DBDomain testDomain02 = TestDBUtils.createDBDomain(TestConstants.TEST_DOMAIN_CODE_2);
domainDao.persistFlushDetach(testDomain02);
DBResource dbServiceGroup = TestDBUtils.createDBServiceGroup();
dbServiceGroup.addDomain(testDomain01);
DBSubresource DBSubresource = TestDBUtils.createDBSubresource(dbServiceGroup.getIdentifierValue(), dbServiceGroup.getIdentifierScheme());
dbServiceGroup.getResourceDomains().get(0).addServiceMetadata(DBSubresource);
// add second domain
dbServiceGroup.addDomain(testDomain02);
serviceGroupDao.persistFlushDetach(dbServiceGroup);
ServiceResult<ServiceGroupRO> res = testInstance.getTableList(-1, -1, null, null, null);
assertNotNull(res);
assertEquals(1, res.getCount().intValue());
ServiceGroupRO sgChanged = res.getServiceEntities().get(0);
ServiceMetadataRO smdToChange = sgChanged.getServiceMetadata().get(0);
assertEquals(testDomain01.getDomainCode(), smdToChange.getDomainCode());
assertEquals(testDomain01.getSmlSubdomain(), smdToChange.getSmlSubdomain());
// then
sgChanged.setStatus(EntityROStatus.UPDATED.getStatusNumber());
smdToChange.setStatus(EntityROStatus.UPDATED.getStatusNumber());
smdToChange.setDomainCode(testDomain02.getDomainCode());
smdToChange.setSmlSubdomain(testDomain02.getSmlSubdomain());
testInstance.updateServiceGroupList(Collections.singletonList(sgChanged), true);
res = testInstance.getTableList(-1, -1, null, null, null);
ServiceGroupRO sgUpdated = res.getServiceEntities().get(0);
ServiceMetadataRO smdUpdated = sgUpdated.getServiceMetadata().get(0);
assertEquals(testDomain02.getDomainCode(), smdUpdated.getDomainCode());
assertEquals(testDomain02.getSmlSubdomain(), smdUpdated.getSmlSubdomain());
}
@Test
public void testUpdateServiceMatadataChangeDomainReverseOrder() {
// given
DBDomain testDomain01 = TestDBUtils.createDBDomain(TestConstants.TEST_DOMAIN_CODE_1);
DBDomain testDomain02 = TestDBUtils.createDBDomain(TestConstants.TEST_DOMAIN_CODE_2);
domainDao.persistFlushDetach(testDomain02);
domainDao.persistFlushDetach(testDomain01);
DBResource dbServiceGroup = TestDBUtils.createDBServiceGroup();
dbServiceGroup.addDomain(testDomain02);
dbServiceGroup.addDomain(testDomain01);
DBSubresource DBSubresource = TestDBUtils.createDBSubresource(dbServiceGroup.getIdentifierValue(), dbServiceGroup.getIdentifierScheme());
dbServiceGroup.getResourceDomains().get(1 ).addServiceMetadata(DBSubresource);
// add second domain
serviceGroupDao.persistFlushDetach(dbServiceGroup);
ServiceResult<ServiceGroupRO> res = testInstance.getTableList(-1, -1, null, null, null);
assertNotNull(res);
assertEquals(1, res.getCount().intValue());
ServiceGroupRO sgChanged = res.getServiceEntities().get(0);
ServiceMetadataRO smdToChange = sgChanged.getServiceMetadata().get(0);
assertEquals(testDomain01.getDomainCode(), smdToChange.getDomainCode());
assertEquals(testDomain01.getSmlSubdomain(), smdToChange.getSmlSubdomain());
// then
sgChanged.setStatus(EntityROStatus.UPDATED.getStatusNumber());
smdToChange.setStatus(EntityROStatus.UPDATED.getStatusNumber());
smdToChange.setDomainCode(testDomain02.getDomainCode());
smdToChange.setSmlSubdomain(testDomain02.getSmlSubdomain());
testInstance.updateServiceGroupList(Collections.singletonList(sgChanged), true);
res = testInstance.getTableList(-1, -1, null, null, null);
ServiceGroupRO sgUpdated = res.getServiceEntities().get(0);
ServiceMetadataRO smdUpdated = sgUpdated.getServiceMetadata().get(0);
assertEquals(testDomain02.getDomainCode(), smdUpdated.getDomainCode());
assertEquals(testDomain02.getSmlSubdomain(), smdUpdated.getSmlSubdomain());
}
@Test
public void validateExtensionValid() throws IOException {
// given
ServiceGroupValidationRO sg = TestROUtils.getValidExtension();
// when
testInstance.validateServiceGroup(sg);
// then
assertNull(sg.getErrorMessage());
assertNotNull(sg.getExtension());
}
@Test
public void validateExtensionMultipleValid() throws IOException {
// given
ServiceGroupValidationRO sg = TestROUtils.getValidMultipleExtension();
// when
testInstance.validateServiceGroup(sg);
// then
assertNull(sg.getErrorMessage());
assertNotNull(sg.getExtension());
}
@Test
public void validateExtensionCustomTextInvalid() throws IOException {
// given
ServiceGroupValidationRO sg = TestROUtils.getValidCustomText();
// when
testInstance.validateServiceGroup(sg);
// then
assertNotNull(sg.getErrorMessage());
assertThat(sg.getErrorMessage(), containsString("Element 'ServiceGroup' cannot have character "));
assertNotNull(sg.getExtension());
}
@Test
public void validateExtensionInvalid() throws IOException {
ServiceGroupValidationRO sg = TestROUtils.getInvalid();
// when
testInstance.validateServiceGroup(sg);
// then
assertNotNull(sg.getErrorMessage());
assertThat(sg.getErrorMessage(), matchesPattern(".*cvc-complex-type.2.4.a: Invalid content was found starting with element \\'\\{?(\"http://docs.oasis-open.org/bdxr/ns/SMP/2016/05\")?:?ExtensionID\\}?\\'.*"));
assertNotNull(sg.getExtension());
}
@Test
public void validateCustomExtension() throws IOException {
ServiceGroupValidationRO sg = TestROUtils.getCustomExtension();
// when
testInstance.validateServiceGroup(sg);
// then
assertNull(sg.getErrorMessage());
assertNotNull(sg.getExtension());
}
@Test
public void getEmptyExtensionById() throws IOException {
DBResource sg = insertServiceGroup("testExt", false, null);
assertNotNull(sg);
assertNotNull(sg.getId());
assertNull(sg.getExtension());
// when
ServiceGroupValidationRO res = testInstance.getServiceGroupExtensionById(sg.getId());
// then
assertNotNull(res);
assertNull(res.getExtension());
}
@Test
public void getExtensionById() throws IOException {
DBResource sg = insertServiceGroup("testExt", true, null);
assertNotNull(sg);
assertNotNull(sg.getId());
assertNotNull(sg.getExtension());
// when
ServiceGroupValidationRO res = testInstance.getServiceGroupExtensionById(sg.getId());
// then
assertNotNull(res);
assertNotNull(res.getExtension());
}
*/
}
smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceGroupServiceUpdateListIntegrationTest.java deleted 100644 → 0
+ 0
− 208
View file @ fdf70bec
package eu.europa.ec.edelivery.smp.services.ui;
import eu.europa.ec.edelivery.smp.config.SmlIntegrationConfiguration;
import eu.europa.ec.edelivery.smp.data.model.DBDomain;
import eu.europa.ec.edelivery.smp.data.model.doc.DBResource;
import eu.europa.ec.edelivery.smp.data.model.user.DBUser;
import eu.europa.ec.edelivery.smp.data.ui.ParticipantSMLRecord;
import eu.europa.ec.edelivery.smp.data.ui.ServiceGroupRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceResult;
import eu.europa.ec.edelivery.smp.data.ui.enums.SMLStatusEnum;
import eu.europa.ec.edelivery.smp.config.enums.SMPPropertyEnum;
import eu.europa.ec.edelivery.smp.services.AbstractServiceIntegrationTest;
import eu.europa.ec.edelivery.smp.testutil.TestConstants;
import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
import eu.europa.ec.edelivery.smp.testutil.TestROUtils;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.transaction.annotation.Transactional;
import java.io.IOException;
import java.util.List;
import java.util.UUID;
import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
/**
* Purpose of class is to test ServiceGroupService base methods
*
* @author Joze Rihtarsic
* @since 4.1
*/
@Ignore
@ContextConfiguration(classes = {UIServiceGroupService.class, UIServiceMetadataService.class,
SmlIntegrationConfiguration.class})
public class UIServiceGroupServiceUpdateListIntegrationTest extends AbstractServiceIntegrationTest {
@Rule
public ExpectedException expectedException = ExpectedException.none();
@Autowired
UIServiceGroupService testInstance;
@Autowired
UIServiceMetadataService uiServiceMetadataService;
@Autowired
SmlIntegrationConfiguration integrationMock;
@Before
public void setup() throws IOException {
resetKeystore();
setDatabaseProperty(SMPPropertyEnum.SML_PHYSICAL_ADDRESS, "0.0.0.0");
setDatabaseProperty(SMPPropertyEnum.SML_LOGICAL_ADDRESS, "http://localhost/smp");
setDatabaseProperty(SMPPropertyEnum.SML_URL, "http://localhost/edelivery-sml");
setDatabaseProperty(SMPPropertyEnum.SML_ENABLED, "true");
prepareDatabaseForMultipeDomainEnv();
integrationMock.reset();
}
protected void insertDataObjectsForOwner(int size, DBUser owner) {
for (int i = 0; i < size; i++) {
insertServiceGroup(String.format("%4d", i), true, owner);
}
}
protected void insertDataObjects(int size) {
insertDataObjectsForOwner(size, null);
}
protected DBResource insertServiceGroup(String id, boolean withExtension, DBUser owner) {
DBResource d = TestDBUtils.createDBResource(String.format("0007:%s:utest", id), TestConstants.TEST_SG_SCHEMA_1, withExtension);
if (owner != null) {
// d.getUsers().add(owner);
}
serviceGroupDao.persistFlushDetach(d);
return d;
}
/*
@Test
public void addNewServiceGroupTestSMLRecords() {
// given
DBDomain dbDomain1 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
DBDomain dbDomain2 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_2).get();
ServiceGroupRO serviceGroupRO = TestROUtils.createROServiceGroupForDomains(UUID.randomUUID().toString(), TEST_SG_SCHEMA_1,
dbDomain1, dbDomain2);
// When
List<ParticipantSMLRecord> lst = testInstance.addNewServiceGroup(serviceGroupRO);
// then
assertEquals(2, lst.size());
assertEquals(SMLStatusEnum.REGISTER, lst.get(0).getStatus());
assertEquals(SMLStatusEnum.REGISTER, lst.get(1).getStatus());
assertEquals(dbDomain1, lst.get(0).getDomain());
assertEquals(dbDomain2, lst.get(1).getDomain());
assertEquals(lst.get(0).getParticipantIdentifier(), lst.get(1).getParticipantIdentifier());
assertEquals(serviceGroupRO.getParticipantIdentifier(), lst.get(0).getParticipantIdentifier());
assertEquals(serviceGroupRO.getParticipantScheme(), lst.get(0).getParticipantScheme());
}
@Test
@Transactional
public void updateServiceGroupTestSMLRecordsRemoveDomain() {
// given
DBDomain dbDomain1 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
DBDomain dbDomain2 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_2).get();
DBResource dbServiceGroup = TestDBUtils.createDBServiceGroupRandom();
dbServiceGroup.addDomain(dbDomain1);
dbServiceGroup.addDomain(dbDomain2);
serviceGroupDao.persistFlushDetach(dbServiceGroup);
ServiceGroupRO roToUpdate = testInstance.getServiceGroupById(dbServiceGroup.getId());
// when
ServiceGroupDomainRO dro = roToUpdate.getServiceGroupDomains().remove(0);
List<ParticipantSMLRecord> lst = testInstance.updateServiceGroup(roToUpdate, true);
// then
assertEquals(1, lst.size());
assertEquals(SMLStatusEnum.UNREGISTER, lst.get(0).getStatus());
assertEquals(dro.getDomainCode(), lst.get(0).getDomain().getDomainCode());
assertEquals(roToUpdate.getParticipantIdentifier(), lst.get(0).getParticipantIdentifier());
assertEquals(roToUpdate.getParticipantScheme(), lst.get(0).getParticipantScheme());
}
@Test
@Transactional
public void updateServiceGroupTestSMLRecordsAddDomain() {
// given
DBDomain dbDomain1 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
DBDomain dbDomain2 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_2).get();
DBResource dbServiceGroup = TestDBUtils.createDBServiceGroupRandom();
dbServiceGroup.addDomain(dbDomain1);
serviceGroupDao.persistFlushDetach(dbServiceGroup);
ServiceGroupRO roToUpdate = testInstance.getServiceGroupById(dbServiceGroup.getId());
// when
ServiceGroupDomainRO sgr = new ServiceGroupDomainRO();
sgr.setDomainCode(dbDomain2.getDomainCode());
sgr.setSmlSubdomain(dbDomain2.getSmlSubdomain());
sgr.setDomainId(dbDomain2.getId());
roToUpdate.getServiceGroupDomains().add(sgr);
List<ParticipantSMLRecord> lst = testInstance.updateServiceGroup(roToUpdate, true);
// then
assertEquals(1, lst.size());
assertEquals(SMLStatusEnum.REGISTER, lst.get(0).getStatus());
assertEquals(sgr.getDomainCode(), lst.get(0).getDomain().getDomainCode());
assertEquals(roToUpdate.getParticipantIdentifier(), lst.get(0).getParticipantIdentifier());
}
*/
/*
@Test
@Transactional
public void updateListSMLRecordsAddDomain() {
// given
DBDomain dbDomain1 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_1).get();
DBDomain dbDomain2 = domainDao.getDomainByCode(TEST_DOMAIN_CODE_2).get();
DBResource dbServiceGroup1 = TestDBUtils.createDBServiceGroupRandom();
DBResource dbServiceGroup2 = TestDBUtils.createDBServiceGroupRandom();
dbServiceGroup1.addDomain(dbDomain1);
dbServiceGroup2.addDomain(dbDomain1);
serviceGroupDao.persistFlushDetach(dbServiceGroup1);
serviceGroupDao.persistFlushDetach(dbServiceGroup2);
ServiceGroupRO serviceGroupROAdd = TestROUtils.createROServiceGroupForDomains(UUID.randomUUID().toString(), UUID.randomUUID().toString(),
dbDomain1, dbDomain2);
ServiceGroupRO serviceGroupROUpdate = testInstance.getServiceGroupById(dbServiceGroup1.getId());
ServiceGroupRO serviceGroupRORemove = testInstance.getServiceGroupById(dbServiceGroup2.getId());
serviceGroupROAdd.setStatus(EntityROStatus.NEW.getStatusNumber());
serviceGroupRORemove.setStatus(EntityROStatus.REMOVE.getStatusNumber());
serviceGroupROUpdate.setStatus(EntityROStatus.UPDATED.getStatusNumber());
serviceGroupROUpdate.getServiceGroupDomains().clear();
ServiceGroupDomainRO sgr = new ServiceGroupDomainRO();
sgr.setDomainCode(dbDomain2.getDomainCode());
sgr.setSmlSubdomain(dbDomain2.getSmlSubdomain());
sgr.setDomainId(dbDomain2.getId());
serviceGroupROUpdate.getServiceGroupDomains().add(sgr);
List<ServiceGroupRO> lstRo = Arrays.asList(serviceGroupROAdd, serviceGroupRORemove, serviceGroupROUpdate);
List<ParticipantSMLRecord> lst = testInstance.updateServiceGroupList(lstRo);
// then
assertEquals(5, lst.size());
assertEquals(SMLAction.REGISTER, lst.get(0).getStatus());
assertEquals(serviceGroupROAdd.getParticipantIdentifier(), lst.get(0).getParticipantIdentifier());
assertEquals(SMLAction.REGISTER, lst.get(1).getStatus());
assertEquals(serviceGroupROAdd.getParticipantIdentifier(), lst.get(1).getParticipantIdentifier());
assertEquals(SMLAction.UNREGISTER, lst.get(2).getStatus());
assertEquals(serviceGroupRORemove.getParticipantIdentifier(), lst.get(2).getParticipantIdentifier());
assertEquals(SMLAction.REGISTER, lst.get(3).getStatus());
assertEquals(dbDomain2.getDomainCode(), lst.get(3).getDomain().getDomainCode());
assertEquals(serviceGroupROUpdate.getParticipantIdentifier(), lst.get(3).getParticipantIdentifier());
assertEquals(SMLAction.UNREGISTER, lst.get(4).getStatus());
assertEquals(dbDomain1.getDomainCode(), lst.get(4).getDomain().getDomainCode());
assertEquals(5, integrationMock.getParticipantManagmentClientMocks().size());
}
*/
}
smp-server-library/src/test/java/eu/europa/ec/edelivery/smp/services/ui/UIServiceMetadataServiceTest.java deleted 100644 → 0
+ 0
− 219
View file @ fdf70bec
package eu.europa.ec.edelivery.smp.services.ui;
import eu.europa.ec.edelivery.smp.data.model.doc.DBSubresource;
import eu.europa.ec.edelivery.smp.data.ui.ServiceMetadataRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceMetadataValidationRO;
import eu.europa.ec.edelivery.smp.services.AbstractServiceIntegrationTest;
import eu.europa.ec.edelivery.smp.services.ConfigurationService;
import eu.europa.ec.edelivery.smp.testutil.TestDBUtils;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.transaction.annotation.Transactional;
import java.io.IOException;
import java.security.cert.CertificateException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import static eu.europa.ec.edelivery.smp.testutil.TestConstants.*;
import static org.junit.Assert.*;
@Ignore
@ContextConfiguration(classes = {UIServiceGroupSearchService.class, UIServiceMetadataService.class})
public class UIServiceMetadataServiceTest extends AbstractServiceIntegrationTest {
private static final String RES_PATH = "/examples/services/";
private static final String RES_PATH_CONV = "/examples/conversion/";
@Autowired
protected UIServiceMetadataService testInstance;
@Before
@Transactional
public void prepareDatabase() {
prepareDatabaseForSingleDomainEnv();
}
/*
@Test
public void getServiceMetadataXMLById() {
Optional<DBSubresource> smd = serviceMetadataDao.findServiceMetadata(TEST_SG_ID_1, TEST_SG_SCHEMA_1, TEST_DOC_ID_1,
TEST_DOC_SCHEMA_1);
assertTrue(smd.isPresent());
ServiceMetadataRO smdro = testInstance.getServiceMetadataXMLById(smd.get().getId());
assertNotNull(smdro);
assertNotNull(smdro.getXmlContent());
assertEquals(smd.get().getId(), smdro.getId());
}
@Test
public void validateServiceMetadataValid() {
DBSubresource md = TestDBUtils.createDBSubresource("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getIdentifierValue());
smv.setDocumentIdentifierScheme(md.getIdentifierScheme());
smv.setParticipantIdentifier("partId");
smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
assertNull(smv.getErrorMessage());
}
@Test
public void validateServiceMetadataRedirectValid() {
DBSubresource md = TestDBUtils.createDBSubresourceRedirect("docId", "docSch", "http://10.1.1.10:1027/test-service-data");
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getIdentifierValue());
smv.setDocumentIdentifierScheme(md.getIdentifierScheme());
smv.setParticipantIdentifier("partId");
smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
assertNull(smv.getErrorMessage());
}
@Test
public void validateServiceMetadataRedirectInvalid() {
DBSubresource md = TestDBUtils.createDBSubresourceRedirect("docId", "docSch", "");
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getIdentifierValue());
smv.setDocumentIdentifierScheme(md.getIdentifierScheme());
smv.setParticipantIdentifier("partId");
smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
assertNotNull(smv.getErrorMessage());
assertEquals("Redirect URL must must be empty!", smv.getErrorMessage());
}
@Test
public void validateServiceMetadataParticipantNotMatch() {
DBSubresource md = TestDBUtils.createDBSubresource("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getIdentifierValue());
smv.setDocumentIdentifierScheme(md.getIdentifierScheme());
smv.setParticipantIdentifier("partIdNotMatch");
smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
assertEquals("Participant identifier and scheme do not match!",smv.getErrorMessage());
}
@Test
public void validateServiceMetadataDocumentNotMatch() {
DBSubresource md = TestDBUtils.createDBSubresource("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getIdentifierScheme());
smv.setDocumentIdentifierScheme(md.getIdentifierValue());
smv.setParticipantIdentifier("partId");
smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()));
smv = testInstance.validateServiceMetadata(smv);
assertEquals("Document identifier and scheme do not match!",smv.getErrorMessage());
}
@Test
public void validateServiceMetadataInvalidXML() {
DBSubresource md = TestDBUtils.createDBSubresource("partId", TEST_SG_SCHEMA_1);
ServiceMetadataValidationRO smv = new ServiceMetadataValidationRO();
smv.setDocumentIdentifier(md.getIdentifierScheme());
smv.setDocumentIdentifierScheme(md.getIdentifierValue());
smv.setParticipantIdentifier("partId");
smv.setParticipantScheme(TEST_SG_SCHEMA_1);
smv.setXmlContent(new String(md.getXmlContent()) + "Something to invalidate xml");
smv = testInstance.validateServiceMetadata(smv);
assertEquals("SAXParseException: Content is not allowed in trailing section.",smv.getErrorMessage());
}
@Test
public void testSearchAllEndpoints() throws IOException {
//given
byte[] inputDoc = XmlTestUtils.loadDocumentAsByteArray(RES_PATH + "ServiceMetadataDifferentCertificatesTypes.xml");
ServiceMetadata serviceMetadata = ServiceMetadataConverter.unmarshal(inputDoc);
List<EndpointType> endpointTypeList = testInstance.searchAllEndpoints(serviceMetadata);
assertEquals(3, endpointTypeList.size());
}
@Test
public void testSearchAllEndpointsEmptyList() throws IOException {
//given
byte[] inputDoc = XmlTestUtils.loadDocumentAsByteArray(RES_PATH_CONV + "ServiceMetadataWithRedirect.xml");
ServiceMetadata serviceMetadata = ServiceMetadataConverter.unmarshal(inputDoc);
List<EndpointType> endpointTypeList = testInstance.searchAllEndpoints(serviceMetadata);
assertEquals(0, endpointTypeList.size());
}
@Test
public void testValidateServiceMetadataCertificatesEmptyOK() throws IOException, CertificateException {
//given
byte[] inputDoc = XmlTestUtils.loadDocumentAsByteArray(RES_PATH + "ServiceMetadataDifferentCertificatesTypes.xml");
ServiceMetadata serviceMetadata = ServiceMetadataConverter.unmarshal(inputDoc);
// then
testInstance.validateServiceMetadataCertificates(serviceMetadata);
// no error is expected
}
@Test
public void testValidateServiceMetadataCertificatesRSAOK() throws IOException, CertificateException {
ConfigurationService configurationService = Mockito.mock(ConfigurationService.class);
UIServiceMetadataService testInstance = new UIServiceMetadataService(null, null,
null, null,
configurationService);
Mockito.doReturn(Arrays.asList("RSA","ED25519","ED448")).when(configurationService).getAllowedDocumentCertificateTypes();
//given
byte[] inputDoc = XmlTestUtils.loadDocumentAsByteArray(RES_PATH + "ServiceMetadataDifferentCertificatesTypes.xml");
ServiceMetadata serviceMetadata = ServiceMetadataConverter.unmarshal(inputDoc);
// then
testInstance.validateServiceMetadataCertificates(serviceMetadata);
}
@Test
public void testValidateServiceMetadataCertificatesNotAllowed() throws IOException{
ConfigurationService configurationService = Mockito.mock(ConfigurationService.class);
UIServiceMetadataService testInstance = new UIServiceMetadataService(null, null,
null, null,
configurationService);
Mockito.doReturn(Collections.singletonList("testKeyAlg")).when(configurationService).getAllowedDocumentCertificateTypes();
//given
byte[] inputDoc = XmlTestUtils.loadDocumentAsByteArray(RES_PATH + "ServiceMetadataDifferentCertificatesTypes.xml");
ServiceMetadata serviceMetadata = ServiceMetadataConverter.unmarshal(inputDoc);
// then
CertificateException result = assertThrows(CertificateException.class, () -> testInstance.validateServiceMetadataCertificates(serviceMetadata));
// no error is expected
assertEquals("Certificate does not have allowed key type!", result.getMessage());
}
*/
}
smp-webapp/src/main/java/eu/europa/ec/edelivery/smp/ui/external/SearchResource.java
+ 3
− 3
View file @ 81e1e9ed
......@@ -6,7 +6,7 @@ import eu.europa.ec.edelivery.smp.data.ui.ServiceGroupSearchRO;
import eu.europa.ec.edelivery.smp.data.ui.ServiceResult;
import eu.europa.ec.edelivery.smp.logging.SMPLogger;
import eu.europa.ec.edelivery.smp.logging.SMPLoggerFactory;
import eu.europa.ec.edelivery.smp.services.ui.UIServiceGroupSearchService;
import eu.europa.ec.edelivery.smp.services.ui.UIResourceSearchService;
import eu.europa.ec.edelivery.smp.services.ui.filters.ResourceFilter;
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.MimeTypeUtils;
......@@ -29,10 +29,10 @@ public class SearchResource {
private static final SMPLogger LOG = SMPLoggerFactory.getLogger(SearchResource.class);
final UIServiceGroupSearchService uiServiceGroupService;
final UIResourceSearchService uiServiceGroupService;
final DomainDao domainDao;
public SearchResource(UIServiceGroupSearchService uiServiceGroupService, DomainDao domainDao) {
public SearchResource(UIResourceSearchService uiServiceGroupService, DomainDao domainDao) {
this.uiServiceGroupService = uiServiceGroupService;
this.domainDao = domainDao;
}
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

For further information about the platform and support, please see https://code.europa.eu/info/about