iSharkFly-Docs
/
packer-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
packer-cn/template/parse_test.go

543 lines
9.1 KiB
Go
Raw Blame History

// +build !windows
package template
import (
"bytes"
"encoding/json"
"path/filepath"
"reflect"
"strings"
"testing"
"time"
)
func TestParse(t *testing.T) {
cases := []struct {
File string
Result *Template
Err bool
}{
/*
* Builders
*/
{
"parse-basic.json",
&Template{
Builders: map[string]*Builder{
"something": {
Name: "something",
Type: "something",
},
},
},
false,
},
{
"parse-basic-config.json",
&Template{
Builders: map[string]*Builder{
"something": {
Name: "something",
Type: "something",
Config: map[string]interface{}{
"foo": "bar",
},
},
},
},
false,
},
{
"parse-builder-no-type.json",
nil,
true,
},
{
"parse-builder-repeat.json",
nil,
true,
},
/*
* Provisioners
*/
{
"parse-provisioner-basic.json",
&Template{
Provisioners: []*Provisioner{
{
Type: "something",
},
},
},
false,
},
{
"parse-provisioner-config.json",
&Template{
Provisioners: []*Provisioner{
{
Type: "something",
Config: map[string]interface{}{
"inline": "echo 'foo'",
},
},
},
},
false,
},
{
"parse-provisioner-pause-before.json",
&Template{
Provisioners: []*Provisioner{
{
Type: "something",
PauseBefore: 1 * time.Second,
},
},
},
false,
},
{
"parse-provisioner-only.json",
&Template{
Provisioners: []*Provisioner{
{
Type: "something",
OnlyExcept: OnlyExcept{
Only: []string{"foo"},
},
},
},
},
false,
},
{
"parse-provisioner-except.json",
&Template{
Provisioners: []*Provisioner{
{
Type: "something",
OnlyExcept: OnlyExcept{
Except: []string{"foo"},
},
},
},
},
false,
},
{
"parse-provisioner-override.json",
&Template{
Provisioners: []*Provisioner{
{
Type: "something",
Override: map[string]interface{}{
"foo": map[string]interface{}{},
},
},
},
},
false,
},
{
"parse-provisioner-no-type.json",
nil,
true,
},
{
"parse-variable-default.json",
&Template{
Variables: map[string]*Variable{
"foo": {
Default: "foo",
Key: "foo",
},
},
},
false,
},
{
"parse-variable-required.json",
&Template{
Variables: map[string]*Variable{
"foo": {
Required: true,
Key: "foo",
},
},
},
false,
},
{
"parse-pp-basic.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
Config: map[string]interface{}{
"foo": "bar",
},
},
},
},
},
false,
},
{
"parse-pp-keep.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
KeepInputArtifact: true,
},
},
},
},
false,
},
{
"parse-pp-only.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
OnlyExcept: OnlyExcept{
Only: []string{"bar"},
},
},
},
},
},
false,
},
{
"parse-pp-except.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
OnlyExcept: OnlyExcept{
Except: []string{"bar"},
},
},
},
},
},
false,
},
{
"parse-pp-string.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
},
},
},
},
false,
},
{
"parse-pp-map.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
},
},
},
},
false,
},
{
"parse-pp-slice.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
},
},
{
{
Type: "bar",
},
},
},
},
false,
},
{
"parse-pp-multi.json",
&Template{
PostProcessors: [][]*PostProcessor{
{
{
Type: "foo",
},
{
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,
},
{
"parse-push.json",
&Template{
Push: Push{
Name: "foo",
},
},
false,
},
{
"parse-comment.json",
&Template{
Builders: map[string]*Builder{
"something": {
Name: "something",
Type: "something",
},
},
Comments: map[string]string{
"_info": "foo",
},
},
false,
},
{
"parse-monolithic.json",
&Template{
Comments: map[string]string{
"_comment": "comment",
},
Description: "Description Test",
MinVersion: "1.3.0",
SensitiveVariables: []*Variable{
{
Required: false,
Key: "one",
Default: "1",
},
},
Variables: map[string]*Variable{
"one": {
Required: false,
Key: "one",
Default: "1",
},
"two": {
Required: false,
Key: "two",
Default: "2",
},
"three": {
Required: true,
Key: "three",
Default: "",
},
},
Builders: map[string]*Builder{
"amazon-ebs": {
Name: "amazon-ebs",
Type: "amazon-ebs",
Config: map[string]interface{}{
"ami_name": "AMI Name",
"instance_type": "t2.micro",
"ssh_username": "ec2-user",
"source_ami": "ami-aaaaaaaaaaaaaa",
},
},
"docker": {
Name: "docker",
Type: "docker",
Config: map[string]interface{}{
"image": "ubuntu",
"export_path": "image.tar",
},
},
},
Provisioners: []*Provisioner{
{
Type: "shell",
Config: map[string]interface{}{
"script": "script.sh",
},
},
{
Type: "shell",
Config: map[string]interface{}{
"script": "script.sh",
},
Override: map[string]interface{}{
"docker": map[string]interface{}{
"execute_command": "echo 'override'",
},
},
},
},
PostProcessors: [][]*PostProcessor{
{
{
Type: "compress",
},
{
Type: "vagrant",
OnlyExcept: OnlyExcept{
Only: []string{"docker"},
},
},
},
{
{
Type: "shell-local",
Config: map[string]interface{}{
"inline": []interface{}{"echo foo"},
},
OnlyExcept: OnlyExcept{
Except: []string{"amazon-ebs"},
},
},
},
},
Push: Push{
Name: "push test",
},
},
false,
},
}
for _, tc := range cases {
path, _ := filepath.Abs(fixtureDir(tc.File))
tpl, err := ParseFile(fixtureDir(tc.File))
if (err != nil) != tc.Err {
t.Fatalf("%s\n\nerr: %s", tc.File, err)
}
if tc.Result != nil {
tc.Result.Path = path
}
if tpl != nil {
tpl.RawContents = nil
}
if !reflect.DeepEqual(tpl, tc.Result) {
t.Fatalf("bad: %s\n\n%#v\n\n%#v", tc.File, tpl, tc.Result)
}
// Only test template writing if the template is valid
if tc.Err == false {
// Get rawTemplate
raw, err := tpl.Raw()
if err != nil {
t.Fatalf("Failed to convert back to raw template: %s\n\n%v\n\n%s", tc.File, tpl, err)
}
out, _ := json.MarshalIndent(raw, "", " ")
if err != nil {
t.Fatalf("Failed to marshal raw template: %s\n\n%v\n\n%s", tc.File, raw, err)
}
// Write JSON to a buffer (emulates filesystem write without dirtying the workspace)
fileBuf := bytes.NewBuffer(out)
// Parse the JSON template we wrote to our buffer
tplRewritten, err := Parse(fileBuf)
if err != nil {
t.Fatalf("Failed to re-read marshalled template: %s\n\n%v\n\n%s\n\n%s", tc.File, tpl, out, err)
}
// Override the metadata we don't care about (file path, raw file contents)
tplRewritten.Path = path
tplRewritten.RawContents = nil
// Test that our output raw template is functionally equal
if !reflect.DeepEqual(tpl, tplRewritten) {
t.Fatalf("Data lost when writing template to file: %s\n\n%v\n\n%v\n\n%s", tc.File, tpl, tplRewritten, out)
}
}
}
}
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)"},
{"malformed.json", "line 16, column 3 (offset 433)"},
}
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())
}
}
}
Reference in New Issue View Git Blame Copy Permalink