func TestList(t *testing.T) {
t.Skip("Flaky. Eventual consistency. Re-enable once the datastore emulator works with gRPC.")
testutil.SystemTest(t)
ctx := context.Background()
desc := makeDesc()
k, err := AddTask(ctx, client, desc)
if err != nil {
t.Fatal(err)
}
foundTask := listAndGetTask(t, desc)
if got, want := foundTask.id, k.ID; got != want {
t.Errorf("k.ID: got %d, want %d", got, want)
}
if err := MarkDone(ctx, client, foundTask.id); err != nil {
t.Fatal(err)
}
foundTask = listAndGetTask(t, desc)
if !foundTask.Done {
t.Error("foundTask.Done: got false, want true")
}
if err := DeleteTask(ctx, client, foundTask.id); err != nil {
t.Fatal(err)
}
}
func TestCustomMetric(t *testing.T) {
hc := testutil.SystemTest(t)
ctx, _ := context.WithTimeout(context.Background(), time.Second*30)
s, err := createService(ctx)
if err != nil {
t.Fatal(err)
}
if err := createCustomMetric(s, hc.ProjectID, metricType); err != nil {
t.Fatal(err)
}
for {
_, err = getCustomMetric(s, hc.ProjectID, metricType)
if err == nil {
break
}
time.Sleep(2 * time.Second)
}
if err != nil {
t.Fatal(err)
}
time.Sleep(2 * time.Second)
if err := writeTimeSeriesValue(s, hc.ProjectID, metricType); err != nil {
t.Error(err)
}
if err := readTimeSeriesValue(s, hc.ProjectID, metricType); err != nil {
t.Error(err)
}
}
func TestCreate(t *testing.T) {
tc := testutil.SystemTest(t)
c := setup(t)
if err := create(c, tc.ProjectID, bucketName); err != nil {
t.Fatalf("failed to create bucket (%q): %v", bucketName, err)
}
}
func TestRecognize(t *testing.T) {
testutil.SystemTest(t)
ctx := context.Background()
client, err := speech.NewClient(ctx)
if err != nil {
t.Fatal(err)
}
opName, err := send(client, "./quit.raw")
if err != nil {
t.Fatal(err)
}
if opName == "" {
t.Fatal("got no op name; want one")
}
resp, err := wait(client, opName)
if err != nil {
t.Fatal(err)
}
if len(resp.Results) == 0 {
t.Fatal("got no results; want at least one")
}
result := resp.Results[0]
if len(result.Alternatives) < 1 {
t.Fatal("got no alternatives; want at least one")
}
if got, want := result.Alternatives[0].Transcript, "quit"; got != want {
t.Errorf("Transcript: got %q; want %q", got, want)
}
}
func TestSimplelog(t *testing.T) {
tc := testutil.SystemTest(t)
ctx := context.Background()
client, err := logging.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatalf("logging.NewClient: %v", err)
}
adminClient, err := logadmin.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatalf("logadmin.NewClient: %v", err)
}
defer func() {
if err := client.Close(); err != nil {
t.Errorf("Close: %v", err)
}
}()
defer func() {
testutil.Retry(t, 10, time.Second, func(r *testutil.R) {
if err := deleteLog(adminClient); err != nil {
r.Errorf("deleteLog: %v", err)
}
})
}()
client.OnError = func(err error) {
t.Errorf("OnError: %v", err)
}
writeEntry(client)
structuredWrite(client)
testutil.Retry(t, 10, time.Second, func(r *testutil.R) {
entries, err := getEntries(adminClient, tc.ProjectID)
if err != nil {
r.Errorf("getEntries: %v", err)
return
}
if got, want := len(entries), 2; got != want {
r.Errorf("len(entries) = %d; want %d", got, want)
return
}
wantContain := map[string]*logging.Entry{
"Anything": entries[0],
"The payload can be any type!": entries[0],
"infolog is a standard Go log.Logger": entries[1],
}
for want, entry := range wantContain {
msg := fmt.Sprintf("%s", entry.Payload)
if !strings.Contains(msg, want) {
r.Errorf("want %q to contain %q", msg, want)
}
}
})
}
func TestDelete(t *testing.T) {
testutil.SystemTest(t)
c := setup(t)
if err := delete(c, bucketName); err != nil {
t.Fatalf("failed to delete bucket (%q): %v", bucketName, err)
}
}
func TestListInstances(t *testing.T) {
tc := testutil.SystemTest(t)
// Just check the call succeeds.
_, err := ListInstances(tc.ProjectID)
if err != nil {
t.Fatal(err)
}
}
func setup(t *testing.T) *pubsub.Client {
ctx := context.Background()
tc := testutil.SystemTest(t)
client, err := pubsub.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatalf("failed to create client: %v", err)
}
return client
}
func TestListBuckets(t *testing.T) {
tc := testutil.SystemTest(t)
buckets, err := ListBuckets(tc.ProjectID)
if err != nil {
t.Errorf("error while listing buckets: %s", err)
}
if len(buckets) <= 0 {
t.Error("want non-empty list of buckets")
}
}
func TestCreateWithAttrs(t *testing.T) {
tc := testutil.SystemTest(t)
c := setup(t)
name := bucketName + "-attrs"
if err := createWithAttrs(c, tc.ProjectID, name); err != nil {
t.Fatalf("failed to create bucket (%q): %v", bucketName, err)
}
if err := delete(c, name); err != nil {
t.Fatalf("failed to delete bucket (%q): %v", bucketName, err)
}
}
func TestListSupported(t *testing.T) {
testutil.SystemTest(t)
buf := &bytes.Buffer{}
if err := listSupportedLanguages(buf, "th"); err != nil {
t.Fatal(err)
}
if got, want := buf.String(), `"en":`; !strings.Contains(got, want) {
t.Errorf("listSupportedLanguages(th): want %q in %q", want, got)
}
}
func TestLabel(t *testing.T) {
testutil.SystemTest(t)
labels, err := findLabels("../testdata/cat.jpg")
if err != nil {
t.Fatalf("got %v, want nil err", err)
}
if len(labels) == 0 {
t.Fatalf("want non-empty slice of labels")
}
}
func TestTranslateText(t *testing.T) {
testutil.SystemTest(t)
got, err := translateText("ja", "The Go Gopher is cute")
if err != nil {
t.Fatalf("translateText: %v", err)
}
if want := "可愛い"; !strings.Contains(got, want) {
t.Errorf("translateText(Gophers are cute)=%q; want to contain %q", got, want)
}
}
func TestListInstances(t *testing.T) {
tc := testutil.SystemTest(t)
instances, err := ListInstances(tc.ProjectID)
if err != nil {
t.Fatal(err)
}
if len(instances) == 0 {
t.Fatalf("want non-zero SQL instances in project %q", tc.ProjectID)
}
}
func TestAll(t *testing.T) {
tc := testutil.SystemTest(t)
ctx := context.Background()
client, err := bigquery.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatal(err)
}
datasetID := fmt.Sprintf("golang_example_dataset_%d", time.Now().Unix())
if err := createDataset(client, datasetID); err != nil {
t.Errorf("failed to create dataset: %v", err)
}
if err := listDatasets(client); err != nil {
t.Errorf("failed to create dataset: %v", err)
}
tableID := fmt.Sprintf("golang_example_table_%d", time.Now().Unix())
if err := createTable(client, datasetID, tableID); err != nil {
t.Errorf("failed to create table: %v", err)
}
buf := &bytes.Buffer{}
if err := listTables(client, buf, datasetID); err != nil {
t.Errorf("failed to list tables: %v", err)
}
if got := buf.String(); !strings.Contains(got, tableID) {
t.Errorf("want table list %q to contain table %q", got, tableID)
}
if err := insertRows(client, datasetID, tableID); err != nil {
t.Errorf("failed to insert rows: %v", err)
}
if err := listRows(client, datasetID, tableID); err != nil {
t.Errorf("failed to list rows: %v", err)
}
if err := browseTable(client, datasetID, tableID); err != nil {
t.Errorf("failed to list rows: %v", err)
}
if err := asyncQuery(client, datasetID, tableID); err != nil {
t.Errorf("failed to async query: %v", err)
}
dstTableID := fmt.Sprintf("golang_example_tabledst_%d", time.Now().Unix())
if err := copyTable(client, datasetID, tableID, dstTableID); err != nil {
t.Errorf("failed to copy table: %v", err)
}
if err := deleteTable(client, datasetID, tableID); err != nil {
t.Errorf("failed to delete table: %v", err)
}
if err := deleteTable(client, datasetID, dstTableID); err != nil {
t.Errorf("failed to delete table: %v", err)
}
deleteDataset(t, ctx, datasetID)
}
func TestSentiment(t *testing.T) {
testutil.SystemTest(t)
ctx, c := newClient(t)
res, err := analyzeSentiment(ctx, c, "I am very happy.")
if err != nil {
t.Fatalf("got %v, want nil err", err)
}
if got := res.DocumentSentiment.Score; got <= 0 {
t.Errorf("sentiment score: got %f, want positive", got)
}
}
func TestDetect(t *testing.T) {
testutil.SystemTest(t)
detection, err := detectLanguage("可愛い")
if err != nil {
t.Fatalf("detectLanguage: %v", err)
}
if got, want := detection.Language, language.Japanese; got != want {
t.Errorf("detection.Language: got %q; want %q", got, want)
}
}
func TestImportExport(t *testing.T) {
tc := testutil.SystemTest(t)
ctx := context.Background()
client, err := bigquery.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatal(err)
}
storageClient, err := storage.NewClient(ctx)
if err != nil {
t.Fatal(err)
}
datasetID := fmt.Sprintf("golang_example_dataset_importexport_%d", time.Now().Unix())
tableID := fmt.Sprintf("golang_example_dataset_importexport_%d", time.Now().Unix())
if err := createDataset(client, datasetID); err != nil {
t.Errorf("failed to create dataset: %v", err)
}
schema := bigquery.Schema{
&bigquery.FieldSchema{Name: "Year", Type: bigquery.IntegerFieldType},
&bigquery.FieldSchema{Name: "City", Type: bigquery.StringFieldType},
}
if err := client.Dataset(datasetID).Table(tableID).Create(ctx, schema); err != nil {
t.Errorf("failed to create dataset: %v", err)
}
defer deleteDataset(t, ctx, datasetID)
if err := importFromFile(client, datasetID, tableID, "testdata/olympics.csv"); err != nil {
t.Fatalf("failed to import from file: %v", err)
}
bucket := fmt.Sprintf("golang-example-bigquery-importexport-bucket-%d", time.Now().Unix())
const object = "values.csv"
if err := storageClient.Bucket(bucket).Create(ctx, tc.ProjectID, nil); err != nil {
t.Fatalf("cannot create bucket: %v", err)
}
gcsURI := fmt.Sprintf("gs://%s/%s", bucket, object)
if err := exportToGCS(client, datasetID, tableID, gcsURI); err != nil {
t.Errorf("failed to export to %v: %v", gcsURI, err)
}
// Cleanup the bucket and object.
if err := storageClient.Bucket(bucket).Object(object).Delete(ctx); err != nil {
t.Errorf("failed to cleanup the GCS object: %v", err)
}
time.Sleep(time.Second) // Give it a second, due to eventual consistency.
if err := storageClient.Bucket(bucket).Delete(ctx); err != nil {
t.Errorf("failed to cleanup the GCS bucket: %v", err)
}
}
func TestEntity(t *testing.T) {
testutil.SystemTest(t)
ctx, c := newClient(t)
res, err := analyzeEntities(ctx, c, "Homer Simpson likes donuts.")
if err != nil {
t.Fatalf("got %v, want nil err", err)
}
for _, e := range res.Entities {
if e.Name == "Homer Simpson" {
return // found
}
}
t.Errorf("got %+v; want Homer in Entities", res)
}
func TestQuery(t *testing.T) {
tc := testutil.SystemTest(t)
rows, err := Query(tc.ProjectID, "SELECT corpus FROM publicdata:samples.shakespeare GROUP BY corpus;")
if err != nil {
t.Fatal(err)
}
for _, row := range rows {
if row[0] == "romeoandjuliet" {
return
}
}
t.Errorf("got rows: %q; want romeoandjuliet", rows)
}
func TestDatastoreDB(t *testing.T) {
tc := testutil.SystemTest(t)
ctx := context.Background()
client, err := datastore.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatal(err)
}
defer client.Close()
db, err := newDatastoreDB(client)
if err != nil {
t.Fatal(err)
}
testDB(t, db)
}
func deleteDataset(t *testing.T, ctx context.Context, datasetID string) {
tc := testutil.SystemTest(t)
hc, err := google.DefaultClient(ctx, rawbq.CloudPlatformScope)
if err != nil {
t.Errorf("DefaultClient: %v", err)
}
s, err := rawbq.New(hc)
if err != nil {
t.Errorf("bigquery.New: %v", err)
}
call := s.Datasets.Delete(tc.ProjectID, datasetID)
call.DeleteContents(true)
call.Context(ctx)
if err := call.Do(); err != nil {
t.Errorf("deleteDataset(%q): %v", datasetID, err)
}
}
func TestSimpleApp(t *testing.T) {
tc := testutil.SystemTest(t)
rows, err := query(tc.ProjectID)
if err != nil {
t.Fatal(err)
}
var b bytes.Buffer
if err := printResults(&b, rows); err != nil {
t.Fatal(err)
}
if !strings.Contains(b.String(), "hamlet") {
t.Errorf("got output: %q; want it to contain hamlet", b.String())
}
}
func TestSyntax(t *testing.T) {
testutil.SystemTest(t)
ctx, c := newClient(t)
res, err := analyzeSyntax(ctx, c, "If you bend the gopher, his belly folds.")
if err != nil {
t.Fatalf("got %v, want nil err", err)
}
for _, tok := range res.Tokens {
if tok.Lemma == "gopher" {
if tok.PartOfSpeech.Tag != languagepb.PartOfSpeech_NOUN {
t.Errorf("PartOfSpeech: got %+v, want NOUN", tok.PartOfSpeech.Tag)
}
return // found
}
}
t.Errorf("got %+v; want gopher in Tokens", res)
}
func TestRecognize(t *testing.T) {
testutil.SystemTest(t)
resp, err := recognize("./quit.raw")
if err != nil {
t.Fatal(err)
}
if len(resp.Results) == 0 {
t.Fatal("got no results; want at least one")
}
result := resp.Results[0]
if len(result.Alternatives) < 1 {
t.Fatal("got no alternatives; want at least one")
}
if got, want := result.Alternatives[0].Transcript, "quit"; got != want {
t.Errorf("Transcript: got %q; want %q", got, want)
}
}
func TestAddMarkDelete(t *testing.T) {
testutil.SystemTest(t)
ctx := context.Background()
desc := makeDesc()
k, err := AddTask(ctx, client, desc)
if err != nil {
t.Fatal(err)
}
if err := MarkDone(ctx, client, k.ID); err != nil {
t.Fatal(err)
}
if err := DeleteTask(ctx, client, k.ID); err != nil {
t.Fatal(err)
}
}
func TestList(t *testing.T) {
tc := testutil.SystemTest(t)
c := setup(t)
buckets, err := list(c, tc.ProjectID)
if err != nil {
t.Fatal(err)
}
var ok bool
outer:
for attempt := 0; attempt < 5; attempt++ { // for eventual consistency
for _, b := range buckets {
if b == bucketName {
ok = true
break outer
}
}
time.Sleep(2 * time.Second)
}
if !ok {
t.Errorf("got bucket list: %v; want %q in the list", buckets, bucketName)
}
}
func setup(t *testing.T) *pubsub.Client {
ctx := context.Background()
tc := testutil.SystemTest(t)
client, err := pubsub.NewClient(ctx, tc.ProjectID)
if err != nil {
t.Fatalf("failed to create client: %v", err)
}
// Cleanup resources from the previous failed tests.
once.Do(func() {
// Create a topic.
topic = client.Topic(topicID)
ok, err := topic.Exists(ctx)
if err != nil {
t.Fatalf("failed to check if topic exists: %v", err)
}
if !ok {
if topic, err = client.CreateTopic(ctx, topicID); err != nil {
t.Fatalf("failed to create the topic: %v", err)
}
}
// Delete the sub if already exists.
sub := client.Subscription(subID)
ok, err = sub.Exists(ctx)
if err != nil {
t.Fatalf("failed to check if sub exists: %v", err)
}
if ok {
if err := client.Subscription(subID).Delete(ctx); err != nil {
t.Fatalf("failed to cleanup the topic (%q): %v", subID, err)
}
}
})
return client
}