Simplify test

bundle/resources/completion_test.go

@@ -6,21 +6,16 @@ import (
 	"github.com/databricks/cli/bundle"
 	"github.com/databricks/cli/bundle/config"
 	"github.com/databricks/cli/bundle/config/resources"
-	"github.com/databricks/databricks-sdk-go/service/jobs"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestCompletions(t *testing.T) {
+func TestCompletions_SkipDuplicates(t *testing.T) {
 	b := &bundle.Bundle{
 		Config: config.Root{
 			Resources: config.Resources{
 				Jobs: map[string]*resources.Job{
 					"foo": {},
-					"bar": {
-						JobSettings: &jobs.JobSettings{
-							Name: "Bar job",
-						},
-					},
+					"bar": {},
 				},
 				Pipelines: map[string]*resources.Pipeline{
 					"foo": {},

bundle/resources/lookup.go

@@ -48,21 +48,21 @@ func References(b *bundle.Bundle) (Map, Map) {
 // Lookup returns the resource with the specified key.
 // If the key maps to more than one resource, an error is returned.
 // If the key does not map to any resource, an error is returned.
-func Lookup(b *bundle.Bundle, key string) (config.ConfigResource, error) {
+func Lookup(b *bundle.Bundle, key string) (Reference, error) {
 	keyOnlyRefs, keyWithTypeRefs := References(b)
 	refs, ok := keyOnlyRefs[key]
 	if !ok {
 		refs, ok = keyWithTypeRefs[key]
 		if !ok {
-			return nil, fmt.Errorf("resource with key %q not found", key)
+			return Reference{}, fmt.Errorf("resource with key %q not found", key)
 		}
 	}
 
 	switch {
 	case len(refs) == 1:
-		return refs[0].Resource, nil
+		return refs[0], nil
 	case len(refs) > 1:
-		return nil, fmt.Errorf("multiple resources with key %q found", key)
+		return Reference{}, fmt.Errorf("multiple resources with key %q found", key)
 	default:
 		panic("unreachable")
 	}

bundle/resources/lookup_test.go

@@ -18,9 +18,8 @@ func TestLookup_EmptyBundle(t *testing.T) {
 		},
 	}
 
-	out, err := Lookup(b, "foo")
+	_, err := Lookup(b, "foo")
 	require.Error(t, err)
-	assert.Nil(t, out)
 	assert.ErrorContains(t, err, "resource with key \"foo\" not found")
 }
 
@@ -36,9 +35,8 @@ func TestLookup_NotFound(t *testing.T) {
 		},
 	}
 
-	out, err := Lookup(b, "qux")
+	_, err := Lookup(b, "qux")
 	require.Error(t, err)
-	assert.Nil(t, out)
 	assert.ErrorContains(t, err, `resource with key "qux" not found`)
 }
 
@@ -56,9 +54,8 @@ func TestLookup_MultipleFound(t *testing.T) {
 		},
 	}
 
-	out, err := Lookup(b, "foo")
+	_, err := Lookup(b, "foo")
 	require.Error(t, err)
-	assert.Nil(t, out)
 	assert.ErrorContains(t, err, `multiple resources with key "foo" found`)
 }
 
@@ -79,15 +76,13 @@ func TestLookup_Nominal(t *testing.T) {
 
 	// Lookup by key only.
 	out, err := Lookup(b, "foo")
-	require.NoError(t, err)
-	if assert.NotNil(t, out) {
-		assert.Equal(t, "Foo job", out.GetName())
+	if assert.NoError(t, err) {
+		assert.Equal(t, "Foo job", out.Resource.GetName())
 	}
 
 	// Lookup by type and key.
 	out, err = Lookup(b, "jobs.foo")
-	require.NoError(t, err)
-	if assert.NotNil(t, out) {
-		assert.Equal(t, "Foo job", out.GetName())
+	if assert.NoError(t, err) {
+		assert.Equal(t, "Foo job", out.Resource.GetName())
 	}
 }

cmd/bundle/open.go

@@ -38,7 +38,7 @@ func promptOpenArgument(ctx context.Context, b *bundle.Bundle) (string, error) {
 }
 
 func resolveOpenArgument(ctx context.Context, b *bundle.Bundle, args []string) (string, error) {
-	// If no arguments are specified, prompt the user to select something to run.
+	// If no arguments are specified, prompt the user to select the resource to open.
 	if len(args) == 0 && cmdio.IsPromptSupported(ctx) {
 		return promptOpenArgument(ctx, b)
 	}
@@ -105,13 +105,13 @@ func newOpenCommand() *cobra.Command {
 		}
 
 		// Locate resource to open.
-		resource, err := resources.Lookup(b, arg)
+		ref, err := resources.Lookup(b, arg)
 		if err != nil {
 			return err
 		}
 
 		// Confirm that the resource has a URL.
-		url := resource.GetURL()
+		url := ref.Resource.GetURL()
 		if url == "" {
 			return fmt.Errorf("resource does not have a URL associated with it (has it been deployed?)")
 		}