1// Copyright 2019 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Code generated by gapic-generator. DO NOT EDIT.
16
17package translate
18
19import (
20	"context"
21	"flag"
22	"fmt"
23	"io"
24	"log"
25	"net"
26	"os"
27	"strings"
28	"testing"
29
30	"github.com/golang/protobuf/proto"
31	"github.com/golang/protobuf/ptypes"
32	"google.golang.org/api/option"
33	translatepb "google.golang.org/genproto/googleapis/cloud/translate/v3"
34	longrunningpb "google.golang.org/genproto/googleapis/longrunning"
35
36	status "google.golang.org/genproto/googleapis/rpc/status"
37	"google.golang.org/grpc"
38	"google.golang.org/grpc/codes"
39	"google.golang.org/grpc/metadata"
40
41	gstatus "google.golang.org/grpc/status"
42)
43
44var _ = io.EOF
45var _ = ptypes.MarshalAny
46var _ status.Status
47
48type mockTranslationServer struct {
49	// Embed for forward compatibility.
50	// Tests will keep working if more methods are added
51	// in the future.
52	translatepb.TranslationServiceServer
53
54	reqs []proto.Message
55
56	// If set, all calls return this error.
57	err error
58
59	// responses to return if err == nil
60	resps []proto.Message
61}
62
63func (s *mockTranslationServer) TranslateText(ctx context.Context, req *translatepb.TranslateTextRequest) (*translatepb.TranslateTextResponse, error) {
64	md, _ := metadata.FromIncomingContext(ctx)
65	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
66		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
67	}
68	s.reqs = append(s.reqs, req)
69	if s.err != nil {
70		return nil, s.err
71	}
72	return s.resps[0].(*translatepb.TranslateTextResponse), nil
73}
74
75func (s *mockTranslationServer) DetectLanguage(ctx context.Context, req *translatepb.DetectLanguageRequest) (*translatepb.DetectLanguageResponse, error) {
76	md, _ := metadata.FromIncomingContext(ctx)
77	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
78		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
79	}
80	s.reqs = append(s.reqs, req)
81	if s.err != nil {
82		return nil, s.err
83	}
84	return s.resps[0].(*translatepb.DetectLanguageResponse), nil
85}
86
87func (s *mockTranslationServer) GetSupportedLanguages(ctx context.Context, req *translatepb.GetSupportedLanguagesRequest) (*translatepb.SupportedLanguages, error) {
88	md, _ := metadata.FromIncomingContext(ctx)
89	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
90		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
91	}
92	s.reqs = append(s.reqs, req)
93	if s.err != nil {
94		return nil, s.err
95	}
96	return s.resps[0].(*translatepb.SupportedLanguages), nil
97}
98
99func (s *mockTranslationServer) BatchTranslateText(ctx context.Context, req *translatepb.BatchTranslateTextRequest) (*longrunningpb.Operation, error) {
100	md, _ := metadata.FromIncomingContext(ctx)
101	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
102		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
103	}
104	s.reqs = append(s.reqs, req)
105	if s.err != nil {
106		return nil, s.err
107	}
108	return s.resps[0].(*longrunningpb.Operation), nil
109}
110
111func (s *mockTranslationServer) CreateGlossary(ctx context.Context, req *translatepb.CreateGlossaryRequest) (*longrunningpb.Operation, error) {
112	md, _ := metadata.FromIncomingContext(ctx)
113	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
114		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
115	}
116	s.reqs = append(s.reqs, req)
117	if s.err != nil {
118		return nil, s.err
119	}
120	return s.resps[0].(*longrunningpb.Operation), nil
121}
122
123func (s *mockTranslationServer) ListGlossaries(ctx context.Context, req *translatepb.ListGlossariesRequest) (*translatepb.ListGlossariesResponse, error) {
124	md, _ := metadata.FromIncomingContext(ctx)
125	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
126		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
127	}
128	s.reqs = append(s.reqs, req)
129	if s.err != nil {
130		return nil, s.err
131	}
132	return s.resps[0].(*translatepb.ListGlossariesResponse), nil
133}
134
135func (s *mockTranslationServer) GetGlossary(ctx context.Context, req *translatepb.GetGlossaryRequest) (*translatepb.Glossary, error) {
136	md, _ := metadata.FromIncomingContext(ctx)
137	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
138		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
139	}
140	s.reqs = append(s.reqs, req)
141	if s.err != nil {
142		return nil, s.err
143	}
144	return s.resps[0].(*translatepb.Glossary), nil
145}
146
147func (s *mockTranslationServer) DeleteGlossary(ctx context.Context, req *translatepb.DeleteGlossaryRequest) (*longrunningpb.Operation, error) {
148	md, _ := metadata.FromIncomingContext(ctx)
149	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
150		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
151	}
152	s.reqs = append(s.reqs, req)
153	if s.err != nil {
154		return nil, s.err
155	}
156	return s.resps[0].(*longrunningpb.Operation), nil
157}
158
159// clientOpt is the option tests should use to connect to the test server.
160// It is initialized by TestMain.
161var clientOpt option.ClientOption
162
163var (
164	mockTranslation mockTranslationServer
165)
166
167func TestMain(m *testing.M) {
168	flag.Parse()
169
170	serv := grpc.NewServer()
171	translatepb.RegisterTranslationServiceServer(serv, &mockTranslation)
172
173	lis, err := net.Listen("tcp", "localhost:0")
174	if err != nil {
175		log.Fatal(err)
176	}
177	go serv.Serve(lis)
178
179	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
180	if err != nil {
181		log.Fatal(err)
182	}
183	clientOpt = option.WithGRPCConn(conn)
184
185	os.Exit(m.Run())
186}
187
188func TestTranslationServiceTranslateText(t *testing.T) {
189	var expectedResponse *translatepb.TranslateTextResponse = &translatepb.TranslateTextResponse{}
190
191	mockTranslation.err = nil
192	mockTranslation.reqs = nil
193
194	mockTranslation.resps = append(mockTranslation.resps[:0], expectedResponse)
195
196	var contents []string = nil
197	var targetLanguageCode string = "targetLanguageCode1323228230"
198	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
199	var request = &translatepb.TranslateTextRequest{
200		Contents:           contents,
201		TargetLanguageCode: targetLanguageCode,
202		Parent:             formattedParent,
203	}
204
205	c, err := NewTranslationClient(context.Background(), clientOpt)
206	if err != nil {
207		t.Fatal(err)
208	}
209
210	resp, err := c.TranslateText(context.Background(), request)
211
212	if err != nil {
213		t.Fatal(err)
214	}
215
216	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
217		t.Errorf("wrong request %q, want %q", got, want)
218	}
219
220	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
221		t.Errorf("wrong response %q, want %q)", got, want)
222	}
223}
224
225func TestTranslationServiceTranslateTextError(t *testing.T) {
226	errCode := codes.PermissionDenied
227	mockTranslation.err = gstatus.Error(errCode, "test error")
228
229	var contents []string = nil
230	var targetLanguageCode string = "targetLanguageCode1323228230"
231	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
232	var request = &translatepb.TranslateTextRequest{
233		Contents:           contents,
234		TargetLanguageCode: targetLanguageCode,
235		Parent:             formattedParent,
236	}
237
238	c, err := NewTranslationClient(context.Background(), clientOpt)
239	if err != nil {
240		t.Fatal(err)
241	}
242
243	resp, err := c.TranslateText(context.Background(), request)
244
245	if st, ok := gstatus.FromError(err); !ok {
246		t.Errorf("got error %v, expected grpc error", err)
247	} else if c := st.Code(); c != errCode {
248		t.Errorf("got error code %q, want %q", c, errCode)
249	}
250	_ = resp
251}
252func TestTranslationServiceDetectLanguage(t *testing.T) {
253	var expectedResponse *translatepb.DetectLanguageResponse = &translatepb.DetectLanguageResponse{}
254
255	mockTranslation.err = nil
256	mockTranslation.reqs = nil
257
258	mockTranslation.resps = append(mockTranslation.resps[:0], expectedResponse)
259
260	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
261	var request = &translatepb.DetectLanguageRequest{
262		Parent: formattedParent,
263	}
264
265	c, err := NewTranslationClient(context.Background(), clientOpt)
266	if err != nil {
267		t.Fatal(err)
268	}
269
270	resp, err := c.DetectLanguage(context.Background(), request)
271
272	if err != nil {
273		t.Fatal(err)
274	}
275
276	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
277		t.Errorf("wrong request %q, want %q", got, want)
278	}
279
280	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
281		t.Errorf("wrong response %q, want %q)", got, want)
282	}
283}
284
285func TestTranslationServiceDetectLanguageError(t *testing.T) {
286	errCode := codes.PermissionDenied
287	mockTranslation.err = gstatus.Error(errCode, "test error")
288
289	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
290	var request = &translatepb.DetectLanguageRequest{
291		Parent: formattedParent,
292	}
293
294	c, err := NewTranslationClient(context.Background(), clientOpt)
295	if err != nil {
296		t.Fatal(err)
297	}
298
299	resp, err := c.DetectLanguage(context.Background(), request)
300
301	if st, ok := gstatus.FromError(err); !ok {
302		t.Errorf("got error %v, expected grpc error", err)
303	} else if c := st.Code(); c != errCode {
304		t.Errorf("got error code %q, want %q", c, errCode)
305	}
306	_ = resp
307}
308func TestTranslationServiceGetSupportedLanguages(t *testing.T) {
309	var expectedResponse *translatepb.SupportedLanguages = &translatepb.SupportedLanguages{}
310
311	mockTranslation.err = nil
312	mockTranslation.reqs = nil
313
314	mockTranslation.resps = append(mockTranslation.resps[:0], expectedResponse)
315
316	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
317	var request = &translatepb.GetSupportedLanguagesRequest{
318		Parent: formattedParent,
319	}
320
321	c, err := NewTranslationClient(context.Background(), clientOpt)
322	if err != nil {
323		t.Fatal(err)
324	}
325
326	resp, err := c.GetSupportedLanguages(context.Background(), request)
327
328	if err != nil {
329		t.Fatal(err)
330	}
331
332	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
333		t.Errorf("wrong request %q, want %q", got, want)
334	}
335
336	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
337		t.Errorf("wrong response %q, want %q)", got, want)
338	}
339}
340
341func TestTranslationServiceGetSupportedLanguagesError(t *testing.T) {
342	errCode := codes.PermissionDenied
343	mockTranslation.err = gstatus.Error(errCode, "test error")
344
345	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
346	var request = &translatepb.GetSupportedLanguagesRequest{
347		Parent: formattedParent,
348	}
349
350	c, err := NewTranslationClient(context.Background(), clientOpt)
351	if err != nil {
352		t.Fatal(err)
353	}
354
355	resp, err := c.GetSupportedLanguages(context.Background(), request)
356
357	if st, ok := gstatus.FromError(err); !ok {
358		t.Errorf("got error %v, expected grpc error", err)
359	} else if c := st.Code(); c != errCode {
360		t.Errorf("got error code %q, want %q", c, errCode)
361	}
362	_ = resp
363}
364func TestTranslationServiceBatchTranslateText(t *testing.T) {
365	var totalCharacters int64 = 1368640955
366	var translatedCharacters int64 = 1337326221
367	var failedCharacters int64 = 1723028396
368	var expectedResponse = &translatepb.BatchTranslateResponse{
369		TotalCharacters:      totalCharacters,
370		TranslatedCharacters: translatedCharacters,
371		FailedCharacters:     failedCharacters,
372	}
373
374	mockTranslation.err = nil
375	mockTranslation.reqs = nil
376
377	any, err := ptypes.MarshalAny(expectedResponse)
378	if err != nil {
379		t.Fatal(err)
380	}
381	mockTranslation.resps = append(mockTranslation.resps[:0], &longrunningpb.Operation{
382		Name:   "longrunning-test",
383		Done:   true,
384		Result: &longrunningpb.Operation_Response{Response: any},
385	})
386
387	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
388	var sourceLanguageCode string = "sourceLanguageCode1687263568"
389	var targetLanguageCodes []string = nil
390	var inputConfigs []*translatepb.InputConfig = nil
391	var outputConfig *translatepb.OutputConfig = &translatepb.OutputConfig{}
392	var request = &translatepb.BatchTranslateTextRequest{
393		Parent:              formattedParent,
394		SourceLanguageCode:  sourceLanguageCode,
395		TargetLanguageCodes: targetLanguageCodes,
396		InputConfigs:        inputConfigs,
397		OutputConfig:        outputConfig,
398	}
399
400	c, err := NewTranslationClient(context.Background(), clientOpt)
401	if err != nil {
402		t.Fatal(err)
403	}
404
405	respLRO, err := c.BatchTranslateText(context.Background(), request)
406	if err != nil {
407		t.Fatal(err)
408	}
409	resp, err := respLRO.Wait(context.Background())
410
411	if err != nil {
412		t.Fatal(err)
413	}
414
415	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
416		t.Errorf("wrong request %q, want %q", got, want)
417	}
418
419	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
420		t.Errorf("wrong response %q, want %q)", got, want)
421	}
422}
423
424func TestTranslationServiceBatchTranslateTextError(t *testing.T) {
425	errCode := codes.PermissionDenied
426	mockTranslation.err = nil
427	mockTranslation.resps = append(mockTranslation.resps[:0], &longrunningpb.Operation{
428		Name: "longrunning-test",
429		Done: true,
430		Result: &longrunningpb.Operation_Error{
431			Error: &status.Status{
432				Code:    int32(errCode),
433				Message: "test error",
434			},
435		},
436	})
437
438	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
439	var sourceLanguageCode string = "sourceLanguageCode1687263568"
440	var targetLanguageCodes []string = nil
441	var inputConfigs []*translatepb.InputConfig = nil
442	var outputConfig *translatepb.OutputConfig = &translatepb.OutputConfig{}
443	var request = &translatepb.BatchTranslateTextRequest{
444		Parent:              formattedParent,
445		SourceLanguageCode:  sourceLanguageCode,
446		TargetLanguageCodes: targetLanguageCodes,
447		InputConfigs:        inputConfigs,
448		OutputConfig:        outputConfig,
449	}
450
451	c, err := NewTranslationClient(context.Background(), clientOpt)
452	if err != nil {
453		t.Fatal(err)
454	}
455
456	respLRO, err := c.BatchTranslateText(context.Background(), request)
457	if err != nil {
458		t.Fatal(err)
459	}
460	resp, err := respLRO.Wait(context.Background())
461
462	if st, ok := gstatus.FromError(err); !ok {
463		t.Errorf("got error %v, expected grpc error", err)
464	} else if c := st.Code(); c != errCode {
465		t.Errorf("got error code %q, want %q", c, errCode)
466	}
467	_ = resp
468}
469func TestTranslationServiceCreateGlossary(t *testing.T) {
470	var name string = "name3373707"
471	var entryCount int32 = 811131134
472	var expectedResponse = &translatepb.Glossary{
473		Name:       name,
474		EntryCount: entryCount,
475	}
476
477	mockTranslation.err = nil
478	mockTranslation.reqs = nil
479
480	any, err := ptypes.MarshalAny(expectedResponse)
481	if err != nil {
482		t.Fatal(err)
483	}
484	mockTranslation.resps = append(mockTranslation.resps[:0], &longrunningpb.Operation{
485		Name:   "longrunning-test",
486		Done:   true,
487		Result: &longrunningpb.Operation_Response{Response: any},
488	})
489
490	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
491	var glossary *translatepb.Glossary = &translatepb.Glossary{}
492	var request = &translatepb.CreateGlossaryRequest{
493		Parent:   formattedParent,
494		Glossary: glossary,
495	}
496
497	c, err := NewTranslationClient(context.Background(), clientOpt)
498	if err != nil {
499		t.Fatal(err)
500	}
501
502	respLRO, err := c.CreateGlossary(context.Background(), request)
503	if err != nil {
504		t.Fatal(err)
505	}
506	resp, err := respLRO.Wait(context.Background())
507
508	if err != nil {
509		t.Fatal(err)
510	}
511
512	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
513		t.Errorf("wrong request %q, want %q", got, want)
514	}
515
516	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
517		t.Errorf("wrong response %q, want %q)", got, want)
518	}
519}
520
521func TestTranslationServiceCreateGlossaryError(t *testing.T) {
522	errCode := codes.PermissionDenied
523	mockTranslation.err = nil
524	mockTranslation.resps = append(mockTranslation.resps[:0], &longrunningpb.Operation{
525		Name: "longrunning-test",
526		Done: true,
527		Result: &longrunningpb.Operation_Error{
528			Error: &status.Status{
529				Code:    int32(errCode),
530				Message: "test error",
531			},
532		},
533	})
534
535	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
536	var glossary *translatepb.Glossary = &translatepb.Glossary{}
537	var request = &translatepb.CreateGlossaryRequest{
538		Parent:   formattedParent,
539		Glossary: glossary,
540	}
541
542	c, err := NewTranslationClient(context.Background(), clientOpt)
543	if err != nil {
544		t.Fatal(err)
545	}
546
547	respLRO, err := c.CreateGlossary(context.Background(), request)
548	if err != nil {
549		t.Fatal(err)
550	}
551	resp, err := respLRO.Wait(context.Background())
552
553	if st, ok := gstatus.FromError(err); !ok {
554		t.Errorf("got error %v, expected grpc error", err)
555	} else if c := st.Code(); c != errCode {
556		t.Errorf("got error code %q, want %q", c, errCode)
557	}
558	_ = resp
559}
560func TestTranslationServiceListGlossaries(t *testing.T) {
561	var nextPageToken string = ""
562	var glossariesElement *translatepb.Glossary = &translatepb.Glossary{}
563	var glossaries = []*translatepb.Glossary{glossariesElement}
564	var expectedResponse = &translatepb.ListGlossariesResponse{
565		NextPageToken: nextPageToken,
566		Glossaries:    glossaries,
567	}
568
569	mockTranslation.err = nil
570	mockTranslation.reqs = nil
571
572	mockTranslation.resps = append(mockTranslation.resps[:0], expectedResponse)
573
574	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
575	var request = &translatepb.ListGlossariesRequest{
576		Parent: formattedParent,
577	}
578
579	c, err := NewTranslationClient(context.Background(), clientOpt)
580	if err != nil {
581		t.Fatal(err)
582	}
583
584	resp, err := c.ListGlossaries(context.Background(), request).Next()
585
586	if err != nil {
587		t.Fatal(err)
588	}
589
590	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
591		t.Errorf("wrong request %q, want %q", got, want)
592	}
593
594	want := (interface{})(expectedResponse.Glossaries[0])
595	got := (interface{})(resp)
596	var ok bool
597
598	switch want := (want).(type) {
599	case proto.Message:
600		ok = proto.Equal(want, got.(proto.Message))
601	default:
602		ok = want == got
603	}
604	if !ok {
605		t.Errorf("wrong response %q, want %q)", got, want)
606	}
607}
608
609func TestTranslationServiceListGlossariesError(t *testing.T) {
610	errCode := codes.PermissionDenied
611	mockTranslation.err = gstatus.Error(errCode, "test error")
612
613	var formattedParent string = fmt.Sprintf("projects/%s/locations/%s", "[PROJECT]", "[LOCATION]")
614	var request = &translatepb.ListGlossariesRequest{
615		Parent: formattedParent,
616	}
617
618	c, err := NewTranslationClient(context.Background(), clientOpt)
619	if err != nil {
620		t.Fatal(err)
621	}
622
623	resp, err := c.ListGlossaries(context.Background(), request).Next()
624
625	if st, ok := gstatus.FromError(err); !ok {
626		t.Errorf("got error %v, expected grpc error", err)
627	} else if c := st.Code(); c != errCode {
628		t.Errorf("got error code %q, want %q", c, errCode)
629	}
630	_ = resp
631}
632func TestTranslationServiceGetGlossary(t *testing.T) {
633	var name2 string = "name2-1052831874"
634	var entryCount int32 = 811131134
635	var expectedResponse = &translatepb.Glossary{
636		Name:       name2,
637		EntryCount: entryCount,
638	}
639
640	mockTranslation.err = nil
641	mockTranslation.reqs = nil
642
643	mockTranslation.resps = append(mockTranslation.resps[:0], expectedResponse)
644
645	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", "[PROJECT]", "[LOCATION]", "[GLOSSARY]")
646	var request = &translatepb.GetGlossaryRequest{
647		Name: formattedName,
648	}
649
650	c, err := NewTranslationClient(context.Background(), clientOpt)
651	if err != nil {
652		t.Fatal(err)
653	}
654
655	resp, err := c.GetGlossary(context.Background(), request)
656
657	if err != nil {
658		t.Fatal(err)
659	}
660
661	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
662		t.Errorf("wrong request %q, want %q", got, want)
663	}
664
665	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
666		t.Errorf("wrong response %q, want %q)", got, want)
667	}
668}
669
670func TestTranslationServiceGetGlossaryError(t *testing.T) {
671	errCode := codes.PermissionDenied
672	mockTranslation.err = gstatus.Error(errCode, "test error")
673
674	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", "[PROJECT]", "[LOCATION]", "[GLOSSARY]")
675	var request = &translatepb.GetGlossaryRequest{
676		Name: formattedName,
677	}
678
679	c, err := NewTranslationClient(context.Background(), clientOpt)
680	if err != nil {
681		t.Fatal(err)
682	}
683
684	resp, err := c.GetGlossary(context.Background(), request)
685
686	if st, ok := gstatus.FromError(err); !ok {
687		t.Errorf("got error %v, expected grpc error", err)
688	} else if c := st.Code(); c != errCode {
689		t.Errorf("got error code %q, want %q", c, errCode)
690	}
691	_ = resp
692}
693func TestTranslationServiceDeleteGlossary(t *testing.T) {
694	var name2 string = "name2-1052831874"
695	var expectedResponse = &translatepb.DeleteGlossaryResponse{
696		Name: name2,
697	}
698
699	mockTranslation.err = nil
700	mockTranslation.reqs = nil
701
702	any, err := ptypes.MarshalAny(expectedResponse)
703	if err != nil {
704		t.Fatal(err)
705	}
706	mockTranslation.resps = append(mockTranslation.resps[:0], &longrunningpb.Operation{
707		Name:   "longrunning-test",
708		Done:   true,
709		Result: &longrunningpb.Operation_Response{Response: any},
710	})
711
712	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", "[PROJECT]", "[LOCATION]", "[GLOSSARY]")
713	var request = &translatepb.DeleteGlossaryRequest{
714		Name: formattedName,
715	}
716
717	c, err := NewTranslationClient(context.Background(), clientOpt)
718	if err != nil {
719		t.Fatal(err)
720	}
721
722	respLRO, err := c.DeleteGlossary(context.Background(), request)
723	if err != nil {
724		t.Fatal(err)
725	}
726	resp, err := respLRO.Wait(context.Background())
727
728	if err != nil {
729		t.Fatal(err)
730	}
731
732	if want, got := request, mockTranslation.reqs[0]; !proto.Equal(want, got) {
733		t.Errorf("wrong request %q, want %q", got, want)
734	}
735
736	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
737		t.Errorf("wrong response %q, want %q)", got, want)
738	}
739}
740
741func TestTranslationServiceDeleteGlossaryError(t *testing.T) {
742	errCode := codes.PermissionDenied
743	mockTranslation.err = nil
744	mockTranslation.resps = append(mockTranslation.resps[:0], &longrunningpb.Operation{
745		Name: "longrunning-test",
746		Done: true,
747		Result: &longrunningpb.Operation_Error{
748			Error: &status.Status{
749				Code:    int32(errCode),
750				Message: "test error",
751			},
752		},
753	})
754
755	var formattedName string = fmt.Sprintf("projects/%s/locations/%s/glossaries/%s", "[PROJECT]", "[LOCATION]", "[GLOSSARY]")
756	var request = &translatepb.DeleteGlossaryRequest{
757		Name: formattedName,
758	}
759
760	c, err := NewTranslationClient(context.Background(), clientOpt)
761	if err != nil {
762		t.Fatal(err)
763	}
764
765	respLRO, err := c.DeleteGlossary(context.Background(), request)
766	if err != nil {
767		t.Fatal(err)
768	}
769	resp, err := respLRO.Wait(context.Background())
770
771	if st, ok := gstatus.FromError(err); !ok {
772		t.Errorf("got error %v, expected grpc error", err)
773	} else if c := st.Code(); c != errCode {
774		t.Errorf("got error code %q, want %q", c, errCode)
775	}
776	_ = resp
777}
778