text/dict-set-context_test.go

// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
// All rights reserved.

// dict-set-context_test.go
package text

import (
	"crypto/sha1"
	"encoding/hex"
	"errors"
	"fmt"
	"strings"
	"testing"
	"time"
)

func TestNewDictSetContext(t *testing.T) {
	type inputType struct {
		ctx        ExpanderContext
		source     string
		wantResult string
		wantErr    error
	}

	funcName := "scan"

	flags := DictSetFlag(0)
	vars := map[string]string{"one": "1", "two": "2", "three": "3"}
	ctx1 := NewDictSetContext(flags, vars)
	ctx2 := NewDictSetContext(KeepVar, vars)
	AddTimeFuncs(ctx2)
	/*
	   err = fmt.Errorf("unsupported '%%%c' time specifier at %d", ch, i)
	*/
	now := time.Now()
	yday := now.Add(-24*time.Hour)
	inputs := []inputType{
		{ctx2, `form: ${|__time-fmt now ""}`, fmt.Sprintf("form: %d-%02d-%02d %02d:%02d:%02d", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second()), nil},
		{ctx2, `form: ${|__time-fmt now "%-D"}`, fmt.Sprintf("form: %d-%d-%d", now.Year(), now.Month(), now.Day()), nil},
		{ctx2, `form: ${|__time-fmt now "%:T"}`, fmt.Sprintf("form: %d:%d:%d", now.Hour(), now.Minute(), now.Second()), nil},
		{ctx2, `form: ${|__time-fmt now "%02:T"}`,"", errors.New("invalid time specifier format at 3")},
		{ctx2, `form: ${|__time-fmt ""}`,"", errors.New("time value is empty")},
		{ctx2, `form: ${|__time-fmt yesterday "%-D"}`, fmt.Sprintf("form: %d-%d-%d", yday.Year(), yday.Month(), yday.Day()), nil},
		{ctx1, "${one|pippo}", "1", nil},
		{ctx1, "${one|__default pluto}", "1", nil},
		{ctx1, "${six|__default pluto}", "pluto", nil},
		{ctx1, "${six|__default - pluto paperino|__lower|__upper}", "PLUTO-PAPERINO", nil},
		{ctx1, "${two|__join + 1 ${.} ${|__get three}}", "1+2+3", nil},
		{ctx1, "${=one|__get}", "1", nil},
		{ctx1, "${|__get unknown default}", "default", nil},
		{ctx1, "${one|__set A ${.}}", "1", nil},
		{ctx1, "${one|__set B }", "1", nil},
		{ctx1, "${one|__set}", "1", nil},
		{ctx1, "${=archive.tar.gz|__trim-suffix}", "archive.tar", nil},
		{ctx1, "${=prog.exe|__trim-suffix .zip .png .exe .com}", "prog", nil},
		{ctx1, "${=prog.exe|__trim-suffix .zip .png .jpeg .com}", "prog.exe", nil},
		{ctx1, "${=ciccio}", "ciccio", nil},
		{ctx1, "${=ciccio{}", "", errors.New("unbalanced open braces at offset 9")},
		{ctx1, "${|__get two}", "2", nil},
		{ctx1, "${one} + ${two} = ${three}", "1 + 2 = 3", nil},
		{ctx1, "${one} + ${two} = ${four}", "1 + 2 = ", nil},
		{ctx2, "${one} + ${two} = ${four}", "1 + 2 = ${four}", nil},
		{ctx2, `now: ${|__time-fmt now "%:02T"}`, fmt.Sprintf("now: %02d:%02d:%02d", now.Hour(), now.Minute(), now.Second()), nil},
		{ctx2, `hour: ${|__time-fmt now "%02H"}`, fmt.Sprintf("hour: %02d", now.Hour()), nil},
		{ctx2, `minute: ${|__time-fmt now "%02M"}`, fmt.Sprintf("minute: %02d", now.Minute()), nil},
		{ctx2, `second: ${|__time-fmt now "%02S" }`, fmt.Sprintf("second: %02d", now.Second()), nil},
		{ctx2, `today: ${|__time-fmt now "%-02D"}`, fmt.Sprintf("today: %d-%02d-%02d", now.Year(), now.Month(), now.Day()), nil},
		{ctx2, `year: ${|__time-fmt now "%Y"}`, fmt.Sprintf("year: %d", now.Year()), nil},
		{ctx2, `month: ${|__time-fmt now "%m"}`, fmt.Sprintf("month: %02d", now.Month()), nil},
		{ctx2, `weird: ${|__time-fmt now "%c"}`, "", errors.New(`unsupported 'c' time specifier at "%c"/2`)},
		{ctx2, `perc: ${|__time-fmt now "%%"}`, "perc: %", nil},
		{ctx1, `unknown var ${!unknown}`, ``, errors.New(`the variable specification "unknown" requires a value`)},
		{ctx1, `${hello-word|}!`, `!`, nil},
		{ctx1, `${hello-word|ciao}!`, `ciao!`, nil},
	}

	for i, input := range inputs {
		gotResult, gotErr := ExpandStringTemplate(input.ctx, input.source)

		if gotResult != input.wantResult {
			t.Errorf("%d: %s(%q)/result = %q, want %q", i, funcName, input.source, gotResult, input.wantResult)
		}
		if gotErr == nil && input.wantErr == nil {
			continue
		}
		if (gotErr != nil && input.wantErr == nil) || (gotErr == nil && input.wantErr != nil) || (gotErr.Error() != input.wantErr.Error()) {
			t.Errorf("%d: %s(%q)/err = <%v>, want <%v>", i, funcName, input.source, gotErr, input.wantErr)
		}

	}
}

func TestCheckNumArgs(t *testing.T) {
	type inputType struct {
		info ExpanderFuncBlock
		n    int // number of args
		want bool
	}
	funcName := "CheckNumArgs"

	inputs := []inputType{
		{ExpanderFuncBlock{"", nil, -1, -1, ""}, 0, true},
		{ExpanderFuncBlock{"", nil, 0, -1, ""}, 10, true},
		{ExpanderFuncBlock{"", nil, 2, 4, ""}, 1, false},
	}
	for i, input := range inputs {
		got := input.info.CheckNumArgs(input.n)

		if got != input.want {
			t.Errorf("%d: %s(%d)/result = %v, want %v", i, funcName, input.n, got, input.want)
		}
	}
}

func TestIterateFunc(t *testing.T) {
	var sb strings.Builder

	funcName := "IterateFunc"

	want := "f141c5fa802ed509c08ec057eea5ba0086a84b21"
	vars := map[string]string{"one": "1", "two": "2", "three": "3"}
	ctx := NewDictSetContext(KeepVar, vars)
	ctx.AddFunc("dumm1", nil, 1, 2, "bla-bla")
	ctx.AddFunc("dumm2", nil, 0, 5, strings.Repeat(".", 81))
	ctx.AddFunc("dumm3", nil, -1, -1, "bla-bla")
	ctx.AddFunc("dumm4", nil, 2, -1, "bla-bla")

	ctx.IterateFunc(func(info *ExpanderFuncBlock) error {
		sb.WriteString(info.String())
		return nil
	})
	hasher := sha1.New()
	hasher.Write([]byte(sb.String()))
	got := hex.EncodeToString(hasher.Sum(nil))
	//fmt.Println("sha:", got)
	//fmt.Println(sb.String())
	if got != want {
		t.Errorf("%s()/result = %q, want %q", funcName, got, want)
	}
}