ScalatestKafkaSpec

abstract def bootstrapServers: String

final def !=(arg0: Any): Boolean

def !==[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def !==(right: Null): TripleEqualsInvocation[Null]

def !==[T](right: T): TripleEqualsInvocation[T]

final def ##(): Int

final def ==(arg0: Any): Boolean

def ===[T](right: Spread[T]): TripleEqualsInvocationOnSpread[T]

def ===(right: Null): TripleEqualsInvocation[Null]

def ===[T](right: T): TripleEqualsInvocation[T]

val DefaultKey: String

implicit val adapter: LoggingAdapter

def adminClient: AdminClient

Access to the Kafka AdminClient which life

def afterAll(): Unit

final def asInstanceOf[T0]: T0

macro def assert(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assert(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assertCompiles(code: String)(implicit pos: Position): Assertion

macro def assertDoesNotCompile(code: String)(implicit pos: Position): Assertion

def assertResult(expected: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertResult(expected: Any, clue: Any)(actual: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

def assertThrows[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): Assertion

macro def assertTypeError(code: String)(implicit pos: Position): Assertion

val assertionsHelper: (ScalatestKafkaSpec.this)#AssertionsHelper

macro def assume(condition: Boolean, clue: Any)(implicit prettifier: Prettifier, pos: Position): Assertion

macro def assume(condition: Boolean)(implicit prettifier: Prettifier, pos: Position): Assertion

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 beforeAll(): Unit

def cancel(cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String, cause: Throwable)(implicit pos: Position): Nothing

def cancel(message: String)(implicit pos: Position): Nothing

def cancel()(implicit pos: Position): Nothing

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: ConsumerSettings[String, String]

def conversionCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], cnv: (B) ⇒ A): CanEqual[A, B]

def convertEquivalenceToAToBConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: <:<[A, B]): CanEqual[A, B]

def convertEquivalenceToAToBConversionConstraint[A, B](equivalenceOfB: Equivalence[B])(implicit ev: (A) ⇒ B): CanEqual[A, B]

def convertEquivalenceToBToAConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: <:<[B, A]): CanEqual[A, B]

def convertEquivalenceToBToAConversionConstraint[A, B](equivalenceOfA: Equivalence[A])(implicit ev: (B) ⇒ A): CanEqual[A, B]

def convertToCheckingEqualizer[T](left: T): (ScalatestKafkaSpec.this)#CheckingEqualizer[T]

implicit def convertToEqualizer[T](left: T): (ScalatestKafkaSpec.this)#Equalizer[T]

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): String

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

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

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

def createTopic(suffix: Int): String

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

def createTopic(): String

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

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.

def defaultEquality[A]: Equality[A]

implicit val ec: ExecutionContext

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def execute(testName: String, configMap: ConfigMap, color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

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 expectedTestCount(filter: Filter): Int

def fail(cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String, cause: Throwable)(implicit pos: Position): Nothing

def fail(message: String)(implicit pos: Position): Nothing

def fail()(implicit pos: Position): Nothing

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 hashCode(): Int

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

def ignoreNoMsg(): Unit

def intercept[T <: AnyRef](f: ⇒ Any)(implicit classTag: ClassTag[T], pos: Position): T

val invokeBeforeAllAndAfterAllEvenIfNoTestsAreExpected: Boolean

final def isInstanceOf[T0]: Boolean

def kafkaPort: Int

def lastSender: ActorRef

val log: Logger

def lowPriorityConversionCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], cnv: (A) ⇒ B): CanEqual[A, B]

def lowPriorityTypeCheckedConstraint[A, B](implicit equivalenceOfB: Equivalence[B], ev: <:<[A, B]): CanEqual[A, B]

implicit val mat: Materializer

def msgAvailable: Boolean

final def ne(arg0: AnyRef): Boolean

def nestedSuites: IndexedSeq[Suite]

final def notify(): Unit

final def notifyAll(): Unit

def now: FiniteDuration

val partition0: Int

def pending: Assertion with PendingStatement

def pendingUntilFixed(f: ⇒ Unit)(implicit pos: Position): Assertion with PendingStatement

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: 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

def rerunner: Option[String]

def run(testName: Option[String], args: Args): Status

def runNestedSuites(args: Args): Status

def runTest(testName: String, args: Args): Status

def runTests(testName: Option[String], args: Args): Status

implicit val scheduler: Scheduler

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

val styleName: String

final val succeed: Assertion

def suiteId: String

def suiteName: String

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

implicit val system: ActorSystem

def tags: Map[String, Set[String]]

val testActor: ActorRef

def testActorName: String

def testDataFor(testName: String, theConfigMap: ConfigMap): TestData

val testKitSettings: TestKitSettings

def testNames: Set[String]

var testProducer: Producer[String, String]

def toString(): String

def typeCheckedConstraint[A, B](implicit equivalenceOfA: Equivalence[A], ev: <:<[B, A]): CanEqual[A, B]

implicit def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B]

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 withClue[T](clue: Any)(fun: ⇒ T): T

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

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

val zooKeeperPort: Int

final def execute: Unit

def expectNoMsg(max: FiniteDuration): Unit

def expectNoMsg(): Unit

def trap[T](f: ⇒ T): Throwable