packer-cn/packer/rpc/builder_test.go

148 lines
3.0 KiB
Go
Raw Normal View History

2013-05-04 16:47:11 -04:00
package rpc
import (
2013-10-16 23:04:57 -04:00
"reflect"
2013-05-04 16:47:11 -04:00
"testing"
2018-01-22 20:21:10 -05:00
"github.com/hashicorp/packer/packer"
2013-05-04 16:47:11 -04:00
)
2013-12-09 17:46:33 -05:00
var testBuilderArtifact = &packer.MockArtifact{}
func TestBuilderPrepare(t *testing.T) {
2013-12-10 15:14:08 -05:00
b := new(packer.MockBuilder)
client, server := testClientServer(t)
defer client.Close()
defer server.Close()
server.RegisterBuilder(b)
bClient := client.Builder()
2013-05-04 16:47:11 -04:00
// Test Prepare
config := 42
warnings, err := bClient.Prepare(config)
if err != nil {
t.Fatalf("bad: %s", err)
}
if len(warnings) > 0 {
t.Fatalf("bad: %#v", warnings)
}
if !b.PrepareCalled {
2013-10-16 23:04:57 -04:00
t.Fatal("should be called")
}
2014-04-26 16:31:22 -04:00
expected := []interface{}{int64(42)}
if !reflect.DeepEqual(b.PrepareConfig, expected) {
t.Fatalf("bad: %#v != %#v", b.PrepareConfig, expected)
2013-10-16 23:04:57 -04:00
}
}
func TestBuilderPrepare_Warnings(t *testing.T) {
2013-12-10 15:14:08 -05:00
b := new(packer.MockBuilder)
client, server := testClientServer(t)
defer client.Close()
defer server.Close()
server.RegisterBuilder(b)
bClient := client.Builder()
expected := []string{"foo"}
b.PrepareWarnings = expected
// Test Prepare
warnings, err := bClient.Prepare(nil)
if err != nil {
t.Fatalf("bad: %s", err)
}
if !reflect.DeepEqual(warnings, expected) {
t.Fatalf("bad: %#v", warnings)
}
}
func TestBuilderRun(t *testing.T) {
2013-12-10 15:14:08 -05:00
b := new(packer.MockBuilder)
client, server := testClientServer(t)
defer client.Close()
defer server.Close()
server.RegisterBuilder(b)
bClient := client.Builder()
2013-05-04 16:50:02 -04:00
// Test Run
2013-06-10 01:00:47 -04:00
cache := new(testCache)
2013-08-30 20:03:55 -04:00
hook := &packer.MockHook{}
2013-05-04 16:50:02 -04:00
ui := &testUi{}
artifact, err := bClient.Run(ui, hook, cache)
2013-10-16 23:04:57 -04:00
if err != nil {
t.Fatalf("err: %s", err)
}
if !b.RunCalled {
2013-10-16 23:04:57 -04:00
t.Fatal("run should be called")
}
2013-05-04 16:50:02 -04:00
if artifact.Id() != testBuilderArtifact.Id() {
t.Fatalf("bad: %s", artifact.Id())
}
}
func TestBuilderRun_nilResult(t *testing.T) {
2013-12-10 15:14:08 -05:00
b := new(packer.MockBuilder)
b.RunNilResult = true
2013-12-10 15:14:08 -05:00
client, server := testClientServer(t)
defer client.Close()
defer server.Close()
server.RegisterBuilder(b)
bClient := client.Builder()
cache := new(testCache)
hook := &packer.MockHook{}
ui := &testUi{}
artifact, err := bClient.Run(ui, hook, cache)
2013-10-16 23:04:57 -04:00
if artifact != nil {
t.Fatalf("bad: %#v", artifact)
}
if err != nil {
t.Fatalf("bad: %#v", err)
}
}
func TestBuilderRun_ErrResult(t *testing.T) {
2013-12-10 15:14:08 -05:00
b := new(packer.MockBuilder)
client, server := testClientServer(t)
defer client.Close()
defer server.Close()
server.RegisterBuilder(b)
bClient := client.Builder()
b.RunErrResult = true
cache := new(testCache)
hook := &packer.MockHook{}
ui := &testUi{}
artifact, err := bClient.Run(ui, hook, cache)
2013-10-16 23:04:57 -04:00
if artifact != nil {
t.Fatalf("bad: %#v", artifact)
}
if err == nil {
t.Fatal("should have error")
}
}
func TestBuilderCancel(t *testing.T) {
2013-12-10 15:14:08 -05:00
b := new(packer.MockBuilder)
client, server := testClientServer(t)
defer client.Close()
defer server.Close()
server.RegisterBuilder(b)
bClient := client.Builder()
2013-06-03 18:30:09 -04:00
bClient.Cancel()
if !b.CancelCalled {
2013-10-16 23:04:57 -04:00
t.Fatal("cancel should be called")
}
2013-05-04 16:47:11 -04:00
}
2013-05-09 14:32:03 -04:00
func TestBuilder_ImplementsBuilder(t *testing.T) {
2013-12-10 16:26:07 -05:00
var _ packer.Builder = new(builder)
2013-05-04 16:47:11 -04:00
}