Now using shunit2 for acceptance tests

.gitignore

@@ -38,3 +38,4 @@ parts/
 prime/
 .snapcraft/
 yq*.snap
+test.yml

acceptance_tests/basic.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+setUp() {
+  rm -f test.yml
+}
+
+testBasicEvalRoundTrip() {
+  random=$((1 + $RANDOM % 10))
+  ./yq e -n ".a = $random" > test.yml
+  X=$(./yq e '.a' test.yml)
+  assertEquals $random $X
+}
+
+testBasicUpdateInPlaceSequence() {
+  cat >test.yml <<EOL
+a: 0
+EOL
+  ./yq e -i ".a = 10" test.yml
+  X=$(./yq e '.a' test.yml)
+  assertEquals "10" $X
+}
+
+testBasicUpdateInPlaceSequenceEvalAll() {
+  cat >test.yml <<EOL
+a: 0
+EOL
+  ./yq ea -i ".a = 10" test.yml
+  X=$(./yq e '.a' test.yml)
+  assertEquals "10" $X
+}
+
+testBasicNoExitStatus() {
+  echo "a: cat" > test.yml
+  X=$(./yq e '.z' test.yml)
+  assertEquals "null" $X
+}
+
+testBasicExitStatus() {
+  echo "a: cat" > test.yml
+  X=$(./yq e -e '.z' test.yml 2&>/dev/null)
+  assertEquals 1 $?
+}
+
+source ./scripts/shunit2

acceptance_tests/empty.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+
+setUp() {
+  cat >test.yml <<EOL
+# comment
+EOL
+}
+
+testEmptyEval() {
+  X=$(./yq e test.yml)
+  assertEquals 0 $?
+}
+
+testEmptyEvalPipe() {
+  X=$(cat test.yml | ./yq e -)
+  assertEquals 0 $?
+}
+
+testEmptyCommentsWithExpressionEval() {
+  read -r -d '' expected << EOM
+# comment
+apple: tree
+EOM
+
+  X=$(./yq e '.apple="tree"' test.yml)
+
+  assertEquals "$expected" "$X"
+}
+
+testEmptyCommentsWithExpressionEvalAll() {
+  read -r -d '' expected << EOM
+# comment
+apple: tree
+EOM
+
+  X=$(./yq ea '.apple="tree"' test.yml)
+
+  assertEquals "$expected" "$X"
+}
+
+testEmptyWithExpressionEval() {
+  rm test.yml
+  touch test.yml
+  expected="apple: tree"
+
+  X=$(./yq e '.apple="tree"' test.yml)
+
+  assertEquals "$expected" "$X"
+}
+
+testEmptyWithExpressionEvalAll() {
+  rm test.yml
+  touch test.yml
+  expected="apple: tree"
+
+  X=$(./yq ea '.apple="tree"' test.yml)
+
+  assertEquals "$expected" "$X"
+}
+
+
+source ./scripts/shunit2

acceptance_tests/front-matter.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+
+setUp() {
+  cat >test.yml <<EOL
+---
+a: apple
+b: cat
+---
+not yaml
+c: at
+EOL
+}
+
+testFrontMatterProcessEval() {
+  read -r -d '' expected << EOM
+---
+a: apple
+b: dog
+---
+not yaml
+c: at
+EOM
+  ./yq e --front-matter="process" '.b = "dog"' test.yml -i
+  assertEquals "$expected" "$(cat test.yml)"
+}
+
+testFrontMatterProcessEvalAll() {
+  read -r -d '' expected << EOM
+---
+a: apple
+b: dog
+---
+not yaml
+c: at
+EOM
+  ./yq ea --front-matter="process" '.b = "dog"' test.yml -i
+  assertEquals "$expected" "$(cat test.yml)"
+}
+
+testFrontMatterExtractEval() {
+    cat >test.yml <<EOL
+a: apple
+b: cat
+---
+not yaml
+c: at
+EOL
+
+  read -r -d '' expected << EOM
+a: apple
+b: dog
+EOM
+  ./yq e --front-matter="extract" '.b = "dog"' test.yml -i
+  assertEquals "$expected" "$(cat test.yml)"
+}
+
+testFrontMatterExtractEvalAll() {
+  cat >test.yml <<EOL
+a: apple
+b: cat
+---
+not yaml
+c: at
+EOL
+
+  read -r -d '' expected << EOM
+a: apple
+b: dog
+EOM
+  ./yq ea --front-matter="extract" '.b = "dog"' test.yml -i
+  assertEquals "$expected" "$(cat test.yml)"
+}
+
+
+source ./scripts/shunit2

acceptance_tests/leading-seperator.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+setUp() {
+  cat >test.yml <<EOL
+---
+a: test
+EOL
+}
+
+testLeadingSeperatorPipeIntoEvalSeq() {
+  X=$(cat test.yml | ./yq e -)
+  expected=$(cat test.yml)
+  assertEquals "$expected" "$X"
+}
+
+
+testLeadingSeperatorEvalSeq() {
+  X=$(./yq e test.yml)
+  expected=$(cat test.yml)
+  assertEquals "$expected" "$X"
+}
+
+testLeadingSeperatorPipeIntoEvalAll() {
+  X=$(cat test.yml | ./yq ea -)
+  expected=$(cat test.yml)
+  assertEquals "$expected" "$X"
+}
+
+
+testLeadingSeperatorEvalAll() {
+  X=$(./yq ea test.yml)
+  expected=$(cat test.yml)
+  assertEquals "$expected" "$X"
+}
+
+testLeadingSeperatorMultiDocEval() {
+  read -r -d '' expected << EOM
+---
+a: test
+---
+version: 3
+application: MyApp
+EOM
+
+
+  X=$(./yq e '.' test.yml examples/order.yaml)
+  assertEquals "$expected" "$X"
+}
+
+testLeadingSeperatorMultiDocEvalAll() {
+  read -r -d '' expected << EOM
+---
+a: test
+---
+version: 3
+application: MyApp
+EOM
+
+
+  X=$(./yq ea '.' test.yml examples/order.yaml)
+  assertEquals "$expected" "$X"
+}
+
+source ./scripts/shunit2

scripts/acceptance.sh

@@ -1,270 +1,10 @@
-#!/bin/bash
+#! /bin/bash
-
 set -e
 
-# acceptance test
+for test in acceptance_tests/*.sh; do
+  echo "--------------------------------------------------------------"
+  echo "$test"
+  echo "--------------------------------------------------------------"
+  (exec $test);
+done
 
-
-
-echo "test eval-sequence"
-random=$((1 + $RANDOM % 10))
-./yq e -n ".a = $random" > test.yml
-X=$(./yq e '.a' test.yml)
-
-if [[ $X != $random ]]; then
-  echo "Failed create: expected $random but was $X"
-  exit 1
-fi
-
-echo "--success"
-
-echo "test update-in-place"
-
-update=$(($random + 1))
-./yq e -i ".a = $update" test.yml
-
-X=$(./yq e '.a' test.yml)
-if [[ $X != $update ]]; then
-  echo "Failed to update inplace test: expected $update but was $X"
-  exit 1
-fi
-
-echo "--success"
-
-echo "test eval-all"
-./yq ea -n ".a = $random" > test-eval-all.yml
-Y=$(./yq ea '.a' test-eval-all.yml)
-
-if [[ $Y != $random ]]; then
-  echo "Failed create with eval all: expected $random but was $X"
-  exit 1
-fi
-echo "--success"
-
-echo "test no exit status"
-./yq e '.z' test.yml
-echo "--success"
-
-echo "test exit status"
-set +e
-
-./yq e -e '.z' test.yml
-
-if [[ $? != 1 ]]; then
-  echo "Expected error code 1 but was $?"
-  exit 1
-fi
-
-echo "Test: leading seperator logic"
-expected=$(cat examples/leading-seperator.yaml)
-
-X=$(cat examples/leading-seperator.yaml | ./yq e '.' -)
-if [[ $X != $expected ]]; then
-  echo "Pipe into e"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-X=$(./yq e '.' examples/leading-seperator.yaml)
-expected=$(cat examples/leading-seperator.yaml)
-if [[ $X != $expected ]]; then
-  echo "read given file e"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-X=$(cat examples/leading-seperator.yaml | ./yq ea '.' -)
-if [[ $X != $expected ]]; then
-  echo "Pipe into e"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-X=$(./yq ea '.' examples/leading-seperator.yaml)
-expected=$(cat examples/leading-seperator.yaml)
-if [[ $X != $expected ]]; then
-  echo "read given file e"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-# multidoc
-read -r -d '' expected << EOM
----
-a: test
----
-version: 3
-application: MyApp
-EOM
-
-X=$(./yq e '.' examples/leading-seperator.yaml examples/order.yaml)
-
-if [[ $X != $expected ]]; then
-  echo "Multidoc with leading seperator"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-X=$(./yq ea '.' examples/leading-seperator.yaml examples/order.yaml)
-
-if [[ $X != $expected ]]; then
-  echo "Multidoc with leading seperator"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-echo "Test: handle empty files"
-./yq e '.' examples/empty.yaml
-if [[ $? != 0 ]]; then
-  echo "Expected no error when processing empty file but got one"
-  exit 1
-fi
-
-cat examples/empty.yaml | ./yq e '.' -
-if [[ $? != 0 ]]; then
-  echo "Expected no error when processing empty stdin but got one"
-  exit 1
-fi
-
-# run expression against empty file
-rm -f temp.yaml
-touch temp.yaml
-expected="apple: tree"
-
-./yq e '.apple = "tree"' temp.yaml -i
-X=$(cat temp.yaml)
-rm -f temp.yaml
-if [[ $X != $expected ]]; then
-  echo "Write empty doc"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-touch temp.yaml
-
-./yq ea '.apple = "tree"' temp.yaml -i
-X=$(cat temp.yaml)
-rm -f temp.yaml
-if [[ $X != $expected ]]; then
-  echo "Write all empty doc"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-echo "Test: handle empty files with just comments"
-rm -f temp.yaml
-echo "# comment" > temp.yaml
-read -r -d '' expected << EOM
-# comment
-apple: tree
-EOM
-
-./yq e '.apple = "tree"' temp.yaml -i
-X=$(cat temp.yaml)
-rm -f temp.yaml
-if [[ $X != $expected ]]; then
-  echo "Write empty doc"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-echo "# comment" > temp.yaml
-
-./yq ea '.apple = "tree"' temp.yaml -i
-X=$(cat temp.yaml)
-rm -f temp.yaml
-if [[ $X != $expected ]]; then
-  echo "Write all empty doc"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-echo "Test: eval front matter process"
-
-cat >temp.yaml <<EOL
----
-a: apple
-b: cat
----
-not yaml
-c: at
-EOL
-
-read -r -d '' expected << EOM
----
-a: apple
-b: dog
----
-not yaml
-c: at
-EOM
-
-./yq e --front-matter="process" '.b = "dog"' temp.yaml -i
-X=$(cat temp.yaml)
-rm -f temp.yaml
-if [[ $X != $expected ]]; then
-  echo "eval fail"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-echo "Test: eval front matter extract"
-
-cat >temp.yaml <<EOL
-a: apple
-b: cat
----
-not yaml
-c: at
-EOL
-
-read -r -d '' expected << EOM
-a: apple
-b: dog
-EOM
-
-./yq e --front-matter="extract" '.b = "dog"' temp.yaml -i
-X=$(cat temp.yaml)
-rm -f temp.yaml
-if [[ $X != $expected ]]; then
-  echo "eval fail"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-echo "Test: eval-all front matter process"
-
-cat >temp.yaml <<EOL
----
-a: apple
-b: cat
----
-not yaml
-c: at
-EOL
-
-read -r -d '' expected << EOM
----
-a: apple
-b: dog
----
-not yaml
-c: at
-EOM
-
-./yq ea --front-matter="process" '.b = "dog"' temp.yaml -i
-X=$(cat temp.yaml)
-rm -f temp.yaml
-if [[ $X != $expected ]]; then
-  echo "eval fail"
-  echo "Expected $expected but was $X"
-  exit 1
-fi
-
-echo "--success"
-
-set -e
-
-rm test.yml
-rm test-eval-all.yml
-echo "acceptance tests passed"