Add DB round-trip tests for new fields in StorageBackendTestValues

digital-asset · fabiotudone-da · Aug 31, 2021 · Aug 19, 2021 · Aug 23, 2021 · Aug 23, 2021
commit 5643b95f2c15ba95bde2a0e5c4edbe21b5fbc4aa
diff --git a/...-integration-api/src/test/lib/scala/platform/store/backend/StorageBackendTestValues.scala b/...-integration-api/src/test/lib/scala/platform/store/backend/StorageBackendTestValues.scala
@@ -41,6 +41,7 @@ private[backend] object StorageBackendTestValues {
     ParameterStorageBackend.IdentityParams(someLedgerId, someParticipantId)
   val someParty: Ref.Party = Ref.Party.assertFromString("party")
   val someApplicationId: Ref.ApplicationId = Ref.ApplicationId.assertFromString("application_id")
+  val someSubmissionId: String = "submission_id"
 
   val someArchive: DamlLf.Archive = DamlLf.Archive.newBuilder
     .setHash("00001")
@@ -205,44 +206,16 @@ private[backend] object StorageBackendTestValues {
     )
   }
 
-  sealed trait Deduplication extends Product with Serializable {
-    import Deduplication.{Offset => DedupOffset, _}
-
-    def startOffset: Option[String] = this match {
-      case DedupOffset(offset) => Some(offset)
-      case _ => None
-    }
-    def duration: Option[SecondsAndNanos] = this match {
-      case Span(span) => Some(span)
-      case _ => None
-    }
-    def startInstant: Option[Instant] = this match {
-      case Start(instant) => Some(instant)
-      case _ => None
-    }
-  }
-  object Deduplication {
-    final case class SecondsAndNanos(seconds: Long, nanos: Int) {
-      def allComponentsAreNonNegative: Boolean = seconds >= 0 && nanos >= 0
-    }
-
-    final case class Offset(offset: String) extends Deduplication
-    final case class Span(span: SecondsAndNanos) extends Deduplication {
-      require(
-        span.allComponentsAreNonNegative,
-        s"All the deduplication window components must not be negative: $span",
-      )
-    }
-    final case class Start(instant: Instant) extends Deduplication
-  }
-
   def dtoCompletion(
       offset: Offset,
       submitter: String = "signatory",
       commandId: String = UUID.randomUUID().toString,
       applicationId: String = someApplicationId,
       submissionId: Option[String] = Some(UUID.randomUUID().toString),
-      deduplication: Option[Deduplication] = None,
+      deduplicationOffset: Option[String] = None,
+      deduplicationTimeSeconds: Option[Long] = None,
+      deduplicationTimeNanos: Option[Int] = None,
+      deduplicationStart: Option[Instant] = None,
   ): DbDto.CommandCompletion =
     DbDto.CommandCompletion(
       completion_offset = offset.toHexString,
@@ -255,10 +228,10 @@ private[backend] object StorageBackendTestValues {
       rejection_status_message = None,
       rejection_status_details = None,
       submission_id = submissionId,
-      deduplication_offset = deduplication.flatMap(_.startOffset),
-      deduplication_time_seconds = deduplication.flatMap(_.duration.map(_.seconds)),
-      deduplication_time_nanos = deduplication.flatMap(_.duration.map(_.nanos)),
-      deduplication_start = deduplication.flatMap(_.startInstant),
+      deduplication_offset = deduplicationOffset,
+      deduplication_time_seconds = deduplicationTimeSeconds,
+      deduplication_time_nanos = deduplicationTimeNanos,
+      deduplication_start = deduplicationStart,
     )
 
   def dtoTransactionId(dto: DbDto): Ref.TransactionId = {

diff --git a/...ration-api/src/test/lib/scala/platform/store/backend/StorageBackendTestsCompletions.scala b/...ration-api/src/test/lib/scala/platform/store/backend/StorageBackendTestsCompletions.scala
@@ -3,6 +3,8 @@
 
 package com.daml.platform.store.backend
 
+import java.time.Duration
+
 import com.daml.ledger.offset.Offset
 import org.scalatest.Inside
 import org.scalatest.flatspec.AsyncFlatSpec
@@ -53,4 +55,183 @@ private[backend] trait StorageBackendTestsCompletions
     }
   }
 
+  it should "correctly persist and retrieve application IDs" in {
+    val party = someParty
+    val applicationId = someApplicationId
+
+    val dtos = Vector(
+      dtoConfiguration(offset(1)),
+      dtoCompletion(offset(2), submitter = party),
+    )
+
+    for {
+      _ <- executeSql(backend.initializeParameters(someIdentityParams))
+      _ <- executeSql(ingest(dtos, _))
+      _ <- executeSql(backend.updateLedgerEnd(ParameterStorageBackend.LedgerEnd(offset(2), 1L)))
+      completions <- executeSql(
+        backend.commandCompletions(offset(1), offset(2), applicationId, Set(party))
+      )
+    } yield {
+      completions should have length 1
+      completions.head.completions should have length 1
+      completions.head.completions.head.applicationId should be(applicationId)
+    }
+  }
+
+  it should "correctly persist and retrieve submission IDs" in {
+    val party = someParty
+    val submissionId = Some(someSubmissionId)
+
+    val dtos = Vector(
+      dtoConfiguration(offset(1)),
+      dtoCompletion(offset(2), submitter = party, submissionId = submissionId),
+      dtoCompletion(offset(3), submitter = party, submissionId = None),
+    )
+
+    for {
+      _ <- executeSql(backend.initializeParameters(someIdentityParams))
+      _ <- executeSql(ingest(dtos, _))
+      _ <- executeSql(backend.updateLedgerEnd(ParameterStorageBackend.LedgerEnd(offset(3), 2L)))
+      completions <- executeSql(
+        backend.commandCompletions(offset(1), offset(3), someApplicationId, Set(party))
+      )
+    } yield {
+      completions should have length 2
+      val List(completionWithSubmissionId, completionWithoutSubmissionId) = completions
+      completionWithSubmissionId.completions should have length 1
+      completionWithSubmissionId.completions.head.submissionId should be(submissionId)
+      completionWithoutSubmissionId.completions should have length 1
+      completionWithoutSubmissionId.completions.head.submissionId should be("")
+    }
+  }
+
+  it should "correctly persist and retrieve command deduplication offsets" in {
+    val party = someParty
+    val anOffset = "someOffset"
+
+    val dtos = Vector(
+      dtoConfiguration(offset(1)),
+      dtoCompletion(
+        offset(2),
+        submitter = party,
+        deduplicationOffset = Some(anOffset),
+      ),
+      dtoCompletion(offset(3), submitter = party, deduplicationOffset = None),
+    )
+
+    for {
+      _ <- executeSql(backend.initializeParameters(someIdentityParams))
+      _ <- executeSql(ingest(dtos, _))
+      _ <- executeSql(backend.updateLedgerEnd(ParameterStorageBackend.LedgerEnd(offset(3), 2L)))
+      completions <- executeSql(
+        backend.commandCompletions(offset(1), offset(3), someApplicationId, Set(party))
+      )
+    } yield {
+      completions should have length 2
+      val List(completionWithDeduplicationOffset, completionWithoutDeduplicationOffset) =
+        completions
+      completionWithDeduplicationOffset.completions should have length 1
+      completionWithDeduplicationOffset.completions.head.deduplicationPeriod.deduplicationOffset should be(
+        Some(anOffset)
+      )
+      completionWithoutDeduplicationOffset.completions should have length 1
+      completionWithoutDeduplicationOffset.completions.head.deduplicationPeriod.deduplicationOffset should not be defined
+    }
+  }
+
+  it should "correctly persist and retrieve command deduplication times" in {
+    val party = someParty
+    val seconds = 100L
+    val nanos = 10
+    val expectedDuration = Duration.ofSeconds(seconds).plusNanos(nanos.toLong)
+
+    val dtos = Vector(
+      dtoConfiguration(offset(1)),
+      dtoCompletion(
+        offset(2),
+        submitter = party,
+        deduplicationTimeSeconds = Some(seconds),
+        deduplicationTimeNanos = Some(nanos),
+      ),
+      dtoCompletion(
+        offset(3),
+        submitter = party,
+        deduplicationTimeSeconds = None,
+        deduplicationTimeNanos = None,
+      ),
+    )
+
+    for {
+      _ <- executeSql(backend.initializeParameters(someIdentityParams))
+      _ <- executeSql(ingest(dtos, _))
+      _ <- executeSql(backend.updateLedgerEnd(ParameterStorageBackend.LedgerEnd(offset(3), 2L)))
+      completions <- executeSql(
+        backend.commandCompletions(offset(1), offset(3), someApplicationId, Set(party))
+      )
+    } yield {
+      completions should have length 2
+      val List(completionWithDeduplicationOffset, completionWithoutDeduplicationOffset) =
+        completions
+      completionWithDeduplicationOffset.completions should have length 1
+      completionWithDeduplicationOffset.completions.head.deduplicationPeriod.deduplicationOffset should be(
+        expectedDuration
+      )
+      completionWithoutDeduplicationOffset.completions should have length 1
+      completionWithoutDeduplicationOffset.completions.head.deduplicationPeriod.deduplicationTime should not be defined
+    }
+  }
+
+  it should "fail on broken command deduplication times in DB" in {
+    val party = someParty
+    val seconds = 100L
+    val nanos = 10
+
+    val dtos1 = Vector(
+      dtoConfiguration(offset(1)),
+      dtoCompletion(
+        offset(2),
+        submitter = party,
+        deduplicationTimeSeconds = Some(seconds),
+        deduplicationTimeNanos = None,
+      ),
+    )
+
+    for {
+      _ <- executeSql(backend.initializeParameters(someIdentityParams))
+      _ <- executeSql(ingest(dtos1, _))
+      _ <- executeSql(backend.updateLedgerEnd(ParameterStorageBackend.LedgerEnd(offset(2), 1L)))
+      result <- executeSql(
+        backend.commandCompletions(offset(1), offset(2), someApplicationId, Set(party))
+      ).failed
+    } yield {
+      result.getCause shouldBe an[IllegalArgumentException]
+      result.getCause.getMessage should be(
+        "One of deduplication time seconds and nanos has been provided " +
+          "but they must be either both provided or both absent"
+      )
+    }
+
+    val dtos2 = Vector(
+      dtoCompletion(
+        offset(3),
+        submitter = party,
+        deduplicationTimeSeconds = None,
+        deduplicationTimeNanos = Some(nanos),
+      )
+    )
+
+    for {
+      _ <- executeSql(ingest(dtos2, _))
+      _ <- executeSql(backend.updateLedgerEnd(ParameterStorageBackend.LedgerEnd(offset(3), 2L)))
+      result <- executeSql(
+        backend.commandCompletions(offset(2), offset(3), someApplicationId, Set(party))
+      ).failed
+    } yield {
+      result.getCause shouldBe an[IllegalArgumentException]
+      result.getCause.getMessage should be(
+        "One of deduplication time seconds and nanos has been provided " +
+          "but they must be either both provided or both absent"
+      )
+    }
+  }
 }