From a4077c9d8a62feb8bb04c0da79e7b964ec47fcb9 Mon Sep 17 00:00:00 2001 From: Mitchell Hashimoto Date: Sat, 2 Nov 2013 22:47:23 -0500 Subject: [PATCH] packer/rpc: use packer.MockBuilder for tests --- packer/builder_mock.go | 15 ++++ packer/rpc/builder_test.go | 138 ++++++++++++++------------------- packer/rpc/environment_test.go | 4 +- 3 files changed, 76 insertions(+), 81 deletions(-) diff --git a/packer/builder_mock.go b/packer/builder_mock.go index c580456e0..bfa0a0e47 100644 --- a/packer/builder_mock.go +++ b/packer/builder_mock.go @@ -1,11 +1,17 @@ package packer +import ( + "errors" +) + // MockBuilder is an implementation of Builder that can be used for tests. // You can set some fake return values and you can keep track of what // methods were called on the builder. It is fairly basic. type MockBuilder struct { ArtifactId string PrepareWarnings []string + RunErrResult bool + RunNilResult bool PrepareCalled bool PrepareConfig []interface{} @@ -27,6 +33,15 @@ func (tb *MockBuilder) Run(ui Ui, h Hook, c Cache) (Artifact, error) { tb.RunHook = h tb.RunUi = ui tb.RunCache = c + + if tb.RunErrResult { + return nil, errors.New("foo") + } + + if tb.RunNilResult { + return nil, nil + } + return &MockArtifact{ IdValue: tb.ArtifactId, }, nil diff --git a/packer/rpc/builder_test.go b/packer/rpc/builder_test.go index b56c8afaf..402cb6920 100644 --- a/packer/rpc/builder_test.go +++ b/packer/rpc/builder_test.go @@ -1,7 +1,6 @@ package rpc import ( - "errors" "github.com/mitchellh/packer/packer" "net/rpc" "reflect" @@ -10,47 +9,8 @@ import ( var testBuilderArtifact = &testArtifact{} -type testBuilder struct { - prepareCalled bool - prepareConfig []interface{} - runCalled bool - runCache packer.Cache - runHook packer.Hook - runUi packer.Ui - cancelCalled bool - - errRunResult bool - nilRunResult bool -} - -func (b *testBuilder) Prepare(config ...interface{}) ([]string, error) { - b.prepareCalled = true - b.prepareConfig = config - return nil, nil -} - -func (b *testBuilder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) { - b.runCache = cache - b.runCalled = true - b.runHook = hook - b.runUi = ui - - if b.errRunResult { - return nil, errors.New("foo") - } else if b.nilRunResult { - return nil, nil - } else { - return testBuilderArtifact, nil - } -} - -func (b *testBuilder) Cancel() { - b.cancelCalled = true -} - -func TestBuilderRPC(t *testing.T) { - // Create the interface to test - b := new(testBuilder) +func builderRPCClient(t *testing.T) (*packer.MockBuilder, packer.Builder) { + b := new(packer.MockBuilder) // Start the server server := rpc.NewServer() @@ -62,18 +22,26 @@ func TestBuilderRPC(t *testing.T) { if err != nil { t.Fatalf("err: %s", err) } + return b, Builder(client) +} + +func TestBuilderPrepare(t *testing.T) { + b, bClient := builderRPCClient(t) // Test Prepare config := 42 - bClient := Builder(client) bClient.Prepare(config) - if !b.prepareCalled { + if !b.PrepareCalled { t.Fatal("should be called") } - if !reflect.DeepEqual(b.prepareConfig, []interface{}{42}) { - t.Fatalf("bad: %#v", b.prepareConfig) + if !reflect.DeepEqual(b.PrepareConfig, []interface{}{42}) { + t.Fatalf("bad: %#v", b.PrepareConfig) } +} + +func TestBuilderRun(t *testing.T) { + b, bClient := builderRPCClient(t) // Test Run cache := new(testCache) @@ -84,59 +52,71 @@ func TestBuilderRPC(t *testing.T) { t.Fatalf("err: %s", err) } - if !b.runCalled { + if !b.RunCalled { t.Fatal("run should be called") } - if b.runCalled { - b.runCache.Lock("foo") - if !cache.lockCalled { - t.Fatal("should be called") - } - - b.runHook.Run("foo", nil, nil, nil) - if !hook.RunCalled { - t.Fatal("should be called") - } - - b.runUi.Say("format") - if !ui.sayCalled { - t.Fatal("say should be called") - } - - if ui.sayMessage != "format" { - t.Fatalf("bad: %s", ui.sayMessage) - } - - if artifact.Id() != testBuilderArtifact.Id() { - t.Fatalf("bad: %s", artifact.Id()) - } + b.RunCache.Lock("foo") + if !cache.lockCalled { + t.Fatal("should be called") } - // Test run with nil result - b.nilRunResult = true - artifact, err = bClient.Run(ui, hook, cache) + b.RunHook.Run("foo", nil, nil, nil) + if !hook.RunCalled { + t.Fatal("should be called") + } + + b.RunUi.Say("format") + if !ui.sayCalled { + t.Fatal("say should be called") + } + + if ui.sayMessage != "format" { + t.Fatalf("bad: %s", ui.sayMessage) + } + + if artifact.Id() != testBuilderArtifact.Id() { + t.Fatalf("bad: %s", artifact.Id()) + } +} + +func TestBuilderRun_nilResult(t *testing.T) { + b, bClient := builderRPCClient(t) + b.RunNilResult = true + + cache := new(testCache) + hook := &packer.MockHook{} + ui := &testUi{} + artifact, err := bClient.Run(ui, hook, cache) if artifact != nil { t.Fatalf("bad: %#v", artifact) } if err != nil { t.Fatalf("bad: %#v", err) } +} - // Test with an error - b.errRunResult = true - b.nilRunResult = false - artifact, err = bClient.Run(ui, hook, cache) +func TestBuilderRun_ErrResult(t *testing.T) { + b, bClient := builderRPCClient(t) + b.RunErrResult = true + + cache := new(testCache) + hook := &packer.MockHook{} + ui := &testUi{} + artifact, err := bClient.Run(ui, hook, cache) if artifact != nil { t.Fatalf("bad: %#v", artifact) } if err == nil { t.Fatal("should have error") } +} + +func TestBuilderCancel(t *testing.T) { + b, bClient := builderRPCClient(t) - // Test Cancel bClient.Cancel() - if !b.cancelCalled { + if !b.CancelCalled { t.Fatal("cancel should be called") } } diff --git a/packer/rpc/environment_test.go b/packer/rpc/environment_test.go index 39d020ce6..cb80929ec 100644 --- a/packer/rpc/environment_test.go +++ b/packer/rpc/environment_test.go @@ -7,7 +7,7 @@ import ( "testing" ) -var testEnvBuilder = &testBuilder{} +var testEnvBuilder = &packer.MockBuilder{} var testEnvCache = &testCache{} var testEnvUi = &testUi{} @@ -90,7 +90,7 @@ func TestEnvironmentRPC(t *testing.T) { } builder.Prepare(nil) - if !testEnvBuilder.prepareCalled { + if !testEnvBuilder.PrepareCalled { t.Fatal("should be called") }