pgpainless / sop-java / #53

Committed 17 Jun 2025 11:45AM UTC coverage: 58.411% (-2.4%) from 60.782%

Build # #53

Build Type

push

other

Committed by

vanitasvitae

Commit Message

SOP-Java 14.0.1-SNAPSHOT

Run Details

2073 of 3549 relevant lines covered (58.41%)

0.58 hits per line

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

56.41

/sop-java-testfixtures/src/main/java/sop/testsuite/operation/GenerateKeyTest.java

// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0

package sop.testsuite.operation;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.condition.EnabledIf;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import sop.Profile;
import sop.SOP;
import sop.exception.SOPGPException;
import sop.testsuite.JUtils;
import sop.testsuite.TestData;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

@EnabledIf("sop.testsuite.operation.AbstractSOPTest#hasBackends")
public class GenerateKeyTest extends AbstractSOPTest {

    static Stream<Arguments> provideInstances() {
        return provideBackends();
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateKeyTest(SOP sop) throws IOException {
        byte[] key = sop.generateKey()
                .userId("Alice <alice@openpgp.org>")
                .generate()
                .getBytes();

        JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateKeyNoArmor(SOP sop) throws IOException {
        byte[] key = sop.generateKey()
                .userId("Alice <alice@openpgp.org>")
                .noArmor()
                .generate()
                .getBytes();

        Assertions.assertFalse(JUtils.arrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateKeyWithMultipleUserIdsTest(SOP sop) throws IOException {
        byte[] key = sop.generateKey()
                .userId("Alice <alice@openpgp.org>")
                .userId("Bob <bob@openpgp.org>")
                .generate()
                .getBytes();

        JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateKeyWithoutUserIdTest(SOP sop) throws IOException {
        byte[] key = sop.generateKey()
                .generate()
                .getBytes();

        JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateKeyWithPasswordTest(SOP sop) throws IOException {
        byte[] key = sop.generateKey()
                .userId("Alice <alice@openpgp.org>")
                .withKeyPassword("sw0rdf1sh")
                .generate()
                .getBytes();

        JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateKeyWithMultipleUserIdsAndPassword(SOP sop) throws IOException {
        byte[] key = sop.generateKey()
                .userId("Alice <alice@openpgp.org>")
                .userId("Bob <bob@openpgp.org>")
                .withKeyPassword("sw0rdf1sh")
                .generate()
                .getBytes();

        JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
        JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateSigningOnlyKey(SOP sop) throws IOException {
        byte[] signingOnlyKey = sop.generateKey()
                .signingOnly()
                .userId("Alice <alice@pgpainless.org>")
                .generate()
                .getBytes();
        byte[] signingOnlyCert = sop.extractCert()
                .key(signingOnlyKey)
                .getBytes();

        assertThrows(SOPGPException.CertCannotEncrypt.class, () ->
                sop.encrypt().withCert(signingOnlyCert)
                        .plaintext(TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8))
                        .toByteArrayAndResult()
                        .getBytes());
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void generateKeyWithSupportedProfiles(SOP sop) throws IOException {
        List<Profile> profiles = sop.listProfiles()
                .generateKey();

        for (Profile profile : profiles) {
            generateKeyWithProfile(sop, profile.getName());
        }
    }

    private void generateKeyWithProfile(SOP sop, String profile) throws IOException {
        byte[] key;
        try {
            key = sop.generateKey()
                    .profile(profile)
                    .userId("Alice <alice@pgpainless.org>")
                    .generate()
                    .getBytes();
        } catch (SOPGPException.UnsupportedProfile e) {
            key = null;
        }
        assumeTrue(key != null, "'generate-key' does not support profile '" + profile + "'.");
        JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);
    }
}

1	// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
2	//
3	// SPDX-License-Identifier: Apache-2.0
4
5	package sop.testsuite.operation;
6
7	import org.junit.jupiter.api.Assertions;
8	import org.junit.jupiter.api.condition.EnabledIf;
9	import org.junit.jupiter.params.ParameterizedTest;
10	import org.junit.jupiter.params.provider.Arguments;
11	import org.junit.jupiter.params.provider.MethodSource;
12	import sop.Profile;
13	import sop.SOP;
14	import sop.exception.SOPGPException;
15	import sop.testsuite.JUtils;
16	import sop.testsuite.TestData;
17
18	import java.io.IOException;
19	import java.nio.charset.StandardCharsets;
20	import java.util.List;
21	import java.util.stream.Stream;
22
23	import static org.junit.jupiter.api.Assertions.assertThrows;
24	import static org.junit.jupiter.api.Assumptions.assumeTrue;
25
26	@EnabledIf("sop.testsuite.operation.AbstractSOPTest#hasBackends")
27	public class GenerateKeyTest extends AbstractSOPTest {	1✔
28
29	static Stream<Arguments> provideInstances() {
30	return provideBackends();	1✔
31	}
32
33	@ParameterizedTest
34	@MethodSource("provideInstances")
35	public void generateKeyTest(SOP sop) throws IOException {
36	byte[] key = sop.generateKey()	1✔
37	.userId("Alice <alice@openpgp.org>")	1✔
38	.generate()	1✔
39	.getBytes();	1✔
40
41	JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	1✔
42	JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);	1✔
43	}	1✔
44
45	@ParameterizedTest
46	@MethodSource("provideInstances")
47	public void generateKeyNoArmor(SOP sop) throws IOException {
48	byte[] key = sop.generateKey()	1✔
49	.userId("Alice <alice@openpgp.org>")	1✔
50	.noArmor()	1✔
51	.generate()	1✔
52	.getBytes();	1✔
53
54	Assertions.assertFalse(JUtils.arrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));	1✔
55	}	1✔
56
57	@ParameterizedTest
58	@MethodSource("provideInstances")
59	public void generateKeyWithMultipleUserIdsTest(SOP sop) throws IOException {
60	byte[] key = sop.generateKey()	1✔
61	.userId("Alice <alice@openpgp.org>")	1✔
62	.userId("Bob <bob@openpgp.org>")	1✔
63	.generate()	1✔
64	.getBytes();	1✔
65
66	JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	1✔
67	JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);	1✔
68	}	1✔
69
70	@ParameterizedTest
71	@MethodSource("provideInstances")
72	public void generateKeyWithoutUserIdTest(SOP sop) throws IOException {
73	byte[] key = sop.generateKey()	1✔
74	.generate()	1✔
75	.getBytes();	1✔
76
77	JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	1✔
78	JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);	1✔
79	}	1✔
80
81	@ParameterizedTest
82	@MethodSource("provideInstances")
83	public void generateKeyWithPasswordTest(SOP sop) throws IOException {
84	byte[] key = sop.generateKey()	1✔
85	.userId("Alice <alice@openpgp.org>")	1✔
86	.withKeyPassword("sw0rdf1sh")	1✔
87	.generate()	1✔
88	.getBytes();	×
89
90	JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	×
91	JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);	×
92	}	×
93
94	@ParameterizedTest
95	@MethodSource("provideInstances")
96	public void generateKeyWithMultipleUserIdsAndPassword(SOP sop) throws IOException {
97	byte[] key = sop.generateKey()	1✔
98	.userId("Alice <alice@openpgp.org>")	1✔
99	.userId("Bob <bob@openpgp.org>")	1✔
100	.withKeyPassword("sw0rdf1sh")	1✔
101	.generate()	1✔
102	.getBytes();	×
103
104	JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	×
105	JUtils.assertArrayEndsWithIgnoreNewlines(key, TestData.END_PGP_PRIVATE_KEY_BLOCK);	×
106	}	×
107
108	@ParameterizedTest
109	@MethodSource("provideInstances")
110	public void generateSigningOnlyKey(SOP sop) throws IOException {
111	byte[] signingOnlyKey = sop.generateKey()	1✔
112	.signingOnly()	1✔
113	.userId("Alice <alice@pgpainless.org>")	1✔
114	.generate()	1✔
115	.getBytes();	×
116	byte[] signingOnlyCert = sop.extractCert()	×
117	.key(signingOnlyKey)	×
118	.getBytes();	×
119
120	assertThrows(SOPGPException.CertCannotEncrypt.class, () ->	×
121	sop.encrypt().withCert(signingOnlyCert)	×
122	.plaintext(TestData.PLAINTEXT.getBytes(StandardCharsets.UTF_8))	×
123	.toByteArrayAndResult()	×
124	.getBytes());	×
125	}	×
126
127	@ParameterizedTest
128	@MethodSource("provideInstances")
129	public void generateKeyWithSupportedProfiles(SOP sop) throws IOException {
130	List<Profile> profiles = sop.listProfiles()	1✔
131	.generateKey();	×
132
133	for (Profile profile : profiles) {	×
134	generateKeyWithProfile(sop, profile.getName());	×
135	}	×
136	}	×
137
138	private void generateKeyWithProfile(SOP sop, String profile) throws IOException {
139	byte[] key;
140	try {
141	key = sop.generateKey()	×
142	.profile(profile)	×
143	.userId("Alice <alice@pgpainless.org>")	×
144	.generate()	×
145	.getBytes();	×
146	} catch (SOPGPException.UnsupportedProfile e) {	×
147	key = null;	×
148	}	×
149	assumeTrue(key != null, "'generate-key' does not support profile '" + profile + "'.");	×
150	JUtils.assertArrayStartsWith(key, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	×
151	}	×
152	}

pgpainless / sop-java / #53

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