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