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

29.17

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

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

import io.iohk.atala.pollux.core.model.error.CredentialSchemaError
import io.iohk.atala.pollux.core.model.schema.CredentialSchema
import io.iohk.atala.pollux.core.model.schema.CredentialSchema.FilteredEntries
import io.iohk.atala.pollux.core.repository.CredentialSchemaRepository
import io.iohk.atala.pollux.core.repository.Repository.SearchQuery
import io.iohk.atala.pollux.core.service.CredentialSchemaService.Error.*
import zio.ZIO.{fail, getOrFailWith, succeed}
import zio.{URLayer, ZLayer}
import zio.IO

import java.util.UUID

class CredentialSchemaServiceImpl(
    credentialSchemaRepository: CredentialSchemaRepository
) extends CredentialSchemaService {
  override def create(in: CredentialSchema.Input): Result[CredentialSchema] = {
    for {
      credentialSchema <- CredentialSchema.make(in)
      _ <- CredentialSchema.validateCredentialSchema(credentialSchema)
      createdCredentialSchema <- credentialSchemaRepository
        .create(credentialSchema)
    } yield createdCredentialSchema
  }.mapError {
    case e: CredentialSchemaError => CredentialSchemaValidationError(e)
    case t: Throwable             => RepositoryError(t)
  }

  override def getByGUID(guid: UUID): IO[CredentialSchemaService.Error, CredentialSchema] = {
    credentialSchemaRepository
      .getByGuid(guid)
      .mapError[CredentialSchemaService.Error](t => RepositoryError(t))
      .flatMap(
        getOrFailWith(NotFoundError.byGuid(guid))(_)
      )
  }

  def getBy(
      author: String,
      id: UUID,
      version: String
  ): Result[CredentialSchema] = {
    getByGUID(CredentialSchema.makeGUID(author, id, version))
  }

  override def update(
      id: UUID,
      in: CredentialSchema.Input
  ): Result[CredentialSchema] = {
    for {
      cs <- CredentialSchema.make(id, in)
      _ <- CredentialSchema.validateCredentialSchema(cs).mapError(CredentialSchemaValidationError.apply)
      existingVersions <- credentialSchemaRepository
        .getAllVersions(id, in.author)
        .mapError[CredentialSchemaService.Error](RepositoryError.apply)
      _ <- existingVersions.headOption match {
        case None =>
          fail(NotFoundError.byId(id))
        case _ =>
          succeed(cs)
      }
      _ <- existingVersions.find(_ > in.version) match {
        case Some(higherVersion) =>
          fail(
            UpdateError(
              id,
              in.version,
              in.author,
              s"Higher version is found: $higherVersion"
            )
          )
        case None =>
          succeed(cs)
      }
      _ <- existingVersions.find(_ == in.version) match {
        case Some(existingVersion) =>
          fail(
            UpdateError(
              id,
              in.version,
              in.author,
              s"The version already exists: $existingVersion"
            )
          )
        case None => succeed(cs)
      }
      updated <- credentialSchemaRepository
        .create(cs)
        .mapError[CredentialSchemaService.Error](RepositoryError.apply)
    } yield updated
  }
  override def delete(guid: UUID): Result[CredentialSchema] = {
    for {
      deleted_row_opt <- credentialSchemaRepository
        .delete(guid)
        .mapError(RepositoryError.apply)
      deleted_row <- getOrFailWith(NotFoundError.byGuid(guid))(deleted_row_opt)
    } yield deleted_row
  }

  override def lookup(
      filter: CredentialSchema.Filter,
      skip: Int,
      limit: Int
  ): Result[CredentialSchema.FilteredEntries] = {
    credentialSchemaRepository
      .search(SearchQuery(filter, skip, limit))
      .mapError(t => RepositoryError(t))
      .map(sr => FilteredEntries(sr.entries, sr.count.toInt, sr.totalCount.toInt))
  }
}

object CredentialSchemaServiceImpl {
  val layer: URLayer[CredentialSchemaRepository, CredentialSchemaService] =
    ZLayer.fromFunction(CredentialSchemaServiceImpl(_))
}

1	package io.iohk.atala.pollux.core.service
2
3	import io.iohk.atala.pollux.core.model.error.CredentialSchemaError
4	import io.iohk.atala.pollux.core.model.schema.CredentialSchema
5	import io.iohk.atala.pollux.core.model.schema.CredentialSchema.FilteredEntries
6	import io.iohk.atala.pollux.core.repository.CredentialSchemaRepository
7	import io.iohk.atala.pollux.core.repository.Repository.SearchQuery
8	import io.iohk.atala.pollux.core.service.CredentialSchemaService.Error.*
9	import zio.ZIO.{fail, getOrFailWith, succeed}
10	import zio.{URLayer, ZLayer}
11	import zio.IO
12
13	import java.util.UUID
14
15	class CredentialSchemaServiceImpl(
16	credentialSchemaRepository: CredentialSchemaRepository
17	) extends CredentialSchemaService {	1✔
18	override def create(in: CredentialSchema.Input): Result[CredentialSchema] = {	×
19	for {	×
20	credentialSchema <- CredentialSchema.make(in)	×
21	_ <- CredentialSchema.validateCredentialSchema(credentialSchema)	×
22	createdCredentialSchema <- credentialSchemaRepository	×
23	.create(credentialSchema)
24	} yield createdCredentialSchema
25	}.mapError {	1✔
26	case e: CredentialSchemaError => CredentialSchemaValidationError(e)	×
27	case t: Throwable => RepositoryError(t)
28	}
29		1✔
30	override def getByGUID(guid: UUID): IO[CredentialSchemaService.Error, CredentialSchema] = {	×
31	credentialSchemaRepository	×
32	.getByGuid(guid)
33	.mapError[CredentialSchemaService.Error](t => RepositoryError(t))
34	.flatMap(	1✔
35	getOrFailWith(NotFoundError.byGuid(guid))(_)
36	)
37	}
38		×
39	def getBy(
40	author: String,
41	id: UUID,
42	version: String
43	): Result[CredentialSchema] = {	×
44	getByGUID(CredentialSchema.makeGUID(author, id, version))
45	}
46		1✔
47	override def update(
48	id: UUID,
49	in: CredentialSchema.Input
50	): Result[CredentialSchema] = {	1✔
51	for {	×
52	cs <- CredentialSchema.make(id, in)	1✔
UNCOV 53	_ <- CredentialSchema.validateCredentialSchema(cs).mapError(CredentialSchemaValidationError.apply)	×
54	existingVersions <- credentialSchemaRepository	×
55	.getAllVersions(id, in.author)
56	.mapError[CredentialSchemaService.Error](RepositoryError.apply)	1✔
57	_ <- existingVersions.headOption match {	×
58	case None =>	×
59	fail(NotFoundError.byId(id))	×
60	case _ =>	×
61	succeed(cs)
62	}	1✔
63	_ <- existingVersions.find(_ > in.version) match {	×
64	case Some(higherVersion) =>	×
65	fail(
66	UpdateError(
67	id,
68	in.version,
69	in.author,	×
70	s"Higher version is found: $higherVersion"
71	)
72	)	×
73	case None =>	×
74	succeed(cs)
75	}	1✔
76	_ <- existingVersions.find(_ == in.version) match {	×
77	case Some(existingVersion) =>	×
78	fail(
79	UpdateError(
80	id,
81	in.version,
82	in.author,	×
83	s"The version already exists: $existingVersion"
84	)
85	)	×
86	case None => succeed(cs)
UNCOV 87	}	×
88	updated <- credentialSchemaRepository	×
89	.create(cs)
90	.mapError[CredentialSchemaService.Error](RepositoryError.apply)
91	} yield updated
92	}	×
93	override def delete(guid: UUID): Result[CredentialSchema] = {	×
94	for {	×
95	deleted_row_opt <- credentialSchemaRepository	×
96	.delete(guid)
97	.mapError(RepositoryError.apply)	×
98	deleted_row <- getOrFailWith(NotFoundError.byGuid(guid))(deleted_row_opt)
99	} yield deleted_row
100	}
101		1✔
102	override def lookup(
103	filter: CredentialSchema.Filter,
104	skip: Int,
105	limit: Int
106	): Result[CredentialSchema.FilteredEntries] = {	1✔
107	credentialSchemaRepository	×
108	.search(SearchQuery(filter, skip, limit))
109	.mapError(t => RepositoryError(t))	1✔
110	.map(sr => FilteredEntries(sr.entries, sr.count.toInt, sr.totalCount.toInt))
111	}
112	}
113
114	object CredentialSchemaServiceImpl {
115	val layer: URLayer[CredentialSchemaRepository, CredentialSchemaService] =	1✔
116	ZLayer.fromFunction(CredentialSchemaServiceImpl(_))
117	}

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