func TestController2UpdateActiveBreakpoint(t *testing.T) {
var expectedResponse *clouddebuggerpb.UpdateActiveBreakpointResponse = &clouddebuggerpb.UpdateActiveBreakpointResponse{}
mockController2.err = nil
mockController2.reqs = nil
mockController2.resps = append(mockController2.resps[:0], expectedResponse)
var debuggeeId string = "debuggeeId-997255898"
var breakpoint *clouddebuggerpb.Breakpoint = &clouddebuggerpb.Breakpoint{}
var request = &clouddebuggerpb.UpdateActiveBreakpointRequest{
DebuggeeId: debuggeeId,
Breakpoint: breakpoint,
}
c, err := NewController2Client(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.UpdateActiveBreakpoint(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockController2.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestReportErrorsServiceReportErrorEvent(t *testing.T) {
var expectedResponse *clouderrorreportingpb.ReportErrorEventResponse = &clouderrorreportingpb.ReportErrorEventResponse{}
mockReportErrors.err = nil
mockReportErrors.reqs = nil
mockReportErrors.resps = append(mockReportErrors.resps[:0], expectedResponse)
var formattedProjectName string = ReportErrorsProjectPath("[PROJECT]")
var event *clouderrorreportingpb.ReportedErrorEvent = &clouderrorreportingpb.ReportedErrorEvent{}
var request = &clouderrorreportingpb.ReportErrorEventRequest{
ProjectName: formattedProjectName,
Event: event,
}
c, err := NewReportErrorsClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ReportErrorEvent(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockReportErrors.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestDebugger2ListDebuggees(t *testing.T) {
var expectedResponse *clouddebuggerpb.ListDebuggeesResponse = &clouddebuggerpb.ListDebuggeesResponse{}
mockDebugger2.err = nil
mockDebugger2.reqs = nil
mockDebugger2.resps = append(mockDebugger2.resps[:0], expectedResponse)
var project string = "project-309310695"
var clientVersion string = "clientVersion-1506231196"
var request = &clouddebuggerpb.ListDebuggeesRequest{
Project: project,
ClientVersion: clientVersion,
}
c, err := NewDebugger2Client(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListDebuggees(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockDebugger2.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestSubscriberPull(t *testing.T) {
var expectedResponse *pubsubpb.PullResponse = &pubsubpb.PullResponse{}
mockSubscriber.err = nil
mockSubscriber.reqs = nil
mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
var formattedSubscription string = SubscriberSubscriptionPath("[PROJECT]", "[SUBSCRIPTION]")
var maxMessages int32 = 496131527
var request = &pubsubpb.PullRequest{
Subscription: formattedSubscription,
MaxMessages: maxMessages,
}
c, err := NewSubscriberClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.Pull(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestClone(t *testing.T) {
m := proto.Clone(cloneTestMessage).(*pb.MyMessage)
if !proto.Equal(m, cloneTestMessage) {
t.Errorf("Clone(%v) = %v", cloneTestMessage, m)
}
// Verify it was a deep copy.
*m.Inner.Port++
if proto.Equal(m, cloneTestMessage) {
t.Error("Mutating clone changed the original")
}
// Byte fields and repeated fields should be copied.
if &m.Pet[0] == &cloneTestMessage.Pet[0] {
t.Error("Pet: repeated field not copied")
}
if &m.Others[0] == &cloneTestMessage.Others[0] {
t.Error("Others: repeated field not copied")
}
if &m.Others[0].Value[0] == &cloneTestMessage.Others[0].Value[0] {
t.Error("Others[0].Value: bytes field not copied")
}
if &m.RepBytes[0] == &cloneTestMessage.RepBytes[0] {
t.Error("RepBytes: repeated field not copied")
}
if &m.RepBytes[0][0] == &cloneTestMessage.RepBytes[0][0] {
t.Error("RepBytes[0]: bytes field not copied")
}
}
func TestIamQueryGrantableRoles(t *testing.T) {
var expectedResponse *adminpb.QueryGrantableRolesResponse = &adminpb.QueryGrantableRolesResponse{}
mockIam.err = nil
mockIam.reqs = nil
mockIam.resps = append(mockIam.resps[:0], expectedResponse)
var fullResourceName string = "fullResourceName1300993644"
var request = &adminpb.QueryGrantableRolesRequest{
FullResourceName: fullResourceName,
}
c, err := NewIamClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.QueryGrantableRoles(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockIam.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestController2RegisterDebuggee(t *testing.T) {
var expectedResponse *clouddebuggerpb.RegisterDebuggeeResponse = &clouddebuggerpb.RegisterDebuggeeResponse{}
mockController2.err = nil
mockController2.reqs = nil
mockController2.resps = append(mockController2.resps[:0], expectedResponse)
var debuggee *clouddebuggerpb.Debuggee = &clouddebuggerpb.Debuggee{}
var request = &clouddebuggerpb.RegisterDebuggeeRequest{
Debuggee: debuggee,
}
c, err := NewController2Client(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.RegisterDebuggee(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockController2.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestImageAnnotatorBatchAnnotateImages(t *testing.T) {
var expectedResponse *visionpb.BatchAnnotateImagesResponse = &visionpb.BatchAnnotateImagesResponse{}
mockImageAnnotator.err = nil
mockImageAnnotator.reqs = nil
mockImageAnnotator.resps = append(mockImageAnnotator.resps[:0], expectedResponse)
var requests []*visionpb.AnnotateImageRequest = nil
var request = &visionpb.BatchAnnotateImagesRequest{
Requests: requests,
}
c, err := NewImageAnnotatorClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.BatchAnnotateImages(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockImageAnnotator.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestIamListServiceAccountKeys(t *testing.T) {
var expectedResponse *adminpb.ListServiceAccountKeysResponse = &adminpb.ListServiceAccountKeysResponse{}
mockIam.err = nil
mockIam.reqs = nil
mockIam.resps = append(mockIam.resps[:0], expectedResponse)
var formattedName string = IamServiceAccountPath("[PROJECT]", "[SERVICE_ACCOUNT]")
var request = &adminpb.ListServiceAccountKeysRequest{
Name: formattedName,
}
c, err := NewIamClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListServiceAccountKeys(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockIam.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestLoggingServiceV2WriteLogEntries(t *testing.T) {
var expectedResponse *loggingpb.WriteLogEntriesResponse = &loggingpb.WriteLogEntriesResponse{}
mockLogging.err = nil
mockLogging.reqs = nil
mockLogging.resps = append(mockLogging.resps[:0], expectedResponse)
var entries []*loggingpb.LogEntry = nil
var request = &loggingpb.WriteLogEntriesRequest{
Entries: entries,
}
c, err := NewClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.WriteLogEntries(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockLogging.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestIamTestIamPermissions(t *testing.T) {
var expectedResponse *iampb.TestIamPermissionsResponse = &iampb.TestIamPermissionsResponse{}
mockIam.err = nil
mockIam.reqs = nil
mockIam.resps = append(mockIam.resps[:0], expectedResponse)
var formattedResource string = IamServiceAccountPath("[PROJECT]", "[SERVICE_ACCOUNT]")
var permissions []string = nil
var request = &iampb.TestIamPermissionsRequest{
Resource: formattedResource,
Permissions: permissions,
}
c, err := NewIamClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.TestIamPermissions(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockIam.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestSpeechSyncRecognize(t *testing.T) {
var expectedResponse *speechpb.SyncRecognizeResponse = &speechpb.SyncRecognizeResponse{}
mockSpeech.err = nil
mockSpeech.reqs = nil
mockSpeech.resps = append(mockSpeech.resps[:0], expectedResponse)
var config *speechpb.RecognitionConfig = &speechpb.RecognitionConfig{}
var audio *speechpb.RecognitionAudio = &speechpb.RecognitionAudio{}
var request = &speechpb.SyncRecognizeRequest{
Config: config,
Audio: audio,
}
c, err := NewClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.SyncRecognize(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockSpeech.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestLanguageServiceAnalyzeSentiment(t *testing.T) {
var language string = "language-1613589672"
var expectedResponse = &languagepb.AnalyzeSentimentResponse{
Language: language,
}
mockLanguage.err = nil
mockLanguage.reqs = nil
mockLanguage.resps = append(mockLanguage.resps[:0], expectedResponse)
var document *languagepb.Document = &languagepb.Document{}
var request = &languagepb.AnalyzeSentimentRequest{
Document: document,
}
c, err := NewClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.AnalyzeSentiment(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockLanguage.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
// TestGetSrvKeyspace will test we properly return updated SrvKeyspace.
func TestGetSrvKeyspace(t *testing.T) {
ft := &fakeTopo{keyspace: "test_ks"}
rsts := NewResilientSrvTopoServer(topo.Server{Impl: ft}, "TestGetSrvKeyspace")
// ask for the known keyspace, that populates the cache
_, err := rsts.GetSrvKeyspace(context.Background(), "", "test_ks")
if err != nil {
t.Fatalf("GetSrvKeyspace got unexpected error: %v", err)
}
// update srvkeyspace with new value
want := &topodatapb.SrvKeyspace{
ShardingColumnName: "id",
ShardingColumnType: topodatapb.KeyspaceIdType_UINT64,
}
ft.UpdateSrvKeyspace(context.Background(), "", "test_ks", want)
var got *topodatapb.SrvKeyspace
expiry := time.Now().Add(5 * time.Second)
for i := time.Now(); i.Before(expiry); {
got, err = rsts.GetSrvKeyspace(context.Background(), "", "test_ks")
if err != nil {
t.Fatalf("GetSrvKeyspace got unexpected error: %v", err)
}
if proto.Equal(want, got) {
break
}
time.Sleep(10 * time.Millisecond)
}
if !proto.Equal(want, got) {
t.Fatalf("GetSrvKeyspace() = %+v, want %+v", got, want)
}
}
func TestPublisherGetTopic(t *testing.T) {
var name string = "name3373707"
var expectedResponse = &pubsubpb.Topic{
Name: name,
}
mockPublisher.err = nil
mockPublisher.reqs = nil
mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
var formattedTopic string = PublisherTopicPath("[PROJECT]", "[TOPIC]")
var request = &pubsubpb.GetTopicRequest{
Topic: formattedTopic,
}
c, err := NewPublisherClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.GetTopic(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestMetricServiceListTimeSeries(t *testing.T) {
var nextPageToken string = ""
var timeSeriesElement *monitoringpb.TimeSeries = &monitoringpb.TimeSeries{}
var timeSeries = []*monitoringpb.TimeSeries{timeSeriesElement}
var expectedResponse = &monitoringpb.ListTimeSeriesResponse{
NextPageToken: nextPageToken,
TimeSeries: timeSeries,
}
mockMetric.err = nil
mockMetric.reqs = nil
mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
var formattedName string = MetricProjectPath("[PROJECT]")
var filter string = "filter-1274492040"
var interval *monitoringpb.TimeInterval = &monitoringpb.TimeInterval{}
var view monitoringpb.ListTimeSeriesRequest_TimeSeriesView = 0
var request = &monitoringpb.ListTimeSeriesRequest{
Name: formattedName,
Filter: filter,
Interval: interval,
View: view,
}
c, err := NewMetricClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListTimeSeries(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.TimeSeries[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestWatchSrvKeyspaceCancel(t *testing.T) {
cell := "cell1"
keyspace := "ks1"
ctx := context.Background()
mt := memorytopo.NewMemoryTopo([]string{"global", cell})
ts := topo.Server{Impl: mt}
// No SrvKeyspace -> ErrNoNode
current, changes, cancel := ts.WatchSrvKeyspace(ctx, cell, keyspace)
if current.Err != topo.ErrNoNode {
t.Errorf("Got invalid result from WatchSrvKeyspace(not there): %v", current.Err)
}
// Create initial value
wanted := &topodatapb.SrvKeyspace{
ShardingColumnName: "scn2",
}
contents, err := proto.Marshal(wanted)
if err != nil {
t.Fatalf("proto.Marshal(wanted) failed: %v", err)
}
if _, err := mt.Create(ctx, cell, "/keyspaces/"+keyspace+"/SrvKeyspace", contents); err != nil {
t.Fatalf("Update(/keyspaces/ks1/SrvKeyspace) failed: %v", err)
}
// Starting the watch should now work.
current, changes, cancel = waitForInitialSrvKeyspace(t, ts, cell, keyspace)
if !proto.Equal(current.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", current.Value, wanted)
}
// Cancel watch, wait for error.
cancel()
for {
wd, ok := <-changes
if !ok {
t.Fatalf("watch channel unexpectedly closed")
}
if wd.Err == topo.ErrInterrupted {
break
}
if wd.Err != nil {
t.Fatalf("watch channel unexpectedly got unknown error: %v", wd.Err)
}
if !proto.Equal(wd.Value, wanted) {
t.Fatalf("got bad data: %v expected: %v", wd.Value, wanted)
}
t.Log("got duplicate right value, skipping.")
}
// Cancel should still work here, although it does nothing.
cancel()
}
// TestCreateTablet tests all the logic in the topo.CreateTablet method.
func TestCreateTablet(t *testing.T) {
cell := "cell1"
keyspace := "ks1"
shard := "shard1"
ctx := context.Background()
ts := zktestserver.New(t, []string{cell})
// Create a tablet.
alias := &topodatapb.TabletAlias{
Cell: cell,
Uid: 1,
}
tablet := &topodatapb.Tablet{
Keyspace: keyspace,
Shard: shard,
Alias: alias,
}
if err := ts.CreateTablet(ctx, tablet); err != nil {
t.Fatalf("CreateTablet failed: %v", err)
}
// Get the tablet, make sure it's good. Also check ShardReplication.
ti, err := ts.GetTablet(ctx, alias)
if err != nil || !proto.Equal(ti.Tablet, tablet) {
t.Fatalf("Created Tablet doesn't match: %v %v", ti, err)
}
sri, err := ts.GetShardReplication(ctx, cell, keyspace, shard)
if err != nil || len(sri.Nodes) != 1 || !proto.Equal(sri.Nodes[0].TabletAlias, alias) {
t.Fatalf("Created ShardReplication doesn't match: %v %v", sri, err)
}
// Create the same tablet again, make sure it fails with ErrNodeExists.
if err := ts.CreateTablet(ctx, tablet); err != topo.ErrNodeExists {
t.Fatalf("CreateTablet(again) returned: %v", err)
}
// Remove the ShardReplication record, try to create the
// tablets again, make sure it's fixed.
if err := topo.RemoveShardReplicationRecord(ctx, ts, cell, keyspace, shard, alias); err != nil {
t.Fatalf("RemoveShardReplicationRecord failed: %v", err)
}
sri, err = ts.GetShardReplication(ctx, cell, keyspace, shard)
if err != nil || len(sri.Nodes) != 0 {
t.Fatalf("Modifed ShardReplication doesn't match: %v %v", sri, err)
}
if err := ts.CreateTablet(ctx, tablet); err != topo.ErrNodeExists {
t.Fatalf("CreateTablet(again and again) returned: %v", err)
}
sri, err = ts.GetShardReplication(ctx, cell, keyspace, shard)
if err != nil || len(sri.Nodes) != 1 || !proto.Equal(sri.Nodes[0].TabletAlias, alias) {
t.Fatalf("Created ShardReplication doesn't match: %v %v", sri, err)
}
}
func TestProtoCopy(t *testing.T) {
person := InitData("ronaflx", 195936, "*****@*****.**")
copyPerson := person
if !proto.Equal(person, copyPerson) {
t.Errorf("expect:\n%s\nactual:\n%s\n", proto.MarshalTextString(person), proto.MarshalTextString(
copyPerson))
}
msg := proto.Clone(person)
if !proto.Equal(person, msg) {
t.Errorf("expect:\n%s\nactual:\n%s\n", proto.MarshalTextString(person), proto.MarshalTextString(
msg))
}
}
func TestGroupServiceListGroupMembers(t *testing.T) {
var nextPageToken string = ""
var totalSize int32 = -705419236
var membersElement *monitoredrespb.MonitoredResource = &monitoredrespb.MonitoredResource{}
var members = []*monitoredrespb.MonitoredResource{membersElement}
var expectedResponse = &monitoringpb.ListGroupMembersResponse{
NextPageToken: nextPageToken,
TotalSize: totalSize,
Members: members,
}
mockGroup.err = nil
mockGroup.reqs = nil
mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
var formattedName string = GroupGroupPath("[PROJECT]", "[GROUP]")
var request = &monitoringpb.ListGroupMembersRequest{
Name: formattedName,
}
c, err := NewGroupClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListGroupMembers(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.Members[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestErrorStatsServiceListEvents(t *testing.T) {
var nextPageToken string = ""
var errorEventsElement *clouderrorreportingpb.ErrorEvent = &clouderrorreportingpb.ErrorEvent{}
var errorEvents = []*clouderrorreportingpb.ErrorEvent{errorEventsElement}
var expectedResponse = &clouderrorreportingpb.ListEventsResponse{
NextPageToken: nextPageToken,
ErrorEvents: errorEvents,
}
mockErrorStats.err = nil
mockErrorStats.reqs = nil
mockErrorStats.resps = append(mockErrorStats.resps[:0], expectedResponse)
var formattedProjectName string = ErrorStatsProjectPath("[PROJECT]")
var groupId string = "groupId506361563"
var request = &clouderrorreportingpb.ListEventsRequest{
ProjectName: formattedProjectName,
GroupId: groupId,
}
c, err := NewErrorStatsClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListEvents(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockErrorStats.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.ErrorEvents[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestProtoSerialize(t *testing.T) {
person := InitData("ronaflx", 195936, "*****@*****.**")
msg, _ := proto.Marshal(person)
another := &tutorial.Person{}
proto.Unmarshal(msg, another)
if !proto.Equal(person, another) {
t.Error("expect person equal to another")
}
person_text := proto.MarshalTextString(person)
proto.UnmarshalText(person_text, another)
if !proto.Equal(person, another) {
t.Error("expect person equal to another")
}
}
func TestIamCreateServiceAccount(t *testing.T) {
var name2 string = "name2-1052831874"
var projectId string = "projectId-1969970175"
var uniqueId string = "uniqueId-538310583"
var email string = "email96619420"
var displayName string = "displayName1615086568"
var etag []byte = []byte("21")
var oauth2ClientId string = "oauth2ClientId-1833466037"
var expectedResponse = &adminpb.ServiceAccount{
Name: name2,
ProjectId: projectId,
UniqueId: uniqueId,
Email: email,
DisplayName: displayName,
Etag: etag,
Oauth2ClientId: oauth2ClientId,
}
mockIam.err = nil
mockIam.reqs = nil
mockIam.resps = append(mockIam.resps[:0], expectedResponse)
var formattedName string = IamProjectPath("[PROJECT]")
var accountId string = "accountId-803333011"
var request = &adminpb.CreateServiceAccountRequest{
Name: formattedName,
AccountId: accountId,
}
c, err := NewIamClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.CreateServiceAccount(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if want, got := request, mockIam.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
if want, got := expectedResponse, resp; !proto.Equal(want, got) {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestMetricServiceListMetricDescriptors(t *testing.T) {
var nextPageToken string = ""
var metricDescriptorsElement *metricpb.MetricDescriptor = &metricpb.MetricDescriptor{}
var metricDescriptors = []*metricpb.MetricDescriptor{metricDescriptorsElement}
var expectedResponse = &monitoringpb.ListMetricDescriptorsResponse{
NextPageToken: nextPageToken,
MetricDescriptors: metricDescriptors,
}
mockMetric.err = nil
mockMetric.reqs = nil
mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
var formattedName string = MetricProjectPath("[PROJECT]")
var request = &monitoringpb.ListMetricDescriptorsRequest{
Name: formattedName,
}
c, err := NewMetricClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListMetricDescriptors(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.MetricDescriptors[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestTraceServiceListTraces(t *testing.T) {
var nextPageToken string = ""
var tracesElement *cloudtracepb.Trace = &cloudtracepb.Trace{}
var traces = []*cloudtracepb.Trace{tracesElement}
var expectedResponse = &cloudtracepb.ListTracesResponse{
NextPageToken: nextPageToken,
Traces: traces,
}
mockTrace.err = nil
mockTrace.reqs = nil
mockTrace.resps = append(mockTrace.resps[:0], expectedResponse)
var projectId string = "projectId-1969970175"
var request = &cloudtracepb.ListTracesRequest{
ProjectId: projectId,
}
c, err := NewClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListTraces(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockTrace.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.Traces[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestIamListServiceAccounts(t *testing.T) {
var nextPageToken string = ""
var accountsElement *adminpb.ServiceAccount = &adminpb.ServiceAccount{}
var accounts = []*adminpb.ServiceAccount{accountsElement}
var expectedResponse = &adminpb.ListServiceAccountsResponse{
NextPageToken: nextPageToken,
Accounts: accounts,
}
mockIam.err = nil
mockIam.reqs = nil
mockIam.resps = append(mockIam.resps[:0], expectedResponse)
var formattedName string = IamProjectPath("[PROJECT]")
var request = &adminpb.ListServiceAccountsRequest{
Name: formattedName,
}
c, err := NewIamClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListServiceAccounts(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockIam.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.Accounts[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestLoggingServiceV2ListLogEntries(t *testing.T) {
var nextPageToken string = ""
var entriesElement *loggingpb.LogEntry = &loggingpb.LogEntry{}
var entries = []*loggingpb.LogEntry{entriesElement}
var expectedResponse = &loggingpb.ListLogEntriesResponse{
NextPageToken: nextPageToken,
Entries: entries,
}
mockLogging.err = nil
mockLogging.reqs = nil
mockLogging.resps = append(mockLogging.resps[:0], expectedResponse)
var resourceNames []string = nil
var request = &loggingpb.ListLogEntriesRequest{
ResourceNames: resourceNames,
}
c, err := NewClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListLogEntries(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockLogging.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.Entries[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestMetricsServiceV2ListLogMetrics(t *testing.T) {
var nextPageToken string = ""
var metricsElement *loggingpb.LogMetric = &loggingpb.LogMetric{}
var metrics = []*loggingpb.LogMetric{metricsElement}
var expectedResponse = &loggingpb.ListLogMetricsResponse{
NextPageToken: nextPageToken,
Metrics: metrics,
}
mockMetrics.err = nil
mockMetrics.reqs = nil
mockMetrics.resps = append(mockMetrics.resps[:0], expectedResponse)
var formattedParent string = MetricsProjectPath("[PROJECT]")
var request = &loggingpb.ListLogMetricsRequest{
Parent: formattedParent,
}
c, err := NewMetricsClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListLogMetrics(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockMetrics.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.Metrics[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestSubscriberListSubscriptions(t *testing.T) {
var nextPageToken string = ""
var subscriptionsElement *pubsubpb.Subscription = &pubsubpb.Subscription{}
var subscriptions = []*pubsubpb.Subscription{subscriptionsElement}
var expectedResponse = &pubsubpb.ListSubscriptionsResponse{
NextPageToken: nextPageToken,
Subscriptions: subscriptions,
}
mockSubscriber.err = nil
mockSubscriber.reqs = nil
mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
var formattedProject string = SubscriberProjectPath("[PROJECT]")
var request = &pubsubpb.ListSubscriptionsRequest{
Project: formattedProject,
}
c, err := NewSubscriberClient(context.Background(), clientOpt)
if err != nil {
t.Fatal(err)
}
resp, err := c.ListSubscriptions(context.Background(), request).Next()
if err != nil {
t.Fatal(err)
}
if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
t.Errorf("wrong request %q, want %q", got, want)
}
want := (interface{})(expectedResponse.Subscriptions[0])
got := (interface{})(resp)
var ok bool
switch want := (want).(type) {
case proto.Message:
ok = proto.Equal(want, got.(proto.Message))
default:
ok = want == got
}
if !ok {
t.Errorf("wrong response %q, want %q)", got, want)
}
}
func TestCornerCases(t *testing.T) {
testRule1 := Rule{regexp.MustCompile(`(?P<first>\w+)(?:/(?P<second>\w+))?`), V{Corpus: "${first}", Path: "${second}"}.pb()}
testRule2 := Rule{regexp.MustCompile(`x/(?P<sig>\w+)/y/(?P<tail>.+)$`), V{Path: "${tail}", Sig: "|${sig}|"}.pb()}
tests := []struct {
rule Rule
input string
want *spb.VName
}{
// Optional portions of the pattern should be handled correctly.
{testRule1, "alpha/bravo", V{Corpus: "alpha", Path: "bravo"}.pb()},
{testRule1, "alpha", V{Corpus: "alpha"}.pb()},
// Substitution of signature fields should work.
{testRule2, "x/kanga/y/roo.txt", V{Path: "roo.txt", Sig: "|kanga|"}.pb()},
}
for _, test := range tests {
got, ok := test.rule.Apply(test.input)
if !ok {
t.Errorf("Apply %v failed", test.rule)
} else if !proto.Equal(got, test.want) {
t.Errorf("Apply %v: got {%+v}, want {%+v}", test.rule, got, test.want)
} else {
t.Logf("Apply %v properly returned {%+v}", test.rule, got)
}
}
}