A minimal set of test utilities to recommend in the meantime.

[louiss0]

I decided to create a script for you guys to use in the mean time. It's called mini-nu-test. it script that allows people to write tests. The code should be easy to understand.

It has three functions

• specify for grouping tests
• test for writing tests that aren't specific to a unit
• it for writing tests that are about a specific unit

I was going to write lots of assertions but I have to do other things.
The script is less than 300 lines long so I copied and pasted it here.
All you have to do is simply copy and paste it then make improvements.

The user is supposed to use the watch command to watch the files that are necessary.

This is the Script

# The mini-nu-test module is for.
# Exporting functions that help with testing
# This isn't a fully featured test framework.
#~# To use the functions in this module.
# 1. Create a file 
# 2. Activate the functions
# 3. Use the watch command to watch that file.
# Remember you can watch folders or even files with the test command

use std/assert  

export use assert

export-env {
    $env.NU_LOG_FORMAT = "%ANSI_START%%DATE%|%LEVEL%|%MSG%%ANSI_STOP%"
    $env.NU_LOG_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S%.3f"
}

use std/log


module custom-log {
	
	use std/log [custom log-level]

	const log_format = "%ANSI_START%|%LEVEL%| %MSG% |%DATE%|%ANSI_STOP%\n"

	export def fail [message: string] {

		custom $message $log_format ( log-level | get 'ERROR' ) --level-prefix "FAILURE"
	
	}
	
	export def warning [message: string] {

		custom $message $log_format ( log-level | get 'WARNING' ) 
	
	}

	export def success [message: string] {

		custom  $message $log_format ( log-level | get 'INFO' ) --level-prefix 'SUCCESS' --ansi (ansi green)

	}
	
	export def info [message: string] {

		custom $message $log_format ( log-level | get 'INFO' ) --ansi (ansi steelblue)

	}

}



use custom-log

	# Function making sure that an error has a specific cause
export def assert-error-message-is [
		callback:closure # function used to catch the error 
		message:string # The expected error message
		] {
			
			try { 
				
        do $callback 
    
    } catch { |err|

        return (
            assert ($err.msg == $message) --error-label {
            text: $"The error message ($err.msg) isn't the expected ($message)"
            span:(metadata $message).span
         }
        )  
    }

    error make {
        msg: "Invalid Argument", 
        label: {
            text:"The function didn't produce an error"
            span:(metadata $callback).span
        }
        help: "Use a function that will create an error. An error message is supposed to be found"
    }

}

export def assert-invalid-argument-error [callback:closure] {

    assert-error-message-is $callback "Invalid Argument" 

}

export def assert-invalid-value-error [callback:closure] {

    assert-error-message-is $callback "Invalid Value" 

}

export def assert-bad-condition-error [callback:closure] {

    assert-error-message-is $callback "Bad Condition" 

}


export def main [] { help mini-nu-test }

# Specify what are you testing or what unit you are testing!
# Each specify block covers a set of test messages in an closing and opening fence message.
# The opening fence will have the 'specification' in it.
# The closing fence will not.
export def specify [
    --todo # Flag specifying that a test's wont be executed until later
    specification:string # What does a series of tests revolve around
    callback:closure # The tests executor 
    ] -> nothing {


    if $todo == true {
    
        return ( custom-log warning $"TODO: |=== ($specification) ===|\n\n" )

    }
         
    print $"|=== ($specification) ===|\n"
    
    do $callback  

    print "|-------------|\n"

}

const capture_labeled_error_regex = 'LabeledError\(LabeledError\s\{\smsg:(?<msg>\s.+),\slabels:\s\[ErrorLabel\s\{\stext:\s(?<text>.+),\sspan:\sSpan\s\{\sstart:\s(?<start>\d+),\send:\s(?<end>\d+)\s}\s}],\scode:\s(?<code>\S+),\surl:\s(?<url>.+),\shelp:\s(?<help>.+),\sinner:\s(?<inner>\[(?:.+)?\])\s}\)'

# This function is used for testing asserstions
# It' logs any assertion error mesage along with the test description When failed
# When passed it logs 'Test Passed' with the test description
export def test [
    --todo # Pause execution of the command but log out the name of the test 
    description:string # What are you testing
    callback:closure # Function used to execute assertions
    ] -> nothing {

	if $todo {

        return (custom-log warning $"TODO: ($description)")
    }

    try {

        do $callback

        custom-log success $"Test Passed ($description)" 

    } catch { |err|

      custom-log fail $"($description) ($err.msg)" 
      
      $err.debug
      | parse --regex $capture_labeled_error_regex
      | print


    }

}

# This function is used for testing asserstions
# When failed the a term ' It doesn't ' with the test description is logged 
# When passed it logs 'It' with the test description
export def it [
    --todo # Pause execution of the command but log out the name of the test 
    description:string # What is the unit you are testing supposed to do
    callback:closure # Function used to execute assertions
    ] -> nothing {

    if $todo {

        return (custom-log warning $"TODO: ($description)")
    }

    try {

        do $callback

        custom-log success $"It ($description)"

    } catch { |err|

      custom-log fail $"It ($description) fails"  
      
      $err.debug
      | parse --regex $capture_labeled_error_regex
      | print
 

    }

}

# This function is created to generate tests based on multiple paramters.
# The input is a list that expects a record of three things.
# - `name` -- a name for a set of parameters with an expected result
# - `params` -- an array of paramters passed through 
# - `expected` -- the expected result of the params
# Each record's values will be logged throughout each iteration
# They will be passed into the closure for each iteration
# The closure will hold the params as the first paramter
# The second parameter will be the expected result
export def param-test [
    --todo # Pause the execution of the callback for each iteration but log the description with a warning 
     description:string # The description of the muiti param test
     callback:closure # The callback to execute per test
    ]: list<record<name:string, params:list<any>, expected:any>> -> nothing  {


    if $todo {
        return (custom-log warning $"TODO: $($description)")
    }

    custom-log info $description

    $in |  each { |value|

    let message = [
        $"For parameter set *name* ($value.name)." 
        $"With these *params* ($value.params | to nuon)."
        $"This ($value.expected | to nuon) is *expected*."
        ] | str join "\n\t" 

        test $message {

            do $callback $value.params $value.expected

        }

    } | ignore 

}