packer-cn/template/parse_test.go

373 lines
5.3 KiB
Go
Raw Normal View History

2015-05-19 17:25:56 -04:00
package template
import (
"path/filepath"
2015-05-19 17:25:56 -04:00
"reflect"
2015-05-26 12:41:42 -04:00
"strings"
2015-05-19 17:25:56 -04:00
"testing"
2015-05-21 15:34:44 -04:00
"time"
2015-05-19 17:25:56 -04:00
)
func TestParse(t *testing.T) {
cases := []struct {
File string
Result *Template
Err bool
}{
2015-05-21 15:34:44 -04:00
/*
* Builders
*/
2015-05-19 17:25:56 -04:00
{
"parse-basic.json",
&Template{
Builders: map[string]*Builder{
2016-11-01 17:08:04 -04:00
"something": {
2015-05-19 17:25:56 -04:00
Name: "something",
Type: "something",
},
},
},
false,
},
{
"parse-builder-no-type.json",
nil,
true,
},
{
"parse-builder-repeat.json",
nil,
true,
},
2015-05-21 15:34:44 -04:00
/*
* Provisioners
*/
{
"parse-provisioner-basic.json",
&Template{
Provisioners: []*Provisioner{
2016-11-01 17:08:04 -04:00
{
2015-05-21 15:34:44 -04:00
Type: "something",
},
},
},
false,
},
{
"parse-provisioner-pause-before.json",
&Template{
Provisioners: []*Provisioner{
2016-11-01 17:08:04 -04:00
{
2015-05-21 15:34:44 -04:00
Type: "something",
PauseBefore: 1 * time.Second,
},
},
},
false,
},
{
"parse-provisioner-only.json",
&Template{
Provisioners: []*Provisioner{
2016-11-01 17:08:04 -04:00
{
2015-05-21 15:34:44 -04:00
Type: "something",
OnlyExcept: OnlyExcept{
Only: []string{"foo"},
},
},
},
},
false,
},
{
"parse-provisioner-except.json",
&Template{
Provisioners: []*Provisioner{
2016-11-01 17:08:04 -04:00
{
2015-05-21 15:34:44 -04:00
Type: "something",
OnlyExcept: OnlyExcept{
Except: []string{"foo"},
},
},
},
},
false,
},
{
"parse-provisioner-override.json",
&Template{
Provisioners: []*Provisioner{
2016-11-01 17:08:04 -04:00
{
2015-05-21 15:34:44 -04:00
Type: "something",
Override: map[string]interface{}{
"foo": map[string]interface{}{},
},
},
},
},
false,
},
{
"parse-provisioner-no-type.json",
nil,
true,
},
2015-05-21 15:40:33 -04:00
{
"parse-variable-default.json",
&Template{
Variables: map[string]*Variable{
2016-11-01 17:08:04 -04:00
"foo": {
2015-05-21 15:40:33 -04:00
Default: "foo",
},
},
},
false,
},
{
"parse-variable-required.json",
&Template{
Variables: map[string]*Variable{
2016-11-01 17:08:04 -04:00
"foo": {
2015-05-21 15:40:33 -04:00
Required: true,
},
},
},
false,
},
2015-05-21 16:32:22 -04:00
{
"parse-pp-basic.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
2015-05-21 16:32:22 -04:00
Type: "foo",
Config: map[string]interface{}{
"foo": "bar",
},
},
},
},
},
false,
},
{
"parse-pp-keep.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
2015-05-21 16:32:22 -04:00
Type: "foo",
KeepInputArtifact: true,
},
},
},
},
false,
},
{
"parse-pp-only.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
Type: "foo",
OnlyExcept: OnlyExcept{
Only: []string{"bar"},
},
},
},
},
},
false,
},
{
"parse-pp-except.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
Type: "foo",
OnlyExcept: OnlyExcept{
Except: []string{"bar"},
},
},
},
},
},
false,
},
2015-05-21 16:32:22 -04:00
{
"parse-pp-string.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
2015-05-21 16:32:22 -04:00
Type: "foo",
},
},
},
},
false,
},
{
"parse-pp-map.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
2015-05-21 16:32:22 -04:00
Type: "foo",
},
},
},
},
false,
},
{
"parse-pp-slice.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
2015-05-21 16:32:22 -04:00
Type: "foo",
},
},
2016-11-01 17:08:04 -04:00
{
{
2015-05-21 16:32:22 -04:00
Type: "bar",
},
},
},
},
false,
},
{
"parse-pp-multi.json",
&Template{
PostProcessors: [][]*PostProcessor{
2016-11-01 17:08:04 -04:00
{
{
2015-05-21 16:32:22 -04:00
Type: "foo",
},
2016-11-01 17:08:04 -04:00
{
2015-05-21 16:32:22 -04:00
Type: "bar",
},
},
},
},
false,
},
{
"parse-pp-no-type.json",
nil,
true,
},
{
"parse-description.json",
&Template{
Description: "foo",
},
false,
},
{
"parse-min-version.json",
&Template{
MinVersion: "1.2",
},
false,
},
2015-05-21 16:44:29 -04:00
{
"parse-push.json",
&Template{
2015-05-28 18:19:22 -04:00
Push: Push{
2015-05-21 16:44:29 -04:00
Name: "foo",
},
},
false,
},
{
"parse-comment.json",
&Template{
Builders: map[string]*Builder{
2016-11-01 17:08:04 -04:00
"something": {
Name: "something",
Type: "something",
},
},
},
false,
},
2015-05-19 17:25:56 -04:00
}
for _, tc := range cases {
path, _ := filepath.Abs(fixtureDir(tc.File))
2015-05-23 18:44:54 -04:00
tpl, err := ParseFile(fixtureDir(tc.File))
2015-05-19 17:25:56 -04:00
if (err != nil) != tc.Err {
t.Fatalf("err: %s", err)
}
2015-05-29 17:05:13 -04:00
if tc.Result != nil {
tc.Result.Path = path
}
2015-05-26 12:38:02 -04:00
if tpl != nil {
tpl.RawContents = nil
}
2015-05-19 17:25:56 -04:00
if !reflect.DeepEqual(tpl, tc.Result) {
2015-05-21 15:34:44 -04:00
t.Fatalf("bad: %s\n\n%#v\n\n%#v", tc.File, tpl, tc.Result)
2015-05-19 17:25:56 -04:00
}
}
}
2015-05-26 12:41:42 -04:00
func TestParse_contents(t *testing.T) {
tpl, err := ParseFile(fixtureDir("parse-contents.json"))
if err != nil {
t.Fatalf("err: %s", err)
}
actual := strings.TrimSpace(string(tpl.RawContents))
expected := `{"builders":[{"type":"test"}]}`
if actual != expected {
t.Fatalf("bad: %s\n\n%s", actual, expected)
}
}
func TestParse_bad(t *testing.T) {
cases := []struct {
File string
Expected string
}{
{"error-beginning.json", "line 1, column 1 (offset 1)"},
{"error-middle.json", "line 5, column 6 (offset 50)"},
{"error-end.json", "line 1, column 30 (offset 30)"},
}
for _, tc := range cases {
_, err := ParseFile(fixtureDir(tc.File))
if err == nil {
t.Fatalf("expected error")
}
if !strings.Contains(err.Error(), tc.Expected) {
t.Fatalf("file: %s\nExpected: %s\n%s\n", tc.File, tc.Expected, err.Error())
}
}
}