8835565085

Committed 25 Apr 2024 03:44PM UTC coverage: 31.613% (-0.06%) from 31.67%

Build Type

Committed by

Commit Message

ATL-6775: integration test + documentation

Signed-off-by: Bassam Riman <bassam.riman@iohk.io>

Pull Request Pull Request #986: ATL-6775: integration test + documentation

Run Details

4 of 7 new or added lines in 3 files covered. (57.14%)

357 existing lines in 84 files now uncovered.

4656 of 14728 relevant lines covered (31.61%)

0.32 hits per line

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

55.56

/pollux/lib/core/src/main/scala/io/iohk/atala/pollux/core/service/CredentialServiceNotifier.scala

package io.iohk.atala.pollux.core.service

import io.circe.Json
import io.iohk.atala.castor.core.model.did.CanonicalPrismDID
import io.iohk.atala.event.notification.*
import io.iohk.atala.mercury.model.DidId
import io.iohk.atala.mercury.protocol.issuecredential.{IssueCredential, OfferCredential, RequestCredential}
import io.iohk.atala.pollux.core.model.error.CredentialServiceError
import io.iohk.atala.pollux.core.model.{DidCommID, IssueCredentialRecord}
import io.iohk.atala.shared.models.WalletAccessContext
import zio.{URLayer, ZIO, ZLayer, IO}

import java.util.UUID

class CredentialServiceNotifier(
    svc: CredentialService,
    eventNotificationService: EventNotificationService
) extends CredentialService {

  private val issueCredentialRecordUpdatedEvent = "IssueCredentialRecordUpdated"

  override def createJWTIssueCredentialRecord(
      pairwiseIssuerDID: DidId,
      pairwiseHolderDID: DidId,
      thid: DidCommID,
      maybeSchemaId: Option[String],
      claims: Json,
      validityPeriod: Option[Double],
      automaticIssuance: Option[Boolean],
      issuingDID: CanonicalPrismDID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(
      svc.createJWTIssueCredentialRecord(
        pairwiseIssuerDID,
        pairwiseHolderDID,
        thid,
        maybeSchemaId,
        claims,
        validityPeriod,
        automaticIssuance,
        issuingDID
      )
    )

  override def createAnonCredsIssueCredentialRecord(
      pairwiseIssuerDID: DidId,
      pairwiseHolderDID: DidId,
      thid: DidCommID,
      credentialDefinitionGUID: UUID,
      credentialDefinitionId: _root_.java.lang.String,
      claims: Json,
      validityPeriod: Option[Double],
      automaticIssuance: Option[Boolean]
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(
      svc.createAnonCredsIssueCredentialRecord(
        pairwiseIssuerDID,
        pairwiseHolderDID,
        thid,
        credentialDefinitionGUID,
        credentialDefinitionId,
        claims,
        validityPeriod,
        automaticIssuance
      )
    )

  override def markOfferSent(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.markOfferSent(recordId))

  override def receiveCredentialOffer(
      offer: OfferCredential
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.receiveCredentialOffer(offer))

  override def acceptCredentialOffer(
      recordId: DidCommID,
      subjectId: Option[String]
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.acceptCredentialOffer(recordId, subjectId))

  override def generateJWTCredentialRequest(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateJWTCredentialRequest(recordId))

  override def generateAnonCredsCredentialRequest(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateAnonCredsCredentialRequest(recordId))

  override def markRequestSent(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.markRequestSent(recordId))

  override def receiveCredentialRequest(
      request: RequestCredential
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.receiveCredentialRequest(request))

  override def acceptCredentialRequest(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.acceptCredentialRequest(recordId))

  override def markCredentialSent(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.markCredentialSent(recordId))

  override def receiveCredentialIssue(
      issueCredential: IssueCredential
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.receiveCredentialIssue(issueCredential))

  override def generateJWTCredential(
      recordId: DidCommID,
      statusListRegistryUrl: String
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateJWTCredential(recordId, statusListRegistryUrl))

  override def generateAnonCredsCredential(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =
    notifyOnSuccess(svc.generateAnonCredsCredential(recordId))

  private[this] def notifyOnSuccess[R](effect: ZIO[R, CredentialServiceError, IssueCredentialRecord]) =
    for {
      record <- effect
      _ <- notify(record)
    } yield record

  private[this] def notify(record: IssueCredentialRecord) = {
    val result = for {
      walletId <- ZIO.serviceWith[WalletAccessContext](_.walletId)
      producer <- eventNotificationService.producer[IssueCredentialRecord]("Issue")
      _ <- producer.send(Event(issueCredentialRecordUpdatedEvent, record, walletId))
    } yield ()
    result.catchAll(e => ZIO.logError(s"Notification service error: $e"))
  }

  override def reportProcessingFailure(
      recordId: DidCommID,
      failReason: Option[_root_.java.lang.String]
  ): ZIO[WalletAccessContext, CredentialServiceError, Unit] =
    svc.reportProcessingFailure(recordId, failReason)

  override def getIssueCredentialRecord(
      recordId: DidCommID
  ): ZIO[WalletAccessContext, CredentialServiceError, Option[IssueCredentialRecord]] =
    svc.getIssueCredentialRecord(recordId)

  override def getIssueCredentialRecordByThreadId(
      thid: DidCommID,
      ignoreWithZeroRetries: Boolean
  ): ZIO[WalletAccessContext, CredentialServiceError, Option[IssueCredentialRecord]] =
    svc.getIssueCredentialRecordByThreadId(thid, ignoreWithZeroRetries)

  override def getIssueCredentialRecords(
      ignoreWithZeroRetries: Boolean,
      offset: Option[Int] = None,
      limit: Option[Int] = None
  ): ZIO[WalletAccessContext, CredentialServiceError, (Seq[IssueCredentialRecord], Int)] =
    svc.getIssueCredentialRecords(ignoreWithZeroRetries, offset, limit)

  override def getIssueCredentialRecordsByStates(
      ignoreWithZeroRetries: Boolean,
      limit: Int,
      states: IssueCredentialRecord.ProtocolState*
  ): ZIO[WalletAccessContext, CredentialServiceError, Seq[IssueCredentialRecord]] =
    svc.getIssueCredentialRecordsByStates(ignoreWithZeroRetries, limit, states: _*)

  override def getIssueCredentialRecordsByStatesForAllWallets(
      ignoreWithZeroRetries: Boolean,
      limit: Int,
      states: IssueCredentialRecord.ProtocolState*
  ): IO[CredentialServiceError, Seq[IssueCredentialRecord]] =
    svc.getIssueCredentialRecordsByStatesForAllWallets(ignoreWithZeroRetries, limit, states: _*)
}

object CredentialServiceNotifier {
  val layer: URLayer[CredentialService & EventNotificationService, CredentialServiceNotifier] =
    ZLayer.fromFunction(CredentialServiceNotifier(_, _))
}

1	package io.iohk.atala.pollux.core.service
2
3	import io.circe.Json
4	import io.iohk.atala.castor.core.model.did.CanonicalPrismDID
5	import io.iohk.atala.event.notification.*
6	import io.iohk.atala.mercury.model.DidId
7	import io.iohk.atala.mercury.protocol.issuecredential.{IssueCredential, OfferCredential, RequestCredential}
8	import io.iohk.atala.pollux.core.model.error.CredentialServiceError
9	import io.iohk.atala.pollux.core.model.{DidCommID, IssueCredentialRecord}
10	import io.iohk.atala.shared.models.WalletAccessContext
11	import zio.{URLayer, ZIO, ZLayer, IO}
12
13	import java.util.UUID
14
15	class CredentialServiceNotifier(
16	svc: CredentialService,
17	eventNotificationService: EventNotificationService
18	) extends CredentialService {
19
20	private val issueCredentialRecordUpdatedEvent = "IssueCredentialRecordUpdated"
21		1✔
22	override def createJWTIssueCredentialRecord(
23	pairwiseIssuerDID: DidId,
24	pairwiseHolderDID: DidId,
25	thid: DidCommID,
26	maybeSchemaId: Option[String],
27	claims: Json,
28	validityPeriod: Option[Double],
29	automaticIssuance: Option[Boolean],
30	issuingDID: CanonicalPrismDID
31	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
32	notifyOnSuccess(	1✔
33	svc.createJWTIssueCredentialRecord(
34	pairwiseIssuerDID,
35	pairwiseHolderDID,
36	thid,
37	maybeSchemaId,
38	claims,
39	validityPeriod,
40	automaticIssuance,
41	issuingDID
42	)
43	)
44		×
45	override def createAnonCredsIssueCredentialRecord(
46	pairwiseIssuerDID: DidId,
47	pairwiseHolderDID: DidId,
48	thid: DidCommID,
49	credentialDefinitionGUID: UUID,
50	credentialDefinitionId: _root_.java.lang.String,
51	claims: Json,
52	validityPeriod: Option[Double],
53	automaticIssuance: Option[Boolean]
54	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	×
55	notifyOnSuccess(	×
56	svc.createAnonCredsIssueCredentialRecord(
57	pairwiseIssuerDID,
58	pairwiseHolderDID,
59	thid,
60	credentialDefinitionGUID,
61	credentialDefinitionId,
62	claims,
63	validityPeriod,
64	automaticIssuance
65	)
66	)
67		1✔
68	override def markOfferSent(
69	recordId: DidCommID
70	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
71	notifyOnSuccess(svc.markOfferSent(recordId))
72		1✔
73	override def receiveCredentialOffer(
74	offer: OfferCredential
75	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
76	notifyOnSuccess(svc.receiveCredentialOffer(offer))
77		1✔
78	override def acceptCredentialOffer(
79	recordId: DidCommID,
80	subjectId: Option[String]
81	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
82	notifyOnSuccess(svc.acceptCredentialOffer(recordId, subjectId))
83		1✔
84	override def generateJWTCredentialRequest(
85	recordId: DidCommID
86	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
87	notifyOnSuccess(svc.generateJWTCredentialRequest(recordId))
88		×
89	override def generateAnonCredsCredentialRequest(
90	recordId: DidCommID
91	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	×
92	notifyOnSuccess(svc.generateAnonCredsCredentialRequest(recordId))
93		1✔
94	override def markRequestSent(
95	recordId: DidCommID
96	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
97	notifyOnSuccess(svc.markRequestSent(recordId))
98		1✔
99	override def receiveCredentialRequest(
100	request: RequestCredential
101	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
102	notifyOnSuccess(svc.receiveCredentialRequest(request))
103		1✔
104	override def acceptCredentialRequest(
105	recordId: DidCommID
106	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
107	notifyOnSuccess(svc.acceptCredentialRequest(recordId))
108		1✔
109	override def markCredentialSent(
110	recordId: DidCommID
111	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
112	notifyOnSuccess(svc.markCredentialSent(recordId))
113		1✔
114	override def receiveCredentialIssue(
115	issueCredential: IssueCredential
116	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
117	notifyOnSuccess(svc.receiveCredentialIssue(issueCredential))
118		1✔
119	override def generateJWTCredential(
120	recordId: DidCommID,
121	statusListRegistryUrl: String
122	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	1✔
123	notifyOnSuccess(svc.generateJWTCredential(recordId, statusListRegistryUrl))
124		×
125	override def generateAnonCredsCredential(
126	recordId: DidCommID
127	): ZIO[WalletAccessContext, CredentialServiceError, IssueCredentialRecord] =	×
128	notifyOnSuccess(svc.generateAnonCredsCredential(recordId))
129		1✔
130	private[this] def notifyOnSuccess[R](effect: ZIO[R, CredentialServiceError, IssueCredentialRecord]) =	1✔
131	for {
UNCOV 132	record <- effect	×
133	_ <- notify(record)
134	} yield record
135		1✔
136	private[this] def notify(record: IssueCredentialRecord) = {	1✔
137	val result = for {	×
138	walletId <- ZIO.serviceWith[WalletAccessContext](_.walletId)	1✔
139	producer <- eventNotificationService.producer[IssueCredentialRecord]("Issue")	1✔
140	_ <- producer.send(Event(issueCredentialRecordUpdatedEvent, record, walletId))
141	} yield ()	×
142	result.catchAll(e => ZIO.logError(s"Notification service error: $e"))
143	}
144		×
145	override def reportProcessingFailure(
146	recordId: DidCommID,
147	failReason: Option[_root_.java.lang.String]
148	): ZIO[WalletAccessContext, CredentialServiceError, Unit] =	×
149	svc.reportProcessingFailure(recordId, failReason)
150		×
151	override def getIssueCredentialRecord(
152	recordId: DidCommID
153	): ZIO[WalletAccessContext, CredentialServiceError, Option[IssueCredentialRecord]] =	×
154	svc.getIssueCredentialRecord(recordId)
155		×
156	override def getIssueCredentialRecordByThreadId(
157	thid: DidCommID,
158	ignoreWithZeroRetries: Boolean
159	): ZIO[WalletAccessContext, CredentialServiceError, Option[IssueCredentialRecord]] =	×
160	svc.getIssueCredentialRecordByThreadId(thid, ignoreWithZeroRetries)
161		×
162	override def getIssueCredentialRecords(
163	ignoreWithZeroRetries: Boolean,	×
164	offset: Option[Int] = None,	×
165	limit: Option[Int] = None
166	): ZIO[WalletAccessContext, CredentialServiceError, (Seq[IssueCredentialRecord], Int)] =	×
167	svc.getIssueCredentialRecords(ignoreWithZeroRetries, offset, limit)
168		×
169	override def getIssueCredentialRecordsByStates(
170	ignoreWithZeroRetries: Boolean,
171	limit: Int,
172	states: IssueCredentialRecord.ProtocolState*
173	): ZIO[WalletAccessContext, CredentialServiceError, Seq[IssueCredentialRecord]] =	×
174	svc.getIssueCredentialRecordsByStates(ignoreWithZeroRetries, limit, states: _*)
175		×
176	override def getIssueCredentialRecordsByStatesForAllWallets(
177	ignoreWithZeroRetries: Boolean,
178	limit: Int,
179	states: IssueCredentialRecord.ProtocolState*
180	): IO[CredentialServiceError, Seq[IssueCredentialRecord]] =	×
181	svc.getIssueCredentialRecordsByStatesForAllWallets(ignoreWithZeroRetries, limit, states: _*)
182	}
183
184	object CredentialServiceNotifier {
185	val layer: URLayer[CredentialService & EventNotificationService, CredentialServiceNotifier] =	1✔
186	ZLayer.fromFunction(CredentialServiceNotifier(_, _))
187	}

input-output-hk / atala-prism-building-blocks / 8835565085

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