9106606089

Committed 16 May 2024 04:43AM UTC coverage: 52.923% (+1.2%) from 51.74%

Build Type

push

Committed by

Commit Message

test: add tests for the new key types (#1044)

Signed-off-by: Pat Losoponkul <pat.losoponkul@iohk.io>

Run Details

34 of 46 new or added lines in 7 files covered. (73.91%)

322 existing lines in 66 files now uncovered.

7531 of 14230 relevant lines covered (52.92%)

0.53 hits per line

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

0.0

/cloud-agent/service/server/src/main/scala/org/hyperledger/identus/controller/http/Service.scala

package org.hyperledger.identus.castor.controller.http

import io.circe.Json
import org.hyperledger.identus.api.http.Annotation
import org.hyperledger.identus.api.http.codec.CirceJsonInterop
import org.hyperledger.identus.castor.controller.http.Service.annotations
import org.hyperledger.identus.castor.core.model.ProtoModelHelper
import org.hyperledger.identus.castor.core.model.did as castorDomain
import org.hyperledger.identus.castor.core.model.did.w3c
import org.hyperledger.identus.shared.utils.Traverse.*
import scala.language.implicitConversions
import sttp.tapir.Schema
import sttp.tapir.Schema.annotations.{description, encodedExample}
import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}

@description("A service that should appear in the DID document. https://www.w3.org/TR/did-core/#services")
final case class Service(
    @description(annotations.id.description)
    @encodedExample(annotations.id.example)
    id: String,
    @description(annotations.`type`.description)
    @encodedExample(annotations.`type`.example)
    `type`: ServiceType,
    @description(annotations.serviceEndpoint.description)
    @encodedExample(annotations.serviceEndpoint.example)
    serviceEndpoint: ServiceEndpoint
)

object Service {

  object annotations {
    object id
        extends Annotation[String](
          description = """The id of the service.
              |Requires a URI fragment when use in create / update DID.
              |Returns the full ID (with DID prefix) when resolving DID""".stripMargin,
          example = "service-1"
        )

    object `type`
        extends Annotation[String](
          description =
            "Service type. Can contain multiple possible values as described in the [Create DID operation](https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#create-did) under the construction section.",
          example = "LinkedDomains"
        )

    object serviceEndpoint
        extends Annotation[Json](
          description =
            "The service endpoint. Can contain multiple possible values as described in the [Create DID operation](https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#create-did)",
          example = Json.fromString("https://example.com")
        )
  }

  given encoder: JsonEncoder[Service] = DeriveJsonEncoder.gen[Service]
  given decoder: JsonDecoder[Service] = DeriveJsonDecoder.gen[Service]
  given schema: Schema[Service] = Schema
    .derived[Service]
    .modify(_.serviceEndpoint)(_.copy(isOptional = false))

  given Conversion[w3c.ServiceRepr, Service] = (service: w3c.ServiceRepr) =>
    Service(
      id = service.id,
      `type` = service.`type`,
      serviceEndpoint = ServiceEndpoint.fromJson(service.serviceEndpoint)
    )

  extension (service: Service) {
    def toDomain: Either[String, castorDomain.Service] = {
      for {
        serviceEndpoint <- service.serviceEndpoint.toDomain
        serviceType <- service.`type`.toDomain
      } yield castorDomain
        .Service(
          id = service.id,
          `type` = serviceType,
          serviceEndpoint = serviceEndpoint
        )
        .normalizeServiceEndpoint()
    }
  }
}

sealed trait ServiceType

object ServiceType {
  final case class Single(value: String) extends ServiceType
  final case class Multiple(values: Seq[String]) extends ServiceType

  given encoder: JsonEncoder[ServiceType] = JsonEncoder.string
    .orElseEither(JsonEncoder.array[String])
    .contramap[ServiceType] {
      case Single(value)    => Left(value)
      case Multiple(values) => Right(values.toArray)
    }
  given decoder: JsonDecoder[ServiceType] = JsonDecoder.string
    .orElseEither(JsonDecoder.array[String])
    .map[ServiceType] {
      case Left(value)   => Single(value)
      case Right(values) => Multiple(values.toSeq)
    }
  given schema: Schema[ServiceType] = Schema
    .schemaForEither(Schema.schemaForString, Schema.schemaForArray[String])
    .map[ServiceType] {
      case Left(value)   => Some(ServiceType.Single(value))
      case Right(values) => Some(ServiceType.Multiple(values.toSeq))
    } {
      case Single(value)    => Left(value)
      case Multiple(values) => Right(values.toArray)
    }

  given Conversion[castorDomain.ServiceType, ServiceType] = {
    case t: castorDomain.ServiceType.Single   => Single(t.value.value)
    case t: castorDomain.ServiceType.Multiple => Multiple(t.values.map(_.value))
  }

  given Conversion[String | Seq[String], ServiceType] = {
    case s: String      => Single(s)
    case s: Seq[String] => Multiple(s)
  }

  extension (serviceType: ServiceType) {
    def toDomain: Either[String, castorDomain.ServiceType] = serviceType match {
      case Single(value) =>
        castorDomain.ServiceType.Name.fromString(value).map(castorDomain.ServiceType.Single.apply)
      case Multiple(values) =>
        values.toList match {
          case Nil => Left("serviceType cannot be empty")
          case head :: tail =>
            for {
              parsedHead <- castorDomain.ServiceType.Name.fromString(head)
              parsedTail <- tail.traverse(s => castorDomain.ServiceType.Name.fromString(s))
            } yield castorDomain.ServiceType.Multiple(parsedHead, parsedTail)
        }
    }
  }
}

opaque type ServiceEndpoint = Json

object ServiceEndpoint {
  given encoder: JsonEncoder[ServiceEndpoint] = CirceJsonInterop.encodeJson
  given decoder: JsonDecoder[ServiceEndpoint] = CirceJsonInterop.decodeJson
  given schema: Schema[ServiceEndpoint] = CirceJsonInterop.schemaJson

  def fromJson(json: Json): ServiceEndpoint = json

  extension (serviceEndpoint: ServiceEndpoint) {
    def toDomain: Either[String, castorDomain.ServiceEndpoint] = {
      val stringEncoded = serviceEndpoint.asString match {
        case Some(s) => s
        case None    => serviceEndpoint.noSpaces
      }
      ProtoModelHelper.parseServiceEndpoint(stringEncoded)
    }
  }
}

1	package org.hyperledger.identus.castor.controller.http
2
3	import io.circe.Json
4	import org.hyperledger.identus.api.http.Annotation
5	import org.hyperledger.identus.api.http.codec.CirceJsonInterop
6	import org.hyperledger.identus.castor.controller.http.Service.annotations
7	import org.hyperledger.identus.castor.core.model.ProtoModelHelper
8	import org.hyperledger.identus.castor.core.model.did as castorDomain
9	import org.hyperledger.identus.castor.core.model.did.w3c
10	import org.hyperledger.identus.shared.utils.Traverse.*
11	import scala.language.implicitConversions
12	import sttp.tapir.Schema
13	import sttp.tapir.Schema.annotations.{description, encodedExample}
14	import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}
15
16	@description("A service that should appear in the DID document. https://www.w3.org/TR/did-core/#services")	×
17	final case class Service(
18	@description(annotations.id.description)	×
19	@encodedExample(annotations.id.example)	×
20	id: String,
21	@description(annotations.`type`.description)	×
22	@encodedExample(annotations.`type`.example)	×
23	`type`: ServiceType,
24	@description(annotations.serviceEndpoint.description)	×
25	@encodedExample(annotations.serviceEndpoint.example)	×
26	serviceEndpoint: ServiceEndpoint
27	)
28
29	object Service {
30
31	object annotations {
32	object id
33	extends Annotation[String](
34	description = """The id of the service.
35	\|Requires a URI fragment when use in create / update DID.
36	\|Returns the full ID (with DID prefix) when resolving DID""".stripMargin,	×
37	example = "service-1"
38	)
39
40	object `type`
41	extends Annotation[String](	×
42	description =
43	"Service type. Can contain multiple possible values as described in the [Create DID operation](https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#create-did) under the construction section.",
44	example = "LinkedDomains"
45	)
46
47	object serviceEndpoint
48	extends Annotation[Json](	×
49	description =
50	"The service endpoint. Can contain multiple possible values as described in the [Create DID operation](https://github.com/input-output-hk/prism-did-method-spec/blob/main/w3c-spec/PRISM-method.md#create-did)",
51	example = Json.fromString("https://example.com")	×
52	)
53	}
54
55	given encoder: JsonEncoder[Service] = DeriveJsonEncoder.gen[Service]	×
56	given decoder: JsonDecoder[Service] = DeriveJsonDecoder.gen[Service]	×
57	given schema: Schema[Service] = Schema
58	.derived[Service]
59	.modify(_.serviceEndpoint)(_.copy(isOptional = false))	×
60
61	given Conversion[w3c.ServiceRepr, Service] = (service: w3c.ServiceRepr) =>
62	Service(
63	id = service.id,
64	`type` = service.`type`,	×
65	serviceEndpoint = ServiceEndpoint.fromJson(service.serviceEndpoint)	×
66	)
67
68	extension (service: Service) {
69	def toDomain: Either[String, castorDomain.Service] = {	×
70	for {	×
71	serviceEndpoint <- service.serviceEndpoint.toDomain	×
72	serviceType <- service.`type`.toDomain	×
73	} yield castorDomain
74	.Service(
75	id = service.id,	×
76	`type` = serviceType,
77	serviceEndpoint = serviceEndpoint
78	)
79	.normalizeServiceEndpoint()	×
80	}
81	}
82	}
83
84	sealed trait ServiceType
85
86	object ServiceType {
87	final case class Single(value: String) extends ServiceType
88	final case class Multiple(values: Seq[String]) extends ServiceType
89
90	given encoder: JsonEncoder[ServiceType] = JsonEncoder.string
91	.orElseEither(JsonEncoder.array[String])	×
92	.contramap[ServiceType] {	×
93	case Single(value) => Left(value)	×
94	case Multiple(values) => Right(values.toArray)	×
95	}
96	given decoder: JsonDecoder[ServiceType] = JsonDecoder.string
97	.orElseEither(JsonDecoder.array[String])	×
98	.map[ServiceType] {	×
99	case Left(value) => Single(value)	×
100	case Right(values) => Multiple(values.toSeq)	×
101	}
102	given schema: Schema[ServiceType] = Schema
103	.schemaForEither(Schema.schemaForString, Schema.schemaForArray[String])	×
104	.map[ServiceType] {
105	case Left(value) => Some(ServiceType.Single(value))	×
106	case Right(values) => Some(ServiceType.Multiple(values.toSeq))	×
107	} {	×
108	case Single(value) => Left(value)	×
109	case Multiple(values) => Right(values.toArray)	×
110	}
111
112	given Conversion[castorDomain.ServiceType, ServiceType] = {
113	case t: castorDomain.ServiceType.Single => Single(t.value.value)	×
114	case t: castorDomain.ServiceType.Multiple => Multiple(t.values.map(_.value))	×
115	}
116
117	given Conversion[String \| Seq[String], ServiceType] = {
118	case s: String => Single(s)	×
119	case s: Seq[String] => Multiple(s)	×
120	}
121
122	extension (serviceType: ServiceType) {
123	def toDomain: Either[String, castorDomain.ServiceType] = serviceType match {	×
124	case Single(value) =>	×
125	castorDomain.ServiceType.Name.fromString(value).map(castorDomain.ServiceType.Single.apply)	×
126	case Multiple(values) =>	×
127	values.toList match {	×
128	case Nil => Left("serviceType cannot be empty")	×
129	case head :: tail =>	×
130	for {	×
131	parsedHead <- castorDomain.ServiceType.Name.fromString(head)	×
132	parsedTail <- tail.traverse(s => castorDomain.ServiceType.Name.fromString(s))	×
UNCOV 133	} yield castorDomain.ServiceType.Multiple(parsedHead, parsedTail)	×
134	}
135	}
136	}
137	}
138
139	opaque type ServiceEndpoint = Json
140
141	object ServiceEndpoint {
142	given encoder: JsonEncoder[ServiceEndpoint] = CirceJsonInterop.encodeJson
143	given decoder: JsonDecoder[ServiceEndpoint] = CirceJsonInterop.decodeJson
144	given schema: Schema[ServiceEndpoint] = CirceJsonInterop.schemaJson
145
146	def fromJson(json: Json): ServiceEndpoint = json	×
147
148	extension (serviceEndpoint: ServiceEndpoint) {
149	def toDomain: Either[String, castorDomain.ServiceEndpoint] = {	×
150	val stringEncoded = serviceEndpoint.asString match {	×
151	case Some(s) => s	×
152	case None => serviceEndpoint.noSpaces	×
153	}
154	ProtoModelHelper.parseServiceEndpoint(stringEncoded)	×
155	}
156	}
157	}

hyperledger / identus-cloud-agent / 9106606089

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