yq/pkg/yqlib/operators_test.go

300 lines
7.4 KiB
Go
Raw Normal View History

2020-11-03 23:48:43 +00:00
package yqlib
import (
"bufio"
"bytes"
2020-11-06 03:37:01 +00:00
"container/list"
2020-11-03 23:48:43 +00:00
"fmt"
2020-11-13 09:58:01 +00:00
"io"
2020-11-03 23:48:43 +00:00
"os"
2020-11-06 01:11:38 +00:00
"strings"
2020-11-03 23:48:43 +00:00
"testing"
"github.com/mikefarah/yq/v4/test"
2020-12-01 03:06:49 +00:00
yaml "gopkg.in/yaml.v3"
2020-11-03 23:48:43 +00:00
)
type expressionScenario struct {
2020-11-14 23:50:30 +00:00
description string
2020-11-17 23:32:30 +00:00
subdescription string
2021-01-09 01:06:19 +00:00
environmentVariable string
2020-11-14 23:50:30 +00:00
document string
2021-01-01 23:27:32 +00:00
document2 string
2020-11-14 23:50:30 +00:00
expression string
expected []string
skipDoc bool
dontFormatInputForDoc bool // dont format input doc for documentation generation
2020-11-03 23:48:43 +00:00
}
2021-11-12 04:02:28 +00:00
func readDocumentWithLeadingContent(content string, fakefilename string, fakeFileIndex int) (*list.List, error) {
reader, firstFileLeadingContent, err := processReadStream(bufio.NewReader(strings.NewReader(content)))
if err != nil {
return nil, err
}
inputs, err := readDocuments(reader, fakefilename, fakeFileIndex)
if err != nil {
return nil, err
}
inputs.Front().Value.(*CandidateNode).LeadingContent = firstFileLeadingContent
return inputs, nil
}
2020-11-03 23:48:43 +00:00
func testScenario(t *testing.T, s *expressionScenario) {
2020-11-06 03:37:01 +00:00
var err error
2020-11-13 02:19:54 +00:00
2021-01-12 23:18:53 +00:00
node, err := NewExpressionParser().ParseExpression(s.expression)
2020-11-13 02:19:54 +00:00
if err != nil {
2021-11-22 06:43:38 +00:00
t.Error(fmt.Errorf("Error parsing expression %v of %v: %w", s.expression, s.description, err))
2020-11-13 02:19:54 +00:00
return
}
inputs := list.New()
2020-11-06 03:37:01 +00:00
if s.document != "" {
2021-11-12 04:02:28 +00:00
inputs, err = readDocumentWithLeadingContent(s.document, "sample.yml", 0)
2020-11-13 02:19:54 +00:00
if err != nil {
2020-12-26 10:37:08 +00:00
t.Error(err, s.document, s.expression)
2020-11-13 02:19:54 +00:00
return
}
2021-11-12 04:02:28 +00:00
2021-01-01 23:27:32 +00:00
if s.document2 != "" {
2021-11-12 04:02:28 +00:00
moreInputs, err := readDocumentWithLeadingContent(s.document2, "another.yml", 1)
2021-01-01 23:27:32 +00:00
if err != nil {
2021-11-12 04:02:28 +00:00
t.Error(err, s.document2, s.expression)
2021-01-01 23:27:32 +00:00
return
}
inputs.PushBackList(moreInputs)
}
2020-12-01 03:06:49 +00:00
} else {
candidateNode := &CandidateNode{
Document: 0,
Filename: "",
2021-01-14 03:25:31 +00:00
Node: &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode},
2020-12-01 03:06:49 +00:00
FileIndex: 0,
}
inputs.PushBack(candidateNode)
2020-11-03 23:48:43 +00:00
}
2021-01-09 00:33:39 +00:00
if s.environmentVariable != "" {
os.Setenv("myenv", s.environmentVariable)
}
context, err := NewDataTreeNavigator().GetMatchingNodes(Context{MatchingNodes: inputs}, node)
2020-11-13 02:19:54 +00:00
2020-11-06 03:37:01 +00:00
if err != nil {
2021-11-22 06:43:38 +00:00
t.Error(fmt.Errorf("%w: %v", err, s.expression))
2020-11-03 23:48:43 +00:00
return
}
2021-11-13 23:51:18 +00:00
test.AssertResultComplexWithContext(t, s.expected, resultsToString(t, context.MatchingNodes), fmt.Sprintf("desc: %v\nexp: %v\ndoc: %v", s.description, s.expression, s.document))
2020-11-03 23:48:43 +00:00
}
2021-11-13 23:51:18 +00:00
func resultsToString(t *testing.T, results *list.List) []string {
2020-11-16 01:09:57 +00:00
var pretty []string = make([]string, 0)
2021-11-13 23:18:02 +00:00
2020-11-16 01:09:57 +00:00
for el := results.Front(); el != nil; el = el.Next() {
n := el.Value.(*CandidateNode)
2021-11-13 23:18:02 +00:00
var valueBuffer bytes.Buffer
printer := NewPrinterWithSingleWriter(bufio.NewWriter(&valueBuffer), YamlOutputFormat, true, false, 4, true)
2021-11-13 23:51:18 +00:00
err := printer.PrintResults(n.AsList())
if err != nil {
t.Error(err)
return nil
}
2021-11-13 23:18:02 +00:00
tag := n.Node.Tag
if n.Node.Kind == yaml.DocumentNode {
tag = "doc"
} else if n.Node.Kind == yaml.AliasNode {
tag = "alias"
}
output := fmt.Sprintf(`D%v, P%v, (%v)::%v`, n.Document, n.Path, tag, valueBuffer.String())
pretty = append(pretty, output)
2020-11-16 01:09:57 +00:00
}
return pretty
}
2020-11-13 03:07:11 +00:00
func writeOrPanic(w *bufio.Writer, text string) {
_, err := w.WriteString(text)
if err != nil {
panic(err)
}
}
2020-11-13 10:22:05 +00:00
func copyFromHeader(title string, out *os.File) error {
2020-11-13 09:58:01 +00:00
source := fmt.Sprintf("doc/headers/%v.md", title)
_, err := os.Stat(source)
if os.IsNotExist(err) {
2020-11-13 10:22:05 +00:00
return nil
2020-11-13 09:58:01 +00:00
}
in, err := os.Open(source) // nolint gosec
if err != nil {
2020-11-13 10:22:05 +00:00
return err
2020-11-13 09:58:01 +00:00
}
defer safelyCloseFile(in)
_, err = io.Copy(out, in)
2020-11-13 10:22:05 +00:00
return err
}
2021-01-01 23:27:32 +00:00
func formatYaml(yaml string, filename string) string {
2020-11-13 10:22:05 +00:00
var output bytes.Buffer
2021-10-29 03:14:39 +00:00
printer := NewPrinterWithSingleWriter(bufio.NewWriter(&output), YamlOutputFormat, true, false, 2, true)
2020-11-13 10:22:05 +00:00
2021-01-12 23:18:53 +00:00
node, err := NewExpressionParser().ParseExpression(".. style= \"\"")
2020-11-13 10:22:05 +00:00
if err != nil {
panic(err)
}
2020-11-22 00:56:28 +00:00
streamEvaluator := NewStreamEvaluator()
2021-07-19 09:58:47 +00:00
_, err = streamEvaluator.Evaluate(filename, strings.NewReader(yaml), node, printer, "")
2020-11-13 10:22:05 +00:00
if err != nil {
panic(err)
}
return output.String()
2020-11-13 09:58:01 +00:00
}
2020-11-03 23:48:43 +00:00
func documentScenarios(t *testing.T, title string, scenarios []expressionScenario) {
f, err := os.Create(fmt.Sprintf("doc/%v.md", title))
if err != nil {
2020-11-13 02:19:54 +00:00
t.Error(err)
2020-11-13 09:58:01 +00:00
return
2020-11-03 23:48:43 +00:00
}
defer f.Close()
2020-11-13 09:58:01 +00:00
2020-11-13 10:22:05 +00:00
err = copyFromHeader(title, f)
2020-11-13 09:58:01 +00:00
if err != nil {
t.Error(err)
return
}
2020-11-03 23:48:43 +00:00
w := bufio.NewWriter(f)
2020-11-22 02:16:54 +00:00
writeOrPanic(w, "\n")
2020-11-13 09:58:01 +00:00
2020-11-22 02:16:54 +00:00
for _, s := range scenarios {
2020-11-06 00:45:18 +00:00
if !s.skipDoc {
documentScenario(t, w, s)
}
}
w.Flush()
}
2020-11-03 23:48:43 +00:00
func documentScenario(t *testing.T, w *bufio.Writer, s expressionScenario) {
writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
2020-11-22 02:16:54 +00:00
if s.subdescription != "" {
writeOrPanic(w, s.subdescription)
writeOrPanic(w, "\n\n")
}
2020-11-03 23:48:43 +00:00
formattedDoc, formattedDoc2 := documentInput(w, s)
2020-11-06 00:45:18 +00:00
writeOrPanic(w, "will output\n")
2021-01-01 23:27:32 +00:00
documentOutput(t, w, s, formattedDoc, formattedDoc2)
}
2021-01-01 23:27:32 +00:00
func documentInput(w *bufio.Writer, s expressionScenario) (string, string) {
formattedDoc := ""
formattedDoc2 := ""
command := "eval"
2021-01-09 00:33:39 +00:00
envCommand := ""
2021-01-09 01:06:19 +00:00
if s.environmentVariable != "" {
envCommand = fmt.Sprintf("myenv=\"%v\" ", s.environmentVariable)
os.Setenv("myenv", s.environmentVariable)
}
if s.document != "" {
if s.dontFormatInputForDoc {
formattedDoc = s.document + "\n"
} else {
formattedDoc = formatYaml(s.document, "sample.yml")
}
2021-01-01 23:27:32 +00:00
writeOrPanic(w, "Given a sample.yml file of:\n")
writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc))
2021-01-01 23:27:32 +00:00
files := "sample.yml"
if s.document2 != "" {
if s.dontFormatInputForDoc {
formattedDoc2 = s.document2 + "\n"
} else {
formattedDoc2 = formatYaml(s.document2, "another.yml")
2021-01-01 23:27:32 +00:00
}
writeOrPanic(w, "And another sample another.yml file of:\n")
writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc2))
files = "sample.yml another.yml"
command = "eval-all"
}
writeOrPanic(w, "then\n")
2021-01-09 00:33:39 +00:00
if s.expression != "" {
2021-01-09 00:33:39 +00:00
writeOrPanic(w, fmt.Sprintf("```bash\n%vyq %v '%v' %v\n```\n", envCommand, command, s.expression, files))
} else {
2021-01-09 00:33:39 +00:00
writeOrPanic(w, fmt.Sprintf("```bash\n%vyq %v %v\n```\n", envCommand, command, files))
}
} else {
writeOrPanic(w, "Running\n")
2021-01-09 00:33:39 +00:00
writeOrPanic(w, fmt.Sprintf("```bash\n%vyq %v --null-input '%v'\n```\n", envCommand, command, s.expression))
}
return formattedDoc, formattedDoc2
}
func documentOutput(t *testing.T, w *bufio.Writer, s expressionScenario, formattedDoc string, formattedDoc2 string) {
var output bytes.Buffer
var err error
2021-10-29 03:14:39 +00:00
printer := NewPrinterWithSingleWriter(bufio.NewWriter(&output), YamlOutputFormat, true, false, 2, true)
2021-01-12 23:18:53 +00:00
node, err := NewExpressionParser().ParseExpression(s.expression)
if err != nil {
2021-11-22 06:43:38 +00:00
t.Error(fmt.Errorf("Error parsing expression %v of %v: %w", s.expression, s.description, err))
return
}
inputs := list.New()
if s.document != "" {
2021-11-12 04:02:28 +00:00
inputs, err = readDocumentWithLeadingContent(formattedDoc, "sample.yml", 0)
if err != nil {
t.Error(err, s.document, s.expression)
return
}
if s.document2 != "" {
2021-11-12 04:02:28 +00:00
moreInputs, err := readDocumentWithLeadingContent(formattedDoc2, "another.yml", 1)
2021-01-01 23:27:32 +00:00
if err != nil {
t.Error(err, s.document, s.expression)
return
2020-11-06 03:37:01 +00:00
}
inputs.PushBackList(moreInputs)
}
} else {
candidateNode := &CandidateNode{
Document: 0,
Filename: "",
2021-01-14 03:25:31 +00:00
Node: &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode},
FileIndex: 0,
}
inputs.PushBack(candidateNode)
2020-11-06 03:37:01 +00:00
}
2020-11-03 23:48:43 +00:00
context, err := NewDataTreeNavigator().GetMatchingNodes(Context{MatchingNodes: inputs}, node)
if err != nil {
t.Error(err, s.expression)
}
2020-11-03 23:48:43 +00:00
err = printer.PrintResults(context.MatchingNodes)
if err != nil {
t.Error(err, s.expression)
2020-11-03 23:48:43 +00:00
}
writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", output.String()))
2020-11-03 23:48:43 +00:00
}