#157

pending completion

Build # #157

Build Type

Pull #125

github-actions

Committed by

web-flow

Commit Message

Merge 4f575b7a7 into 7470716c4

Pull Request Pull Request #125: 114 Unclear/non-standard response for post api/v1/pit/pid

Run Details

124 of 124 new or added lines in 11 files covered. (100.0%)

758 of 1377 relevant lines covered (55.05%)

0.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.36

/src/main/java/edu/kit/datamanager/pit/pitservice/impl/EmbeddedStrictValidatorStrategy.java

package edu.kit.datamanager.pit.pitservice.impl;

import edu.kit.datamanager.pit.common.ExternalServiceException;
import edu.kit.datamanager.pit.common.RecordValidationException;
import edu.kit.datamanager.pit.configuration.ApplicationProperties;
import edu.kit.datamanager.pit.domain.PIDRecord;
import edu.kit.datamanager.pit.domain.TypeDefinition;
import edu.kit.datamanager.pit.pitservice.IValidationStrategy;
import edu.kit.datamanager.pit.util.TypeValidationUtils;

import java.util.concurrent.ExecutionException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import com.google.common.cache.LoadingCache;

public class EmbeddedStrictValidatorStrategy implements IValidationStrategy {

    private static final Logger LOG = LoggerFactory.getLogger(EmbeddedStrictValidatorStrategy.class);

    @Autowired
    public LoadingCache<String, TypeDefinition> typeLoader;

    @Autowired
    ApplicationProperties applicationProps;

    @Override
    public void validate(PIDRecord pidRecord) throws RecordValidationException, ExternalServiceException {
        String profileKey = applicationProps.getProfileKey();
        if (!pidRecord.hasProperty(profileKey)) {
            throw new RecordValidationException(
                    pidRecord.getPid(),
                    "Profile attribute not found. Expected key: " + profileKey);
        }

        String[] profilePIDs = pidRecord.getPropertyValues(profileKey);
        boolean hasProfile = profilePIDs.length > 0;
        if (!hasProfile) {
            throw new RecordValidationException(
                    pidRecord.getPid(),
                    "Profile attribute " + profileKey + " has no values.");
        }

        for (String profilePID : profilePIDs) {
            TypeDefinition profileDefinition;
            try {
                profileDefinition = this.typeLoader.get(profilePID);
            } catch (ExecutionException e) {
                LOG.error("Could not resolve identifier {}.", profilePID);
                throw new ExternalServiceException(
                        applicationProps.getTypeRegistryUri().toString());
            }
            if (profileDefinition == null) {
                LOG.error("No type definition found for identifier {}.", profilePID);
                throw new RecordValidationException(
                        pidRecord.getPid(),
                        String.format("No type found for identifier %s.", profilePID));
            }

            LOG.debug("validating profile {}", profilePID);
            this.strictProfileValidation(pidRecord, profileDefinition);
            LOG.debug("successfully validated {}", profilePID);
        }
    }

    /**
     * Exceptions indicate failure. No Exceptions mean success.
     * 
     * @param pidRecord the PID record to validate.
     * @param profile   the profile to validate against.
     * @throws RecordValidationException with error message on validation errors.
     */
    private void strictProfileValidation(PIDRecord pidRecord, TypeDefinition profile) throws RecordValidationException {
        // if (profile.hasSchema()) {
        // TODO issue https://github.com/kit-data-manager/pit-service/issues/104
        // validate using schema and you are done (strict validation)
        // String jsonRecord = ""; // TODO format depends on schema source
        // return profile.validate(jsonRecord);
        // }

        LOG.trace("Validating PID record against type definition.");

        TypeValidationUtils.checkMandatoryAttributes(pidRecord, profile);

        for (String attributeKey : pidRecord.getPropertyIdentifiers()) {
            LOG.trace("Checking PID record key {}.", attributeKey);

            TypeDefinition type = profile.getSubTypes().get(attributeKey);
            if (type == null) {
                LOG.error("No sub-type found for key {}.", attributeKey);
                // TODO try to resolve it (for later when we support "allow additional
                // attributes")
                // if profile.allowsAdditionalAttributes() {...} else
                throw new RecordValidationException(
                        pidRecord.getPid(),
                        String.format("Attribute %s is not allowed in profile %s",
                                attributeKey,
                                profile.getIdentifier()));
            }

            validateValuesForKey(pidRecord, attributeKey, type);
        }
    }

    private void validateValuesForKey(PIDRecord pidRecord, String attributeKey, TypeDefinition type)
            throws RecordValidationException {
        String[] values = pidRecord.getPropertyValues(attributeKey);
        for (String value : values) {
            if (value == null) {
                LOG.error("'null' record value found for key {}.", attributeKey);
                throw new RecordValidationException(
                        pidRecord.getPid(),
                        String.format("Validation of value %s against type %s failed.",
                                value,
                                type.getIdentifier()));
            }

            if (!type.validate(value)) {
                LOG.error("Validation of value {} against type {} failed.", value, type.getIdentifier());
                throw new RecordValidationException(
                        pidRecord.getPid(),
                        String.format("Validation of value %s against type %s failed.",
                                value,
                                type.getIdentifier()));
            }
        }
    }
}

1	package edu.kit.datamanager.pit.pitservice.impl;
2
3	import edu.kit.datamanager.pit.common.ExternalServiceException;
4	import edu.kit.datamanager.pit.common.RecordValidationException;
5	import edu.kit.datamanager.pit.configuration.ApplicationProperties;
6	import edu.kit.datamanager.pit.domain.PIDRecord;
7	import edu.kit.datamanager.pit.domain.TypeDefinition;
8	import edu.kit.datamanager.pit.pitservice.IValidationStrategy;
9	import edu.kit.datamanager.pit.util.TypeValidationUtils;
10
11	import java.util.concurrent.ExecutionException;
12
13	import org.slf4j.Logger;
14	import org.slf4j.LoggerFactory;
15	import org.springframework.beans.factory.annotation.Autowired;
16
17	import com.google.common.cache.LoadingCache;
18
19	public class EmbeddedStrictValidatorStrategy implements IValidationStrategy {	1✔
20
21	private static final Logger LOG = LoggerFactory.getLogger(EmbeddedStrictValidatorStrategy.class);	1✔
22
23	@Autowired
24	public LoadingCache<String, TypeDefinition> typeLoader;
25
26	@Autowired
27	ApplicationProperties applicationProps;
28
29	@Override
30	public void validate(PIDRecord pidRecord) throws RecordValidationException, ExternalServiceException {
31	String profileKey = applicationProps.getProfileKey();	1✔
32	if (!pidRecord.hasProperty(profileKey)) {	1✔
33	throw new RecordValidationException(	1✔
34	pidRecord.getPid(),	1✔
35	"Profile attribute not found. Expected key: " + profileKey);
36	}
37
38	String[] profilePIDs = pidRecord.getPropertyValues(profileKey);	1✔
39	boolean hasProfile = profilePIDs.length > 0;	1✔
40	if (!hasProfile) {	1✔
41	throw new RecordValidationException(	×
42	pidRecord.getPid(),	×
43	"Profile attribute " + profileKey + " has no values.");
44	}
45
46	for (String profilePID : profilePIDs) {	1✔
47	TypeDefinition profileDefinition;
48	try {
49	profileDefinition = this.typeLoader.get(profilePID);	1✔
50	} catch (ExecutionException e) {	×
51	LOG.error("Could not resolve identifier {}.", profilePID);	×
52	throw new ExternalServiceException(	×
53	applicationProps.getTypeRegistryUri().toString());	×
54	}	1✔
55	if (profileDefinition == null) {	1✔
56	LOG.error("No type definition found for identifier {}.", profilePID);	×
57	throw new RecordValidationException(	×
58	pidRecord.getPid(),	×
59	String.format("No type found for identifier %s.", profilePID));	×
60	}
61
62	LOG.debug("validating profile {}", profilePID);	1✔
63	this.strictProfileValidation(pidRecord, profileDefinition);	1✔
64	LOG.debug("successfully validated {}", profilePID);	1✔
65	}
66	}	1✔
67
68	/**
69	* Exceptions indicate failure. No Exceptions mean success.
70	*
71	* @param pidRecord the PID record to validate.
72	* @param profile the profile to validate against.
73	* @throws RecordValidationException with error message on validation errors.
74	*/
75	private void strictProfileValidation(PIDRecord pidRecord, TypeDefinition profile) throws RecordValidationException {
76	// if (profile.hasSchema()) {
77	// TODO issue https://github.com/kit-data-manager/pit-service/issues/104
78	// validate using schema and you are done (strict validation)
79	// String jsonRecord = ""; // TODO format depends on schema source
80	// return profile.validate(jsonRecord);
81	// }
82
83	LOG.trace("Validating PID record against type definition.");	1✔
84
85	TypeValidationUtils.checkMandatoryAttributes(pidRecord, profile);	1✔
86
87	for (String attributeKey : pidRecord.getPropertyIdentifiers()) {	1✔
88	LOG.trace("Checking PID record key {}.", attributeKey);	1✔
89
90	TypeDefinition type = profile.getSubTypes().get(attributeKey);	1✔
91	if (type == null) {	1✔
92	LOG.error("No sub-type found for key {}.", attributeKey);	×
93	// TODO try to resolve it (for later when we support "allow additional
94	// attributes")
95	// if profile.allowsAdditionalAttributes() {...} else
96	throw new RecordValidationException(	×
97	pidRecord.getPid(),	×
98	String.format("Attribute %s is not allowed in profile %s",	×
99	attributeKey,
100	profile.getIdentifier()));	×
101	}
102
103	validateValuesForKey(pidRecord, attributeKey, type);	1✔
104	}	1✔
105	}	1✔
106
107	private void validateValuesForKey(PIDRecord pidRecord, String attributeKey, TypeDefinition type)
108	throws RecordValidationException {
109	String[] values = pidRecord.getPropertyValues(attributeKey);	1✔
110	for (String value : values) {	1✔
111	if (value == null) {	1✔
112	LOG.error("'null' record value found for key {}.", attributeKey);	×
113	throw new RecordValidationException(	×
114	pidRecord.getPid(),	×
115	String.format("Validation of value %s against type %s failed.",	×
116	value,
117	type.getIdentifier()));	×
118	}
119
120	if (!type.validate(value)) {	1✔
121	LOG.error("Validation of value {} against type {} failed.", value, type.getIdentifier());	×
122	throw new RecordValidationException(	×
123	pidRecord.getPid(),	×
124	String.format("Validation of value %s against type %s failed.",	×
125	value,
126	type.getIdentifier()));	×
127	}
128	}
129	}	1✔
130	}

kit-data-manager / pit-service / #157

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous