1 // SPDX-License-Identifier: Apache-2.0
2 // SPDX-FileCopyrightText: Copyright OpenBMC Authors
3
4 #include "utility.hpp"
5
6 #include <boost/system/result.hpp>
7 #include <boost/url/parse.hpp>
8 #include <boost/url/url.hpp>
9 #include <boost/url/url_view.hpp>
10 #include <nlohmann/json.hpp>
11
12 #include <algorithm>
13 #include <ctime>
14 #include <functional>
15 #include <string>
16 #include <string_view>
17
18 #include <gtest/gtest.h>
19
20 namespace crow::utility
21 {
22 namespace
23 {
24
TEST(Utility,Base64DecodeAuthString)25 TEST(Utility, Base64DecodeAuthString)
26 {
27 std::string authString("dXNlcm40bWU6cGFzc3cwcmQ=");
28 std::string result;
29 EXPECT_TRUE(base64Decode(authString, result));
30 EXPECT_EQ(result, "usern4me:passw0rd");
31 }
32
TEST(Utility,Base64DecodeUrlsafe)33 TEST(Utility, Base64DecodeUrlsafe)
34 {
35 std::string result;
36 EXPECT_TRUE(base64Decode<true>("-_abcde", result));
37 EXPECT_EQ(result, "\xfb\xf6\x9b\x71\xd7");
38 }
39
TEST(Utility,Base64DecodeNonAscii)40 TEST(Utility, Base64DecodeNonAscii)
41 {
42 std::string junkString("\xff\xee\xdd\xcc\x01\x11\x22\x33");
43 std::string result;
44 EXPECT_FALSE(base64Decode(junkString, result));
45 }
46
TEST(Utility,Base64EncodeString)47 TEST(Utility, Base64EncodeString)
48 {
49 using namespace std::string_literals;
50 std::string encoded;
51
52 encoded = base64encode("");
53 EXPECT_EQ(encoded, "");
54
55 encoded = base64encode("f");
56 EXPECT_EQ(encoded, "Zg==");
57
58 encoded = base64encode("f0");
59 EXPECT_EQ(encoded, "ZjA=");
60
61 encoded = base64encode("f0\0"s);
62 EXPECT_EQ(encoded, "ZjAA");
63
64 encoded = base64encode("f0\0 "s);
65 EXPECT_EQ(encoded, "ZjAAIA==");
66
67 encoded = base64encode("f0\0 B"s);
68 EXPECT_EQ(encoded, "ZjAAIEI=");
69
70 encoded = base64encode("f0\0 Ba"s);
71 EXPECT_EQ(encoded, "ZjAAIEJh");
72
73 encoded = base64encode("f0\0 Bar"s);
74 EXPECT_EQ(encoded, "ZjAAIEJhcg==");
75 }
76
TEST(Utility,Base64Encoder)77 TEST(Utility, Base64Encoder)
78 {
79 using namespace std::string_literals;
80 std::string data = "f0\0 Bar"s;
81 for (size_t chunkSize = 1; chunkSize < 6; chunkSize++)
82 {
83 std::string_view testString(data);
84 std::string out;
85 Base64Encoder encoder;
86 while (!testString.empty())
87 {
88 size_t thisChunk = std::min(testString.size(), chunkSize);
89 encoder.encode(testString.substr(0, thisChunk), out);
90 testString.remove_prefix(thisChunk);
91 }
92
93 encoder.finalize(out);
94 EXPECT_EQ(out, "ZjAAIEJhcg==");
95 }
96 }
97
TEST(Utility,Base64EncodeDecodeString)98 TEST(Utility, Base64EncodeDecodeString)
99 {
100 using namespace std::string_literals;
101 std::string data("Data fr\0m 90 reading a \nFile"s);
102 std::string encoded = base64encode(data);
103 std::string decoded;
104 EXPECT_TRUE(base64Decode(encoded, decoded));
105 EXPECT_EQ(data, decoded);
106 }
107
TEST(Utility,readUrlSegments)108 TEST(Utility, readUrlSegments)
109 {
110 boost::system::result<boost::urls::url_view> parsed =
111 boost::urls::parse_relative_ref("/redfish/v1/Chassis");
112
113 EXPECT_TRUE(readUrlSegments(*parsed, "redfish", "v1", "Chassis"));
114
115 EXPECT_FALSE(readUrlSegments(*parsed, "FOOBAR", "v1", "Chassis"));
116
117 EXPECT_FALSE(readUrlSegments(*parsed, "redfish", "v1"));
118
119 EXPECT_FALSE(
120 readUrlSegments(*parsed, "redfish", "v1", "Chassis", "FOOBAR"));
121
122 std::string out1;
123 std::string out2;
124 std::string out3;
125 EXPECT_TRUE(readUrlSegments(*parsed, "redfish", "v1", std::ref(out1)));
126 EXPECT_EQ(out1, "Chassis");
127
128 out1 = out2 = out3 = "";
129 EXPECT_TRUE(readUrlSegments(*parsed, std::ref(out1), std::ref(out2),
130 std::ref(out3)));
131 EXPECT_EQ(out1, "redfish");
132 EXPECT_EQ(out2, "v1");
133 EXPECT_EQ(out3, "Chassis");
134
135 out1 = out2 = out3 = "";
136 EXPECT_TRUE(readUrlSegments(*parsed, "redfish", std::ref(out1), "Chassis"));
137 EXPECT_EQ(out1, "v1");
138
139 out1 = out2 = out3 = "";
140 EXPECT_TRUE(readUrlSegments(*parsed, std::ref(out1), "v1", std::ref(out2)));
141 EXPECT_EQ(out1, "redfish");
142 EXPECT_EQ(out2, "Chassis");
143
144 EXPECT_FALSE(readUrlSegments(*parsed, "too", "short"));
145
146 EXPECT_FALSE(readUrlSegments(*parsed, "too", "long", "too", "long"));
147
148 EXPECT_FALSE(
149 readUrlSegments(*parsed, std::ref(out1), "v2", std::ref(out2)));
150
151 EXPECT_FALSE(readUrlSegments(*parsed, "redfish", std::ref(out1),
152 std::ref(out2), std::ref(out3)));
153
154 parsed = boost::urls::parse_relative_ref("/absolute/url");
155 EXPECT_TRUE(readUrlSegments(*parsed, "absolute", "url"));
156
157 parsed = boost::urls::parse_relative_ref("not/absolute/url");
158 EXPECT_FALSE(readUrlSegments(*parsed, "not", "absolute", "url"));
159
160 parsed = boost::urls::parse_relative_ref("/excellent/path");
161
162 EXPECT_TRUE(readUrlSegments(*parsed, "excellent", "path", OrMorePaths()));
163 EXPECT_TRUE(readUrlSegments(*parsed, "excellent", OrMorePaths()));
164 EXPECT_TRUE(readUrlSegments(*parsed, OrMorePaths()));
165 }
166
TEST(Utility,readUrlSegmentsManager)167 TEST(Utility, readUrlSegmentsManager)
168 {
169 boost::urls::url_view url(
170 "/redfish/v1/Managers/bmc#/Oem/OpenBmc/Fan/FanZones/Left");
171 std::string managerId;
172 std::string input;
173 EXPECT_TRUE(
174 readUrlSegments(url, "redfish", "v1", "Managers", std::ref(managerId),
175 "Oem", "OpenBmc", "Fan", "FanZones", std::ref(input)));
176 EXPECT_EQ(managerId, "bmc");
177 EXPECT_EQ(input, "Left");
178 }
179
TEST(Router,ParameterTagging)180 TEST(Router, ParameterTagging)
181 {
182 EXPECT_EQ(1, getParameterTag("<str>"));
183 EXPECT_EQ(1, getParameterTag("<string>"));
184 EXPECT_EQ(1, getParameterTag("<path>"));
185 EXPECT_EQ(2, getParameterTag("<str>/<str>"));
186 EXPECT_EQ(2, getParameterTag("<string>/<string>"));
187 EXPECT_EQ(2, getParameterTag("<path>/<path>"));
188 }
189
TEST(URL,JsonEncoding)190 TEST(URL, JsonEncoding)
191 {
192 std::string urlString = "/foo";
193 EXPECT_EQ(nlohmann::json(boost::urls::url(urlString)), urlString);
194 EXPECT_EQ(nlohmann::json(boost::urls::url_view(urlString)), urlString);
195 }
196
TEST(AppendUrlFromPieces,PiecesAreAppendedViaDelimiters)197 TEST(AppendUrlFromPieces, PiecesAreAppendedViaDelimiters)
198 {
199 boost::urls::url url("/redfish/v1/foo");
200 EXPECT_EQ(std::string_view(url.data(), url.size()), "/redfish/v1/foo");
201
202 appendUrlPieces(url, "bar");
203 EXPECT_EQ(std::string_view(url.data(), url.size()), "/redfish/v1/foo/bar");
204
205 appendUrlPieces(url, "/", "bad&string");
206 EXPECT_EQ(std::string_view(url.data(), url.size()),
207 "/redfish/v1/foo/bar/%2F/bad&string");
208 }
209
210 } // namespace
211 } // namespace crow::utility
212