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 speech
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	speechpb "google.golang.org/genproto/googleapis/cloud/speech/v1"
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 mockSpeechServer struct {
49	// Embed for forward compatibility.
50	// Tests will keep working if more methods are added
51	// in the future.
52	speechpb.SpeechServer
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 *mockSpeechServer) Recognize(ctx context.Context, req *speechpb.RecognizeRequest) (*speechpb.RecognizeResponse, 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].(*speechpb.RecognizeResponse), nil
73}
74
75func (s *mockSpeechServer) LongRunningRecognize(ctx context.Context, req *speechpb.LongRunningRecognizeRequest) (*longrunningpb.Operation, 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].(*longrunningpb.Operation), nil
85}
86
87func (s *mockSpeechServer) StreamingRecognize(stream speechpb.Speech_StreamingRecognizeServer) error {
88	md, _ := metadata.FromIncomingContext(stream.Context())
89	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
90		return fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
91	}
92	for {
93		if req, err := stream.Recv(); err == io.EOF {
94			break
95		} else if err != nil {
96			return err
97		} else {
98			s.reqs = append(s.reqs, req)
99		}
100	}
101	if s.err != nil {
102		return s.err
103	}
104	for _, v := range s.resps {
105		if err := stream.Send(v.(*speechpb.StreamingRecognizeResponse)); err != nil {
106			return err
107		}
108	}
109	return nil
110}
111
112// clientOpt is the option tests should use to connect to the test server.
113// It is initialized by TestMain.
114var clientOpt option.ClientOption
115
116var (
117	mockSpeech mockSpeechServer
118)
119
120func TestMain(m *testing.M) {
121	flag.Parse()
122
123	serv := grpc.NewServer()
124	speechpb.RegisterSpeechServer(serv, &mockSpeech)
125
126	lis, err := net.Listen("tcp", "localhost:0")
127	if err != nil {
128		log.Fatal(err)
129	}
130	go serv.Serve(lis)
131
132	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
133	if err != nil {
134		log.Fatal(err)
135	}
136	clientOpt = option.WithGRPCConn(conn)
137
138	os.Exit(m.Run())
139}
140
141func TestSpeechRecognize(t *testing.T) {
142	var expectedResponse *speechpb.RecognizeResponse = &speechpb.RecognizeResponse{}
143
144	mockSpeech.err = nil
145	mockSpeech.reqs = nil
146
147	mockSpeech.resps = append(mockSpeech.resps[:0], expectedResponse)
148
149	var encoding speechpb.RecognitionConfig_AudioEncoding = speechpb.RecognitionConfig_FLAC
150	var sampleRateHertz int32 = 44100
151	var languageCode string = "en-US"
152	var config = &speechpb.RecognitionConfig{
153		Encoding:        encoding,
154		SampleRateHertz: sampleRateHertz,
155		LanguageCode:    languageCode,
156	}
157	var uri string = "gs://bucket_name/file_name.flac"
158	var audio = &speechpb.RecognitionAudio{
159		AudioSource: &speechpb.RecognitionAudio_Uri{
160			Uri: uri,
161		},
162	}
163	var request = &speechpb.RecognizeRequest{
164		Config: config,
165		Audio:  audio,
166	}
167
168	c, err := NewClient(context.Background(), clientOpt)
169	if err != nil {
170		t.Fatal(err)
171	}
172
173	resp, err := c.Recognize(context.Background(), request)
174
175	if err != nil {
176		t.Fatal(err)
177	}
178
179	if want, got := request, mockSpeech.reqs[0]; !proto.Equal(want, got) {
180		t.Errorf("wrong request %q, want %q", got, want)
181	}
182
183	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
184		t.Errorf("wrong response %q, want %q)", got, want)
185	}
186}
187
188func TestSpeechRecognizeError(t *testing.T) {
189	errCode := codes.PermissionDenied
190	mockSpeech.err = gstatus.Error(errCode, "test error")
191
192	var encoding speechpb.RecognitionConfig_AudioEncoding = speechpb.RecognitionConfig_FLAC
193	var sampleRateHertz int32 = 44100
194	var languageCode string = "en-US"
195	var config = &speechpb.RecognitionConfig{
196		Encoding:        encoding,
197		SampleRateHertz: sampleRateHertz,
198		LanguageCode:    languageCode,
199	}
200	var uri string = "gs://bucket_name/file_name.flac"
201	var audio = &speechpb.RecognitionAudio{
202		AudioSource: &speechpb.RecognitionAudio_Uri{
203			Uri: uri,
204		},
205	}
206	var request = &speechpb.RecognizeRequest{
207		Config: config,
208		Audio:  audio,
209	}
210
211	c, err := NewClient(context.Background(), clientOpt)
212	if err != nil {
213		t.Fatal(err)
214	}
215
216	resp, err := c.Recognize(context.Background(), request)
217
218	if st, ok := gstatus.FromError(err); !ok {
219		t.Errorf("got error %v, expected grpc error", err)
220	} else if c := st.Code(); c != errCode {
221		t.Errorf("got error code %q, want %q", c, errCode)
222	}
223	_ = resp
224}
225func TestSpeechLongRunningRecognize(t *testing.T) {
226	var expectedResponse *speechpb.LongRunningRecognizeResponse = &speechpb.LongRunningRecognizeResponse{}
227
228	mockSpeech.err = nil
229	mockSpeech.reqs = nil
230
231	any, err := ptypes.MarshalAny(expectedResponse)
232	if err != nil {
233		t.Fatal(err)
234	}
235	mockSpeech.resps = append(mockSpeech.resps[:0], &longrunningpb.Operation{
236		Name:   "longrunning-test",
237		Done:   true,
238		Result: &longrunningpb.Operation_Response{Response: any},
239	})
240
241	var encoding speechpb.RecognitionConfig_AudioEncoding = speechpb.RecognitionConfig_FLAC
242	var sampleRateHertz int32 = 44100
243	var languageCode string = "en-US"
244	var config = &speechpb.RecognitionConfig{
245		Encoding:        encoding,
246		SampleRateHertz: sampleRateHertz,
247		LanguageCode:    languageCode,
248	}
249	var uri string = "gs://bucket_name/file_name.flac"
250	var audio = &speechpb.RecognitionAudio{
251		AudioSource: &speechpb.RecognitionAudio_Uri{
252			Uri: uri,
253		},
254	}
255	var request = &speechpb.LongRunningRecognizeRequest{
256		Config: config,
257		Audio:  audio,
258	}
259
260	c, err := NewClient(context.Background(), clientOpt)
261	if err != nil {
262		t.Fatal(err)
263	}
264
265	respLRO, err := c.LongRunningRecognize(context.Background(), request)
266	if err != nil {
267		t.Fatal(err)
268	}
269	resp, err := respLRO.Wait(context.Background())
270
271	if err != nil {
272		t.Fatal(err)
273	}
274
275	if want, got := request, mockSpeech.reqs[0]; !proto.Equal(want, got) {
276		t.Errorf("wrong request %q, want %q", got, want)
277	}
278
279	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
280		t.Errorf("wrong response %q, want %q)", got, want)
281	}
282}
283
284func TestSpeechLongRunningRecognizeError(t *testing.T) {
285	errCode := codes.PermissionDenied
286	mockSpeech.err = nil
287	mockSpeech.resps = append(mockSpeech.resps[:0], &longrunningpb.Operation{
288		Name: "longrunning-test",
289		Done: true,
290		Result: &longrunningpb.Operation_Error{
291			Error: &status.Status{
292				Code:    int32(errCode),
293				Message: "test error",
294			},
295		},
296	})
297
298	var encoding speechpb.RecognitionConfig_AudioEncoding = speechpb.RecognitionConfig_FLAC
299	var sampleRateHertz int32 = 44100
300	var languageCode string = "en-US"
301	var config = &speechpb.RecognitionConfig{
302		Encoding:        encoding,
303		SampleRateHertz: sampleRateHertz,
304		LanguageCode:    languageCode,
305	}
306	var uri string = "gs://bucket_name/file_name.flac"
307	var audio = &speechpb.RecognitionAudio{
308		AudioSource: &speechpb.RecognitionAudio_Uri{
309			Uri: uri,
310		},
311	}
312	var request = &speechpb.LongRunningRecognizeRequest{
313		Config: config,
314		Audio:  audio,
315	}
316
317	c, err := NewClient(context.Background(), clientOpt)
318	if err != nil {
319		t.Fatal(err)
320	}
321
322	respLRO, err := c.LongRunningRecognize(context.Background(), request)
323	if err != nil {
324		t.Fatal(err)
325	}
326	resp, err := respLRO.Wait(context.Background())
327
328	if st, ok := gstatus.FromError(err); !ok {
329		t.Errorf("got error %v, expected grpc error", err)
330	} else if c := st.Code(); c != errCode {
331		t.Errorf("got error code %q, want %q", c, errCode)
332	}
333	_ = resp
334}
335func TestSpeechStreamingRecognize(t *testing.T) {
336	var expectedResponse *speechpb.StreamingRecognizeResponse = &speechpb.StreamingRecognizeResponse{}
337
338	mockSpeech.err = nil
339	mockSpeech.reqs = nil
340
341	mockSpeech.resps = append(mockSpeech.resps[:0], expectedResponse)
342
343	var request *speechpb.StreamingRecognizeRequest = &speechpb.StreamingRecognizeRequest{}
344
345	c, err := NewClient(context.Background(), clientOpt)
346	if err != nil {
347		t.Fatal(err)
348	}
349
350	stream, err := c.StreamingRecognize(context.Background())
351	if err != nil {
352		t.Fatal(err)
353	}
354	if err := stream.Send(request); err != nil {
355		t.Fatal(err)
356	}
357	if err := stream.CloseSend(); err != nil {
358		t.Fatal(err)
359	}
360	resp, err := stream.Recv()
361
362	if err != nil {
363		t.Fatal(err)
364	}
365
366	if want, got := request, mockSpeech.reqs[0]; !proto.Equal(want, got) {
367		t.Errorf("wrong request %q, want %q", got, want)
368	}
369
370	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
371		t.Errorf("wrong response %q, want %q)", got, want)
372	}
373}
374
375func TestSpeechStreamingRecognizeError(t *testing.T) {
376	errCode := codes.PermissionDenied
377	mockSpeech.err = gstatus.Error(errCode, "test error")
378
379	var request *speechpb.StreamingRecognizeRequest = &speechpb.StreamingRecognizeRequest{}
380
381	c, err := NewClient(context.Background(), clientOpt)
382	if err != nil {
383		t.Fatal(err)
384	}
385
386	stream, err := c.StreamingRecognize(context.Background())
387	if err != nil {
388		t.Fatal(err)
389	}
390	if err := stream.Send(request); err != nil {
391		t.Fatal(err)
392	}
393	if err := stream.CloseSend(); err != nil {
394		t.Fatal(err)
395	}
396	resp, err := stream.Recv()
397
398	if st, ok := gstatus.FromError(err); !ok {
399		t.Errorf("got error %v, expected grpc error", err)
400	} else if c := st.Code(); c != errCode {
401		t.Errorf("got error code %q, want %q", c, errCode)
402	}
403	_ = resp
404}
405