diff --git a/.github/actions/gradle-setup/action.yml b/.github/actions/gradle-setup/action.yml index 6cb09f15..0581bfac 100644 --- a/.github/actions/gradle-setup/action.yml +++ b/.github/actions/gradle-setup/action.yml @@ -9,7 +9,7 @@ runs: with: repository: eclipse-dataspaceconnector/DataSpaceConnector path: DataSpaceConnector - ref: 9085e5e71e07b1e1eef05248dbff2c8d6b911e27 + ref: 3ff940b720f44826df28e893fb31344eb6faacef # Install Java and cache MVD Gradle build. - uses: actions/setup-java@v2 diff --git a/client-cli/README.md b/client-cli/README.md index 4ded3db0..9aed810d 100644 --- a/client-cli/README.md +++ b/client-cli/README.md @@ -16,10 +16,14 @@ For example, to list dataspace participants: ``` java -jar client-cli/build/libs/registration-service-cli.jar \ - -s=http://localhost:8182/authority \ + -d=did:web:dataspaceauthoritydid \ + -c=did:web:clientdid + -k=file.pem participants list ``` +More about available did:web formats: [https://w3c-ccg.github.io/did-method-web/#example-example-web-method-dids](Web DID method specification). + The client can also be run from a local Maven repository: ``` diff --git a/client-cli/build.gradle.kts b/client-cli/build.gradle.kts index dc0f6cea..4d57e770 100644 --- a/client-cli/build.gradle.kts +++ b/client-cli/build.gradle.kts @@ -10,6 +10,9 @@ val jupiterVersion: String by project val assertj: String by project val mockitoVersion: String by project val faker: String by project +val edcGroup: String by project +val edcVersion: String by project +val okHttp: String by project dependencies { api("info.picocli:picocli:4.6.3") @@ -19,10 +22,14 @@ dependencies { implementation("com.fasterxml.jackson.core:jackson-databind:$jacksonVersion") testImplementation(testFixtures(project(":rest-client"))) + implementation("${edcGroup}:identity-did-web:${edcVersion}") + implementation("${edcGroup}:common-util:${edcVersion}") + implementation("com.squareup.okhttp3:okhttp:${okHttp}") testImplementation("org.assertj:assertj-core:${assertj}") testImplementation("org.mockito:mockito-core:${mockitoVersion}") testImplementation("com.github.javafaker:javafaker:${faker}") testImplementation("org.junit.jupiter:junit-jupiter-api:${jupiterVersion}") + testImplementation("org.junit.jupiter:junit-jupiter-params:${jupiterVersion}") testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:${jupiterVersion}") } diff --git a/client-cli/src/main/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationServiceCli.java b/client-cli/src/main/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationServiceCli.java index a004d5b3..e62c912a 100644 --- a/client-cli/src/main/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationServiceCli.java +++ b/client-cli/src/main/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationServiceCli.java @@ -14,13 +14,22 @@ package org.eclipse.dataspaceconnector.registration.cli; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import okhttp3.OkHttpClient; +import org.eclipse.dataspaceconnector.iam.did.web.resolution.WebDidResolver; import org.eclipse.dataspaceconnector.registration.client.api.RegistryApi; +import org.eclipse.dataspaceconnector.spi.monitor.ConsoleMonitor; +import org.jetbrains.annotations.NotNull; import picocli.CommandLine; import picocli.CommandLine.Command; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.util.concurrent.TimeUnit; + +import static org.eclipse.dataspaceconnector.registration.cli.ClientUtils.createApiClient; @Command(name = "registration-service-cli", mixinStandardHelpOptions = true, description = "Client utility for MVD registration service.", @@ -28,17 +37,29 @@ ParticipantsCommand.class }) public class RegistrationServiceCli { - @CommandLine.Option(names = "-s", required = true, description = "Registration service URL", defaultValue = "http://localhost:8182/authority") + + private static final ObjectMapper MAPPER = new ObjectMapper().disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); + + @Deprecated + @CommandLine.Option(names = "-s", description = "Registration service URL. Deprecated. Use -d instead.", defaultValue = "http://localhost:8182/authority") String service; - @CommandLine.Option(names = "-d", required = true, description = "Client DID") + @CommandLine.Option(names = { "-d", "--dataspace-did" }, description = "Dataspace Authority DID.", defaultValue = "") + String dataspaceDid; + + @CommandLine.Option(names = { "-c", "--client-did" }, required = true, description = "Client DID.") String clientDid; - @CommandLine.Option(names = "-k", required = true, description = "File containing the private key in PEM format") + @CommandLine.Option(names = { "-k", "--private-key" }, required = true, description = "File containing the private key in PEM format") Path privateKeyFile; + @CommandLine.Option(names = "--http-scheme", description = "Flag to create DID URLs with http instead of https scheme. Used for testing purposes.") + boolean useHttpScheme; + RegistryApi registryApiClient; + private final ConsoleMonitor monitor = new ConsoleMonitor(); + public static void main(String... args) { CommandLine commandLine = getCommandLine(); var exitCode = commandLine.execute(args); @@ -63,7 +84,32 @@ private void init() { } catch (IOException e) { throw new RuntimeException("Error reading file " + privateKeyFile, e); } - var apiClient = ClientUtils.createApiClient(service, clientDid, privateKeyData); - this.registryApiClient = new RegistryApi(apiClient); + + // TODO: temporary to preserve the backwards compatibility (https://github.com/agera-edc/MinimumViableDataspace/issues/174) + if (dataspaceDid.isEmpty()) { + var apiClient = createApiClient(service, clientDid, privateKeyData); + this.registryApiClient = new RegistryApi(apiClient); + return; + } + + registryApiClient = new RegistryApi(createApiClient(registrationUrl(), clientDid, privateKeyData)); + } + + private String registrationUrl() { + var didWebResolver = new WebDidResolver(httpClient(), !useHttpScheme, MAPPER, monitor); + var urlResolver = new RegistrationUrlResolver(didWebResolver); + var url = urlResolver.resolveUrl(dataspaceDid); + if (url.failed()) { + throw new CliException("Error resolving the registration url."); + } + return url.getContent(); + } + + @NotNull + private OkHttpClient httpClient() { + return new OkHttpClient.Builder() + .connectTimeout(30, TimeUnit.SECONDS) + .readTimeout(30, TimeUnit.SECONDS) + .build(); } } diff --git a/client-cli/src/main/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationUrlResolver.java b/client-cli/src/main/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationUrlResolver.java new file mode 100644 index 00000000..add703d5 --- /dev/null +++ b/client-cli/src/main/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationUrlResolver.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2022 Microsoft Corporation + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Microsoft Corporation - initial API and implementation + * + */ + +package org.eclipse.dataspaceconnector.registration.cli; + +import org.eclipse.dataspaceconnector.iam.did.spi.document.DidDocument; +import org.eclipse.dataspaceconnector.iam.did.spi.document.Service; +import org.eclipse.dataspaceconnector.iam.did.spi.resolution.DidResolver; +import org.eclipse.dataspaceconnector.spi.result.Result; +import org.jetbrains.annotations.NotNull; + +/** + * Resolves the registration url from the DID. + */ +public class RegistrationUrlResolver { + + public static final String REGISTRATION_URL = "RegistrationUrl"; + + /** + * Resolves the DID document from did:web. + */ + private final DidResolver resolver; + + public RegistrationUrlResolver(DidResolver resolver) { + this.resolver = resolver; + } + + @NotNull + public Result resolveUrl(String did) { + Result didDocument = resolver.resolve(did); + if (didDocument.failed()) { + throw new CliException("Error resolving the DID " + did); + } + return didDocument.getContent().getService() + .stream() + .filter(service -> service.getType().equals(REGISTRATION_URL)) + .map(Service::getServiceEndpoint) + .findFirst() + .map(Result::success) + .orElse(Result.failure("Error resolving service endpoint from DID Document for " + did)); + } + +} diff --git a/client-cli/src/test/java/org/eclipse/dataspaceconnector/registration/cli/ParticipantsCommandTest.java b/client-cli/src/test/java/org/eclipse/dataspaceconnector/registration/cli/ParticipantsCommandTest.java index 03ed492c..4db06792 100644 --- a/client-cli/src/test/java/org/eclipse/dataspaceconnector/registration/cli/ParticipantsCommandTest.java +++ b/client-cli/src/test/java/org/eclipse/dataspaceconnector/registration/cli/ParticipantsCommandTest.java @@ -14,6 +14,7 @@ package org.eclipse.dataspaceconnector.registration.cli; +import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.github.javafaker.Faker; @@ -47,7 +48,8 @@ class ParticipantsCommandTest { Participant participant2 = createParticipant(); String serverUrl = FAKER.internet().url(); String idsUrl = FAKER.internet().url(); - String did = FAKER.internet().url(); + String clientDid = FAKER.internet().url(); + String dataspaceDid = "did:web:" + FAKER.internet().domainName(); RegistrationServiceCli app = new RegistrationServiceCli(); CommandLine cmd = new CommandLine(app); @@ -72,40 +74,82 @@ void list() throws Exception { when(app.registryApiClient.listParticipants()) .thenReturn(participants); - var exitCode = executeParticipantsList(); - assertThat(exitCode).isEqualTo(0); - assertThat(serverUrl).isEqualTo(app.service); - - var parsedResult = MAPPER.readValue(sw.toString(), new TypeReference>() { - }); - assertThat(parsedResult) - .usingRecursiveFieldByFieldElementComparator() - .isEqualTo(participants); + var exitCode = executeParticipantsList("-d", dataspaceDid); + assertListParticipants(participants, exitCode, app.dataspaceDid, dataspaceDid); } @Test void add() { - var exitCode = executeParticipantsAdd(idsUrl); + var exitCode = executeParticipantsAdd("-d", dataspaceDid); + assertAddParticipants(exitCode, dataspaceDid, app.dataspaceDid); + } + + @Deprecated + @Test + void list_using_serviceUrl() throws Exception { + var participants = List.of(this.participant1, participant2); + when(app.registryApiClient.listParticipants()) + .thenReturn(participants); + + var exitCode = executeParticipantsList("-s", serverUrl); + assertListParticipants(participants, exitCode, app.service, serverUrl); + } + + @Deprecated + @Test + void add_using_serviceUrl() { + var exitCode = executeParticipantsAdd("-s", serverUrl); + assertAddParticipants(exitCode, serverUrl, app.service); + } + + @Deprecated + @Test + void add_both_inputs() { + var exitCode = cmd.execute( + "-c", clientDid, + "-k", privateKeyFile.toString(), + "-s", serverUrl, + "-d", dataspaceDid, + "participants", "add", + "--ids-url", idsUrl); assertThat(exitCode).isEqualTo(0); + assertThat(dataspaceDid).isEqualTo(app.dataspaceDid); assertThat(serverUrl).isEqualTo(app.service); verify(app.registryApiClient).addParticipant(idsUrl); } - private int executeParticipantsAdd(String idsUrl) { + private void assertAddParticipants(int exitCode, String serverUrl, String service) { + assertThat(exitCode).isEqualTo(0); + assertThat(serverUrl).isEqualTo(service); + verify(app.registryApiClient).addParticipant(idsUrl); + } + + private void assertListParticipants(List participants, int exitCode, String value, String expectedValue) throws JsonProcessingException { + assertThat(exitCode).isEqualTo(0); + assertThat(expectedValue).isEqualTo(value); + + var parsedResult = MAPPER.readValue(sw.toString(), new TypeReference>() { + }); + assertThat(parsedResult) + .usingRecursiveFieldByFieldElementComparator() + .isEqualTo(participants); + } + + private int executeParticipantsAdd(String inputCmd, String inputValue) { return cmd.execute( - "-d", did, + "-c", clientDid, "-k", privateKeyFile.toString(), - "-s", serverUrl, + inputCmd, inputValue, "participants", "add", "--ids-url", idsUrl); } - private int executeParticipantsList() { + private int executeParticipantsList(String inputCmd, String inputValue) { return cmd.execute( - "-d", did, + "-c", clientDid, "-k", privateKeyFile.toString(), - "-s", serverUrl, + inputCmd, inputValue, "participants", "list"); } } \ No newline at end of file diff --git a/client-cli/src/test/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationUrlResolverTest.java b/client-cli/src/test/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationUrlResolverTest.java new file mode 100644 index 00000000..f6d142d6 --- /dev/null +++ b/client-cli/src/test/java/org/eclipse/dataspaceconnector/registration/cli/RegistrationUrlResolverTest.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2022 Microsoft Corporation + * + * This program and the accompanying materials are made available under the + * terms of the Apache License, Version 2.0 which is available at + * https://www.apache.org/licenses/LICENSE-2.0 + * + * SPDX-License-Identifier: Apache-2.0 + * + * Contributors: + * Microsoft Corporation - initial API and implementation + * + */ + +package org.eclipse.dataspaceconnector.registration.cli; + +import com.github.javafaker.Faker; +import org.eclipse.dataspaceconnector.iam.did.spi.document.DidDocument; +import org.eclipse.dataspaceconnector.iam.did.spi.document.Service; +import org.eclipse.dataspaceconnector.iam.did.spi.resolution.DidResolver; +import org.eclipse.dataspaceconnector.iam.did.web.resolution.WebDidResolver; +import org.eclipse.dataspaceconnector.spi.result.Result; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.List; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +class RegistrationUrlResolverTest { + + private static final String REGISTRATION_URL_TYPE = "RegistrationUrl"; + private static final Faker FAKER = new Faker(); + + DidResolver didResolver = mock(WebDidResolver.class); + RegistrationUrlResolver urlResolver = new RegistrationUrlResolver(didResolver); + + String did = "did:web:" + FAKER.internet().domainName(); + static String apiUrl = FAKER.internet().url(); + + @Test + void resolveUrl_success() { + + DidDocument didDocument = didDocument(List.of(new Service("some-id", REGISTRATION_URL_TYPE, apiUrl), new Service("some-id", "some-other-type", apiUrl))); + when(didResolver.resolve(did)).thenReturn(Result.success(didDocument)); + + Result resultApiUrl = urlResolver.resolveUrl(did); + + assertThat(resultApiUrl.succeeded()).isTrue(); + assertThat(resultApiUrl.getContent()).isEqualTo(apiUrl); + + } + + @ParameterizedTest + @MethodSource("listsOfServices") + void resolveUrl_incorrectServices(List services) { + + DidDocument didDocument = didDocument(services); + when(didResolver.resolve(did)).thenReturn(Result.success(didDocument)); + + Result resultApiUrl = urlResolver.resolveUrl(did); + + assertThat(resultApiUrl.failed()).isTrue(); + assertThat(resultApiUrl.getFailureMessages()).containsExactly("Error resolving service endpoint from DID Document for " + did); + } + + @Test + void resolveUrl_failureToGetDid() { + + when(didResolver.resolve(did)).thenReturn(Result.failure("Failure")); + + assertThatThrownBy(() -> urlResolver.resolveUrl(did)).isInstanceOf(CliException.class); + } + + private DidDocument didDocument(List services) { + return DidDocument.Builder.newInstance().service(services).build(); + } + + private static Stream listsOfServices() { + return Stream.of( + Arguments.of(List.of(new Service("some-id", "some-other-type", apiUrl))), + Arguments.of(List.of()) + ); + } + +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties index eb2f1fc6..686abe77 100644 --- a/gradle.properties +++ b/gradle.properties @@ -13,10 +13,12 @@ rsApi=3.0.0 faker=1.0.2 swagger=2.1.13 jacksonVersion=2.13.1 +okHttp=4.9.3 + # information required for publishing artifacts: edcDeveloperId=mspiekermann edcDeveloperName=Markus Spiekermann edcDeveloperEmail=markus.spiekermann@isst.fraunhofer.de edcScmConnection=scm:git:git@github.com:eclipse-dataspaceconnector/RegistrationService.git edcWebsiteUrl=https://github.com/eclipse-dataspaceconnector/RegistrationService.git -edcScmUrl=https://github.com/eclipse-dataspaceconnector/RegistrationService.git \ No newline at end of file +edcScmUrl=https://github.com/eclipse-dataspaceconnector/RegistrationService.git diff --git a/resources/webdid/README.md b/resources/webdid/README.md index 01eab05f..7018998f 100644 --- a/resources/webdid/README.md +++ b/resources/webdid/README.md @@ -1,6 +1,5 @@ This directory contains a sample DID Document used in docker-compose deployment. -The `publicKeyJwk` section of `test-authority/did.json` was generated by running: -``` -docker run -i danedmunds/pem-to-jwk:1.2.1 --public --pretty < rest-client/src/test/resources/private_p256.pem > key.public.jwk +The `publicKeyJwk` section of `test-client/did.json` was generated by running: ``` +docker run -i danedmunds/pem-to-jwk:1.2.1 --public --pretty < rest-client/src/testFixtures/resources/private_p256.pem > key.public.jwk``` diff --git a/resources/webdid/test-authority/did.json b/resources/webdid/test-client/did.json similarity index 84% rename from resources/webdid/test-authority/did.json rename to resources/webdid/test-client/did.json index c0929922..df4cdd5d 100644 --- a/resources/webdid/test-authority/did.json +++ b/resources/webdid/test-client/did.json @@ -1,9 +1,9 @@ { - "id": "did:web:did-server:test-authority", + "id": "did:web:did-server:test-client", "@context": [ "https://www.w3.org/ns/did/v1", { - "@base": "did:web:did-server:test-authority" + "@base": "did:web:did-server:test-client" } ], "verificationMethod": [ diff --git a/resources/webdid/test-dataspace-authority/did.json b/resources/webdid/test-dataspace-authority/did.json new file mode 100644 index 00000000..070eca33 --- /dev/null +++ b/resources/webdid/test-dataspace-authority/did.json @@ -0,0 +1,33 @@ +{ + "id": "did:web:did-server:test-dataspace-authority", + "@context": [ + "https://www.w3.org/ns/did/v1", + { + "@base": "did:web:did-server:test-dataspace-authority" + } + ], + "service": [ + { + "id": "#registration-url", + "serviceEndpoint": "http://localhost:8182/authority", + "type": "RegistrationUrl" + } + ], + "verificationMethod": [ + { + "controller": "", + "id": "#dataspace-authority", + "publicKeyJwk": { + "crv": "P-256", + "kid": "43W7BLEhKmasrJYqax399SY3tbAWZ9gbE2Em1pIQIds", + "kty": "EC", + "x": "wwP_-TypFsR1k41KDoxYelM5nlMDWkW1xI3dfD_JSIE", + "y": "iqDGWy1rbemhYrN4NCtn5dCeElIO8KLqXDT2RuzQWH0" + }, + "type": "JsonWebKey2020" + } + ], + "authentication": [ + "#dataspace-authority" + ] +} \ No newline at end of file diff --git a/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiClientTest.java b/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiClientTest.java index 09f0a692..4ab16c57 100644 --- a/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiClientTest.java +++ b/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiClientTest.java @@ -21,7 +21,7 @@ import org.junit.jupiter.api.Test; import static org.assertj.core.api.Assertions.assertThat; -import static org.eclipse.dataspaceconnector.registration.client.TestUtils.DID_WEB; +import static org.eclipse.dataspaceconnector.registration.client.TestUtils.CLIENT_DID_WEB; @IntegrationTest public class RegistrationApiClientTest { @@ -33,7 +33,7 @@ public class RegistrationApiClientTest { @BeforeAll static void setUpClass() { - var apiClient = ClientUtils.createApiClient(API_URL, DID_WEB, TestKeyData.PRIVATE_KEY_P256); + var apiClient = ClientUtils.createApiClient(API_URL, CLIENT_DID_WEB, TestKeyData.PRIVATE_KEY_P256); api = new RegistryApi(apiClient); } diff --git a/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiCommandLineClientTest.java b/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiCommandLineClientTest.java index a53f8f83..cd6e9729 100644 --- a/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiCommandLineClientTest.java +++ b/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/RegistrationApiCommandLineClientTest.java @@ -31,7 +31,8 @@ import java.util.List; import static org.assertj.core.api.Assertions.assertThat; -import static org.eclipse.dataspaceconnector.registration.client.TestUtils.DID_WEB; +import static org.eclipse.dataspaceconnector.registration.client.TestUtils.CLIENT_DID_WEB; +import static org.eclipse.dataspaceconnector.registration.client.TestUtils.DATASPACE_DID_WEB; @IntegrationTest public class RegistrationApiCommandLineClientTest { @@ -54,8 +55,27 @@ void listParticipants() throws Exception { assertThat(getParticipants(cmd)).noneSatisfy(p -> assertThat(p.getUrl()).isEqualTo(idsUrl)); var addCmdExitCode = cmd.execute( - "-d", DID_WEB, + "-c", CLIENT_DID_WEB, + "-d", DATASPACE_DID_WEB, "-k", privateKeyFile.toString(), + "--http-scheme", + "participants", "add", + "--ids-url", idsUrl); + assertThat(addCmdExitCode).isEqualTo(0); + assertThat(getParticipants(cmd)).anySatisfy(p -> assertThat(p.getUrl()).isEqualTo(idsUrl)); + } + + @Deprecated + @Test + void listParticipants_usingServiceUrl() throws Exception { + CommandLine cmd = RegistrationServiceCli.getCommandLine(); + + assertThat(getParticipants(cmd)).noneSatisfy(p -> assertThat(p.getUrl()).isEqualTo(idsUrl)); + + var addCmdExitCode = cmd.execute( + "-c", CLIENT_DID_WEB, + "-k", privateKeyFile.toString(), + "--http-scheme", "participants", "add", "--ids-url", idsUrl); assertThat(addCmdExitCode).isEqualTo(0); @@ -66,7 +86,7 @@ private List getParticipants(CommandLine cmd) throws JsonProcessing var writer = new StringWriter(); cmd.setOut(new PrintWriter(writer)); var listCmdExitCode = cmd.execute( - "-d", DID_WEB, + "-c", CLIENT_DID_WEB, "-k", privateKeyFile.toString(), "participants", "list"); assertThat(listCmdExitCode).isEqualTo(0); diff --git a/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/TestUtils.java b/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/TestUtils.java index a37e5a94..7a4fda5e 100644 --- a/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/TestUtils.java +++ b/system-tests/src/test/java/org/eclipse/dataspaceconnector/registration/client/TestUtils.java @@ -19,7 +19,13 @@ private TestUtils() { } /** - * The DID that resolves to the sample DID Document in docker compose (served by the nginx container) + * The DID that resolves to the sample DID Document for a client in docker compose (served by the nginx container) */ - static final String DID_WEB = "did:web:did-server:test-authority"; + static final String CLIENT_DID_WEB = "did:web:did-server:test-client"; + + /** + * The DID that resolves to the sample DID Document for the Dataspace Authority in docker compose (served by the nginx container). + * Did web format reference: https://w3c-ccg.github.io/did-method-web/#create-register + */ + static final String DATASPACE_DID_WEB = "did:web:localhost%3A8080:test-dataspace-authority"; }