mirror of
https://github.com/digital-asset/daml.git
synced 2024-09-19 08:48:21 +03:00
kvutils: Use mockito-scala's ArgumentMatchersSugar. (#8218)
CHANGELOG_BEGIN CHANGELOG_END
This commit is contained in:
Samir Talwar
GitHub
parent
5f1d5ad118
commit
79a91669b2
@ -12,8 +12,7 @@ import com.daml.lf.data.Ref
|
||||
import com.daml.metrics.Metrics
|
||||
import com.daml.platform.akkastreams.dispatcher.Dispatcher
|
||||
import com.google.protobuf.ByteString
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
|
||||
@ -23,12 +22,13 @@ class InMemoryLedgerReaderWriterSpec
|
||||
extends AsyncWordSpec
|
||||
with AkkaBeforeAndAfterAll
|
||||
with Matchers
|
||||
with MockitoSugar {
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
"commit" should {
|
||||
"not signal new head in case of failure" in {
|
||||
val mockDispatcher = mock[Dispatcher[Index]]
|
||||
val mockCommitter = mock[ValidateAndCommit]
|
||||
when(mockCommitter(anyString(), any[ByteString](), any[ParticipantId]()))
|
||||
when(mockCommitter(any[String], any[ByteString], any[ParticipantId]))
|
||||
.thenReturn(
|
||||
Future.successful(SubmissionResult.InternalError("Validation failed with an exception")))
|
||||
val instance = new InMemoryLedgerReaderWriter(
|
||||
@ -43,7 +43,7 @@ class InMemoryLedgerReaderWriterSpec
|
||||
instance
|
||||
.commit("correlation ID", ByteString.copyFromUtf8("some bytes"), CommitMetadata.Empty)
|
||||
.map { actual =>
|
||||
verify(mockDispatcher, times(0)).signalNewHead(anyInt())
|
||||
verify(mockDispatcher, times(0)).signalNewHead(any[Int])
|
||||
actual should be(a[SubmissionResult.InternalError])
|
||||
}
|
||||
}
|
||||
|
||||
@ -14,12 +14,15 @@ import com.daml.lf.transaction.test.TransactionBuilder
|
||||
import com.daml.lf.transaction.{SubmittedTransaction, Transaction}
|
||||
import com.daml.logging.LoggingContext
|
||||
import com.daml.metrics.Metrics
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
|
||||
class StoreBackedCommandExecutorSpec extends AsyncWordSpec with MockitoSugar with Matchers {
|
||||
class StoreBackedCommandExecutorSpec
|
||||
extends AsyncWordSpec
|
||||
with Matchers
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
|
||||
private val emptyTransactionMetadata = Transaction.Metadata(
|
||||
submissionSeed = None,
|
||||
|
||||
@ -7,15 +7,12 @@ import akka.stream.Materializer
|
||||
import com.daml.ledger.api.health.HealthStatus
|
||||
import com.daml.ledger.api.testing.utils.AkkaBeforeAndAfterAll
|
||||
import com.daml.ledger.participant.state.kvutils.DamlKvutils.DamlSubmissionBatch
|
||||
import com.daml.ledger.participant.state.kvutils.{Envelope, MockitoHelpers}
|
||||
import com.daml.ledger.participant.state.kvutils.{Bytes, Envelope, MockitoHelpers}
|
||||
import com.daml.ledger.participant.state.v1.SubmissionResult
|
||||
import com.daml.ledger.participant.state.{kvutils, v1}
|
||||
import com.daml.logging.LoggingContext
|
||||
import com.google.protobuf.ByteString
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.Mockito.{times, verify, when}
|
||||
import org.mockito.MockitoSugar._
|
||||
import org.mockito.{ArgumentCaptor, ArgumentMatchers}
|
||||
import org.mockito.{ArgumentCaptor, ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.concurrent.Eventually
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
@ -27,7 +24,9 @@ class BatchingLedgerWriterSpec
|
||||
extends AsyncWordSpec
|
||||
with AkkaBeforeAndAfterAll
|
||||
with Eventually
|
||||
with Matchers {
|
||||
with Matchers
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
|
||||
import BatchingLedgerWriterSpec._
|
||||
|
||||
@ -40,8 +39,7 @@ class BatchingLedgerWriterSpec
|
||||
val handle = mock[RunningBatchingQueueHandle]
|
||||
when(handle.state).thenReturn(RunningBatchingQueueState.Closing)
|
||||
val queue = mock[BatchingQueue]
|
||||
when(queue.run(any[BatchingQueue.CommitBatchFunction]())(any[Materializer]))
|
||||
.thenReturn(handle)
|
||||
when(queue.run(any[BatchingQueue.CommitBatchFunction])(any[Materializer])).thenReturn(handle)
|
||||
val writer = mock[LedgerWriter]
|
||||
val batchingWriter =
|
||||
LoggingContext.newLoggingContext { implicit ctx =>
|
||||
@ -63,10 +61,9 @@ class BatchingLedgerWriterSpec
|
||||
submissionResult <- batchingWriter.commit(aCorrelationId, aSubmission, someCommitMetadata)
|
||||
} yield {
|
||||
verify(mockWriter).commit(
|
||||
anyString(),
|
||||
ArgumentMatchers.eq(expectedBatch),
|
||||
ArgumentMatchers.argThat((metadata: CommitMetadata) =>
|
||||
metadata.estimatedInterpretationCost.isEmpty)
|
||||
any[String],
|
||||
eqTo(expectedBatch),
|
||||
argThat((metadata: CommitMetadata) => metadata.estimatedInterpretationCost.isEmpty),
|
||||
)
|
||||
submissionResult should be(SubmissionResult.Acknowledged)
|
||||
}
|
||||
@ -84,8 +81,7 @@ class BatchingLedgerWriterSpec
|
||||
result2 <- batchingWriter.commit("test2", aSubmission, someCommitMetadata)
|
||||
result3 <- batchingWriter.commit("test3", aSubmission, someCommitMetadata)
|
||||
} yield {
|
||||
verify(mockWriter, times(3))
|
||||
.commit(anyString(), any[kvutils.Bytes], any[CommitMetadata])
|
||||
verify(mockWriter, times(3)).commit(any[String], any[Bytes], any[CommitMetadata])
|
||||
all(Seq(result1, result2, result3)) should be(SubmissionResult.Acknowledged)
|
||||
batchingWriter.currentHealth should be(HealthStatus.healthy)
|
||||
}
|
||||
@ -95,7 +91,7 @@ class BatchingLedgerWriterSpec
|
||||
|
||||
}
|
||||
|
||||
object BatchingLedgerWriterSpec {
|
||||
object BatchingLedgerWriterSpec extends MockitoSugar with ArgumentMatchersSugar {
|
||||
private val aCorrelationId = "aCorrelationId"
|
||||
private val aSubmission = ByteString.copyFromUtf8("a submission")
|
||||
|
||||
@ -119,11 +115,7 @@ object BatchingLedgerWriterSpec {
|
||||
|
||||
private def createMockWriter(captor: Option[ArgumentCaptor[kvutils.Bytes]]): LedgerWriter = {
|
||||
val writer = mock[LedgerWriter]
|
||||
when(
|
||||
writer.commit(
|
||||
anyString(),
|
||||
captor.map(_.capture()).getOrElse(any[kvutils.Bytes]),
|
||||
any[CommitMetadata]))
|
||||
when(writer.commit(any[String], captor.map(_.capture()).getOrElse(any), any[CommitMetadata]))
|
||||
.thenReturn(Future.successful(SubmissionResult.Acknowledged))
|
||||
when(writer.participantId).thenReturn(v1.ParticipantId.assertFromString("test-participant"))
|
||||
when(writer.currentHealth()).thenReturn(HealthStatus.healthy)
|
||||
|
||||
@ -7,8 +7,7 @@ import com.daml.ledger.api.health.{Healthy, Unhealthy}
|
||||
import com.daml.ledger.participant.state.kvutils.Bytes
|
||||
import com.daml.ledger.participant.state.v1.SubmissionResult.Acknowledged
|
||||
import com.google.protobuf.ByteString
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
|
||||
@ -17,7 +16,8 @@ import scala.concurrent.Future
|
||||
class InterpretationCostBasedLedgerWriterChooserSpec
|
||||
extends AsyncWordSpec
|
||||
with Matchers
|
||||
with MockitoSugar {
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
"commit" should {
|
||||
"delegate to cheap writer in case of no estimated interpretation cost" in {
|
||||
val commitMetadata = simpleCommitMetadata(estimatedInterpretationCost = None)
|
||||
@ -36,7 +36,7 @@ class InterpretationCostBasedLedgerWriterChooserSpec
|
||||
"delegate to cheap writer in case estimated interpretation cost is below threshold" in {
|
||||
val commitMetadata = simpleCommitMetadata(estimatedInterpretationCost = Some(1))
|
||||
val mockWriterCheap = mock[LedgerWriter]
|
||||
when(mockWriterCheap.commit(anyString(), any[Bytes], any[CommitMetadata]))
|
||||
when(mockWriterCheap.commit(any[String], any[Bytes], any[CommitMetadata]))
|
||||
.thenReturn(Future.successful(Acknowledged))
|
||||
val instance =
|
||||
new InterpretationCostBasedLedgerWriterChooser(2L, mockWriterCheap, mock[LedgerWriter])
|
||||
@ -50,7 +50,7 @@ class InterpretationCostBasedLedgerWriterChooserSpec
|
||||
"delegate to expensive writer in case estimated interpretation cost reaches the threshold" in {
|
||||
val commitMetadata = simpleCommitMetadata(estimatedInterpretationCost = Some(1))
|
||||
val mockWriterExpensive = mock[LedgerWriter]
|
||||
when(mockWriterExpensive.commit(anyString(), any[Bytes], any[CommitMetadata]))
|
||||
when(mockWriterExpensive.commit(any[String], any[Bytes], any[CommitMetadata]))
|
||||
.thenReturn(Future.successful(Acknowledged))
|
||||
val instance =
|
||||
new InterpretationCostBasedLedgerWriterChooser(1L, mock[LedgerWriter], mockWriterExpensive)
|
||||
@ -64,7 +64,7 @@ class InterpretationCostBasedLedgerWriterChooserSpec
|
||||
"delegate to expensive writer in case threshold is 0" in {
|
||||
val commitMetadata = simpleCommitMetadata(estimatedInterpretationCost = None)
|
||||
val mockWriterExpensive = mock[LedgerWriter]
|
||||
when(mockWriterExpensive.commit(anyString(), any[Bytes], any[CommitMetadata]))
|
||||
when(mockWriterExpensive.commit(any[String], any[Bytes], any[CommitMetadata]))
|
||||
.thenReturn(Future.successful(Acknowledged))
|
||||
val instance =
|
||||
new InterpretationCostBasedLedgerWriterChooser(0L, mock[LedgerWriter], mockWriterExpensive)
|
||||
|
||||
@ -22,17 +22,18 @@ import com.daml.lf.data.Ref
|
||||
import com.daml.lf.data.Time.Timestamp
|
||||
import com.daml.lf.transaction.test.TransactionBuilder
|
||||
import com.daml.metrics.Metrics
|
||||
import org.mockito.ArgumentCaptor
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.Mockito.{times, verify, when}
|
||||
import org.mockito.MockitoSugar._
|
||||
import org.mockito.{ArgumentCaptor, ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.Assertion
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AnyWordSpec
|
||||
|
||||
import scala.concurrent.Future
|
||||
|
||||
class KeyValueParticipantStateWriterSpec extends AnyWordSpec with Matchers {
|
||||
class KeyValueParticipantStateWriterSpec
|
||||
extends AnyWordSpec
|
||||
with Matchers
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
"participant state writer" should {
|
||||
"submit a transaction" in {
|
||||
val transactionCaptor = captor[Bytes]
|
||||
@ -49,7 +50,7 @@ class KeyValueParticipantStateWriterSpec extends AnyWordSpec with Matchers {
|
||||
TransactionBuilder.EmptySubmitted,
|
||||
anInterpretationCost)
|
||||
|
||||
verify(writer, times(1)).commit(anyString(), any[Bytes], any[CommitMetadata])
|
||||
verify(writer, times(1)).commit(any[String], any[Bytes], any[CommitMetadata])
|
||||
verifyEnvelope(transactionCaptor.getValue)(_.hasTransactionEntry)
|
||||
correlationIdCaptor.getValue should be(expectedCorrelationId)
|
||||
val actualCommitMetadata = metadataCaptor.getValue
|
||||
@ -66,7 +67,7 @@ class KeyValueParticipantStateWriterSpec extends AnyWordSpec with Matchers {
|
||||
|
||||
instance.uploadPackages(aSubmissionId, List.empty, sourceDescription = None)
|
||||
|
||||
verify(writer, times(1)).commit(anyString(), any[Bytes], any[CommitMetadata])
|
||||
verify(writer, times(1)).commit(any[String], any[Bytes], any[CommitMetadata])
|
||||
verifyEnvelope(packageUploadCaptor.getValue)(_.hasPackageUploadEntry)
|
||||
val actualCommitMetadata = metadataCaptor.getValue
|
||||
actualCommitMetadata.inputKeys(aSerializationStrategy) should not be empty
|
||||
@ -81,7 +82,7 @@ class KeyValueParticipantStateWriterSpec extends AnyWordSpec with Matchers {
|
||||
|
||||
instance.submitConfiguration(newRecordTime().addMicros(10000), aSubmissionId, aConfiguration)
|
||||
|
||||
verify(writer, times(1)).commit(anyString(), any[Bytes], any[CommitMetadata])
|
||||
verify(writer, times(1)).commit(any[String], any[Bytes], any[CommitMetadata])
|
||||
verifyEnvelope(configurationCaptor.getValue)(_.hasConfigurationSubmission)
|
||||
val actualCommitMetadata = metadataCaptor.getValue
|
||||
actualCommitMetadata.inputKeys(aSerializationStrategy) should not be empty
|
||||
@ -96,7 +97,7 @@ class KeyValueParticipantStateWriterSpec extends AnyWordSpec with Matchers {
|
||||
|
||||
instance.allocateParty(hint = None, displayName = None, aSubmissionId)
|
||||
|
||||
verify(writer, times(1)).commit(anyString(), any[Bytes], any[CommitMetadata])
|
||||
verify(writer, times(1)).commit(any[String], any[Bytes], any[CommitMetadata])
|
||||
verifyEnvelope(partyAllocationCaptor.getValue)(_.hasPartyAllocationEntry)
|
||||
val actualCommitMetadata = metadataCaptor.getValue
|
||||
actualCommitMetadata.inputKeys(aSerializationStrategy) should not be empty
|
||||
@ -113,6 +114,8 @@ class KeyValueParticipantStateWriterSpec extends AnyWordSpec with Matchers {
|
||||
|
||||
object KeyValueParticipantStateWriterSpec {
|
||||
|
||||
import MockitoSugar._
|
||||
|
||||
private val aParty = Ref.Party.assertFromString("aParty")
|
||||
|
||||
private val aSubmissionId: SubmissionId =
|
||||
|
||||
@ -9,20 +9,22 @@ import com.daml.ledger.validator.LedgerStateOperations.{Key, Value}
|
||||
import com.daml.ledger.validator.LogAppendingCommitStrategySpec._
|
||||
import com.daml.ledger.validator.TestHelper._
|
||||
import com.google.protobuf.ByteString
|
||||
import org.mockito.ArgumentMatchers
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
|
||||
import scala.concurrent.{ExecutionContext, Future}
|
||||
|
||||
final class LogAppendingCommitStrategySpec extends AsyncWordSpec with Matchers with MockitoSugar {
|
||||
final class LogAppendingCommitStrategySpec
|
||||
extends AsyncWordSpec
|
||||
with Matchers
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
"commit" should {
|
||||
"return index from appendToLog" in {
|
||||
val mockLedgerStateOperations = mock[LedgerStateOperations[Long]]
|
||||
val expectedIndex = 1234L
|
||||
when(mockLedgerStateOperations.appendToLog(any[Key](), any[Value]())(any[ExecutionContext]()))
|
||||
when(mockLedgerStateOperations.appendToLog(any[Key], any[Value])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(expectedIndex))
|
||||
val instance =
|
||||
new LogAppendingCommitStrategy[Long](
|
||||
@ -32,20 +34,19 @@ final class LogAppendingCommitStrategySpec extends AsyncWordSpec with Matchers w
|
||||
instance
|
||||
.commit(aParticipantId, "a correlation ID", aLogEntryId(), aLogEntry, Map.empty, Map.empty)
|
||||
.map { actualIndex =>
|
||||
verify(mockLedgerStateOperations, times(1)).appendToLog(any[Key](), any[Value]())(
|
||||
any[ExecutionContext]())
|
||||
verify(mockLedgerStateOperations, times(1)).appendToLog(any[Key], any[Value])(
|
||||
anyExecutionContext)
|
||||
verify(mockLedgerStateOperations, times(0))
|
||||
.writeState(any[Seq[(Key, Value)]]())(any[ExecutionContext]())
|
||||
.writeState(any[Iterable[(Key, Value)]])(anyExecutionContext)
|
||||
actualIndex should be(expectedIndex)
|
||||
}
|
||||
}
|
||||
|
||||
"write keys serialized according to strategy" in {
|
||||
val mockLedgerStateOperations = mock[LedgerStateOperations[Long]]
|
||||
when(
|
||||
mockLedgerStateOperations.writeState(any[Iterable[(Key, Value)]])(any[ExecutionContext]()))
|
||||
when(mockLedgerStateOperations.writeState(any[Iterable[(Key, Value)]])(anyExecutionContext))
|
||||
.thenReturn(Future.unit)
|
||||
when(mockLedgerStateOperations.appendToLog(any[Key], any[Value])(any[ExecutionContext]()))
|
||||
when(mockLedgerStateOperations.appendToLog(any[Key], any[Value])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(0L))
|
||||
val mockStateKeySerializationStrategy = mock[StateKeySerializationStrategy]
|
||||
val expectedStateKey = ByteString.copyFromUtf8("some key")
|
||||
@ -68,7 +69,7 @@ final class LogAppendingCommitStrategySpec extends AsyncWordSpec with Matchers w
|
||||
.map { _: Long =>
|
||||
verify(mockStateKeySerializationStrategy, times(1)).serializeStateKey(aStateKey)
|
||||
verify(mockLedgerStateOperations, times(1))
|
||||
.writeState(ArgumentMatchers.eq(expectedOutputStateBytes))(any[ExecutionContext]())
|
||||
.writeState(eqTo(expectedOutputStateBytes))(anyExecutionContext)
|
||||
succeed
|
||||
}
|
||||
}
|
||||
@ -76,6 +77,11 @@ final class LogAppendingCommitStrategySpec extends AsyncWordSpec with Matchers w
|
||||
}
|
||||
|
||||
object LogAppendingCommitStrategySpec {
|
||||
|
||||
import ArgumentMatchersSugar._
|
||||
|
||||
private def anyExecutionContext = any[ExecutionContext]
|
||||
|
||||
private val aStateKey: DamlStateKey = DamlStateKey
|
||||
.newBuilder()
|
||||
.setContractId(1.toString)
|
||||
|
||||
@ -9,15 +9,20 @@ import com.daml.ledger.participant.state.kvutils.DamlKvutils.{
|
||||
DamlStateValue
|
||||
}
|
||||
import com.daml.ledger.participant.state.kvutils.Envelope
|
||||
import com.daml.ledger.validator.LedgerStateOperations.Key
|
||||
import com.daml.ledger.validator.RawToDamlLedgerStateReaderAdapterSpec._
|
||||
import com.daml.ledger.validator.TestHelper.{anInvalidEnvelope, makePartySubmission}
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
|
||||
import scala.concurrent.{ExecutionContext, Future}
|
||||
|
||||
class RawToDamlLedgerStateReaderAdapterSpec extends AsyncWordSpec with Matchers with MockitoSugar {
|
||||
class RawToDamlLedgerStateReaderAdapterSpec
|
||||
extends AsyncWordSpec
|
||||
with Matchers
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
"readState" should {
|
||||
"read the right key and deserialize it" in {
|
||||
val expectedKey = DefaultStateKeySerializationStrategy.serializeStateKey(aDamlStateKey())
|
||||
@ -25,7 +30,7 @@ class RawToDamlLedgerStateReaderAdapterSpec extends AsyncWordSpec with Matchers
|
||||
.setParty(DamlPartyAllocation.newBuilder.setDisplayName("aParty"))
|
||||
.build
|
||||
val mockReader = mock[LedgerStateReader]
|
||||
when(mockReader.read(any[Seq[LedgerStateOperations.Key]]())(any[ExecutionContext]()))
|
||||
when(mockReader.read(any[Seq[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(Envelope.enclose(expectedValue)))))
|
||||
val instance =
|
||||
new RawToDamlLedgerStateReaderAdapter(mockReader, DefaultStateKeySerializationStrategy)
|
||||
@ -38,7 +43,7 @@ class RawToDamlLedgerStateReaderAdapterSpec extends AsyncWordSpec with Matchers
|
||||
|
||||
"throw in case of an invalid envelope returned from underlying reader" in {
|
||||
val mockReader = mock[LedgerStateReader]
|
||||
when(mockReader.read(any[Seq[LedgerStateOperations.Key]]())(any[ExecutionContext]()))
|
||||
when(mockReader.read(any[Seq[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(anInvalidEnvelope))))
|
||||
val instance =
|
||||
new RawToDamlLedgerStateReaderAdapter(mockReader, DefaultStateKeySerializationStrategy)
|
||||
@ -52,7 +57,7 @@ class RawToDamlLedgerStateReaderAdapterSpec extends AsyncWordSpec with Matchers
|
||||
"throw in case an enveloped value other than a DamlStateValue is returned from underlying reader" in {
|
||||
val notADamlStateValue = makePartySubmission("aParty")
|
||||
val mockReader = mock[LedgerStateReader]
|
||||
when(mockReader.read(any[Seq[LedgerStateOperations.Key]]())(any[ExecutionContext]()))
|
||||
when(mockReader.read(any[Seq[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(Envelope.enclose(notADamlStateValue)))))
|
||||
val instance =
|
||||
new RawToDamlLedgerStateReaderAdapter(mockReader, DefaultStateKeySerializationStrategy)
|
||||
@ -63,6 +68,13 @@ class RawToDamlLedgerStateReaderAdapterSpec extends AsyncWordSpec with Matchers
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
object RawToDamlLedgerStateReaderAdapterSpec {
|
||||
|
||||
import ArgumentMatchersSugar._
|
||||
|
||||
private def anyExecutionContext = any[ExecutionContext]
|
||||
|
||||
private def aDamlStateKey(): DamlStateKey =
|
||||
DamlStateKey.newBuilder
|
||||
|
||||
@ -11,6 +11,7 @@ import com.daml.ledger.participant.state.kvutils.DamlKvutils._
|
||||
import com.daml.ledger.participant.state.kvutils.MockitoHelpers.captor
|
||||
import com.daml.ledger.participant.state.kvutils.{Bytes, Envelope, KeyValueCommitting}
|
||||
import com.daml.ledger.participant.state.v1.ParticipantId
|
||||
import com.daml.ledger.validator.LedgerStateOperations.{Key, Value}
|
||||
import com.daml.ledger.validator.SubmissionValidator.RawKeyValuePairs
|
||||
import com.daml.ledger.validator.SubmissionValidatorSpec._
|
||||
import com.daml.ledger.validator.ValidationFailed.{MissingInputState, ValidationError}
|
||||
@ -18,9 +19,7 @@ import com.daml.lf.data.Time.Timestamp
|
||||
import com.daml.lf.engine.Engine
|
||||
import com.daml.metrics.Metrics
|
||||
import com.google.protobuf.{ByteString, Empty}
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.Mockito.{times, verify, when}
|
||||
import org.mockito.MockitoSugar._
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.Inside
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
@ -28,11 +27,16 @@ import org.scalatest.wordspec.AsyncWordSpec
|
||||
import scala.concurrent.{ExecutionContext, Future}
|
||||
import scala.util.Try
|
||||
|
||||
class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
class SubmissionValidatorSpec
|
||||
extends AsyncWordSpec
|
||||
with Matchers
|
||||
with Inside
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
"validate" should {
|
||||
"return success in case of no errors during processing of submission" in {
|
||||
val mockStateOperations = mock[LedgerStateOperations[Unit]]
|
||||
when(mockStateOperations.readState(any[Seq[Bytes]]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.readState(any[Iterable[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(aStateValue()))))
|
||||
val instance = SubmissionValidator.create(
|
||||
new FakeStateAccess(mockStateOperations),
|
||||
@ -49,7 +53,7 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
|
||||
"signal missing input in case state cannot be retrieved" in {
|
||||
val mockStateOperations = mock[LedgerStateOperations[Unit]]
|
||||
when(mockStateOperations.readState(any[Seq[Bytes]]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.readState(any[Iterable[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(None)))
|
||||
val instance = SubmissionValidator.create(
|
||||
ledgerStateAccess = new FakeStateAccess(mockStateOperations),
|
||||
@ -86,7 +90,7 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
|
||||
"return invalid submission in case exception is thrown during processing of submission" in {
|
||||
val mockStateOperations = mock[BatchingLedgerStateOperations[Unit]]
|
||||
when(mockStateOperations.readState(any[Seq[Bytes]]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.readState(any[Iterable[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(aStateValue()))))
|
||||
|
||||
val failingProcessSubmission: SubmissionValidator.ProcessSubmission =
|
||||
@ -112,13 +116,13 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
"write marshalled log entry to ledger" in {
|
||||
val mockStateOperations = mock[LedgerStateOperations[Int]]
|
||||
val expectedLogResult: Int = 3
|
||||
when(mockStateOperations.readState(any[Seq[Bytes]]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.readState(any[Iterable[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(aStateValue()))))
|
||||
val logEntryValueCaptor = captor[Bytes]
|
||||
val logEntryIdCaptor = captor[Bytes]
|
||||
when(
|
||||
mockStateOperations.appendToLog(logEntryIdCaptor.capture(), logEntryValueCaptor.capture())(
|
||||
any[ExecutionContext]()))
|
||||
anyExecutionContext))
|
||||
.thenReturn(Future.successful(expectedLogResult))
|
||||
val expectedLogEntryId = aLogEntryId()
|
||||
val mockLogEntryIdGenerator = mockFunctionReturning(expectedLogEntryId)
|
||||
@ -140,7 +144,7 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
actualLogResult should be(expectedLogResult)
|
||||
verify(mockLogEntryIdGenerator, times(1)).apply()
|
||||
verify(mockStateOperations, times(0))
|
||||
.writeState(any[RawKeyValuePairs]())(any[ExecutionContext]())
|
||||
.writeState(any[Iterable[(Key, Value)]])(anyExecutionContext)
|
||||
logEntryValueCaptor.getAllValues should have size 1
|
||||
logEntryIdCaptor.getAllValues should have size 1
|
||||
logEntryIdCaptor.getValue should be(expectedLogEntryId.toByteString)
|
||||
@ -152,16 +156,13 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
"write marshalled key-value pairs to ledger" in {
|
||||
val mockStateOperations = mock[LedgerStateOperations[Int]]
|
||||
val expectedLogResult: Int = 7
|
||||
when(mockStateOperations.readState(any[Seq[Bytes]]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.readState(any[Iterable[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(aStateValue()))))
|
||||
val writtenKeyValuesCaptor = captor[RawKeyValuePairs]
|
||||
when(
|
||||
mockStateOperations.writeState(writtenKeyValuesCaptor.capture())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.writeState(writtenKeyValuesCaptor.capture())(anyExecutionContext))
|
||||
.thenReturn(Future.unit)
|
||||
val logEntryCaptor = captor[Bytes]
|
||||
when(
|
||||
mockStateOperations.appendToLog(any[Bytes](), logEntryCaptor.capture())(
|
||||
any[ExecutionContext]()))
|
||||
when(mockStateOperations.appendToLog(any[Key], logEntryCaptor.capture())(anyExecutionContext))
|
||||
.thenReturn(Future.successful(expectedLogResult))
|
||||
val logEntryAndStateResult = (aLogEntry(), someStateUpdates)
|
||||
val instance = new SubmissionValidator(
|
||||
@ -190,16 +191,13 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
"support batch with single submission" in {
|
||||
val mockStateOperations = mock[LedgerStateOperations[Int]]
|
||||
val expectedLogResult: Int = 7
|
||||
when(mockStateOperations.readState(any[Seq[Bytes]]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.readState(any[Iterable[Key]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(aStateValue()))))
|
||||
val writtenKeyValuesCaptor = captor[RawKeyValuePairs]
|
||||
when(
|
||||
mockStateOperations.writeState(writtenKeyValuesCaptor.capture())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.writeState(writtenKeyValuesCaptor.capture())(anyExecutionContext))
|
||||
.thenReturn(Future.unit)
|
||||
val logEntryCaptor = captor[Bytes]
|
||||
when(
|
||||
mockStateOperations.appendToLog(any[Bytes](), logEntryCaptor.capture())(
|
||||
any[ExecutionContext]()))
|
||||
when(mockStateOperations.appendToLog(any[Key], logEntryCaptor.capture())(anyExecutionContext))
|
||||
.thenReturn(Future.successful(expectedLogResult))
|
||||
val logEntryAndStateResult = (aLogEntry(), someStateUpdates)
|
||||
val instance = new SubmissionValidator(
|
||||
@ -266,11 +264,11 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
|
||||
"return invalid submission if state cannot be written" in {
|
||||
val mockStateOperations = mock[LedgerStateOperations[Int]]
|
||||
when(mockStateOperations.writeState(any[RawKeyValuePairs]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.writeState(any[Iterable[(Key, Value)]])(anyExecutionContext))
|
||||
.thenThrow(new IllegalArgumentException("Write error"))
|
||||
when(mockStateOperations.readState(any[Seq[Bytes]]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.readState(any[Iterable[Bytes]])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(Seq(Some(aStateValue()))))
|
||||
when(mockStateOperations.appendToLog(any[Bytes](), any[Bytes]())(any[ExecutionContext]()))
|
||||
when(mockStateOperations.appendToLog(any[Key], any[Value])(anyExecutionContext))
|
||||
.thenReturn(Future.successful(99))
|
||||
val logEntryAndStateResult = (aLogEntry(), someStateUpdates)
|
||||
val instance = new SubmissionValidator(
|
||||
@ -294,6 +292,11 @@ class SubmissionValidatorSpec extends AsyncWordSpec with Matchers with Inside {
|
||||
|
||||
object SubmissionValidatorSpec {
|
||||
|
||||
import ArgumentMatchersSugar._
|
||||
import MockitoSugar._
|
||||
|
||||
private def anyExecutionContext = any[ExecutionContext]
|
||||
|
||||
private def aLogEntry(): DamlLogEntry =
|
||||
DamlLogEntry
|
||||
.newBuilder()
|
||||
@ -331,7 +334,7 @@ object SubmissionValidatorSpec {
|
||||
|
||||
private def mockFunctionReturning[A](returnValue: A): () => A = {
|
||||
val mockFunction = mock[() => A]
|
||||
when(mockFunction.apply).thenReturn(returnValue)
|
||||
when(mockFunction.apply()).thenReturn(returnValue)
|
||||
mockFunction
|
||||
}
|
||||
|
||||
@ -342,5 +345,4 @@ object SubmissionValidatorSpec {
|
||||
)(implicit executionContext: ExecutionContext): Future[T] =
|
||||
body(mockStateOperations)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -15,12 +15,12 @@ import com.daml.ledger.participant.state.kvutils.export.SubmissionAggregator
|
||||
import com.daml.ledger.participant.state.v1.ParticipantId
|
||||
import com.daml.ledger.validator.CommitStrategy
|
||||
import com.daml.ledger.validator.TestHelper._
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import com.daml.ledger.validator.caching.CachingCommitStrategySpec._
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
|
||||
import scala.concurrent.Future
|
||||
import scala.concurrent.{ExecutionContext, Future}
|
||||
|
||||
class CachingCommitStrategySpec extends AsyncWordSpec with Matchers with MockitoSugar {
|
||||
"commit" should {
|
||||
@ -50,22 +50,29 @@ class CachingCommitStrategySpec extends AsyncWordSpec with Matchers with Mockito
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
object CachingCommitStrategySpec {
|
||||
|
||||
import ArgumentMatchersSugar._
|
||||
import MockitoSugar._
|
||||
|
||||
private def newCache(): Cache[DamlStateKey, DamlStateValue] =
|
||||
WeightedCache.from[DamlStateKey, DamlStateValue](WeightedCache.Configuration(1024))
|
||||
|
||||
private def createInstance(
|
||||
cache: Cache[DamlStateKey, DamlStateValue],
|
||||
shouldCache: Boolean): CachingCommitStrategy[Unit] = {
|
||||
shouldCache: Boolean,
|
||||
)(implicit executionContext: ExecutionContext): CachingCommitStrategy[Unit] = {
|
||||
val mockCommitStrategy = mock[CommitStrategy[Unit]]
|
||||
when(
|
||||
mockCommitStrategy.commit(
|
||||
any[ParticipantId](),
|
||||
anyString(),
|
||||
any[DamlLogEntryId](),
|
||||
any[DamlLogEntry](),
|
||||
any[Map[DamlStateKey, Option[DamlStateValue]]](),
|
||||
any[Map[DamlStateKey, DamlStateValue]](),
|
||||
any[ParticipantId],
|
||||
any[String],
|
||||
any[DamlLogEntryId],
|
||||
any[DamlLogEntry],
|
||||
any[Map[DamlStateKey, Option[DamlStateValue]]],
|
||||
any[Map[DamlStateKey, DamlStateValue]],
|
||||
any[Option[SubmissionAggregator.WriteSetBuilder]],
|
||||
))
|
||||
.thenReturn(Future.unit)
|
||||
|
||||
@ -7,8 +7,7 @@ import com.daml.caching.WeightedCache
|
||||
import com.daml.ledger.participant.state.kvutils.DamlKvutils.{DamlStateKey, DamlStateValue}
|
||||
import com.daml.ledger.participant.state.kvutils.caching.`Message Weight`
|
||||
import com.daml.ledger.validator.{DamlLedgerStateReader, DefaultStateKeySerializationStrategy}
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.Inside
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
@ -19,7 +18,8 @@ class CachingDamlLedgerStateReaderSpec
|
||||
extends AsyncWordSpec
|
||||
with Matchers
|
||||
with Inside
|
||||
with MockitoSugar {
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
|
||||
"readState" should {
|
||||
"record read keys" in {
|
||||
@ -59,7 +59,7 @@ class CachingDamlLedgerStateReaderSpec
|
||||
|
||||
"serve request from cache for seen key (if policy allows)" in {
|
||||
val mockReader = mock[DamlLedgerStateReader]
|
||||
when(mockReader.readState(any[Seq[DamlStateKey]]())).thenReturn(Future.successful(Seq(None)))
|
||||
when(mockReader.readState(any[Seq[DamlStateKey]])).thenReturn(Future.successful(Seq(None)))
|
||||
val instance = newInstance(mockReader, shouldCache = true)
|
||||
|
||||
for {
|
||||
|
||||
@ -28,8 +28,7 @@ import com.daml.lf.data.Time.Timestamp
|
||||
import com.daml.logging.LoggingContext
|
||||
import com.daml.metrics.Metrics
|
||||
import com.google.protobuf.ByteString
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.Assertion
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
@ -206,6 +205,7 @@ class PreExecutingSubmissionValidatorSpec extends AsyncWordSpec with Matchers wi
|
||||
|
||||
object PreExecutingSubmissionValidatorSpec {
|
||||
|
||||
import ArgumentMatchersSugar._
|
||||
import MockitoSugar._
|
||||
|
||||
private val recordTime = Timestamp.now()
|
||||
|
||||
@ -7,14 +7,17 @@ import java.nio.file.Paths
|
||||
|
||||
import com.daml.ledger.participant.state.kvutils.tools.integritycheck.Builders._
|
||||
import com.daml.ledger.validator.LedgerStateOperations.{Key, Value}
|
||||
import org.mockito.ArgumentMatchers._
|
||||
import org.mockito.MockitoSugar
|
||||
import org.mockito.{ArgumentMatchersSugar, MockitoSugar}
|
||||
import org.scalatest.matchers.should.Matchers
|
||||
import org.scalatest.wordspec.AsyncWordSpec
|
||||
|
||||
import scala.concurrent.Future
|
||||
|
||||
final class IntegrityCheckerSpec extends AsyncWordSpec with Matchers with MockitoSugar {
|
||||
final class IntegrityCheckerSpec
|
||||
extends AsyncWordSpec
|
||||
with Matchers
|
||||
with MockitoSugar
|
||||
with ArgumentMatchersSugar {
|
||||
"compareSameSizeWriteSets" should {
|
||||
"return None in case strategy cannot explain difference" in {
|
||||
val mockCommitStrategySupport = mock[CommitStrategySupport[Unit]]
|
||||
|
||||
Loading…
Reference in New Issue
Block a user