17557135178

Committed 08 Sep 2025 04:12PM UTC coverage: 13.293% (+0.4%) from 12.856%

Build # 17557135178

Build Type

push

github

Committed by

ashleycaselli

Commit Message

test(NanopubElement): add unit tests

Run Details

387 of 3854 branches covered (10.04%)

Branch coverage included in aggregate %.

1053 of 6979 relevant lines covered (15.09%)

0.67 hits per line

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

36.36

src/main/java/com/knowledgepixels/nanodash/NanopubElement.java

package com.knowledgepixels.nanodash;

import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.nanopub.Nanopub;
import org.nanopub.NanopubUtils;
import org.nanopub.SimpleTimestampPattern;
import org.nanopub.extra.security.MalformedCryptoElementException;
import org.nanopub.extra.security.NanopubSignatureElement;
import org.nanopub.extra.security.SignatureUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;
import java.security.GeneralSecurityException;
import java.util.*;

/**
 * Represents a wrapper for a Nanopub object, providing additional metadata and utility methods.
 * This class includes caching mechanisms to avoid redundant Nanopub retrievals.
 */
public class NanopubElement implements Serializable {

    private static final long serialVersionUID = 1L;

    private static Map<String, NanopubElement> nanopubCache = new HashMap<>();
    private static final Logger logger = LoggerFactory.getLogger(NanopubElement.class);

    /**
     * Retrieves a NanopubElement instance for the given URI.
     * If the instance is not already cached, it creates a new one and caches it.
     *
     * @param uri The URI of the Nanopub.
     * @return The NanopubElement instance.
     */
    public static NanopubElement get(String uri) {
        if (!nanopubCache.containsKey(uri)) {
            nanopubCache.put(uri, new NanopubElement(uri));
        }
        return nanopubCache.get(uri);
    }

    /**
     * Retrieves a NanopubElement instance for the given Nanopub object.
     * If the instance is not already cached, it creates a new one and caches it.
     *
     * @param nanopub The Nanopub object.
     * @return The NanopubElement instance.
     */
    public static NanopubElement get(Nanopub nanopub) {
        if (nanopub == null) {
            throw new IllegalArgumentException("Nanopub cannot be null");
        }
        String uri = nanopub.getUri().stringValue();
        if (!nanopubCache.containsKey(uri)) {
            nanopubCache.put(uri, new NanopubElement(nanopub));
        }
        return nanopubCache.get(uri);
    }

    private Nanopub nanopub;
    private String uriString; // Keeping URI separately, as nanopub might be null when it cannot be fetched
    private String label;
    private Calendar creationTime;
    private Boolean seemsToHaveSignature;
    private Boolean hasValidSignature;
    private IRI signerId;
    private List<IRI> types;
    private Map<String, String> foafNameMap;

    /**
     * Constructs a NanopubElement for the given URI.
     * Fetches the Nanopub object using the URI.
     *
     * @param uri The URI of the Nanopub.
     * @throws IllegalArgumentException If no Nanopub is found for the given URI.
     */
    private NanopubElement(String uri) {
        this.uriString = uri;
        this.nanopub = Utils.getNanopub(uri);
        if (nanopub == null) {
            throw new IllegalArgumentException("No nanopublication found for URI: " + uri);
        }
    }

    /**
     * Constructs a NanopubElement for the given Nanopub object.
     *
     * @param nanopub The Nanopub object.
     */
    private NanopubElement(Nanopub nanopub) {
        this.uriString = nanopub.getUri().stringValue();
        this.nanopub = nanopub;
    }

    /**
     * Returns the Nanopub object.
     *
     * @return The Nanopub object.
     */
    public Nanopub getNanopub() {
        return nanopub;
    }

    /**
     * Returns the URI of the Nanopub.
     *
     * @return The URI as a string.
     */
    public String getUri() {
        return uriString;
    }

    /**
     * Returns the label of the Nanopub.
     * If the label is not already set, it retrieves it from the Nanopub.
     *
     * @return The label of the Nanopub.
     */
    public String getLabel() {
        if (label != null) return label;
        if (nanopub == null) return null;
        label = NanopubUtils.getLabel(nanopub);
        if (label == null) label = "";
        return label;
    }

    /**
     * Returns the creation time of the Nanopub.
     * If the creation time is not already set, it retrieves it using a timestamp pattern.
     *
     * @return The creation time as a Calendar object.
     */
    public Calendar getCreationTime() {
        if (nanopub == null) return null;
        if (creationTime == null) {
            creationTime = SimpleTimestampPattern.getCreationTime(nanopub);
        }
        return creationTime;
    }

    /**
     * Checks if the Nanopub seems to have a signature.
     *
     * @return True if the Nanopub seems to have a signature, false otherwise.
     */
    public boolean seemsToHaveSignature() {
        if (nanopub == null) return false;
        if (seemsToHaveSignature == null) {
            seemsToHaveSignature = SignatureUtils.seemsToHaveSignature(nanopub);
        }
        return seemsToHaveSignature;
    }

    /**
     * Returns the public key of the Nanopub's signature.
     * If the signature is not valid, returns null.
     *
     * @return The public key as a string, or null if invalid.
     */
    public String getPubkey() {
        if (!hasValidSignature()) return null;
        try {
            return SignatureUtils.getSignatureElement(nanopub).getPublicKeyString();
        } catch (MalformedCryptoElementException ex) {
            logger.error("Error in getting the signature element of the nanopub {}", uriString, ex);
            return null;
        }
    }

    /**
     * Returns the SHA-256 hash of the public key of the Nanopub's signature
     *
     * @return The SHA-256 hash of the public key as a hexadecimal string, or null if the public key is not available.
     */
    public String getPubkeyhash() {
        String pubkey = getPubkey();
        if (pubkey == null) return null;
        return Utils.createSha256HexHash(pubkey);
    }

    /**
     * Checks if the Nanopub has a valid signature.
     *
     * @return True if the Nanopub has a valid signature, false otherwise.
     */
    public boolean hasValidSignature() {
        if (nanopub == null) return false;
        if (hasValidSignature == null) {
            try {
                NanopubSignatureElement se;
                se = SignatureUtils.getSignatureElement(nanopub);
                if (se != null) {
                    hasValidSignature = SignatureUtils.hasValidSignature(se);
                    if (se.getSigners().size() == 1) signerId = se.getSigners().iterator().next();
                } else {
                    hasValidSignature = false;
                }
            } catch (MalformedCryptoElementException | GeneralSecurityException ex) {
                logger.error("Error in checking the signature of the nanopub {}", uriString, ex);
                return false;
            }
        }
        return hasValidSignature;
    }

    /**
     * Returns the ID of the signer of the Nanopub.
     * If the signature is not valid, returns null.
     *
     * @return The signer ID as an IRI, or null if invalid.
     */
    public IRI getSignerId() {
        if (nanopub == null) return null;
        if (!hasValidSignature()) return null;
        return signerId;
    }

    /**
     * Returns the list of RDF types associated with the Nanopub.
     * If the types are not already set, it retrieves them from the Nanopub's pubinfo.
     *
     * @return A list of RDF types as IRIs.
     */
    public List<IRI> getTypes() {
        if (types == null) {
            types = new ArrayList<>();
            if (nanopub == null) return types;
            for (Statement st : nanopub.getPubinfo()) {
                if (st.getSubject().equals(nanopub.getUri()) && st.getPredicate().equals(RDF.TYPE) && st.getObject() instanceof IRI) {
                    types.add((IRI) st.getObject());
                }
            }
        }
        return types;
    }

    /**
     * Returns a map of FOAF names associated with the Nanopub.
     * If the map is not already set, it retrieves it using a utility method.
     *
     * @return A map of FOAF names.
     */
    public Map<String, String> getFoafNameMap() {
        if (foafNameMap == null) foafNameMap = Utils.getFoafNameMap(nanopub);
        return foafNameMap;
    }

}

1	package com.knowledgepixels.nanodash;
2
3	import org.eclipse.rdf4j.model.IRI;
4	import org.eclipse.rdf4j.model.Statement;
5	import org.eclipse.rdf4j.model.vocabulary.RDF;
6	import org.nanopub.Nanopub;
7	import org.nanopub.NanopubUtils;
8	import org.nanopub.SimpleTimestampPattern;
9	import org.nanopub.extra.security.MalformedCryptoElementException;
10	import org.nanopub.extra.security.NanopubSignatureElement;
11	import org.nanopub.extra.security.SignatureUtils;
12	import org.slf4j.Logger;
13	import org.slf4j.LoggerFactory;
14
15	import java.io.Serializable;
16	import java.security.GeneralSecurityException;
17	import java.util.*;
18
19	/**
20	* Represents a wrapper for a Nanopub object, providing additional metadata and utility methods.
21	* This class includes caching mechanisms to avoid redundant Nanopub retrievals.
22	*/
23	public class NanopubElement implements Serializable {
24
25	private static final long serialVersionUID = 1L;
26
27	private static Map<String, NanopubElement> nanopubCache = new HashMap<>();	4✔
28	private static final Logger logger = LoggerFactory.getLogger(NanopubElement.class);	4✔
29
30	/**
31	* Retrieves a NanopubElement instance for the given URI.
32	* If the instance is not already cached, it creates a new one and caches it.
33	*
34	* @param uri The URI of the Nanopub.
35	* @return The NanopubElement instance.
36	*/
37	public static NanopubElement get(String uri) {
38	if (!nanopubCache.containsKey(uri)) {	4!
39	nanopubCache.put(uri, new NanopubElement(uri));	8✔
40	}
41	return nanopubCache.get(uri);	5✔
42	}
43
44	/**
45	* Retrieves a NanopubElement instance for the given Nanopub object.
46	* If the instance is not already cached, it creates a new one and caches it.
47	*
48	* @param nanopub The Nanopub object.
49	* @return The NanopubElement instance.
50	*/
51	public static NanopubElement get(Nanopub nanopub) {
52	if (nanopub == null) {	2✔
53	throw new IllegalArgumentException("Nanopub cannot be null");	5✔
54	}
55	String uri = nanopub.getUri().stringValue();	4✔
56	if (!nanopubCache.containsKey(uri)) {	4✔
57	nanopubCache.put(uri, new NanopubElement(nanopub));	8✔
58	}
59	return nanopubCache.get(uri);	5✔
60	}
61
62	private Nanopub nanopub;
63	private String uriString; // Keeping URI separately, as nanopub might be null when it cannot be fetched
64	private String label;
65	private Calendar creationTime;
66	private Boolean seemsToHaveSignature;
67	private Boolean hasValidSignature;
68	private IRI signerId;
69	private List<IRI> types;
70	private Map<String, String> foafNameMap;
71
72	/**
73	* Constructs a NanopubElement for the given URI.
74	* Fetches the Nanopub object using the URI.
75	*
76	* @param uri The URI of the Nanopub.
77	* @throws IllegalArgumentException If no Nanopub is found for the given URI.
78	*/
79	private NanopubElement(String uri) {	2✔
80	this.uriString = uri;	3✔
81	this.nanopub = Utils.getNanopub(uri);	4✔
82	if (nanopub == null) {	3!
83	throw new IllegalArgumentException("No nanopublication found for URI: " + uri);	×
84	}
85	}	1✔
86
87	/**
88	* Constructs a NanopubElement for the given Nanopub object.
89	*
90	* @param nanopub The Nanopub object.
91	*/
92	private NanopubElement(Nanopub nanopub) {	2✔
93	this.uriString = nanopub.getUri().stringValue();	5✔
94	this.nanopub = nanopub;	3✔
95	}	1✔
96
97	/**
98	* Returns the Nanopub object.
99	*
100	* @return The Nanopub object.
101	*/
102	public Nanopub getNanopub() {
103	return nanopub;	3✔
104	}
105
106	/**
107	* Returns the URI of the Nanopub.
108	*
109	* @return The URI as a string.
110	*/
111	public String getUri() {
112	return uriString;	3✔
113	}
114
115	/**
116	* Returns the label of the Nanopub.
117	* If the label is not already set, it retrieves it from the Nanopub.
118	*
119	* @return The label of the Nanopub.
120	*/
121	public String getLabel() {
122	if (label != null) return label;	6✔
123	if (nanopub == null) return null;	3!
124	label = NanopubUtils.getLabel(nanopub);	5✔
125	if (label == null) label = "";	3!
126	return label;	3✔
127	}
128
129	/**
130	* Returns the creation time of the Nanopub.
131	* If the creation time is not already set, it retrieves it using a timestamp pattern.
132	*
133	* @return The creation time as a Calendar object.
134	*/
135	public Calendar getCreationTime() {
136	if (nanopub == null) return null;	3!
137	if (creationTime == null) {	3✔
138	creationTime = SimpleTimestampPattern.getCreationTime(nanopub);	5✔
139	}
140	return creationTime;	3✔
141	}
142
143	/**
144	* Checks if the Nanopub seems to have a signature.
145	*
146	* @return True if the Nanopub seems to have a signature, false otherwise.
147	*/
148	public boolean seemsToHaveSignature() {
149	if (nanopub == null) return false;	×
150	if (seemsToHaveSignature == null) {	×
151	seemsToHaveSignature = SignatureUtils.seemsToHaveSignature(nanopub);	×
152	}
153	return seemsToHaveSignature;	×
154	}
155
156	/**
157	* Returns the public key of the Nanopub's signature.
158	* If the signature is not valid, returns null.
159	*
160	* @return The public key as a string, or null if invalid.
161	*/
162	public String getPubkey() {
163	if (!hasValidSignature()) return null;	×
164	try {
165	return SignatureUtils.getSignatureElement(nanopub).getPublicKeyString();	×
166	} catch (MalformedCryptoElementException ex) {	×
167	logger.error("Error in getting the signature element of the nanopub {}", uriString, ex);	×
168	return null;	×
169	}
170	}
171
172	/**
173	* Returns the SHA-256 hash of the public key of the Nanopub's signature
174	*
175	* @return The SHA-256 hash of the public key as a hexadecimal string, or null if the public key is not available.
176	*/
177	public String getPubkeyhash() {
178	String pubkey = getPubkey();	×
179	if (pubkey == null) return null;	×
180	return Utils.createSha256HexHash(pubkey);	×
181	}
182
183	/**
184	* Checks if the Nanopub has a valid signature.
185	*
186	* @return True if the Nanopub has a valid signature, false otherwise.
187	*/
188	public boolean hasValidSignature() {
189	if (nanopub == null) return false;	×
190	if (hasValidSignature == null) {	×
191	try {
192	NanopubSignatureElement se;
193	se = SignatureUtils.getSignatureElement(nanopub);	×
194	if (se != null) {	×
195	hasValidSignature = SignatureUtils.hasValidSignature(se);	×
196	if (se.getSigners().size() == 1) signerId = se.getSigners().iterator().next();	×
197	} else {
198	hasValidSignature = false;	×
199	}
200	} catch (MalformedCryptoElementException \| GeneralSecurityException ex) {	×
201	logger.error("Error in checking the signature of the nanopub {}", uriString, ex);	×
202	return false;	×
203	}	×
204	}
205	return hasValidSignature;	×
206	}
207
208	/**
209	* Returns the ID of the signer of the Nanopub.
210	* If the signature is not valid, returns null.
211	*
212	* @return The signer ID as an IRI, or null if invalid.
213	*/
214	public IRI getSignerId() {
215	if (nanopub == null) return null;	×
216	if (!hasValidSignature()) return null;	×
217	return signerId;	×
218	}
219
220	/**
221	* Returns the list of RDF types associated with the Nanopub.
222	* If the types are not already set, it retrieves them from the Nanopub's pubinfo.
223	*
224	* @return A list of RDF types as IRIs.
225	*/
226	public List<IRI> getTypes() {
227	if (types == null) {	×
228	types = new ArrayList<>();	×
229	if (nanopub == null) return types;	×
230	for (Statement st : nanopub.getPubinfo()) {	×
231	if (st.getSubject().equals(nanopub.getUri()) && st.getPredicate().equals(RDF.TYPE) && st.getObject() instanceof IRI) {	×
232	types.add((IRI) st.getObject());	×
233	}
234	}	×
235	}
236	return types;	×
237	}
238
239	/**
240	* Returns a map of FOAF names associated with the Nanopub.
241	* If the map is not already set, it retrieves it using a utility method.
242	*
243	* @return A map of FOAF names.
244	*/
245	public Map<String, String> getFoafNameMap() {
246	if (foafNameMap == null) foafNameMap = Utils.getFoafNameMap(nanopub);	×
247	return foafNameMap;	×
248	}
249
250	}

knowledgepixels / nanodash / 17557135178

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