cyber-dojo web server default  start-points


  • The languages start-point page holds the choices where you select your language (eg C#) and test-framework (eg NUnit).
  • The default languages start-point page is called languages.
  • languages is created from the languages_list file which contains a list of repo-URLs in the cyber-dojo-languages github organization, each of which contain a manifest.json file.


  • The exercises start-point page holds the choices where you select your exercise (eg Fizz Buzz).
  • The default exercises start-point page is called exercises
  • exercises is created from the start-points-exercises github repo which contains instructions text files.


  • The custom start-point page holds the choices displayed when you switch to custom choices.
  • The default custom start-point is called custom
  • custom is created from the start-points-custom github repo which contains manifest.json files.

creating a new default start-point

To use a different default start-point simply bring down the server, delete the one you wish to replace, create a new one with that name, and bring the server back up. For example, to create a new languages start-point:
$ ./cyber-dojo down $ ./cyber-dojo start-point rm languages $ ./cyber-dojo start-point create languages --dir=... $ ./cyber-dojo up

$ ./cyber-dojo start-point ...

Start-points are controlled using the start-point command of the cyber-dojo script.
$ ./cyber-dojo start-point Use: cyber-dojo start-point [COMMAND] Manage cyber-dojo start-points Commands: create Creates a new start-point rm Removes a start-point ls Lists the names of all start-points inspect Displays details of a start-point pull Pulls all the images named inside a start-point Run 'cyber-dojo start-point COMMAND --help' for more information on a command

For example:
$ ./cyber-dojo start-point ls NAME TYPE SRC custom custom exercises exercises languages languages

For example:
$ ./cyber-dojo start-point inspect languages MAJOR_NAME MINOR_NAME IMAGE_NAME PULLED? Asm assert cyberdojofoundation/nasm_assert no BCPL all_tests_passed cyberdojofoundation/bcpl_all_tests_passed no Bash bash_unit cyberdojofoundation/bash_unit yes ... C (clang) Cgreen cyberdojofoundation/clang_cgreen no ... C (gcc) Cgreen cyberdojofoundation/gcc_cgreen no ... C# Moq cyberdojofoundation/csharp_moq yes ... C++ (clang++) Cgreen cyberdojofoundation/clangpp_cgreen no ... C++ (g++) Boost.Test cyberdojofoundation/gpp_boosttest no ... Clojure Midje cyberdojofoundation/clojure_midje no ... CoffeeScript jasmine cyberdojofoundation/coffeescript_jasmine no D unittest cyberdojofoundation/d_unittest no Erlang eunit cyberdojofoundation/erlang_eunit no F# NUnit cyberdojofoundation/fsharp_nunit no Fortran FUnit cyberdojofoundation/fortran_funit no Go testing cyberdojofoundation/go_testing no Groovy JUnit cyberdojofoundation/groovy_junit no ... Haskell hunit cyberdojofoundation/haskell_hunit no Java Cucumber cyberdojofoundation/java_cucumber no ... Javascript Mocha+chai+sinon cyberdojofoundation/javascript-node_mocha_chai_sinon no ... PHP PHPUnit cyberdojofoundation/php_phpunit no Perl Test::Simple cyberdojofoundation/perl_test_simple no Python py.test cyberdojofoundation/python_pytest no Python unittest cyberdojofoundation/python_unittest yes R RUnit cyberdojofoundation/r_runit no Ruby Cucumber cyberdojofoundation/ruby_cucumber no ... Rust test cyberdojofoundation/rust_test no Scala scalatest cyberdojofoundation/scala_scalatest no Swift XCTest cyberdojofoundation/swift_xctest yes VHDL assert cyberdojofoundation/vhdl_assert no VisualBasic NUnit cyberdojofoundation/visual-basic_nunit no

$ ./cyber-dojo start-point create Use: cyber-dojo start-point create NAME --git=URL Use: cyber-dojo start-point create NAME --dir=PATH Creates a start-point named NAME from a git clone of URL Creates a start-point named NAME from a copy of PATH

cyber-dojo new release

The new release of cyber-dojo just went live :-)

creating your own server start-points

cyber-dojo's new architecture has customisable start-points.
If you want to use your own start-points you do not need to build a new web server image.

preparing your custom/languages start-point

  • Create a folder for the start-point
    $ md douglas
  • In the top-level folder create a file start_point_type.json
    $ touch douglas/start_point_type.json
    This file must specify the type of start-point.
    • languages (the type where setup will ask for an exercise)
      { 'type' : 'languages' }
    • custom (the type where setup will not ask for an exercise)
      { 'type' : 'custom' }
  • Create a sub-folder for each start-point entry
    $ md douglas/first
  • Create a manifest.json file in each folder
    $ nano douglas/first/manifest.json
  • Here's an example. Here's an explanation of the manifest.json format.
  • In each folder create the visible files named in manifest.json
    Here's an example

preparing your exercises start-point

  • Create a folder for the start-point
    $ md arthur
  • In the top-level folder create a file start_point_type.json
    $ touch arthur/start_point_type.json
    This file must specify the type of start-point.
    { 'type' : 'exercises' }
  • Create a sub-folder for each exercise
    $ md arthur/first
  • Create an instructions file in each folder
    $ nano arthur/first/instructions
    Here's an example

creating your start-point

Use the cyber-dojo script to create a new start-point. For example
$ cd douglas $ [sudo] ./cyber-dojo start-point create adams --dir=${PWD}
which attempts to create a start-point called adams from all the files in the douglas directory. If the creation fails the cyber-dojo script will print diagnostics.

starting your server with your start-point

eg with a type=custom start-point called hiker
$ [sudo] ./cyber-dojo up --custom=hiker
eg with a type=languages start-point named adams
$ [sudo] ./cyber-dojo up --languages=adams
eg with a type=exercises start-point named arthur
$ [sudo] ./cyber-dojo up --exercises=arthur
eg with a combination
$ [sudo] ./cyber-dojo up --languages=adams --exercises=arthur

adding a new language + test-framework to cyber-dojo

It will be updated properly soon.
Meanwhile, follow step 0 below, and then look at these examples from the cyber-dojo-languages github organization: Note how each repo's .travis.yml file simply runs the script which builds and tests the docker image and any associated start-point code. In particular the script augments the Dockerfile commands in various ways (eg adding users for the 64 avatars). Alternatively, if you are building your docker-image using a raw [docker build] command you must base your docker-image FROM a cyber-dojo-languages dockerhub image.

0. Install docker

1. Create a docker-image for just the language

Make this docker-image unit-test-framework agnostic.
If you are adding a new unit-test-framework to an existing language skip this step.
For example, suppose you were building Lisp
  • Create a new folder for your language
    $ md lisp
  • In your language's folder, create a file called Dockerfile
    $ cd Lisp $ touch Dockerfile
    If you can, base your new image on Alpine-linux as this will help keep images small. To do this make the first line of Dockerfile as follows
    FROM cyberdojofoundation/language-base
    Here's one based on Alpine-linux (217 MB: C#) Dockerfile
    Here's one not based on Alpine (Ubuntu 1.26 GB: Python) Dockerfile
  • Use the Dockerfile to build a docker-image for your language.
    For example
    $ docker build -t cyberdojofoundation/lisp .
    which, if it completes, creates a new docker-image called cyberdojofoundation/lisp using the Dockerfile (and build context) in . (the current folder).

2. Create a docker-image for the language and test-framework

Repeat the same process, building FROM the docker-image you created in the previous step.
For example, suppose your Lisp unit-test framework is called lunit
  • Create a new folder underneath your language folder
    $ cd lisp $ md lunit
  • In your new test folder, create a file called Dockerfile
    $ cd lunit $ touch Dockerfile
    The first line of this file must name the language docker-image you built in the previous step.
    Add lines for all the commands needed to install your unit-test framework...
    FROM cyberdojofoundation/lisp RUN apt-get install -y lispy-lunit RUN apt-get install -y ...
  • Create a file called red_amber_green.rb
    $ touch red_amber_green.rb
  • In red_amber_green.rb write a Ruby lambda accepting three arguments. For example, here is the C#-NUnit red_amber_green.rb:
    lambda { |stdout,stderr,status| output = stdout + stderr return :red if /^Errors and Failures:/.match(output) return :green if /^Tests run: (\d+), Errors: 0, Failures: 0/.match(output) return :amber }
    cyber-dojo uses this to determine the test's traffic-light colour by passing it the stdout, stderr, and status outcomes of the test run.
  • The Dockerfile for your language+testFramework must COPY red_amber_green.rb into the /usr/local/bin folder of your image. For example:
    FROM cyberdojofoundation/lisp RUN apt-get install -y lispy-lunit RUN apt-get install -y ... COPY red_amber_green.rb /usr/local/bin
    I usually start with a red_amber_green.rb that simply returns :red. Then, once I have a start-point using the language+testFramework docker-image, I use cyber-dojo to gather outputs which I use to build up a working red_amber_green.rb
  • Use the Dockerfile to try and build your language+testFramework docker-image.
    The name of an image takes the form hub-name/image-name. Do not include a version number in the image-name. For example
    $ docker build -t cyberdojofoundation/lisp_lunit .
    which, if it completes, creates a new docker image called cyberdojofoundation/lisp_lunit using the Dockerfile in . (the current folder).

3. Use the language+testFramework docker-image in a new start-point

Use the new image name (eg cyberdojofoundation/lisp_lunit) in a new manifest.json file in a new start-point.

cyber-dojo start-points manifest.json entries explained

Example: the manifest.json file for Java/JUnit looks like this:

{ "display_name": "Java, JUnit", "visible_filenames": [ "", "", "" ], "image_name": "cyberdojofoundation/java_junit", "runner_choice": "stateless", "filename_extension": ".java", "tab_size": 4, "progress_regexs" : [ "Tests run\\: (\\d)+,(\\s)+Failures\\: (\\d)+", "OK \\((\\d)+ test(s)?\\)" ] }

Required entries

"display_name": string

The (major, minor) names as they appear in the start-point setup pages where you select your language and test-framework. For example, "Java, JUnit" means that "Java" will appear in the left-hand-side language-list and, if you select it, then "JUnit" will appear in the right-hand-side test-framework-list for "Java". A single string with the major name first, then a comma, then the minor name. The major name cannot contain a comma.

"visible_filenames": [ string, string, ... ]

Filenames that will be visible in the browser's editor when an animal initially enter's a cyber-dojo. Each of these files must exist in the manifest.json's directory. Filenames can be in nested sub-directories, eg "tests/". Must include This is because is the name of the shell file assumed by the runner to be the start point for running the tests. You can write any actions inside but clearly any programs it tries to run must be installed in the docker image_name. For example, if runs gcc to compile C files then gcc has to be installed. If runs javac to compile java files then javac has to be installed.

"image_name": string

The name of the docker image used to run a container in which is executed. Do not include any version numbers (eg of the compiler or test-framework). The docker image must contain a file called red_amber_green.rb in the /usr/local/bin directory. The runner uses this to determine the traffic-light colour of each test run outcome. For example, here's the one for Java-JUnit.

"runner_choice": string

The string "stateless" or "stateful" or "processful". Each test run is handled by either the stateless-runner or the stateful-runner the processful-runner. The stateful and processful runners maintain state between test runs, the stateless runner does not. In other words, when using the stateful or processful runner the files produced by your script (eg .o files created from .c files via a makefile) do exist at the start of the next test run. With the stateless runner, they don't. Use the stateless runner unless you can gain a significant speed up with the stateful or processful runner (which require extra disk-space and cpu from the host server).

Optional entries

"max_seconds": int

The maximum number of seconds has to complete the tests. Cannot be greater than 20.
Defaults to 10.

"filename_extension": string

The filename extension used when creating a new filename. For example, if set to ".java" the new filename will be
Defaults to "". (and the new filename will be filename).

"tab_size": int

The number of spaces a tab character expands to in the browser's textarea editor.
Defaults to 4.

"progress_regexs": [ string, string ]

Two regexs, the first one to match a red traffic light's test output, and the second one to match a green traffic light's test output. Used on the dashboard to show the test output line (which often contains the number of passing and failing tests) of each animal's most recent red/green traffic light. Useful when your practice session starts from a large number of pre-written tests and you wish to monitor the progress of each animal.
Defaults to [].

"highlight_filenames": [ string, string, ... ]

Filenames whose appearance is highlighted in the browser. This can be useful if you have many "visible_filenames" and want to mark which files form the focus of the practice.
A strict subset of "visible_filenames".
For example
"highlight_filenames": [ "buffer.cpp", "buffer.hpp" ]
The appearance of "highlight_filenames" is controlled by the CSS in kata.css.scss
div[class~='filename'][class~='highlight'] { ... }
The highlight_filenames entry also interacts with lowlights_filenames, see StartPoint.lowlight_filenames() in start_point.rb and cd.notLowlightFilenames() in cyber-dojo_file_load.js
Again, its appearance in controlled from the same CSS file...
div[class~='filename'][class~='lowlight'] { ... }
If there is a "highlight_filenames" entry, then lowlight-filenames will be
[visible_filenames] - [highlight_filenames]
If there is no "highlight_filenames" entry, then lowlight-filenames will default to something like
[ 'cyber-dojo', 'makefile', 'Makefile' ]
Defaults to [].

running your own cyber-dojo web server