• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.speech.v1;
18 
19 import com.google.api.gax.core.NoCredentialsProvider;
20 import com.google.api.gax.grpc.GaxGrpcProperties;
21 import com.google.api.gax.grpc.testing.LocalChannelProvider;
22 import com.google.api.gax.grpc.testing.MockGrpcService;
23 import com.google.api.gax.grpc.testing.MockServiceHelper;
24 import com.google.api.gax.grpc.testing.MockStreamObserver;
25 import com.google.api.gax.rpc.ApiClientHeaderProvider;
26 import com.google.api.gax.rpc.ApiStreamObserver;
27 import com.google.api.gax.rpc.BidiStreamingCallable;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Any;
33 import com.google.protobuf.Duration;
34 import com.google.rpc.Status;
35 import io.grpc.StatusRuntimeException;
36 import java.io.IOException;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.List;
40 import java.util.UUID;
41 import java.util.concurrent.ExecutionException;
42 import javax.annotation.Generated;
43 import org.junit.After;
44 import org.junit.AfterClass;
45 import org.junit.Assert;
46 import org.junit.Before;
47 import org.junit.BeforeClass;
48 import org.junit.Test;
49 
50 @Generated("by gapic-generator-java")
51 public class SpeechClientTest {
52   private static MockServiceHelper mockServiceHelper;
53   private static MockSpeech mockSpeech;
54   private LocalChannelProvider channelProvider;
55   private SpeechClient client;
56 
57   @BeforeClass
startStaticServer()58   public static void startStaticServer() {
59     mockSpeech = new MockSpeech();
60     mockServiceHelper =
61         new MockServiceHelper(
62             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockSpeech));
63     mockServiceHelper.start();
64   }
65 
66   @AfterClass
stopServer()67   public static void stopServer() {
68     mockServiceHelper.stop();
69   }
70 
71   @Before
setUp()72   public void setUp() throws IOException {
73     mockServiceHelper.reset();
74     channelProvider = mockServiceHelper.createChannelProvider();
75     SpeechSettings settings =
76         SpeechSettings.newBuilder()
77             .setTransportChannelProvider(channelProvider)
78             .setCredentialsProvider(NoCredentialsProvider.create())
79             .build();
80     client = SpeechClient.create(settings);
81   }
82 
83   @After
tearDown()84   public void tearDown() throws Exception {
85     client.close();
86   }
87 
88   @Test
recognizeTest()89   public void recognizeTest() throws Exception {
90     RecognizeResponse expectedResponse =
91         RecognizeResponse.newBuilder()
92             .addAllResults(new ArrayList<SpeechRecognitionResult>())
93             .setTotalBilledTime(Duration.newBuilder().build())
94             .setSpeechAdaptationInfo(SpeechAdaptationInfo.newBuilder().build())
95             .setRequestId(37109963)
96             .build();
97     mockSpeech.addResponse(expectedResponse);
98 
99     RecognitionConfig config = RecognitionConfig.newBuilder().build();
100     RecognitionAudio audio = RecognitionAudio.newBuilder().build();
101 
102     RecognizeResponse actualResponse = client.recognize(config, audio);
103     Assert.assertEquals(expectedResponse, actualResponse);
104 
105     List<AbstractMessage> actualRequests = mockSpeech.getRequests();
106     Assert.assertEquals(1, actualRequests.size());
107     RecognizeRequest actualRequest = ((RecognizeRequest) actualRequests.get(0));
108 
109     Assert.assertEquals(config, actualRequest.getConfig());
110     Assert.assertEquals(audio, actualRequest.getAudio());
111     Assert.assertTrue(
112         channelProvider.isHeaderSent(
113             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
114             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
115   }
116 
117   @Test
recognizeExceptionTest()118   public void recognizeExceptionTest() throws Exception {
119     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
120     mockSpeech.addException(exception);
121 
122     try {
123       RecognitionConfig config = RecognitionConfig.newBuilder().build();
124       RecognitionAudio audio = RecognitionAudio.newBuilder().build();
125       client.recognize(config, audio);
126       Assert.fail("No exception raised");
127     } catch (InvalidArgumentException e) {
128       // Expected exception.
129     }
130   }
131 
132   @Test
longRunningRecognizeTest()133   public void longRunningRecognizeTest() throws Exception {
134     LongRunningRecognizeResponse expectedResponse =
135         LongRunningRecognizeResponse.newBuilder()
136             .addAllResults(new ArrayList<SpeechRecognitionResult>())
137             .setTotalBilledTime(Duration.newBuilder().build())
138             .setOutputConfig(TranscriptOutputConfig.newBuilder().build())
139             .setOutputError(Status.newBuilder().build())
140             .setSpeechAdaptationInfo(SpeechAdaptationInfo.newBuilder().build())
141             .setRequestId(37109963)
142             .build();
143     Operation resultOperation =
144         Operation.newBuilder()
145             .setName("longRunningRecognizeTest")
146             .setDone(true)
147             .setResponse(Any.pack(expectedResponse))
148             .build();
149     mockSpeech.addResponse(resultOperation);
150 
151     RecognitionConfig config = RecognitionConfig.newBuilder().build();
152     RecognitionAudio audio = RecognitionAudio.newBuilder().build();
153 
154     LongRunningRecognizeResponse actualResponse =
155         client.longRunningRecognizeAsync(config, audio).get();
156     Assert.assertEquals(expectedResponse, actualResponse);
157 
158     List<AbstractMessage> actualRequests = mockSpeech.getRequests();
159     Assert.assertEquals(1, actualRequests.size());
160     LongRunningRecognizeRequest actualRequest =
161         ((LongRunningRecognizeRequest) actualRequests.get(0));
162 
163     Assert.assertEquals(config, actualRequest.getConfig());
164     Assert.assertEquals(audio, actualRequest.getAudio());
165     Assert.assertTrue(
166         channelProvider.isHeaderSent(
167             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
168             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
169   }
170 
171   @Test
longRunningRecognizeExceptionTest()172   public void longRunningRecognizeExceptionTest() throws Exception {
173     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
174     mockSpeech.addException(exception);
175 
176     try {
177       RecognitionConfig config = RecognitionConfig.newBuilder().build();
178       RecognitionAudio audio = RecognitionAudio.newBuilder().build();
179       client.longRunningRecognizeAsync(config, audio).get();
180       Assert.fail("No exception raised");
181     } catch (ExecutionException e) {
182       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
183       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
184       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
185     }
186   }
187 
188   @Test
streamingRecognizeTest()189   public void streamingRecognizeTest() throws Exception {
190     StreamingRecognizeResponse expectedResponse =
191         StreamingRecognizeResponse.newBuilder()
192             .setError(Status.newBuilder().build())
193             .addAllResults(new ArrayList<StreamingRecognitionResult>())
194             .setSpeechEventTime(Duration.newBuilder().build())
195             .setTotalBilledTime(Duration.newBuilder().build())
196             .setSpeechAdaptationInfo(SpeechAdaptationInfo.newBuilder().build())
197             .setRequestId(37109963)
198             .build();
199     mockSpeech.addResponse(expectedResponse);
200     StreamingRecognizeRequest request = StreamingRecognizeRequest.newBuilder().build();
201 
202     MockStreamObserver<StreamingRecognizeResponse> responseObserver = new MockStreamObserver<>();
203 
204     BidiStreamingCallable<StreamingRecognizeRequest, StreamingRecognizeResponse> callable =
205         client.streamingRecognizeCallable();
206     ApiStreamObserver<StreamingRecognizeRequest> requestObserver =
207         callable.bidiStreamingCall(responseObserver);
208 
209     requestObserver.onNext(request);
210     requestObserver.onCompleted();
211 
212     List<StreamingRecognizeResponse> actualResponses = responseObserver.future().get();
213     Assert.assertEquals(1, actualResponses.size());
214     Assert.assertEquals(expectedResponse, actualResponses.get(0));
215   }
216 
217   @Test
streamingRecognizeExceptionTest()218   public void streamingRecognizeExceptionTest() throws Exception {
219     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
220     mockSpeech.addException(exception);
221     StreamingRecognizeRequest request = StreamingRecognizeRequest.newBuilder().build();
222 
223     MockStreamObserver<StreamingRecognizeResponse> responseObserver = new MockStreamObserver<>();
224 
225     BidiStreamingCallable<StreamingRecognizeRequest, StreamingRecognizeResponse> callable =
226         client.streamingRecognizeCallable();
227     ApiStreamObserver<StreamingRecognizeRequest> requestObserver =
228         callable.bidiStreamingCall(responseObserver);
229 
230     requestObserver.onNext(request);
231 
232     try {
233       List<StreamingRecognizeResponse> actualResponses = responseObserver.future().get();
234       Assert.fail("No exception thrown");
235     } catch (ExecutionException e) {
236       Assert.assertTrue(e.getCause() instanceof InvalidArgumentException);
237       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
238       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
239     }
240   }
241 }
242