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