Skip to content

Commit ce4b994

Browse files
tensorflower-gardenertensorflow-copybara
tensorflower-gardener
authored and
tensorflow-copybara
committed
Automated Code Change
PiperOrigin-RevId: 781484465
1 parent 7491ad5 commit ce4b994

File tree

4 files changed

+50
-50
lines changed

4 files changed

+50
-50
lines changed

‎tensorflow_serving/model_servers/http_rest_api_handler_test.cc‎

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -182,78 +182,78 @@ TEST_F(HttpRestApiHandlerTest, UnsupportedApiCalls) {
182182
absl::Status status;
183183
status = handler_.ProcessRequest("GET", "/v1/foo", "", &headers, &model_name,
184184
&method, &output);
185-
EXPECT_TRUE(errors::IsInvalidArgument(status));
185+
EXPECT_TRUE(absl::IsInvalidArgument(status));
186186
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
187187

188188
status = handler_.ProcessRequest("POST", "/v1/foo", "", &headers, &model_name,
189189
&method, &output);
190-
EXPECT_TRUE(errors::IsInvalidArgument(status));
190+
EXPECT_TRUE(absl::IsInvalidArgument(status));
191191
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
192192

193193
status = handler_.ProcessRequest("GET", "/v1/models", "", &headers,
194194
&model_name, &method, &output);
195-
EXPECT_TRUE(errors::IsInvalidArgument(status));
195+
EXPECT_TRUE(absl::IsInvalidArgument(status));
196196
EXPECT_THAT(status.message(), HasSubstr("Missing model name"));
197197
status = handler_.ProcessRequest("GET", "/v1/models/debug/model_name", "",
198198
&headers, &model_name, &method, &output);
199-
EXPECT_TRUE(errors::IsInvalidArgument(status));
199+
EXPECT_TRUE(absl::IsInvalidArgument(status));
200200
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
201201

202202
status = handler_.ProcessRequest("POST", "/v1/models", "", &headers,
203203
&model_name, &method, &output);
204-
EXPECT_TRUE(errors::IsInvalidArgument(status));
204+
EXPECT_TRUE(absl::IsInvalidArgument(status));
205205
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
206206

207207
status = handler_.ProcessRequest("GET", "/v1/models/foo:predict", "",
208208
&headers, &model_name, &method, &output);
209-
EXPECT_TRUE(errors::IsInvalidArgument(status));
209+
EXPECT_TRUE(absl::IsInvalidArgument(status));
210210
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
211211

212212
status = handler_.ProcessRequest("GET", "/v1/models/foo/version/50:predict",
213213
"", &headers, &model_name, &method, &output);
214-
EXPECT_TRUE(errors::IsInvalidArgument(status));
214+
EXPECT_TRUE(absl::IsInvalidArgument(status));
215215
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
216216

217217
status = handler_.ProcessRequest("POST", "/v1/models/foo/version/50:regress",
218218
"", &headers, &model_name, &method, &output);
219-
EXPECT_TRUE(errors::IsInvalidArgument(status));
219+
EXPECT_TRUE(absl::IsInvalidArgument(status));
220220
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
221221

222222
status =
223223
handler_.ProcessRequest("POST", "/v1/models/foo/versions/HELLO:regress",
224224
"", &headers, &model_name, &method, &output);
225-
EXPECT_TRUE(errors::IsInvalidArgument(status));
225+
EXPECT_TRUE(absl::IsInvalidArgument(status));
226226
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
227227

228228
status = handler_.ProcessRequest(
229229
"POST",
230230
absl::StrCat("/v1/models/foo/versions/",
231231
std::numeric_limits<uint64_t>::max(), ":regress"),
232232
"", &headers, &model_name, &method, &output);
233-
EXPECT_TRUE(errors::IsInvalidArgument(status));
233+
EXPECT_TRUE(absl::IsInvalidArgument(status));
234234
EXPECT_THAT(status.message(), HasSubstr("Failed to convert version"));
235235

236236
status = handler_.ProcessRequest("POST", "/v1/models/foo/metadata", "",
237237
&headers, &model_name, &method, &output);
238-
EXPECT_TRUE(errors::IsInvalidArgument(status));
238+
EXPECT_TRUE(absl::IsInvalidArgument(status));
239239
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
240240

241241
status =
242242
handler_.ProcessRequest("POST", "/v1/models/foo/label/some_label:regress",
243243
"", &headers, &model_name, &method, &output);
244-
EXPECT_TRUE(errors::IsInvalidArgument(status));
244+
EXPECT_TRUE(absl::IsInvalidArgument(status));
245245
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
246246

247247
status = handler_.ProcessRequest(
248248
"POST", "/v1/models/foo/versions/50/labels/some_label:regress", "",
249249
&headers, &model_name, &method, &output);
250-
EXPECT_TRUE(errors::IsInvalidArgument(status));
250+
EXPECT_TRUE(absl::IsInvalidArgument(status));
251251
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
252252

253253
status = handler_.ProcessRequest("POST",
254254
"/v1/models/foo/versions/some_label:regress",
255255
"", &headers, &model_name, &method, &output);
256-
EXPECT_TRUE(errors::IsInvalidArgument(status));
256+
EXPECT_TRUE(absl::IsInvalidArgument(status));
257257
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
258258
}
259259

@@ -265,19 +265,19 @@ TEST_F(HttpRestApiHandlerTest, PredictModelNameVersionErrors) {
265265
status = handler_.ProcessRequest("POST", "/v1/models/foo:predict",
266266
R"({ "instances": [1] })", &headers,
267267
&model_name, &method, &output);
268-
EXPECT_TRUE(errors::IsNotFound(status));
268+
EXPECT_TRUE(absl::IsNotFound(status));
269269

270270
// 'foo' is not a valid model name.
271271
status = handler_.ProcessRequest("POST", "/v1/models/foo/versions/50:predict",
272272
R"({ "instances": [1] })", &headers,
273273
&model_name, &method, &output);
274-
EXPECT_TRUE(errors::IsNotFound(status));
274+
EXPECT_TRUE(absl::IsNotFound(status));
275275

276276
// Valid model name, but invalid version number (99).
277277
status = handler_.ProcessRequest(
278278
"POST", absl::StrCat("/v1/models/", kTestModelName, "99:predict"),
279279
R"({ "instances": [1] })", &headers, &model_name, &method, &output);
280-
EXPECT_TRUE(errors::IsNotFound(status));
280+
EXPECT_TRUE(absl::IsNotFound(status));
281281
}
282282

283283
TEST_F(HttpRestApiHandlerTest, PredictRequestErrors) {
@@ -290,21 +290,21 @@ TEST_F(HttpRestApiHandlerTest, PredictRequestErrors) {
290290
// Empty document.
291291
status = handler_.ProcessRequest("POST", req_path, "", &headers, &model_name,
292292
&method, &output);
293-
EXPECT_TRUE(errors::IsInvalidArgument(status));
293+
EXPECT_TRUE(absl::IsInvalidArgument(status));
294294
EXPECT_THAT(status.message(),
295295
HasSubstr("JSON Parse error: The document is empty"));
296296

297297
// Badly formatted JSON.
298298
status = handler_.ProcessRequest("POST", req_path, "instances = [1, 2]",
299299
&headers, &model_name, &method, &output);
300-
EXPECT_TRUE(errors::IsInvalidArgument(status));
300+
EXPECT_TRUE(absl::IsInvalidArgument(status));
301301
EXPECT_THAT(status.message(), HasSubstr("JSON Parse error: Invalid value"));
302302

303303
// Incorrect type.
304304
status = handler_.ProcessRequest("POST", req_path,
305305
R"({ "instances": ["x", "y"] })", &headers,
306306
&model_name, &method, &output);
307-
EXPECT_TRUE(errors::IsInvalidArgument(status));
307+
EXPECT_TRUE(absl::IsInvalidArgument(status));
308308
EXPECT_THAT(status.message(), HasSubstr("not of expected type: float"));
309309

310310
// Nonexistent version label.
@@ -314,15 +314,15 @@ TEST_F(HttpRestApiHandlerTest, PredictRequestErrors) {
314314
kNonexistentModelVersionLabel, ":predict"),
315315
R"({ "instances": ["x", "y"] })", &headers, &model_name, &method,
316316
&output);
317-
EXPECT_TRUE(errors::IsInvalidArgument(status));
317+
EXPECT_TRUE(absl::IsInvalidArgument(status));
318318
EXPECT_THAT(status.message(),
319319
HasSubstr("Unrecognized servable version label"));
320320

321321
// Incorrect signature_name type.
322322
status =
323323
handler_.ProcessRequest("POST", req_path, R"({ "signature_name": 100 })",
324324
&headers, &model_name, &method, &output);
325-
EXPECT_TRUE(errors::IsInvalidArgument(status));
325+
EXPECT_TRUE(absl::IsInvalidArgument(status));
326326
EXPECT_THAT(GetJsonErrorMsg(output),
327327
HasSubstr("'signature_name' key must be a string value."));
328328
}

‎tensorflow_serving/model_servers/http_rest_api_util_test.cc‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -209,7 +209,7 @@ TEST_F(HttpRestApiUtilTest, TestParseModelInfoForPost) {
209209
&model_name, &model_version, &model_version_label, &method,
210210
&model_subresource, &parse_successful);
211211
EXPECT_TRUE(parse_successful);
212-
EXPECT_TRUE(errors::IsInvalidArgument(status));
212+
EXPECT_TRUE(absl::IsInvalidArgument(status));
213213
EXPECT_THAT(status.message(), HasSubstr("Failed to convert version"));
214214
TF_EXPECT_OK(ParseModelInfo("POST", "/v1/models/foo/metadata", &model_name,
215215
&model_version, &model_version_label, &method,

‎tensorflow_serving/model_servers/http_server.cc‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@ namespace serving {
4343

4444
namespace {
4545

46-
net_http::HTTPStatusCode ToHTTPStatusCode(const Status& status) {
46+
net_http::HTTPStatusCode ToHTTPStatusCode(const absl::Status& status) {
4747
using error::Code;
4848
using net_http::HTTPStatusCode;
4949
switch (static_cast<absl::StatusCode>(status.code())) {
@@ -91,14 +91,14 @@ void ProcessPrometheusRequest(PrometheusExporter* exporter, const string& path,
9191
std::vector<std::pair<string, string>> headers;
9292
headers.push_back({"Content-Type", "text/plain"});
9393
string output;
94-
Status status;
94+
absl::Status status;
9595
// Check if url matches the path.
9696
if (req->uri_path() != path) {
9797
output = absl::StrFormat("Unexpected path: %s. Should be %s",
9898
req->uri_path(), path);
99-
status = Status(static_cast<tensorflow::errors::Code>(
100-
absl::StatusCode::kInvalidArgument),
101-
output);
99+
status = absl::Status(
100+
static_cast<absl::StatusCode>(absl::StatusCode::kInvalidArgument),
101+
output);
102102
} else {
103103
status = exporter->GeneratePage(&output);
104104
}
@@ -166,7 +166,7 @@ class RestApiRequestDispatcher {
166166
VLOG(1) << "Processing HTTP request: " << req->http_method() << " "
167167
<< req->uri_path() << " body: " << body.size() << " bytes.";
168168

169-
Status status;
169+
absl::Status status;
170170
if (req->http_method() == "OPTIONS") {
171171
absl::string_view origin_header = req->GetRequestHeader("Origin");
172172
if (RE2::PartialMatch(origin_header, "https?://")) {

‎tensorflow_serving/model_servers/tfrt_http_rest_api_handler_test.cc‎

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -191,74 +191,74 @@ TEST_F(TFRTHttpRestApiHandlerTest, UnsupportedApiCalls) {
191191
absl::Status status;
192192
status = handler_.ProcessRequest("GET", "/v1/foo", "", &headers, &model_name,
193193
&method, &output);
194-
EXPECT_TRUE(errors::IsInvalidArgument(status));
194+
EXPECT_TRUE(absl::IsInvalidArgument(status));
195195
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
196196

197197
status = handler_.ProcessRequest("POST", "/v1/foo", "", &headers, &model_name,
198198
&method, &output);
199-
EXPECT_TRUE(errors::IsInvalidArgument(status));
199+
EXPECT_TRUE(absl::IsInvalidArgument(status));
200200
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
201201

202202
status = handler_.ProcessRequest("GET", "/v1/models", "", &headers,
203203
&model_name, &method, &output);
204-
EXPECT_TRUE(errors::IsInvalidArgument(status));
204+
EXPECT_TRUE(absl::IsInvalidArgument(status));
205205
EXPECT_THAT(status.message(), HasSubstr("Missing model name"));
206206

207207
status = handler_.ProcessRequest("POST", "/v1/models", "", &headers,
208208
&model_name, &method, &output);
209-
EXPECT_TRUE(errors::IsInvalidArgument(status));
209+
EXPECT_TRUE(absl::IsInvalidArgument(status));
210210
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
211211

212212
status = handler_.ProcessRequest("GET", "/v1/models/foo:predict", "",
213213
&headers, &model_name, &method, &output);
214-
EXPECT_TRUE(errors::IsInvalidArgument(status));
214+
EXPECT_TRUE(absl::IsInvalidArgument(status));
215215
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
216216

217217
status = handler_.ProcessRequest("GET", "/v1/models/foo/version/50:predict",
218218
"", &headers, &model_name, &method, &output);
219-
EXPECT_TRUE(errors::IsInvalidArgument(status));
219+
EXPECT_TRUE(absl::IsInvalidArgument(status));
220220
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
221221

222222
status = handler_.ProcessRequest("POST", "/v1/models/foo/version/50:regress",
223223
"", &headers, &model_name, &method, &output);
224-
EXPECT_TRUE(errors::IsInvalidArgument(status));
224+
EXPECT_TRUE(absl::IsInvalidArgument(status));
225225
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
226226

227227
status =
228228
handler_.ProcessRequest("POST", "/v1/models/foo/versions/HELLO:regress",
229229
"", &headers, &model_name, &method, &output);
230-
EXPECT_TRUE(errors::IsInvalidArgument(status));
230+
EXPECT_TRUE(absl::IsInvalidArgument(status));
231231
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
232232

233233
status = handler_.ProcessRequest(
234234
"POST",
235235
absl::StrCat("/v1/models/foo/versions/",
236236
std::numeric_limits<uint64_t>::max(), ":regress"),
237237
"", &headers, &model_name, &method, &output);
238-
EXPECT_TRUE(errors::IsInvalidArgument(status));
238+
EXPECT_TRUE(absl::IsInvalidArgument(status));
239239
EXPECT_THAT(status.message(), HasSubstr("Failed to convert version"));
240240

241241
status = handler_.ProcessRequest("POST", "/v1/models/foo/metadata", "",
242242
&headers, &model_name, &method, &output);
243-
EXPECT_TRUE(errors::IsInvalidArgument(status));
243+
EXPECT_TRUE(absl::IsInvalidArgument(status));
244244
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
245245

246246
status =
247247
handler_.ProcessRequest("POST", "/v1/models/foo/label/some_label:regress",
248248
"", &headers, &model_name, &method, &output);
249-
EXPECT_TRUE(errors::IsInvalidArgument(status));
249+
EXPECT_TRUE(absl::IsInvalidArgument(status));
250250
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
251251

252252
status = handler_.ProcessRequest(
253253
"POST", "/v1/models/foo/versions/50/labels/some_label:regress", "",
254254
&headers, &model_name, &method, &output);
255-
EXPECT_TRUE(errors::IsInvalidArgument(status));
255+
EXPECT_TRUE(absl::IsInvalidArgument(status));
256256
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
257257

258258
status = handler_.ProcessRequest("POST",
259259
"/v1/models/foo/versions/some_label:regress",
260260
"", &headers, &model_name, &method, &output);
261-
EXPECT_TRUE(errors::IsInvalidArgument(status));
261+
EXPECT_TRUE(absl::IsInvalidArgument(status));
262262
EXPECT_THAT(status.message(), HasSubstr("Malformed request"));
263263
}
264264

@@ -270,19 +270,19 @@ TEST_F(TFRTHttpRestApiHandlerTest, PredictModelNameVersionErrors) {
270270
status = handler_.ProcessRequest("POST", "/v1/models/foo:predict",
271271
R"({ "instances": [1] })", &headers,
272272
&model_name, &method, &output);
273-
EXPECT_TRUE(errors::IsNotFound(status));
273+
EXPECT_TRUE(absl::IsNotFound(status));
274274

275275
// 'foo' is not a valid model name.
276276
status = handler_.ProcessRequest("POST", "/v1/models/foo/versions/50:predict",
277277
R"({ "instances": [1] })", &headers,
278278
&model_name, &method, &output);
279-
EXPECT_TRUE(errors::IsNotFound(status));
279+
EXPECT_TRUE(absl::IsNotFound(status));
280280

281281
// Valid model name, but invalid version number (99).
282282
status = handler_.ProcessRequest(
283283
"POST", absl::StrCat("/v1/models/", kTestModelName, "99:predict"),
284284
R"({ "instances": [1] })", &headers, &model_name, &method, &output);
285-
EXPECT_TRUE(errors::IsNotFound(status));
285+
EXPECT_TRUE(absl::IsNotFound(status));
286286
}
287287

288288
TEST_F(TFRTHttpRestApiHandlerTest, PredictRequestErrors) {
@@ -295,21 +295,21 @@ TEST_F(TFRTHttpRestApiHandlerTest, PredictRequestErrors) {
295295
// Empty document.
296296
status = handler_.ProcessRequest("POST", req_path, "", &headers, &model_name,
297297
&method, &output);
298-
EXPECT_TRUE(errors::IsInvalidArgument(status));
298+
EXPECT_TRUE(absl::IsInvalidArgument(status));
299299
EXPECT_THAT(status.message(),
300300
HasSubstr("JSON Parse error: The document is empty"));
301301

302302
// Badly formatted JSON.
303303
status = handler_.ProcessRequest("POST", req_path, "instances = [1, 2]",
304304
&headers, &model_name, &method, &output);
305-
EXPECT_TRUE(errors::IsInvalidArgument(status));
305+
EXPECT_TRUE(absl::IsInvalidArgument(status));
306306
EXPECT_THAT(status.message(), HasSubstr("JSON Parse error: Invalid value"));
307307

308308
// Incorrect type.
309309
status = handler_.ProcessRequest("POST", req_path,
310310
R"({ "instances": ["x", "y"] })", &headers,
311311
&model_name, &method, &output);
312-
EXPECT_TRUE(errors::IsInvalidArgument(status));
312+
EXPECT_TRUE(absl::IsInvalidArgument(status));
313313
EXPECT_THAT(status.message(), HasSubstr("not of expected type: float"));
314314

315315
// Nonexistent version label.
@@ -319,15 +319,15 @@ TEST_F(TFRTHttpRestApiHandlerTest, PredictRequestErrors) {
319319
kNonexistentModelVersionLabel, ":predict"),
320320
R"({ "instances": ["x", "y"] })", &headers, &model_name, &method,
321321
&output);
322-
EXPECT_TRUE(errors::IsInvalidArgument(status));
322+
EXPECT_TRUE(absl::IsInvalidArgument(status));
323323
EXPECT_THAT(status.message(),
324324
HasSubstr("Unrecognized servable version label"));
325325

326326
// Incorrect signature_name type.
327327
status =
328328
handler_.ProcessRequest("POST", req_path, R"({ "signature_name": 100 })",
329329
&headers, &model_name, &method, &output);
330-
EXPECT_TRUE(errors::IsInvalidArgument(status));
330+
EXPECT_TRUE(absl::IsInvalidArgument(status));
331331
EXPECT_THAT(GetJsonErrorMsg(output),
332332
HasSubstr("'signature_name' key must be a string value."));
333333
}

0 commit comments

Comments
 (0)