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