API

abstract def addGroupMetas(test: TestId, metas: Map[GroupName, GroupMeta]): F[Entity[AbtestExtras]]

abstract def addOverrides(featureName: FeatureName, overrides: Overrides): F[Feature]

abstract def continue(spec: AbtestSpec): F[Entity[Abtest]]

abstract def create(testSpec: AbtestSpec, auto: Boolean): F[Entity[Abtest]]

abstract def getAllFeatures: F[List[FeatureName]]

abstract def getAllTests(time: Option[OffsetDateTime]): F[Vector[Entity[Abtest]]]

Get all the tests

abstract def getAllTestsCached(time: Option[OffsetDateTime]): F[Vector[(Entity[Abtest], Feature)]]

Get all the tests together with their Feature cached.

abstract def getAllTestsEndAfter(time: OffsetDateTime): F[Vector[Entity[Abtest]]]

Get all the tests that end after a certain time

abstract def getGroupAssignments(ids: List[String], feature: FeatureName, at: OffsetDateTime): F[List[(String, GroupName)]]

Get the assignments for a list of ids bypassing the eligibility control

abstract def getGroups(userId: UserId, time: Option[OffsetDateTime], tags: List[Tag]): F[Map[FeatureName, GroupName]]

get all groups of a user by features

abstract def getGroupsWithMeta(query: UserGroupQuery): F[UserGroupQueryResult]

abstract def getOverrides(featureName: FeatureName): F[Feature]

abstract def getTest(test: TestId): F[Entity[Abtest]]

abstract def getTestExtras(test: TestId): F[Option[Entity[AbtestExtras]]]

abstract def getTestsByFeature(feature: FeatureName): F[Vector[Entity[Abtest]]]

abstract def removeAllOverrides(featureName: FeatureName): F[Feature]

abstract def removeOverrides(featureName: FeatureName, userId: UserId): F[Feature]

abstract def setOverrideEligibilityIn(feature: FeatureName, overrideEligibility: Boolean): F[Feature]

abstract def terminate(test: TestId): F[Option[Entity[Abtest]]]

Stop a test before it ends

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def getAllTestsCachedEpoch(time: Option[Long]): F[Vector[(Entity[Abtest], Feature)]]

def getAllTestsEndAfter(time: Long): F[Vector[Entity[Abtest]]]

def getAllTestsEpoch(time: Option[Long]): F[Vector[Entity[Abtest]]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit