Spec

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val DefaultKey: String

val StringDeserializer: StringDeserializer

val StringSerializer: StringSerializer

implicit val adapter: LoggingAdapter

def adminClient: AdminClient

Access to the Kafka AdminClient which life

final def asInstanceOf[T0]: T0

def awaitAssert[A](a: ⇒ A, max: Duration, interval: Duration): A

def awaitCond(p: ⇒ Boolean, max: Duration, interval: Duration, message: String): Unit

def awaitMultiple[T](d: FiniteDuration, futures: Future[T]*): Seq[T]

def awaitProduce(futures: Future[Done]*): Unit

def batchMessagesExpected(topics: Seq[String], batches: Int, batchSize: Int): (Seq[String], Long)

Messages expected from #produceBatches generation.

def bootstrapServers: String

def brokerContainers: Vector[AlpakkaKafkaContainer]

def childActorOf(props: Props): ActorRef

def childActorOf(props: Props, name: String): ActorRef

def childActorOf(props: Props, supervisorStrategy: SupervisorStrategy): ActorRef

def childActorOf(props: Props, name: String, supervisorStrategy: SupervisorStrategy): ActorRef

def cleanUp(): Unit

def cleanUpAdminClient(): Unit

Close internal admin client instances.

def clone(): AnyRef

def committerDefaults: CommitterSettings

def consumerDefaults[K, V](keyDeserializer: Deserializer[K], valueDeserializer: Deserializer[V]): ConsumerSettings[K, V]

def consumerDefaults(): ConsumerSettings[String, String]

def createGroupId(suffix: Int): String

Return a unique group id with a given suffix.

def createGroupId(): String

Return a unique group id with a default suffix.

def createProbe(consumerSettings: ConsumerSettings[String, String], topic: String*): (Control, Probe[String])

def createTopic(suffix: Int, partitions: Int, replication: Int, config: Map[String, String]): String

Java Api

def createTopic(suffix: Int, partitions: Int, replication: Int, config: Map[String, String]): String

Create a topic with given suffix, partition number, replication factor, and topic configuration.

def createTopic(suffix: Int, partitions: Int, replication: Int): String

Create a topic with given suffix, partition number, replication factor, and no topic configuration.

def createTopic(suffix: Int, partitions: Int): String

Create a topic with a given suffix, partition number, a replication factor of one, and no topic configuration.

def createTopic(suffix: Int): String

Create a topic with a given suffix, single partitions, a replication factor of one, and no topic configuration.

def createTopic(): String

Create a topic with a default suffix, single partition, a replication factor of one, and no topic configuration.

def createTopicName(suffix: Int): String

Return a unique topic name.

def createTopics(topics: Int*): Seq[String]

def createTransactionalId(suffix: Int): String

Return a unique transactional id with a given suffix.

def createTransactionalId(): String

Return a unique transactional id with a default suffix.

implicit val ec: ExecutionContext

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expectMsg[T](max: FiniteDuration, hint: String, obj: T): T

def expectMsg[T](max: FiniteDuration, obj: T): T

def expectMsg[T](obj: T): T

def expectMsgAllClassOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

def expectMsgAllClassOf[T](obj: Class[_ <: T]*): Seq[T]

def expectMsgAllConformingOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

def expectMsgAllConformingOf[T](obj: Class[_ <: T]*): Seq[T]

def expectMsgAllOf[T](max: FiniteDuration, obj: T*): Seq[T]

def expectMsgAllOf[T](obj: T*): Seq[T]

def expectMsgAnyClassOf[C](max: FiniteDuration, obj: Class[_ <: C]*): C

def expectMsgAnyClassOf[C](obj: Class[_ <: C]*): C

def expectMsgAnyOf[T](max: FiniteDuration, obj: T*): T

def expectMsgAnyOf[T](obj: T*): T

def expectMsgClass[C](max: FiniteDuration, c: Class[C]): C

def expectMsgClass[C](c: Class[C]): C

def expectMsgPF[T](max: Duration, hint: String)(f: PartialFunction[Any, T]): T

def expectMsgType[T](max: FiniteDuration)(implicit t: ClassTag[T]): T

def expectMsgType[T](implicit t: ClassTag[T]): T

def expectNoMessage(): Unit

def expectNoMessage(max: FiniteDuration): Unit

def expectTerminated(target: ActorRef, max: Duration): Terminated

def finalize(): Unit

def fishForMessage(max: Duration, hint: String)(f: PartialFunction[Any, Boolean]): Any

def fishForSpecificMessage[T](max: Duration, hint: String)(f: PartialFunction[Any, T]): T

final def getClass(): Class[_]

def getSchemaRegistryUrl: String

def hashCode(): Int

def ignoreMsg(f: PartialFunction[Any, Boolean]): Unit

def ignoreNoMsg(): Unit

final def isInstanceOf[T0]: Boolean

def kafkaPort: Int

def lastSender: ActorRef

val log: Logger

implicit val mat: Materializer

def msgAvailable: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def now: FiniteDuration

val partition0: Int

def periodicalCheck[T](description: String, maxTries: Int, sleepInBetween: FiniteDuration)(data: () ⇒ T)(predicate: (T) ⇒ Boolean): Unit

def produce(topic: String, range: Range, settings: ProducerSettings[String, String]): Future[Done]

Produce messages to topic using specified range and return a Future so the caller can synchronize consumption.

def produce(topic: String, range: Seq[Int], partition: Int = partition0): Future[Done]

Produce messages to topic using specified range and return a Future so the caller can synchronize consumption.

def produceBatches(topics: Seq[String], batches: Int, batchSize: Int): Future[Seq[Done]]

Produce batches over several topics.

def produceString(topic: String, range: Seq[String], partition: Int = partition0): Future[Done]

def produceTimestamped(topic: String, timestampedRange: Seq[(Int, Long)]): Future[Done]

def producerDefaults[K, V](keySerializer: Serializer[K], valueSerializer: Serializer[V]): ProducerSettings[K, V]

def producerDefaults: ProducerSettings[String, String]

def receiveN(n: Int, max: FiniteDuration): Seq[AnyRef]

def receiveN(n: Int): Seq[AnyRef]

def receiveOne(max: Duration): AnyRef

def receiveWhile[T](max: Duration, idle: Duration, messages: Int)(f: PartialFunction[AnyRef, T]): Seq[T]

def remaining: FiniteDuration

def remainingOr(duration: FiniteDuration): FiniteDuration

def remainingOrDefault: FiniteDuration

implicit val scheduler: Scheduler

def schemaRegistryContainer: Option[SchemaRegistryContainer]

def schemaRegistryUrl: String

def setAutoPilot(pilot: AutoPilot): Unit

def setUp(): Unit

def setUpAdminClient(): Unit

Create internal admin clients.

val settings: KafkaTestkitSettings

def shutdown(actorSystem: ActorSystem, duration: Duration, verifySystemShutdown: Boolean): Unit

def sleep(time: FiniteDuration, msg: String = ""): Unit

def sleepAfterProduce: FiniteDuration

def sleepMillis(ms: Long, msg: String): Unit

def sleepQuietly(time: FiniteDuration): Unit

def sleepSeconds(s: Int, msg: String): Unit

def startKafka(settings: KafkaTestkitTestcontainersSettings): String

def startKafka(): String

def stopKafka(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

implicit val system: ActorSystem

val testActor: ActorRef

def testActorName: String

val testKitSettings: TestKitSettings

var testProducer: Producer[String, String]

val testcontainersSettings: KafkaTestkitTestcontainersSettings

Override this to change default settings for starting the Kafka testcontainers cluster.

def toString(): String

def unwatch(ref: ActorRef): ActorRef

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def waitUntilCluster()(predicate: (DescribeClusterResult) ⇒ Boolean): Unit

Periodically checks if a given predicate on cluster state holds.

def waitUntilConsumerGroup(groupId: String)(predicate: (ConsumerGroupDescription) ⇒ Boolean): Unit

Periodically checks if the given predicate on consumer group state holds.

def waitUntilConsumerSummary(groupId: String)(predicate: PartialFunction[List[MemberDescription], Boolean]): Unit

Periodically checks if the given predicate on consumer summary holds.

def watch(ref: ActorRef): ActorRef

def within[T](max: FiniteDuration)(f: ⇒ T): T

def within[T](min: FiniteDuration, max: FiniteDuration)(f: ⇒ T): T

val zooKeeperPort: Int

def zookeeperContainer: GenericContainer[_]

def confluentPlatformVersion: String

Override this to select a different Kafka version be choosing the desired version of Confluent Platform: Available Docker images, Kafka versions in Confluent Platform

def expectNoMsg(max: FiniteDuration): Unit

def expectNoMsg(): Unit