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 }