gcloud

package module
v0.35.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 10, 2025 License: MIT Imports: 8 Imported by: 3

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GCloudContainer 

type GCloudContainer struct {
	testcontainers.Container
	Settings options
	URI      string
}

func RunBigQuery added in v0.32.0 

func RunBigQuery(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

RunBigQuery creates an instance of the GCloud container type for BigQuery. The URI will always use http:// as the protocol.

func RunBigQueryContainer deprecated 

func RunBigQueryContainer(ctx context.Context, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

Deprecated: use RunBigQuery instead RunBigQueryContainer creates an instance of the GCloud container type for BigQuery.

Example 
// runBigQueryContainer {
ctx := context.Background()

bigQueryContainer, err := gcloud.RunBigQuery(
	ctx,
	"ghcr.io/goccy/bigquery-emulator:0.6.1",
	gcloud.WithProjectID("bigquery-project"),
)
defer func() {
	if err := testcontainers.TerminateContainer(bigQueryContainer); err != nil {
		log.Printf("failed to terminate container: %s", err)
	}
}()
if err != nil {
	log.Printf("failed to run container: %v", err)
	return
}
// }

// bigQueryClient {
projectID := bigQueryContainer.Settings.ProjectID

opts := []option.ClientOption{
	option.WithEndpoint(bigQueryContainer.URI),
	option.WithGRPCDialOption(grpc.WithTransportCredentials(insecure.NewCredentials())),
	option.WithoutAuthentication(),
	internaloption.SkipDialSettingsValidation(),
}

client, err := bigquery.NewClient(ctx, projectID, opts...)
if err != nil {
	log.Printf("failed to create bigquery client: %v", err)
	return
}
defer client.Close()
// }

createFnQuery := client.Query("CREATE FUNCTION testr(arr ARRAY<STRUCT<name STRING, val INT64>>) AS ((SELECT SUM(IF(elem.name = \"foo\",elem.val,null)) FROM UNNEST(arr) AS elem))")
_, err = createFnQuery.Read(ctx)
if err != nil {
	log.Printf("failed to create function: %v", err)
	return
}

selectQuery := client.Query("SELECT testr([STRUCT<name STRING, val INT64>(\"foo\", 10), STRUCT<name STRING, val INT64>(\"bar\", 40), STRUCT<name STRING, val INT64>(\"foo\", 20)])")
it, err := selectQuery.Read(ctx)
if err != nil {
	log.Printf("failed to read query: %v", err)
	return
}

var val []bigquery.Value
for {
	err := it.Next(&val)
	if errors.Is(err, iterator.Done) {
		break
	}
	if err != nil {
		log.Printf("failed to iterate: %v", err)
		return
	}
}

fmt.Println(val)

Output:

[30]

func RunBigTable added in v0.32.0 

func RunBigTable(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

RunBigTable creates an instance of the GCloud container type for BigTable.

func RunBigTableContainer deprecated 

func RunBigTableContainer(ctx context.Context, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

Deprecated: use RunBigTable instead RunBigTableContainer creates an instance of the GCloud container type for BigTable.

Example 
// runBigTableContainer {
ctx := context.Background()

bigTableContainer, err := gcloud.RunBigTable(
	ctx,
	"gcr.io/google.com/cloudsdktool/cloud-sdk:367.0.0-emulators",
	gcloud.WithProjectID("bigtable-project"),
)
defer func() {
	if err := testcontainers.TerminateContainer(bigTableContainer); err != nil {
		log.Printf("failed to terminate container: %s", err)
	}
}()
if err != nil {
	log.Printf("failed to run container: %v", err)
	return
}
// }

// bigTableAdminClient {
projectId := bigTableContainer.Settings.ProjectID

const (
	instanceId = "test-instance"
	tableName  = "test-table"
)

options := []option.ClientOption{
	option.WithEndpoint(bigTableContainer.URI),
	option.WithoutAuthentication(),
	option.WithGRPCDialOption(grpc.WithTransportCredentials(insecure.NewCredentials())),
}
adminClient, err := bigtable.NewAdminClient(ctx, projectId, instanceId, options...)
if err != nil {
	log.Printf("failed to create admin client: %v", err)
	return
}
defer adminClient.Close()
// }

err = adminClient.CreateTable(ctx, tableName)
if err != nil {
	log.Printf("failed to create table: %v", err)
	return
}
err = adminClient.CreateColumnFamily(ctx, tableName, "name")
if err != nil {
	log.Printf("failed to create column family: %v", err)
	return
}

// bigTableClient {
client, err := bigtable.NewClient(ctx, projectId, instanceId, options...)
if err != nil {
	log.Printf("failed to create client: %v", err)
	return
}
defer client.Close()
// }

tbl := client.Open(tableName)

mut := bigtable.NewMutation()
mut.Set("name", "firstName", bigtable.Now(), []byte("Gopher"))
err = tbl.Apply(ctx, "1", mut)
if err != nil {
	log.Printf("failed to apply mutation: %v", err)
	return
}

row, err := tbl.ReadRow(ctx, "1", bigtable.RowFilter(bigtable.FamilyFilter("name")))
if err != nil {
	log.Printf("failed to read row: %v", err)
	return
}

fmt.Println(string(row["name"][0].Value))

Output:

Gopher

func RunDatastore added in v0.32.0 

func RunDatastore(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

RunDatastore creates an instance of the GCloud container type for Datastore.

func RunDatastoreContainer deprecated 

func RunDatastoreContainer(ctx context.Context, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

Deprecated: use RunDatastore instead RunDatastoreContainer creates an instance of the GCloud container type for Datastore.

Example 
// runDatastoreContainer {
ctx := context.Background()

datastoreContainer, err := gcloud.RunDatastore(
	ctx,
	"gcr.io/google.com/cloudsdktool/cloud-sdk:367.0.0-emulators",
	gcloud.WithProjectID("datastore-project"),
)
defer func() {
	if err := testcontainers.TerminateContainer(datastoreContainer); err != nil {
		log.Printf("failed to terminate container: %s", err)
	}
}()
if err != nil {
	log.Printf("failed to run container: %v", err)
	return
}
// }

// datastoreClient {
projectID := datastoreContainer.Settings.ProjectID

options := []option.ClientOption{
	option.WithEndpoint(datastoreContainer.URI),
	option.WithoutAuthentication(),
	option.WithGRPCDialOption(grpc.WithTransportCredentials(insecure.NewCredentials())),
}

dsClient, err := datastore.NewClient(ctx, projectID, options...)
if err != nil {
	log.Printf("failed to create client: %v", err)
	return
}
defer dsClient.Close()
// }

type Task struct {
	Description string
}

k := datastore.NameKey("Task", "sample", nil)
data := Task{
	Description: "my description",
}
_, err = dsClient.Put(ctx, k, &data)
if err != nil {
	log.Printf("failed to put data: %v", err)
	return
}

saved := Task{}
err = dsClient.Get(ctx, k, &saved)
if err != nil {
	log.Printf("failed to get data: %v", err)
	return
}

fmt.Println(saved.Description)

Output:

my description

func RunFirestore added in v0.32.0 

func RunFirestore(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

RunFirestore creates an instance of the GCloud container type for Firestore.

func RunFirestoreContainer deprecated 

func RunFirestoreContainer(ctx context.Context, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

Deprecated: use RunFirestore instead RunFirestoreContainer creates an instance of the GCloud container type for Firestore.

Example 
package main

import (
	"context"
	"fmt"
	"log"

	"cloud.google.com/go/firestore"
	"google.golang.org/api/option"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"

	"github.com/testcontainers/testcontainers-go"
	"github.com/testcontainers/testcontainers-go/modules/gcloud"
)

type emulatorCreds struct{}

func (ec emulatorCreds) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
	return map[string]string{"authorization": "Bearer owner"}, nil
}

func (ec emulatorCreds) RequireTransportSecurity() bool {
	return false
}

func main() {
	// runFirestoreContainer {
	ctx := context.Background()

	firestoreContainer, err := gcloud.RunFirestore(
		ctx,
		"gcr.io/google.com/cloudsdktool/cloud-sdk:367.0.0-emulators",
		gcloud.WithProjectID("firestore-project"),
	)
	defer func() {
		if err := testcontainers.TerminateContainer(firestoreContainer); err != nil {
			log.Printf("failed to terminate container: %s", err)
		}
	}()
	if err != nil {
		log.Printf("failed to run container: %v", err)
		return
	}
	// }

	// firestoreClient {
	projectID := firestoreContainer.Settings.ProjectID

	conn, err := grpc.NewClient(firestoreContainer.URI, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithPerRPCCredentials(emulatorCreds{}))
	if err != nil {
		log.Printf("failed to dial: %v", err)
		return
	}

	options := []option.ClientOption{option.WithGRPCConn(conn)}
	client, err := firestore.NewClient(ctx, projectID, options...)
	if err != nil {
		log.Printf("failed to create client: %v", err)
		return
	}
	defer client.Close()
	// }

	users := client.Collection("users")
	docRef := users.Doc("alovelace")

	type Person struct {
		Firstname string `json:"firstname"`
		Lastname  string `json:"lastname"`
	}

	data := Person{
		Firstname: "Ada",
		Lastname:  "Lovelace",
	}
	_, err = docRef.Create(ctx, data)
	if err != nil {
		log.Printf("failed to create document: %v", err)
		return
	}

	docsnap, err := docRef.Get(ctx)
	if err != nil {
		log.Printf("failed to get document: %v", err)
		return
	}

	var saved Person
	if err := docsnap.DataTo(&saved); err != nil {
		log.Printf("failed to convert data: %v", err)
		return
	}

	fmt.Println(saved.Firstname, saved.Lastname)

}

Output:

Ada Lovelace

func RunPubsub added in v0.32.0 

func RunPubsub(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

RunPubsub creates an instance of the GCloud container type for Pubsub.

func RunPubsubContainer deprecated 

func RunPubsubContainer(ctx context.Context, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

Deprecated: use RunPubsub instead RunPubsubContainer creates an instance of the GCloud container type for Pubsub.

Example 
// runPubsubContainer {
ctx := context.Background()

pubsubContainer, err := gcloud.RunPubsub(
	ctx,
	"gcr.io/google.com/cloudsdktool/cloud-sdk:367.0.0-emulators",
	gcloud.WithProjectID("pubsub-project"),
)
defer func() {
	if err := testcontainers.TerminateContainer(pubsubContainer); err != nil {
		log.Printf("failed to terminate container: %s", err)
	}
}()
if err != nil {
	log.Printf("failed to run container: %v", err)
	return
}
// }

// pubsubClient {
projectID := pubsubContainer.Settings.ProjectID

conn, err := grpc.NewClient(pubsubContainer.URI, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
	log.Printf("failed to dial: %v", err)
	return
}

options := []option.ClientOption{option.WithGRPCConn(conn)}
client, err := pubsub.NewClient(ctx, projectID, options...)
if err != nil {
	log.Printf("failed to create client: %v", err)
	return
}
defer client.Close()
// }

topic, err := client.CreateTopic(ctx, "greetings")
if err != nil {
	log.Printf("failed to create topic: %v", err)
	return
}
subscription, err := client.CreateSubscription(ctx, "subscription",
	pubsub.SubscriptionConfig{Topic: topic})
if err != nil {
	log.Printf("failed to create subscription: %v", err)
	return
}
result := topic.Publish(ctx, &pubsub.Message{Data: []byte("Hello World")})
_, err = result.Get(ctx)
if err != nil {
	log.Printf("failed to publish message: %v", err)
	return
}

var data []byte
cctx, cancel := context.WithCancel(ctx)
err = subscription.Receive(cctx, func(ctx context.Context, m *pubsub.Message) {
	data = m.Data
	m.Ack()
	defer cancel()
})
if err != nil {
	log.Printf("failed to receive message: %v", err)
	return
}

fmt.Println(string(data))

Output:

Hello World

func RunSpanner added in v0.32.0 

func RunSpanner(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

RunSpanner creates an instance of the GCloud container type for Spanner.

func RunSpannerContainer deprecated 

func RunSpannerContainer(ctx context.Context, opts ...testcontainers.ContainerCustomizer) (*GCloudContainer, error)

Deprecated: use RunSpanner instead RunSpannerContainer creates an instance of the GCloud container type for Spanner.

Example 
// runSpannerContainer {
ctx := context.Background()

spannerContainer, err := gcloud.RunSpanner(
	ctx,
	"gcr.io/cloud-spanner-emulator/emulator:1.4.0",
	gcloud.WithProjectID("spanner-project"),
)
defer func() {
	if err := testcontainers.TerminateContainer(spannerContainer); err != nil {
		log.Printf("failed to terminate container: %s", err)
	}
}()
if err != nil {
	log.Printf("failed to run container: %v", err)
	return
}
// }

// spannerAdminClient {
projectId := spannerContainer.Settings.ProjectID

const (
	instanceId   = "test-instance"
	databaseName = "test-db"
)

options := []option.ClientOption{
	option.WithEndpoint(spannerContainer.URI),
	option.WithGRPCDialOption(grpc.WithTransportCredentials(insecure.NewCredentials())),
	option.WithoutAuthentication(),
	internaloption.SkipDialSettingsValidation(),
}

instanceAdmin, err := instance.NewInstanceAdminClient(ctx, options...)
if err != nil {
	log.Printf("failed to create instance admin client: %v", err)
	return
}
defer instanceAdmin.Close()
// }

instanceOp, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
	Parent:     "projects/" + projectId,
	InstanceId: instanceId,
	Instance: &instancepb.Instance{
		DisplayName: instanceId,
	},
})
if err != nil {
	log.Printf("failed to create instance: %v", err)
	return
}

_, err = instanceOp.Wait(ctx)
if err != nil {
	log.Printf("failed to wait for instance creation: %v", err)
	return
}

// spannerDBAdminClient {
c, err := database.NewDatabaseAdminClient(ctx, options...)
if err != nil {
	log.Printf("failed to create admin client: %v", err)
	return
}
defer c.Close()
// }

databaseOp, err := c.CreateDatabase(ctx, &databasepb.CreateDatabaseRequest{
	Parent:          fmt.Sprintf("projects/%s/instances/%s", projectId, instanceId),
	CreateStatement: fmt.Sprintf("CREATE DATABASE `%s`", databaseName),
	ExtraStatements: []string{
		"CREATE TABLE Languages (Language STRING(MAX), Mascot STRING(MAX)) PRIMARY KEY (Language)",
	},
})
if err != nil {
	log.Printf("failed to create database: %v", err)
	return
}
_, err = databaseOp.Wait(ctx)
if err != nil {
	log.Printf("failed to wait for database creation: %v", err)
	return
}

db := fmt.Sprintf("projects/%s/instances/%s/databases/%s", projectId, instanceId, databaseName)
client, err := spanner.NewClient(ctx, db, options...)
if err != nil {
	log.Printf("failed to create client: %v", err)
	return
}
defer client.Close()

_, err = client.Apply(ctx, []*spanner.Mutation{
	spanner.Insert("Languages",
		[]string{"language", "mascot"},
		[]interface{}{"Go", "Gopher"}),
})
if err != nil {
	log.Printf("failed to apply mutation: %v", err)
	return
}
row, err := client.Single().ReadRow(ctx, "Languages",
	spanner.Key{"Go"}, []string{"mascot"})
if err != nil {
	log.Printf("failed to read row: %v", err)
	return
}

var mascot string
err = row.ColumnByName("Mascot", &mascot)
if err != nil {
	log.Printf("failed to read column: %v", err)
	return
}

fmt.Println(mascot)

Output:

Gopher

type Option 

type Option func(*options) error

Option is an option for the GCloud container.

func WithDataYAML added in v0.35.0 

func WithDataYAML(r io.Reader) Option

WithDataYAML seeds the BigQuery project for the GCloud container with an io.Reader representing the data yaml file, which is used to copy the file to the container, and then processed to seed the BigQuery project.

Other GCloud containers will ignore this option. If this option is passed multiple times, an error is returned.

func WithProjectID 

func WithProjectID(projectID string) Option

WithProjectID sets the project ID for the GCloud container.

func (Option) Customize 

func (o Option) Customize(*testcontainers.GenericContainerRequest) error

Customize is a NOOP. It's defined to satisfy the testcontainers.ContainerCustomizer interface.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.