Packages

trait ParticipantTestContext extends UserManagementTestContext

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ParticipantTestContext
  2. UserManagementTestContext
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Abstract Value Members

  1. abstract def activeContracts(parties: Option[Seq[Party]], activeAtOffsetO: Option[Long] = None, verbose: Boolean = true): Future[Vector[CreatedEvent]]
  2. abstract def activeContracts(request: GetActiveContractsRequest): Future[Vector[CreatedEvent]]
  3. abstract def activeContractsByTemplateId(templateIds: Seq[Identifier], parties: Option[Seq[Party]], activeAtOffsetO: Option[Long] = None, verbose: Boolean = true): Future[Vector[CreatedEvent]]
  4. abstract def activeContractsRequest(parties: Option[Seq[Party]], activeAtOffset: Long, templateIds: Seq[Identifier] = Seq.empty, interfaceFilters: Seq[(Identifier, IncludeInterfaceView)] = Seq.empty, verbose: Boolean = true): GetActiveContractsRequest
  5. abstract def allocateExternalParty(request: AllocateExternalPartyRequest, minSynchronizers: Option[Int] = None): Future[Party]
  6. abstract def allocateExternalPartyRequest(partyIdHint: Option[String] = None, synchronizerId: String = ""): AllocateExternalPartyRequest
  7. abstract def allocateParties(n: Int, minSynchronizers: Int): Future[Vector[Party]]
  8. abstract def allocateParty(req: AllocatePartyRequest, connectedSynchronizers: Int): Future[(AllocatePartyResponse, Seq[String])]
  9. abstract def allocateParty(partyIdHint: Option[String] = None, localMetadata: Option[ObjectMeta] = None, identityProviderId: Option[String] = None, minSynchronizers: Option[Int] = None): Future[Party]

    Non managed version of party allocation.

    Non managed version of party allocation. Use exclusively when testing the party management service.

  10. abstract def allocateParty(): Future[Party]

    Managed version of party allocation, should be used anywhere a party has to be allocated unless the party management service itself is under test

  11. abstract def checkHealth(): Future[HealthCheckResponse]
  12. abstract def completionStreamRequest(from: Long = referenceOffset)(parties: Party*): CompletionStreamRequest
  13. abstract def completions(within: NonNegativeFiniteDuration, request: CompletionStreamRequest): Future[Vector[CompletionResponse]]
  14. abstract def create[TCid <: ContractId[T], T <: Template](actAs: List[Party], readAs: List[Party], template: T)(implicit companion: ContractCompanion[_, TCid, T]): Future[TCid]
  15. abstract def create[TCid <: ContractId[T], T <: Template](party: Party, template: T)(implicit companion: ContractCompanion[_, TCid, T]): Future[TCid]
  16. abstract def createAndGetTransactionId[TCid <: ContractId[T], T <: Template](party: Party, template: T)(implicit companion: ContractCompanion[_, TCid, T]): Future[(String, TCid)]
  17. abstract def currentEnd(): Future[Long]

    Gets the absolute offset of the ledger end at a point in time.

  18. abstract def delayMechanism: DelayMechanism
  19. abstract val endpointId: String
  20. abstract def eventFormat(verbose: Boolean, parties: Option[Seq[Party]], templateIds: Seq[Identifier] = Seq.empty, interfaceFilters: Seq[(Identifier, IncludeInterfaceView)] = Seq.empty): EventFormat

    Create an EventFormat with a set of Party objects.

    Create an EventFormat with a set of Party objects.

    You should use this only when you need to tweak the request of transactions(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, otherwise use the shortcut override that allows you to directly pass a set of Party

  21. abstract def exercise[T](actAs: List[Party], readAs: List[Party], exercise: Update[T]): Future[TransactionTree]
  22. abstract def exercise[T](party: Party, exercise: Update[T]): Future[TransactionTree]
  23. abstract def exerciseAndGetContract[TCid <: ContractId[T], T](party: Party, exercise: Update[Exercised[TCid]])(implicit companion: ContractCompanion[_, TCid, T]): Future[TCid]
  24. abstract def exerciseAndGetContractNoDisclose[TCid <: ContractId[_]](party: Party, exercise: Update[Exercised[Unit]])(implicit companion: ContractCompanion[_, TCid, _]): Future[TCid]
  25. abstract def exerciseByKey(party: Party, template: Identifier, key: Value, choice: String, argument: Value): Future[TransactionTree]
  26. abstract def exerciseForTransaction[T](party: Party, exercise: Update[T]): Future[Transaction]
  27. abstract def features: Features
  28. abstract def filters(templateIds: Seq[Identifier] = Seq.empty, interfaceFilters: Seq[(Identifier, IncludeInterfaceView)] = Seq.empty): Filters
  29. abstract def findCompletion(parties: Party*)(p: (Completion) => Boolean): Future[Option[Completion]]
  30. abstract def findCompletion(request: CompletionStreamRequest)(p: (Completion) => Boolean): Future[Option[Completion]]
  31. abstract def findCompletionAtOffset(offset: Long, p: (Completion) => Boolean)(parties: Party*): Future[Option[Completion]]
  32. abstract def firstCompletions(parties: Party*): Future[Vector[Completion]]
  33. abstract def firstCompletions(request: CompletionStreamRequest): Future[Vector[Completion]]
  34. abstract def flatTransactionByIdLegacy(transactionId: String, parties: Party*): Future[Transaction]

    Managed version of flatTransactionByIdLegacy(transactionId:String,parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e.

    Managed version of flatTransactionByIdLegacy(transactionId:String,parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e. to test low-level details)

  35. abstract def flatTransactionByOffsetLegacy(offset: Long, parties: Party*): Future[Transaction]

    Managed version of transactionByOffsetLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this unless you need to tweak the request (i.e.

    Managed version of transactionByOffsetLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this unless you need to tweak the request (i.e. to test low-level details)

  36. abstract def flatTransactionsByTemplateId(templateId: Identifier, parties: Option[Seq[Party]]): Future[Vector[Transaction]]
  37. abstract def flatTransactionsLegacy(take: Int, parties: Party*): Future[Vector[Transaction]]

    Managed version of flatTransactionsLegacy(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e.

    Managed version of flatTransactionsLegacy(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e. to test low-level details)

  38. abstract def flatTransactionsLegacy(parties: Party*): Future[Vector[Transaction]]

    Managed version of flatTransactionsLegacy(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e.

    Managed version of flatTransactionsLegacy(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e. to test low-level details)

  39. abstract def getConnectedSynchronizers(party: Option[Party], participantId: Option[String]): Future[Set[String]]
  40. abstract def getEventsByContractId(request: GetEventsByContractIdRequest): Future[GetEventsByContractIdResponse]
  41. abstract def getPackage(packageId: String): Future[GetPackageResponse]
  42. abstract def getPackageStatus(packageId: String): Future[PackageStatus]
  43. abstract def getParticipantId(): Future[String]
  44. abstract def getParties(parties: Seq[Party]): Future[Seq[PartyDetails]]
  45. abstract def getParties(req: GetPartiesRequest): Future[GetPartiesResponse]
  46. abstract def getPreferredPackageVersion(parties: Seq[Party], packageName: String, vettingValidAt: Option[Instant] = None, synchronizerIdO: Option[String] = None): Future[GetPreferredPackageVersionResponse]
  47. abstract def getPreferredPackages(vettingRequirements: Map[String, Seq[Party]], vettingValidAt: Option[Instant] = None, synchronizerIdO: Option[String] = None): Future[GetPreferredPackagesResponse]
  48. abstract def getTransactionByIdRequestLegacy(transactionId: String, parties: Seq[Party]): GetTransactionByIdRequest

    Create a GetTransactionByIdRequest with an identifier and a set of Party objects.

    Create a GetTransactionByIdRequest with an identifier and a set of Party objects. You should use this only when you need to tweak the request of transactionTreeById or flatTransactionByIdLegacy, otherwise use the shortcut override that allows you to directly pass the identifier and parties.

  49. abstract def getTransactionByOffsetRequestLegacy(offset: Long, parties: Seq[Party]): GetTransactionByOffsetRequest

    Create a GetTransactionByOffsetRequest with an identifier and a set of Party objects.

    Create a GetTransactionByOffsetRequest with an identifier and a set of Party objects. You should use this only when you need to tweak the request of transactionTreeByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):* or flatTransactionByOffsetLegacy(offset:Long,parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, otherwise use the shortcut override that allows you to directly pass the identifier and parties.

  50. abstract def getTransactionsRequest(transactionFilter: TransactionFilter, transactionShape: TransactionShape, begin: Long = referenceOffset): Future[GetUpdatesRequest]
  51. abstract def getTransactionsRequestLegacy(transactionFilter: TransactionFilter, begin: Long = referenceOffset): Future[GetUpdatesRequest]
  52. abstract def getTransactionsRequestWithEnd(transactionFilter: TransactionFilter, transactionShape: TransactionShape, begin: Long = referenceOffset, end: Option[Long]): GetUpdatesRequest
  53. abstract def getTransactionsRequestWithEndLegacy(transactionFilter: TransactionFilter, begin: Long = referenceOffset, end: Option[Long]): GetUpdatesRequest
  54. abstract def getUpdatesRequestWithEnd(transactionFormatO: Option[(TransactionFilter, TransactionShape)] = None, reassignmentsFilterO: Option[TransactionFilter] = None, topologyFilterO: Option[Seq[Party]] = None, begin: Long = referenceOffset, end: Option[Long] = None): GetUpdatesRequest
  55. abstract def latestPrunedOffsets(): Future[(Long, Long)]
  56. abstract def ledgerEndpoint: Either[JsonApiEndpoint, ChannelEndpoint]
  57. abstract def legacyActiveContracts(parties: Option[Seq[Party]], activeAtOffsetO: Option[Long] = None): Future[Vector[CreatedEvent]]
  58. abstract def legacyActiveContractsByTemplateId(templateIds: Seq[Identifier], parties: Option[Seq[Party]], activeAtOffsetO: Option[Long] = None): Future[Vector[CreatedEvent]]
  59. abstract def legacyActiveContractsRequest(parties: Option[Seq[Party]], activeAtOffset: Long, templateIds: Seq[Identifier] = Seq.empty, interfaceFilters: Seq[(Identifier, IncludeInterfaceView)] = Seq.empty): GetActiveContractsRequest
  60. abstract def listKnownPackages(): Future[Seq[PackageDetails]]
  61. abstract def listKnownParties(): Future[ListKnownPartiesResponse]
  62. abstract def listKnownParties(req: ListKnownPartiesRequest): Future[ListKnownPartiesResponse]
  63. abstract def listKnownPartiesExpanded(): Future[Set[Party]]
  64. abstract def listPackages(): Future[Seq[String]]
  65. abstract def maxOffsetCheckpointEmissionDelay: NonNegativeFiniteDuration
  66. abstract def nextIdentityProviderId: () => String
  67. abstract def nextKeyId: () => String
  68. abstract def nextPartyId: () => String
  69. abstract def nextUserId: () => String
  70. abstract def offsetBeyondLedgerEnd(): Future[Long]

    Returns an absolute offset (positive integer) that is beyond the current ledger end.

    Returns an absolute offset (positive integer) that is beyond the current ledger end.

    Note: the offset might not be valid for the underlying ledger. This method can therefore only be used for offsets that are only interpreted by the ledger API server and not sent to the ledger.

  71. abstract def offsets(n: Int, request: CompletionStreamRequest): Future[Vector[Long]]
  72. abstract def prune(pruneUpTo: Long, attempts: Int = 10, pruneAllDivulgedContracts: Boolean = false): Future[PruneResponse]
  73. abstract def pruneCantonSafe(pruneUpTo: Long, party: Party, dummyCommand: (Party) => List[Command], pruneAllDivulgedContracts: Boolean = false)(implicit ec: ExecutionContext): Future[Unit]

    We are retrying a command submission + pruning to get a safe-to-prune offset for Canton.

    We are retrying a command submission + pruning to get a safe-to-prune offset for Canton. That's because in Canton pruning will fail unless ACS commitments have been exchanged between participants. To this end, repeatedly submitting commands is prompting Canton to exchange ACS commitments and allows the pruning call to eventually succeed.

  74. abstract def referenceOffset: Long
  75. abstract def setTime(currentTime: Instant, newTime: Instant): Future[Unit]
  76. abstract def submit(request: SubmitRequest): Future[Unit]
  77. abstract def submitAndWait(request: SubmitAndWaitRequest): Future[SubmitAndWaitResponse]
  78. abstract def submitAndWaitForTransaction(request: SubmitAndWaitForTransactionRequest): Future[SubmitAndWaitForTransactionResponse]
  79. abstract def submitAndWaitForTransactionRequest(party: Party, commands: List[Command], transactionShape: TransactionShape, filterParties: Option[Seq[Party]] = None, templateIds: Option[Seq[Identifier]] = None): SubmitAndWaitForTransactionRequest
  80. abstract def submitAndWaitForTransactionRequest(party: Party, commands: List[Command]): SubmitAndWaitForTransactionRequest
  81. abstract def submitAndWaitForTransactionRequest(actAs: List[Party], readAs: List[Party], commands: List[Command]): SubmitAndWaitForTransactionRequest
  82. abstract def submitAndWaitForTransactionTree(request: SubmitAndWaitRequest): Future[SubmitAndWaitForTransactionTreeResponse]
  83. abstract def submitAndWaitRequest(party: Party, commands: List[Command]): SubmitAndWaitRequest
  84. abstract def submitAndWaitRequest(actAs: List[Party], readAs: List[Party], commands: List[Command]): SubmitAndWaitRequest
  85. abstract def submitRequest(party: Party, commands: List[Command] = JList.of()): SubmitRequest
  86. abstract def submitRequest(actAs: List[Party], readAs: List[Party], commands: List[Command]): SubmitRequest
  87. abstract def submitRequestAndTolerateGrpcError[T](errorCode: ErrorCode, submitAndWaitGeneric: (ParticipantTestContext) => Future[T]): Future[T]
  88. abstract def time(): Future[Instant]
  89. abstract def topologyTransactionById(updateId: String, parties: Seq[Party]): Future[TopologyTransaction]

    Managed version of updateById(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByIdRequest):* for topology transactions, use this unless you need to tweak the request (i.e.

    Managed version of updateById(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByIdRequest):* for topology transactions, use this unless you need to tweak the request (i.e. to test low-level details). If the parties list is empty then no filtering is applied to the topology transactions.

  90. abstract def topologyTransactionByOffset(offset: Long, parties: Seq[Party]): Future[TopologyTransaction]

    Managed version of updateByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByOffsetRequest):* for topology transactions, use this unless you need to tweak the request (i.e.

    Managed version of updateByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByOffsetRequest):* for topology transactions, use this unless you need to tweak the request (i.e. to test low-level details). If the parties list is empty then no filtering is applied to the topology transactions.

  91. abstract def transactionById(updateId: String, parties: Seq[Party], transactionShape: TransactionShape, templateIds: Seq[Identifier] = Seq.empty): Future[Transaction]

    Managed version of updateById(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByIdRequest):* for transactions, use this unless you need to tweak the request (i.e.

    Managed version of updateById(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByIdRequest):* for transactions, use this unless you need to tweak the request (i.e. to test low-level details)

  92. abstract def transactionByIdLegacy(transactionId: String, parties: Seq[Party], transactionShape: TransactionShape, templateIds: Seq[Identifier] = Seq.empty): Future[Transaction]

    Managed version of transactionByIdLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByIdRequest):*, use this unless you need to tweak the request (i.e.

    Managed version of transactionByIdLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByIdRequest):*, use this unless you need to tweak the request (i.e. to test low-level details)

  93. abstract def transactionByIdLegacy(request: GetTransactionByIdRequest): Future[Transaction]

    Non-managed version of transactionByIdLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByIdRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of transactionByIdLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByIdRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  94. abstract def transactionByOffset(offset: Long, parties: Seq[Party], transactionShape: TransactionShape, templateIds: Seq[Identifier] = Seq.empty): Future[Transaction]

    Managed version of updateByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByOffsetRequest):* for transactions, use this unless you need to tweak the request (i.e.

    Managed version of updateByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByOffsetRequest):* for transactions, use this unless you need to tweak the request (i.e. to test low-level details)

  95. abstract def transactionByOffsetLegacy(offset: Long, parties: Seq[Party], transactionShape: TransactionShape, templateIds: Seq[Identifier] = Seq.empty): Future[Transaction]

    Managed version of transactionByOffsetLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this unless you need to tweak the request (i.e.

    Managed version of transactionByOffsetLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this unless you need to tweak the request (i.e. to test low-level details)

  96. abstract def transactionByOffsetLegacy(request: GetTransactionByOffsetRequest): Future[Transaction]

    Non-managed version of transactionByOffsetLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of transactionByOffsetLegacy(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  97. abstract def transactionFilter(parties: Option[Seq[Party]], templateIds: Seq[Identifier] = Seq.empty, interfaceFilters: Seq[(Identifier, IncludeInterfaceView)] = Seq.empty): TransactionFilter

    Create a TransactionFilter with a set of Party objects.

    Create a TransactionFilter with a set of Party objects.

    You should use this only when you need to tweak the request of transactions(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):* or transactionTrees(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, otherwise use the shortcut override that allows you to directly pass a set of Party

  98. abstract def transactionTreeById(transactionId: String, parties: Party*): Future[TransactionTree]

    Managed version of transactionTrees, use this unless you need to tweak the request (i.e.

    Managed version of transactionTrees, use this unless you need to tweak the request (i.e. to test low-level details)

  99. abstract def transactionTreeById(request: GetTransactionByIdRequest): Future[TransactionTree]

    Non-managed version of transactionTreeById, use this only if you need to tweak the request (i.e.

    Non-managed version of transactionTreeById, use this only if you need to tweak the request (i.e. to test low-level details)

  100. abstract def transactionTreeByOffset(offset: Long, parties: Party*): Future[TransactionTree]

    Managed version of transactionTreeByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this unless you need to tweak the request (i.e.

    Managed version of transactionTreeByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this unless you need to tweak the request (i.e. to test low-level details)

  101. abstract def transactionTreeByOffset(request: GetTransactionByOffsetRequest): Future[TransactionTree]

    Non-managed version of transactionTreeByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of transactionTreeByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetTransactionByOffsetRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  102. abstract def transactionTrees(take: Int, parties: Party*): Future[Vector[TransactionTree]]

    Managed version of transactionTrees(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e.

    Managed version of transactionTrees(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e. to test low-level details)

  103. abstract def transactionTrees(take: Int, request: GetUpdatesRequest): Future[Vector[TransactionTree]]

    Non-managed version of transactionTrees(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of transactionTrees(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  104. abstract def transactionTrees(parties: Party*): Future[Vector[TransactionTree]]

    Managed version of transactionTrees(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e.

    Managed version of transactionTrees(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e. to test low-level details)

  105. abstract def transactionTrees(request: GetUpdatesRequest): Future[Vector[TransactionTree]]

    Non-managed version of transactionTrees(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of transactionTrees(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  106. abstract def transactionTreesByTemplateId(templateId: Identifier, parties: Party*): Future[Vector[TransactionTree]]
  107. abstract def transactions(take: Int, parties: Party*): Future[Vector[Transaction]]
  108. abstract def transactions(take: Int, request: GetUpdatesRequest): Future[Vector[Transaction]]

    Non-managed version of transactions(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of transactions(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  109. abstract def transactions(transactionShape: TransactionShape, parties: Party*): Future[Vector[Transaction]]

    Managed version of flatTransactionsLegacy(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e.

    Managed version of flatTransactionsLegacy(parties:com\.daml\.ledger\.api\.testtool\.infrastructure\.Party*):*, use this unless you need to tweak the request (i.e. to test low-level details)

  110. abstract def transactions(request: GetUpdatesRequest): Future[Vector[Transaction]]

    Non-managed version of transactions(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of transactions(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdatesRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  111. abstract def updateById(request: GetUpdateByIdRequest): Future[GetUpdateResponse]

    Non-managed version of updateById(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByIdRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of updateById(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByIdRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  112. abstract def updateByOffset(request: GetUpdateByOffsetRequest): Future[GetUpdateResponse]

    Non-managed version of updateByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByOffsetRequest):*, use this only if you need to tweak the request (i.e.

    Non-managed version of updateByOffset(request:com\.daml\.ledger\.api\.v2\.update_service\.GetUpdateByOffsetRequest):*, use this only if you need to tweak the request (i.e. to test low-level details)

  113. abstract def updatePartyDetails(req: UpdatePartyDetailsRequest): Future[UpdatePartyDetailsResponse]
  114. abstract def updatePartyIdentityProviderId(request: UpdatePartyIdentityProviderIdRequest): Future[UpdatePartyIdentityProviderIdResponse]
  115. abstract def updateTrees(within: NonNegativeFiniteDuration, request: GetUpdatesRequest): Future[Vector[Update]]
  116. abstract def updateTrees(take: Int, request: GetUpdatesRequest, resultFilter: (GetUpdateTreesResponse) => Boolean): Future[Vector[Update]]
  117. abstract def updateTrees(take: Int, request: GetUpdatesRequest): Future[Vector[Update]]
  118. abstract def updates(within: NonNegativeFiniteDuration, request: GetUpdatesRequest): Future[Vector[Update]]
  119. abstract def updates(take: Int, request: GetUpdatesRequest, resultFilter: (GetUpdatesResponse) => Boolean): Future[Vector[Update]]
  120. abstract def updates(take: Int, request: GetUpdatesRequest): Future[Vector[Update]]
  121. abstract def uploadDarFile(request: UploadDarFileRequest): Future[Unit]
  122. abstract def uploadDarRequest(bytes: ByteString): UploadDarFileRequest
  123. abstract val userId: String
  124. abstract def waitForPartiesOnOtherParticipants(otherParticipants: Iterable[ParticipantTestContext], expectedParties: Set[Party], connectedSynchronizers: Int): Future[Unit]

    returns

    a future that completes when all the participants can list all the expected parties

  125. abstract def watchHealth(): Future[Seq[HealthCheckResponse]]

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def activeContractsIds(request: GetActiveContractsRequest): Future[Vector[ContractId[Any]]]
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. val begin: Long
  7. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @IntrinsicCandidate() @native()
  8. def createIdentityProviderConfig(request: CreateIdentityProviderConfigRequest): Future[CreateIdentityProviderConfigResponse]
    Definition Classes
    UserManagementTestContext
  9. def createIdentityProviderConfig(identityProviderId: String = UUID.randomUUID().toString, isDeactivated: Boolean = false, issuer: String = UUID.randomUUID().toString, jwksUrl: String = "http://daml.com/jwks.json"): Future[CreateIdentityProviderConfigResponse]
    Definition Classes
    UserManagementTestContext
  10. def createUser(createUserRequest: CreateUserRequest): Future[CreateUserResponse]

    Creates a new user.

    Creates a new user.

    Additionally keeps track of the created users so that they can be cleaned up automatically when the test case ends.

    Definition Classes
    UserManagementTestContext
  11. def deleteCreateIdentityProviders(): Future[Unit]
    Definition Classes
    UserManagementTestContext
  12. def deleteCreatedUsers(): Future[Unit]

    Intended to be called by the infrastructure code after a test case's execution has ended.

    Intended to be called by the infrastructure code after a test case's execution has ended.

    Definition Classes
    UserManagementTestContext
  13. def deleteIdentityProviderConfig(request: DeleteIdentityProviderConfigRequest): Future[DeleteIdentityProviderConfigResponse]
    Definition Classes
    UserManagementTestContext
  14. def deleteUser(request: DeleteUserRequest): Future[DeleteUserResponse]

    Deletes a user.

    Deletes a user.

    Additionally keeps track of the created users so that they can be cleaned up automatically when the test case ends.

    Definition Classes
    UserManagementTestContext
  15. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  16. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  17. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @IntrinsicCandidate() @native()
  18. def getIdentityProviderConfig(request: GetIdentityProviderConfigRequest): Future[GetIdentityProviderConfigResponse]
    Definition Classes
    UserManagementTestContext
  19. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @IntrinsicCandidate() @native()
  20. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  21. def listIdentityProviderConfig(): Future[ListIdentityProviderConfigsResponse]
    Definition Classes
    UserManagementTestContext
  22. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @IntrinsicCandidate() @native()
  24. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @IntrinsicCandidate() @native()
  25. def participantAuthorizationTransaction(partyIdSubstring: String, begin: Option[Long] = None, end: Option[Long] = None): Future[TopologyTransaction]
  26. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  27. def toString(): String
    Definition Classes
    AnyRef → Any
  28. def updateIdentityProviderConfig(request: UpdateIdentityProviderConfigRequest): Future[UpdateIdentityProviderConfigResponse]
    Definition Classes
    UserManagementTestContext
  29. def updateIdentityProviderConfig(identityProviderId: String = UUID.randomUUID().toString, isDeactivated: Boolean = false, issuer: String = UUID.randomUUID().toString, jwksUrl: String = "http://daml.com/jwks.json", updateMask: Option[FieldMask] = None): Future[UpdateIdentityProviderConfigResponse]
    Definition Classes
    UserManagementTestContext
  30. def uploadDarFile(bytes: ByteString): Future[Unit]
  31. def userManagement: UserManagementService
    Definition Classes
    UserManagementTestContext
  32. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  33. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  34. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

    (Since version 9)

Inherited from UserManagementTestContext

Inherited from AnyRef

Inherited from Any

Ungrouped