is

package main

import (
	"errors"
	"fmt"
	"strconv"
	"strings"

	"codeberg.org/japh/is"
)

var t = &mockTestingT{}

func main() {
	testData, _ := is.TableFromString(`

                A simple example of using a text table to define a group of tests

                +-----+---------+---------+------+-------------------+-------------------------+
                | wip | given   | when    | then | error             | comment                 |
                +=====+=========+=========+======+===================+=========================+
                |     |         |         |      | empty expression  |                         |
                |     |         | 1 + 2   | 3    |                   |                         |
                |     |         | a + b   |      | a is not a number |                         |
                |     | a:1 b:2 | a + b   | 3    |                   |                         |
                +-----+---------+---------+------+-------------------+-------------------------+
                |     | a:1     | sqrt(a) | 1    |                   |                         |
                | ==> | a:4     | sqrt(a) | 2    |                   |                         |
                | ==> | a:-1    | sqrt(a) |      | undefined         | need imaginary numbers? |
                `)

	testCases, err := testCasesFromTable(testData)

	if err != nil {
		t.Error(err)
		return
	}

	wipOnly := testCases.wipCount > 0

	if wipOnly {
		t.Logf("Running %d of %d tests", testCases.wipCount, len(testCases.tests))
	}

	for _, testCase := range testCases.tests {
		if wipOnly && !testCase.wip {
			continue
		}

		t.Run(
			fmt.Sprintf("line %d: %s", testCase.line, testCase.name),
			func(t *mockTestingT /* t *testing.T */) {

				// a little extra context
				if testCase.comment != "" {
					t.Logf("# %s", testCase.comment)
				}

				// given <preconditions>
				for name, value := range testCase.given {
					t.Logf("set %s = %v", name, value)
				}

				// when <action>
				t.Logf("run %s", testCase.when)

				// then <expectations>
				t.Logf("got %v (error: %v)", testCase.then, testCase.err)
			},
		)

	}

	if testCases.wipCount > 0 {
		t.Errorf("skipped %d non-wip tests", len(testCases.tests)-testCases.wipCount)
	}

}

////////////////////////////////////////////////////////////////////////////////
//
// utiltity code to convert a table ([][]string) into something more practical
//

type testCaseTable struct {
	wipCount int
	tests    []*testCase
}

type testCase struct {
	line    int
	wip     bool
	name    string
	given   map[string]float64
	when    string
	then    float64
	err     error
	comment string
}

func testCasesFromTable(dataTable *is.Table) (*testCaseTable, error) {
	tct := &testCaseTable{}
	rows := dataTable.DataRows()
	lineOfRow := dataTable.RowLineMap()
	colMap := map[string]int{}
	for col, name := range rows[0] {
		colMap[name] = col
	}
	for r, row := range rows[1:] {
		tc := testCaseFromSlice(lineOfRow[r], row, colMap)
		tct.tests = append(tct.tests, tc)
		if tc.wip {
			tct.wipCount++
		}
	}
	return tct, nil
}

func testCaseFromSlice(line int, cell []string, col map[string]int) *testCase {
	tc := &testCase{}
	tc.line = line
	tc.wip = cell[col["wip"]] != ""
	tc.when = cell[col["when"]]
	tc.then, _ = strconv.ParseFloat(cell[col["then"]], 64)
	tc.comment = cell[col["comment"]]

	tc.name = cell[col["when"]]

	// 'given' is a little more complicated:
	//      split into space separated fields
	//      then split each field into a 'name' and 'value'
	tc.given = map[string]float64{}
	for _, f := range strings.Fields(cell[col["given"]]) {
		nv := strings.Split(f, ":")
		tc.given[nv[0]], _ = strconv.ParseFloat(nv[1], 64)
	}

	if err := cell[col["error"]]; err != "" {
		tc.err = errors.New(err)
	}

	return tc
}

////////////////////////////////////////////////////////////////////////////////
//
// Mock testing.T for demonstration purposes only
//

// Normal test functions use their testing.T parameters to report errors.
// Since Example() must be defined without parameters, we define a little
// mock 't' variable to assume the role of testing.T
type mockTestingT struct {
	indent string
}

func (t *mockTestingT) Run(name string, testFn func(*mockTestingT)) {
	fmt.Println("=== RUN", name)
	t.indent = "    "
	testFn(t)
	t.indent = ""
}

func (t *mockTestingT) Error(args ...interface{}) {
	fmt.Printf("%s%s\n", t.indent, fmt.Sprint(args...))
}

func (t *mockTestingT) Errorf(msgFmt string, args ...interface{}) {
	fmt.Printf("%s%s\n", t.indent, fmt.Sprintf(msgFmt, args...))
}

func (t *mockTestingT) Log(args ...interface{}) {
	fmt.Printf("%s%s\n", t.indent, fmt.Sprint(args...))
}

func (t *mockTestingT) Logf(msgFmt string, args ...interface{}) {
	fmt.Printf("%s%s\n", t.indent, fmt.Sprintf(msgFmt, args...))
}

Output:


Running 2 of 7 tests
=== RUN line 13: sqrt(a)
    set a = 4
    run sqrt(a)
    got 2 (error: <nil>)
=== RUN line 14: sqrt(a)
    # need imaginary numbers?
    set a = -1
    run sqrt(a)
    got 0 (error: undefined)
skipped 5 non-wip tests