CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-scala-js--scalajs-test-interface

Scala.js version of the sbt testing interface that provides a standardized API for test frameworks to integrate with SBT and run tests in a Scala.js (JavaScript) environment

—

Pending
Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

Scala.js Test Interface

The Scala.js Test Interface provides a standardized API for test frameworks to integrate with SBT and run tests in JavaScript environments compiled by Scala.js. It serves as the bridge between SBT's testing infrastructure and JavaScript-based test execution, enabling test frameworks to define test discovery patterns, execute tests asynchronously, handle test events, and support distributed testing across worker processes.

Package Information

  • Package Name: org.scala-js:scalajs-test-interface_2.12
  • Package Type: maven
  • Language: Scala (compiles to JavaScript via Scala.js)
  • Installation: Add to build.sbt: libraryDependencies += "org.scala-js" %%% "scalajs-test-interface" % "1.19.0"

Core Imports

import sbt.testing._

For specific components:

import sbt.testing.{Framework, Runner, Task, TaskDef, Event, EventHandler}
import sbt.testing.{Logger, Status, Fingerprint, Selector}

Basic Usage

import sbt.testing._
import scala.scalajs.reflect.annotation.EnableReflectiveInstantiation

// Implement a test framework
@EnableReflectiveInstantiation
class MyTestFramework extends Framework {
  def name(): String = "MyTestFramework"
  
  def fingerprints(): Array[Fingerprint] = Array(
    new SubclassFingerprint {
      def isModule() = false
      def superclassName() = "MyTestSuite"
      def requireNoArgConstructor() = true
    }
  )
  
  def runner(args: Array[String], remoteArgs: Array[String], 
            testClassLoader: ClassLoader): Runner = {
    new MyTestRunner(args, remoteArgs, testClassLoader)
  }
  
  def slaveRunner(args: Array[String], remoteArgs: Array[String],
                 testClassLoader: ClassLoader, send: String => Unit): Runner = {
    new MyWorkerRunner(args, remoteArgs, testClassLoader, send)
  }
}

// Create and execute test tasks
class MyTestRunner(args: Array[String], remoteArgs: Array[String], 
                  testClassLoader: ClassLoader) extends Runner {
  
  def tasks(taskDefs: Array[TaskDef]): Array[Task] = {
    taskDefs.map(taskDef => new MyTask(taskDef))
  }
  
  def done(): String = "Tests completed"
  
  // ... other required methods
}

Architecture

The Scala.js Test Interface is built around several key components:

  • Framework Discovery: Test frameworks implement Framework trait with fingerprints for test class identification
  • Test Execution: Runner manages test lifecycle and creates executable Task instances
  • Event System: Event and EventHandler provide structured test result reporting
  • Worker Architecture: slaveRunner enables distributed testing across JavaScript workers
  • Async Support: Dual execute methods support both synchronous and asynchronous (continuation-based) execution
  • Serialization: Task serialization/deserialization enables cross-worker task distribution

Capabilities

Framework Implementation

Core interface for implementing test frameworks with support for test discovery, runner creation, and worker-based distributed testing.

trait Framework {
  def name(): String
  def fingerprints(): Array[Fingerprint]
  def runner(args: Array[String], remoteArgs: Array[String], 
            testClassLoader: ClassLoader): Runner
  def slaveRunner(args: Array[String], remoteArgs: Array[String],
                 testClassLoader: ClassLoader, send: String => Unit): Runner
}

Framework Implementation

Test Execution

Test execution system providing task creation, lifecycle management, and support for both synchronous and asynchronous JavaScript execution.

trait Runner {
  def tasks(taskDefs: Array[TaskDef]): Array[Task]
  def done(): String
  def remoteArgs(): Array[String]
  def args: Array[String]
  def receiveMessage(msg: String): Option[String]
  def serializeTask(task: Task, serializer: TaskDef => String): String
  def deserializeTask(task: String, deserializer: String => TaskDef): Task
}

trait Task {
  def tags(): Array[String]
  def execute(eventHandler: EventHandler, loggers: Array[Logger]): Array[Task]
  def execute(eventHandler: EventHandler, loggers: Array[Logger],
             continuation: Array[Task] => Unit): Unit
  def taskDef(): TaskDef
}

Test Execution

Test Discovery

Test discovery system using fingerprints to identify test classes through annotations or inheritance patterns.

trait Fingerprint

trait AnnotatedFingerprint extends Fingerprint {
  def isModule(): Boolean
  def annotationName(): String
}

trait SubclassFingerprint extends Fingerprint {
  def isModule(): Boolean
  def superclassName(): String
  def requireNoArgConstructor(): Boolean
}

Test Discovery

Event Handling

Event system for reporting test results, progress, and metadata with support for different test selection patterns.

trait Event {
  def fullyQualifiedName(): String
  def fingerprint(): Fingerprint
  def selector(): Selector
  def status(): Status
  def throwable(): OptionalThrowable
  def duration(): Long
}

trait EventHandler {
  def handle(event: Event): Unit
}

Event Handling

Logging System

Thread-safe logging interface supporting multiple log levels and ANSI color codes for user-facing messages.

trait Logger {
  def ansiCodesSupported(): Boolean
  def error(msg: String): Unit
  def warn(msg: String): Unit
  def info(msg: String): Unit
  def debug(msg: String): Unit
  def trace(t: Throwable): Unit
}

Logging System

Types

Core Types

final class TaskDef private (
  _fullyQualifiedName: String,
  _fingerprint: Fingerprint,
  _explicitlySpecified: Boolean,
  _selectors: Array[Selector]
) extends Serializable {
  def fullyQualifiedName(): String
  def fingerprint(): Fingerprint
  def explicitlySpecified(): Boolean
  def selectors(): Array[Selector]
}

final class OptionalThrowable(exception: Throwable) extends Serializable {
  def this()
  def isDefined(): Boolean
  def isEmpty(): Boolean
  def get(): Throwable
}

Status Enumeration

class Status private (name: String, ordinal: Int) extends Enum[Status](name, ordinal)

object Status {
  final val Success: Status
  final val Error: Status
  final val Failure: Status
  final val Skipped: Status
  final val Ignored: Status
  final val Canceled: Status
  final val Pending: Status
  
  def values(): Array[Status]
  def valueOf(name: String): Status
}

Selector Types

abstract sealed class Selector

final class SuiteSelector extends Selector with Serializable

final class TestSelector(testName: String) extends Selector with Serializable {
  def testName(): String
}

final class NestedSuiteSelector(suiteId: String) extends Selector with Serializable {
  def suiteId(): String
}

final class NestedTestSelector(suiteId: String, testName: String) extends Selector with Serializable {
  def suiteId(): String
  def testName(): String
}

final class TestWildcardSelector(testWildcard: String) extends Selector with Serializable {
  def testWildcard(): String
}
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.scala-js/scalajs-test-interface_2.12@1.19.x
Publish Source
CLI
Badge
tessl/maven-org-scala-js--scalajs-test-interface badge