Merge pull request #69 from pulumi/eronwright/issue-65

Launch providers into workspace directory

providers/attach.go

@@ -9,7 +9,7 @@ import (
 
 // StartProviders starts each of the given providers and returns a map of provider names to the ports they are listening on.
 // The context should be cancelled when the test is complete to shut down the providers.
-func StartProviders(ctx context.Context, factories map[ProviderName]ProviderFactory) (map[ProviderName]Port, error) {
+func StartProviders(ctx context.Context, factories map[ProviderName]ProviderFactory, pt PulumiTest) (map[ProviderName]Port, error) {
 	if len(factories) == 0 {
 		return nil, nil
 	}
@@ -24,7 +24,7 @@ func StartProviders(ctx context.Context, factories map[ProviderName]ProviderFact
 	portMappings := map[ProviderName]Port{}
 	for _, providerName := range providerNames {
 		factory := factories[providerName]
-		port, err := factory(ctx)
+		port, err := factory(ctx, pt)
 		if err != nil {
 			return nil, fmt.Errorf("failed to start provider %s: %v", providerName, err)
 		}

providers/downloadPluginBinary.go

@@ -9,12 +9,12 @@ import (
 )
 
 func DownloadPluginBinaryFactory(name, version string) ProviderFactory {
-	factory := func(ctx context.Context) (Port, error) {
+	factory := func(ctx context.Context, pt PulumiTest) (Port, error) {
 		binaryPath, err := DownloadPluginBinary(name, version)
 		if err != nil {
 			return 0, err
 		}
-		return startLocalBinary(ctx, binaryPath, name)
+		return startLocalBinary(ctx, binaryPath, name, pt.Source())
 	}
 	return factory
 }

providers/factory.go

@@ -8,7 +8,13 @@ type ProviderName string
 // Port is the port that a provider is listening on.
 type Port int
 
+// PulumiTest provides context about the program under test.
+type PulumiTest interface {
+	// Source returns the current source directory.
+	Source() string
+}
+
 // ProviderFactory is a function that starts a provider and returns the port it is listening on.
 // The function should return an error if the provider fails to start.
 // When the test is complete, the context will be cancelled and the provider should exit.
-type ProviderFactory func(ctx context.Context) (Port, error)
+type ProviderFactory func(ctx context.Context, pt PulumiTest) (Port, error)

providers/localBinary.go

@@ -12,13 +12,13 @@ import (
 )
 
 func LocalBinary(name, path string) ProviderFactory {
-	factory := func(ctx context.Context) (Port, error) {
-		return startLocalBinary(ctx, path, name)
+	factory := func(ctx context.Context, pt PulumiTest) (Port, error) {
+		return startLocalBinary(ctx, path, name, pt.Source())
 	}
 	return factory
 }
 
-func startLocalBinary(ctx context.Context, path string, name string) (Port, error) {
+func startLocalBinary(ctx context.Context, path, name, cwd string) (Port, error) {
 	stat, err := os.Stat(path)
 	if err != nil {
 		return 0, err
@@ -28,6 +28,7 @@ func startLocalBinary(ctx context.Context, path string, name string) (Port, erro
 		path = filepath.Join(path, binaryName)
 	}
 	cmd := exec.CommandContext(ctx, path)
+	cmd.Dir = cwd
 	reader, err := cmd.StdoutPipe()
 	cmd.Stderr = os.Stderr
 	if err != nil {

providers/localBinary_test.go

@@ -8,11 +8,20 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+type mockPulumiTest struct {
+	source string
+}
+
+func (m *mockPulumiTest) Source() string {
+	return m.source
+}
+
 func TestLocalBinaryAttach(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
+	pt := &mockPulumiTest{source: t.TempDir()}
 	factory := providers.DownloadPluginBinaryFactory("azure-native", "2.25.0")
-	port, err := factory(ctx)
+	port, err := factory(ctx, pt)
 	assert.NoError(t, err)
 	assert.NotZero(t, port)
 }

providers/providerInterceptProxy.go

@@ -41,8 +41,8 @@ type ProviderInterceptors struct {
 
 // ProviderInterceptFactory creates a new provider factory that can be used to intercept calls to a downstream provider.
 func ProviderInterceptFactory(ctx context.Context, factory ProviderFactory, interceptors ProviderInterceptors) ProviderFactory {
-	return ResourceProviderFactory(func() (rpc.ResourceProviderServer, error) {
-		port, err := factory(ctx)
+	return ResourceProviderFactory(func(pt PulumiTest) (rpc.ResourceProviderServer, error) {
+		port, err := factory(ctx, pt)
 		if err != nil {
 			return nil, err
 		}

providers/providerMock.go

@@ -37,7 +37,7 @@ type ProviderMocks struct {
 
 // ProviderInterceptFactory creates a new provider factory that can be used to intercept calls to a downstream provider.
 func ProviderMockFactory(mocks ProviderMocks) ProviderFactory {
-	return ResourceProviderFactory(func() (rpc.ResourceProviderServer, error) {
+	return ResourceProviderFactory(func(_ PulumiTest) (rpc.ResourceProviderServer, error) {
 		return NewProviderMock(mocks)
 	})
 }

providers/resourceProvider.go

@@ -9,12 +9,12 @@ import (
 	"google.golang.org/grpc"
 )
 
-type ResourceProviderServerFactory func() (pulumirpc.ResourceProviderServer, error)
+type ResourceProviderServerFactory func(PulumiTest) (pulumirpc.ResourceProviderServer, error)
 
 // startProvider starts the provider in a goProc and returns the port it's listening on.
 // To shut down the provider, cancel the context.
 func ResourceProviderFactory(makeResourceProviderServer ResourceProviderServerFactory) ProviderFactory {
-	return func(ctx context.Context) (Port, error) {
+	return func(ctx context.Context, pt PulumiTest) (Port, error) {
 		cancelChannel := make(chan bool)
 		go func() {
 			<-ctx.Done()
@@ -24,7 +24,7 @@ func ResourceProviderFactory(makeResourceProviderServer ResourceProviderServerFa
 		handle, err := rpcutil.ServeWithOptions(rpcutil.ServeOptions{
 			Cancel: cancelChannel,
 			Init: func(srv *grpc.Server) error {
-				prov, proverr := makeResourceProviderServer()
+				prov, proverr := makeResourceProviderServer(pt)
 				if proverr != nil {
 					return fmt.Errorf("failed to create resource provider server: %v", proverr)
 				}

pulumitest/newStack.go

@@ -56,7 +56,7 @@ func (pt *PulumiTest) NewStack(stackName string, opts ...optnewstack.NewStackOpt
 	if len(providerFactories) > 0 {
 		pt.t.Log("starting providers")
 		providerContext, cancelProviders := context.WithCancel(pt.ctx)
-		providerPorts, err := providers.StartProviders(providerContext, providerFactories)
+		providerPorts, err := providers.StartProviders(providerContext, providerFactories, pt)
 		if err != nil {
 			cancelProviders()
 			pt.t.Fatalf("failed to start providers: %v", err)