xref: /openbmc/bmcweb/test/http/utility_test.cpp (revision ed76121b) 
1 #include "bmcweb_config.h"
2 
3 #include "utility.hpp"
4 
5 #include <boost/url/error.hpp>
6 #include <boost/url/url.hpp>
7 #include <boost/url/url_view.hpp>
8 #include <nlohmann/json.hpp>
9 
10 #include <cstdint>
11 #include <ctime>
12 #include <functional>
13 #include <limits>
14 #include <string>
15 #include <string_view>
16 
17 #include <gtest/gtest.h> // IWYU pragma: keep
18 // IWYU pragma: no_include <gtest/gtest-message.h>
19 // IWYU pragma: no_include <gtest/gtest-test-part.h>
20 // IWYU pragma: no_include "gtest/gtest_pred_impl.h"
21 
22 namespace crow::utility
23 {
24 namespace
25 {
26 
27 using ::crow::black_magic::getParameterTag;
28 
29 TEST(Utility, Base64DecodeAuthString)
30 {
31     std::string authString("dXNlcm40bWU6cGFzc3cwcmQ=");
32     std::string result;
33     EXPECT_TRUE(base64Decode(authString, result));
34     EXPECT_EQ(result, "usern4me:passw0rd");
35 }
36 
37 TEST(Utility, Base64DecodeNonAscii)
38 {
39     std::string junkString("\xff\xee\xdd\xcc\x01\x11\x22\x33");
40     std::string result;
41     EXPECT_FALSE(base64Decode(junkString, result));
42 }
43 
44 TEST(Utility, Base64EncodeString)
45 {
46     using namespace std::string_literals;
47     std::string encoded;
48 
49     encoded = base64encode("");
50     EXPECT_EQ(encoded, "");
51 
52     encoded = base64encode("f");
53     EXPECT_EQ(encoded, "Zg==");
54 
55     encoded = base64encode("f0");
56     EXPECT_EQ(encoded, "ZjA=");
57 
58     encoded = base64encode("f0\0"s);
59     EXPECT_EQ(encoded, "ZjAA");
60 
61     encoded = base64encode("f0\0 "s);
62     EXPECT_EQ(encoded, "ZjAAIA==");
63 
64     encoded = base64encode("f0\0 B"s);
65     EXPECT_EQ(encoded, "ZjAAIEI=");
66 
67     encoded = base64encode("f0\0 Ba"s);
68     EXPECT_EQ(encoded, "ZjAAIEJh");
69 
70     encoded = base64encode("f0\0 Bar"s);
71     EXPECT_EQ(encoded, "ZjAAIEJhcg==");
72 }
73 
74 TEST(Utility, Base64EncodeDecodeString)
75 {
76     using namespace std::string_literals;
77     std::string data("Data fr\0m 90 reading a \nFile"s);
78     std::string encoded = base64encode(data);
79     std::string decoded;
80     EXPECT_TRUE(base64Decode(encoded, decoded));
81     EXPECT_EQ(data, decoded);
82 }
83 
84 TEST(Utility, UrlFromPieces)
85 {
86     boost::urls::url url = urlFromPieces("redfish", "v1", "foo");
87     EXPECT_EQ(std::string_view(url.data(), url.size()), "/redfish/v1/foo");
88 
89     url = urlFromPieces("/", "badString");
90     EXPECT_EQ(std::string_view(url.data(), url.size()), "/%2f/badString");
91 
92     url = urlFromPieces("bad?tring");
93     EXPECT_EQ(std::string_view(url.data(), url.size()), "/bad%3ftring");
94 
95     url = urlFromPieces("/", "bad&tring");
96     EXPECT_EQ(std::string_view(url.data(), url.size()), "/%2f/bad&tring");
97 }
98 
99 TEST(Utility, readUrlSegments)
100 {
101     boost::urls::result<boost::urls::url_view> parsed =
102         boost::urls::parse_relative_ref("/redfish/v1/Chassis#/Fans/0/Reading");
103 
104     EXPECT_TRUE(readUrlSegments(*parsed, "redfish", "v1", "Chassis"));
105 
106     EXPECT_FALSE(readUrlSegments(*parsed, "FOOBAR", "v1", "Chassis"));
107 
108     EXPECT_FALSE(readUrlSegments(*parsed, "redfish", "v1"));
109 
110     EXPECT_FALSE(
111         readUrlSegments(*parsed, "redfish", "v1", "Chassis", "FOOBAR"));
112 
113     std::string out1;
114     std::string out2;
115     std::string out3;
116     EXPECT_TRUE(readUrlSegments(*parsed, "redfish", "v1", std::ref(out1)));
117     EXPECT_EQ(out1, "Chassis");
118 
119     out1 = out2 = out3 = "";
120     EXPECT_TRUE(readUrlSegments(*parsed, std::ref(out1), std::ref(out2),
121                                 std::ref(out3)));
122     EXPECT_EQ(out1, "redfish");
123     EXPECT_EQ(out2, "v1");
124     EXPECT_EQ(out3, "Chassis");
125 
126     out1 = out2 = out3 = "";
127     EXPECT_TRUE(readUrlSegments(*parsed, "redfish", std::ref(out1), "Chassis"));
128     EXPECT_EQ(out1, "v1");
129 
130     out1 = out2 = out3 = "";
131     EXPECT_TRUE(readUrlSegments(*parsed, std::ref(out1), "v1", std::ref(out2)));
132     EXPECT_EQ(out1, "redfish");
133     EXPECT_EQ(out2, "Chassis");
134 
135     EXPECT_FALSE(readUrlSegments(*parsed, "too", "short"));
136 
137     EXPECT_FALSE(readUrlSegments(*parsed, "too", "long", "too", "long"));
138 
139     EXPECT_FALSE(
140         readUrlSegments(*parsed, std::ref(out1), "v2", std::ref(out2)));
141 
142     EXPECT_FALSE(readUrlSegments(*parsed, "redfish", std::ref(out1),
143                                  std::ref(out2), std::ref(out3)));
144 
145     parsed = boost::urls::parse_relative_ref("/absolute/url");
146     EXPECT_TRUE(readUrlSegments(*parsed, "absolute", "url"));
147 
148     parsed = boost::urls::parse_relative_ref("not/absolute/url");
149     EXPECT_FALSE(readUrlSegments(*parsed, "not", "absolute", "url"));
150 
151     parsed = boost::urls::parse_relative_ref("/excellent/path");
152 
153     EXPECT_TRUE(readUrlSegments(*parsed, "excellent", "path", OrMorePaths()));
154     EXPECT_TRUE(readUrlSegments(*parsed, "excellent", OrMorePaths()));
155     EXPECT_TRUE(readUrlSegments(*parsed, OrMorePaths()));
156 }
157 
158 TEST(Utility, ValidateAndSplitUrlPositive)
159 {
160     std::string host;
161     std::string urlProto;
162     uint16_t port = 0;
163     std::string path;
164     ASSERT_TRUE(validateAndSplitUrl("https://foo.com:18080/bar", urlProto, host,
165                                     port, path));
166     EXPECT_EQ(host, "foo.com");
167     EXPECT_EQ(urlProto, "https");
168     EXPECT_EQ(port, 18080);
169 
170     EXPECT_EQ(path, "/bar");
171 
172     // query string
173     ASSERT_TRUE(validateAndSplitUrl("https://foo.com:18080/bar?foobar=1",
174                                     urlProto, host, port, path));
175     EXPECT_EQ(path, "/bar?foobar=1");
176 
177     // fragment
178     ASSERT_TRUE(validateAndSplitUrl("https://foo.com:18080/bar#frag", urlProto,
179                                     host, port, path));
180     EXPECT_EQ(path, "/bar#frag");
181 
182     // Missing port
183     ASSERT_TRUE(
184         validateAndSplitUrl("https://foo.com/bar", urlProto, host, port, path));
185     EXPECT_EQ(port, 443);
186 
187     // Missing path defaults to "/"
188     ASSERT_TRUE(
189         validateAndSplitUrl("https://foo.com/", urlProto, host, port, path));
190     EXPECT_EQ(path, "/");
191 
192     // If http push eventing is allowed, allow http and pick a default port of
193     // 80, if it's not, parse should fail.
194     ASSERT_EQ(
195         validateAndSplitUrl("http://foo.com/bar", urlProto, host, port, path),
196         bmcwebInsecureEnableHttpPushStyleEventing);
197     if constexpr (bmcwebInsecureEnableHttpPushStyleEventing)
198     {
199         EXPECT_EQ(port, 80);
200     }
201 }
202 
203 TEST(Router, ParameterTagging)
204 {
205     EXPECT_EQ(6 * 6 + 6 * 3 + 2, getParameterTag("<uint><double><int>"));
206     EXPECT_EQ(1, getParameterTag("<int>"));
207     EXPECT_EQ(2, getParameterTag("<uint>"));
208     EXPECT_EQ(3, getParameterTag("<float>"));
209     EXPECT_EQ(3, getParameterTag("<double>"));
210     EXPECT_EQ(4, getParameterTag("<str>"));
211     EXPECT_EQ(4, getParameterTag("<string>"));
212     EXPECT_EQ(5, getParameterTag("<path>"));
213     EXPECT_EQ(6 * 6 + 6 + 1, getParameterTag("<int><int><int>"));
214     EXPECT_EQ(6 * 6 + 6 + 2, getParameterTag("<uint><int><int>"));
215     EXPECT_EQ(6 * 6 + 6 * 3 + 2, getParameterTag("<uint><double><int>"));
216 }
217 
218 TEST(URL, JsonEncoding)
219 {
220     std::string urlString = "/foo";
221     EXPECT_EQ(nlohmann::json(boost::urls::url(urlString)), urlString);
222     EXPECT_EQ(nlohmann::json(boost::urls::url_view(urlString)), urlString);
223 }
224 
225 } // namespace
226 } // namespace crow::utility
227