1 // Copyright 2024 The Abseil Authors
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 // -----------------------------------------------------------------------------
16 // File: status_matchers_test.cc
17 // -----------------------------------------------------------------------------
18 #include "absl/status/status_matchers.h"
19
20 #include <string>
21
22 #include "gmock/gmock.h"
23 #include "gtest/gtest-spi.h"
24 #include "gtest/gtest.h"
25 #include "absl/status/status.h"
26 #include "absl/status/statusor.h"
27 #include "absl/strings/string_view.h"
28
29 namespace {
30
31 using ::absl_testing::IsOk;
32 using ::absl_testing::IsOkAndHolds;
33 using ::absl_testing::StatusIs;
34 using ::testing::Eq;
35 using ::testing::Gt;
36 using ::testing::MatchesRegex;
37
TEST(StatusMatcherTest,StatusIsOk)38 TEST(StatusMatcherTest, StatusIsOk) { EXPECT_THAT(absl::OkStatus(), IsOk()); }
39
TEST(StatusMatcherTest,StatusOrIsOk)40 TEST(StatusMatcherTest, StatusOrIsOk) {
41 absl::StatusOr<int> ok_int = {0};
42 EXPECT_THAT(ok_int, IsOk());
43 }
44
TEST(StatusMatcherTest,StatusIsNotOk)45 TEST(StatusMatcherTest, StatusIsNotOk) {
46 absl::Status error = absl::UnknownError("Smigla");
47 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(error, IsOk()), "Smigla");
48 }
49
TEST(StatusMatcherTest,StatusOrIsNotOk)50 TEST(StatusMatcherTest, StatusOrIsNotOk) {
51 absl::StatusOr<int> error = absl::UnknownError("Smigla");
52 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(error, IsOk()), "Smigla");
53 }
54
TEST(StatusMatcherTest,IsOkAndHolds)55 TEST(StatusMatcherTest, IsOkAndHolds) {
56 absl::StatusOr<int> ok_int = {4};
57 absl::StatusOr<absl::string_view> ok_str = {"text"};
58 EXPECT_THAT(ok_int, IsOkAndHolds(4));
59 EXPECT_THAT(ok_int, IsOkAndHolds(Gt(0)));
60 EXPECT_THAT(ok_str, IsOkAndHolds("text"));
61 }
62
TEST(StatusMatcherTest,IsOkAndHoldsFailure)63 TEST(StatusMatcherTest, IsOkAndHoldsFailure) {
64 absl::StatusOr<int> ok_int = {502};
65 absl::StatusOr<int> error = absl::UnknownError("Smigla");
66 absl::StatusOr<absl::string_view> ok_str = {"actual"};
67 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(ok_int, IsOkAndHolds(0)), "502");
68 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(error, IsOkAndHolds(0)), "Smigla");
69 EXPECT_NONFATAL_FAILURE(EXPECT_THAT(ok_str, IsOkAndHolds("expected")),
70 "actual");
71 }
72
73 template <typename MatcherType, typename Value>
Explain(const MatcherType & m,const Value & x)74 std::string Explain(const MatcherType& m, const Value& x) {
75 ::testing::StringMatchResultListener listener;
76 ExplainMatchResult(m, x, &listener);
77 return listener.str();
78 }
79
TEST(StatusMatcherTest,StatusIs)80 TEST(StatusMatcherTest, StatusIs) {
81 absl::Status unknown = absl::UnknownError("unbekannt");
82 absl::Status invalid = absl::InvalidArgumentError("ungueltig");
83 EXPECT_THAT(absl::OkStatus(), StatusIs(absl::StatusCode::kOk));
84 EXPECT_THAT(absl::OkStatus(), StatusIs(0));
85 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown));
86 EXPECT_THAT(unknown, StatusIs(2));
87 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown, "unbekannt"));
88 EXPECT_THAT(invalid, StatusIs(absl::StatusCode::kInvalidArgument));
89 EXPECT_THAT(invalid, StatusIs(3));
90 EXPECT_THAT(invalid,
91 StatusIs(absl::StatusCode::kInvalidArgument, "ungueltig"));
92
93 auto m = StatusIs(absl::StatusCode::kInternal, "internal error");
94 EXPECT_THAT(
95 ::testing::DescribeMatcher<absl::Status>(m),
96 MatchesRegex(
97 "has a status code that .*, and has an error message that .*"));
98 EXPECT_THAT(
99 ::testing::DescribeMatcher<absl::Status>(m, /*negation=*/true),
100 MatchesRegex(
101 "either has a status code that .*, or has an error message that .*"));
102 EXPECT_THAT(Explain(m, absl::InvalidArgumentError("internal error")),
103 Eq("whose status code is wrong"));
104 EXPECT_THAT(Explain(m, absl::InternalError("unexpected error")),
105 Eq("whose error message is wrong"));
106 }
107
TEST(StatusMatcherTest,StatusOrIs)108 TEST(StatusMatcherTest, StatusOrIs) {
109 absl::StatusOr<int> ok = {42};
110 absl::StatusOr<int> unknown = absl::UnknownError("unbekannt");
111 absl::StatusOr<absl::string_view> invalid =
112 absl::InvalidArgumentError("ungueltig");
113 EXPECT_THAT(ok, StatusIs(absl::StatusCode::kOk));
114 EXPECT_THAT(ok, StatusIs(0));
115 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown));
116 EXPECT_THAT(unknown, StatusIs(2));
117 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown, "unbekannt"));
118 EXPECT_THAT(invalid, StatusIs(absl::StatusCode::kInvalidArgument));
119 EXPECT_THAT(invalid, StatusIs(3));
120 EXPECT_THAT(invalid,
121 StatusIs(absl::StatusCode::kInvalidArgument, "ungueltig"));
122
123 auto m = StatusIs(absl::StatusCode::kInternal, "internal error");
124 EXPECT_THAT(
125 ::testing::DescribeMatcher<absl::StatusOr<int>>(m),
126 MatchesRegex(
127 "has a status code that .*, and has an error message that .*"));
128 EXPECT_THAT(
129 ::testing::DescribeMatcher<absl::StatusOr<int>>(m, /*negation=*/true),
130 MatchesRegex(
131 "either has a status code that .*, or has an error message that .*"));
132 EXPECT_THAT(Explain(m, absl::StatusOr<int>(57)), Eq("which is OK"));
133 EXPECT_THAT(Explain(m, absl::StatusOr<int>(
134 absl::InvalidArgumentError("internal error"))),
135 Eq("whose status code is wrong"));
136 EXPECT_THAT(
137 Explain(m, absl::StatusOr<int>(absl::InternalError("unexpected error"))),
138 Eq("whose error message is wrong"));
139 }
140
TEST(StatusMatcherTest,StatusIsFailure)141 TEST(StatusMatcherTest, StatusIsFailure) {
142 absl::Status unknown = absl::UnknownError("unbekannt");
143 absl::Status invalid = absl::InvalidArgumentError("ungueltig");
144 EXPECT_NONFATAL_FAILURE(
145 EXPECT_THAT(absl::OkStatus(),
146 StatusIs(absl::StatusCode::kInvalidArgument)),
147 "OK");
148 EXPECT_NONFATAL_FAILURE(
149 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kCancelled)), "UNKNOWN");
150 EXPECT_NONFATAL_FAILURE(
151 EXPECT_THAT(unknown, StatusIs(absl::StatusCode::kUnknown, "inconnu")),
152 "unbekannt");
153 EXPECT_NONFATAL_FAILURE(
154 EXPECT_THAT(invalid, StatusIs(absl::StatusCode::kOutOfRange)), "INVALID");
155 EXPECT_NONFATAL_FAILURE(
156 EXPECT_THAT(invalid,
157 StatusIs(absl::StatusCode::kInvalidArgument, "invalide")),
158 "ungueltig");
159 }
160
161 } // namespace
162