userver: /data/code/userver/libraries/sqs/src/sqs/json_client_test.cpp Source File
Loading...
Searching...
No Matches
json_client_test.cpp
1#include <sqs/json_client_fixture_test.hpp>
2
3#include <userver/utest/http_client.hpp>
4
5#include <aws/sqs/model/CreateQueueRequest.h>
6#include <aws/sqs/model/DeleteMessageBatchRequest.h>
7#include <aws/sqs/model/DeleteMessageBatchRequestEntry.h>
8#include <aws/sqs/model/GetQueueUrlRequest.h>
9#include <aws/sqs/model/MessageAttributeValue.h>
10#include <aws/sqs/model/ReceiveMessageRequest.h>
11#include <aws/sqs/model/SendMessageBatchRequest.h>
12#include <aws/sqs/model/SendMessageBatchRequestEntry.h>
13#include <aws/sqs/model/SendMessageRequest.h>
14
15#include <chrono>
16#include <stdexcept>
17#include <utility>
18
19USERVER_NAMESPACE_BEGIN
20
21namespace {
22
23namespace sqs_model = Aws::SQS::Model;
24
25void SampleSqsJsonClient(clients::http::Client& http_client) {
26 /// [Sample SQS JsonClient]
27 sqs::ClientSettings settings;
28 settings.endpoint = "https://sqs.example.com";
29 settings.region = "us-east-1";
30 settings.timeout = std::chrono::seconds{30};
31
32 const sqs::Credentials credentials{
33 .access_key_id = "access-key",
34 .secret_key = "secret-key",
35 };
36
37 sqs::JsonClient client{http_client, credentials, settings};
38 /// [Sample SQS JsonClient]
39}
40
41void SampleSqsExtraCredentials(clients::http::Client& http_client) {
42 sqs::ClientSettings settings;
43 settings.endpoint = "https://sqs.example.com";
44 settings.region = "us-east-1";
45 const sqs::Credentials credentials{
46 .access_key_id = "access-key",
47 .secret_key = "secret-key",
48 };
49
50 /// [Sample SQS ExtraCredentials]
51 sqs::ExtraCredentials extra{
52 .cloud_iam_token = "iam-token",
53 .authorization_override = {},
54 };
55
56 sqs::JsonClient client{http_client, credentials, settings, extra};
57 /// [Sample SQS ExtraCredentials]
58}
59
60void SampleSqsSendAndReceive(sqs::JsonClient& client) {
61 /// [Sample SQS send and receive]
62 namespace model = Aws::SQS::Model;
63
64 model::CreateQueueRequest create_request;
65 create_request.SetQueueName("orders");
66
67 const auto create_outcome = client.CreateQueue(create_request);
68 if (!create_outcome.IsSuccess()) {
69 throw std::runtime_error{create_outcome.GetError().GetMessage()};
70 }
71
72 const auto queue_url = create_outcome.GetResult().GetQueueUrl();
73
74 model::SendMessageRequest send_request;
75 send_request.SetQueueUrl(queue_url);
76 send_request.SetMessageBody(R"({"order_id":"42"})");
77
78 const auto send_outcome = client.SendMessage(send_request);
79 if (!send_outcome.IsSuccess()) {
80 throw std::runtime_error{send_outcome.GetError().GetMessage()};
81 }
82
83 model::ReceiveMessageRequest receive_request;
84 receive_request.SetQueueUrl(queue_url);
85 receive_request.SetMaxNumberOfMessages(1);
86 receive_request.SetWaitTimeSeconds(5);
87
88 const auto receive_outcome = client.ReceiveMessage(receive_request);
89 if (!receive_outcome.IsSuccess()) {
90 throw std::runtime_error{receive_outcome.GetError().GetMessage()};
91 }
92 /// [Sample SQS send and receive]
93}
94
95} // namespace
96
97UTEST_F(SqsJsonClient, DocumentationSnippets) {
98 auto http_client = utest::CreateHttpClient();
99 SampleSqsJsonClient(*http_client);
100 SampleSqsExtraCredentials(*http_client);
101
102 auto client = MakeClient();
103 UEXPECT_NO_THROW(SampleSqsSendAndReceive(*client));
104}
105
106UTEST_F(SqsJsonClient, RegionIsRequired) {
107 auto http_client = utest::CreateHttpClient();
108 sqs::ClientSettings settings;
109 settings.endpoint = "https://sqs.example.com";
110 EXPECT_UINVARIANT_FAILURE_MSG((sqs::JsonClient{*http_client, {}, settings}), "sqs::ClientSettings.region is empty");
111}
112
113UTEST_F(SqsJsonClient, CreateQueueAndGetQueueUrl) {
114 auto client = MakeClient();
115 const auto queue_url = CreateQueue(*client, "json-client-create");
116 ASSERT_FALSE(queue_url.empty());
117
118 sqs_model::GetQueueUrlRequest request;
119 request.SetQueueName(queue_url.substr(queue_url.rfind('/') + 1));
120
121 const auto outcome = client->GetQueueUrl(request);
122 ASSERT_TRUE(outcome.IsSuccess()) << GetErrorMessage(outcome.GetError());
123 EXPECT_EQ(outcome.GetResult().GetQueueUrl(), queue_url);
124}
125
126UTEST_F(SqsJsonClient, MoveClient) {
127 auto client = MakeClient();
128 sqs::JsonClient moved{std::move(*client)};
129 const auto queue_url = CreateQueue(moved, "json-client-move");
130 ASSERT_FALSE(queue_url.empty());
131
132 auto other = MakeClient();
133 *other = std::move(moved);
134
135 sqs_model::GetQueueUrlRequest request;
136 request.SetQueueName(queue_url.substr(queue_url.rfind('/') + 1));
137 const auto outcome = other->GetQueueUrl(request);
138 ASSERT_TRUE(outcome.IsSuccess()) << GetErrorMessage(outcome.GetError());
139 EXPECT_EQ(outcome.GetResult().GetQueueUrl(), queue_url);
140}
141
142UTEST_F(SqsJsonClient, SendReceiveDeleteMessage) {
143 auto client = MakeClient();
144 const auto queue_url = CreateQueue(*client, "json-client-message");
145 ASSERT_FALSE(queue_url.empty());
146
147 const Aws::String message_body = "hello-from-json-client";
148
149 sqs_model::SendMessageRequest send_request;
150 send_request.SetQueueUrl(queue_url);
151 send_request.SetMessageBody(message_body);
152
153 const auto send_outcome = RunWhenQueueIsReady([&] { return client->SendMessage(send_request); });
154 ASSERT_TRUE(send_outcome.IsSuccess()) << GetErrorMessage(send_outcome.GetError());
155 ASSERT_FALSE(send_outcome.GetResult().GetMessageId().empty());
156
157 sqs_model::ReceiveMessageRequest receive_request;
158 receive_request.SetQueueUrl(queue_url);
159 receive_request.SetMaxNumberOfMessages(1);
160 receive_request.SetWaitTimeSeconds(5);
161
162 const auto receive_outcome = client->ReceiveMessage(receive_request);
163 ASSERT_TRUE(receive_outcome.IsSuccess()) << GetErrorMessage(receive_outcome.GetError());
164 ASSERT_EQ(receive_outcome.GetResult().GetMessages().size(), 1);
165 EXPECT_EQ(receive_outcome.GetResult().GetMessages()[0].GetBody(), message_body);
166
167 sqs_model::DeleteMessageBatchRequest delete_request;
168 delete_request.SetQueueUrl(queue_url);
169 delete_request
170 .AddEntries(sqs_model::DeleteMessageBatchRequestEntry{}
171 .WithId("msg-0")
172 .WithReceiptHandle(receive_outcome.GetResult().GetMessages()[0].GetReceiptHandle()));
173
174 const auto delete_outcome = client->DeleteMessageBatch(delete_request);
175 ASSERT_TRUE(delete_outcome.IsSuccess()) << GetErrorMessage(delete_outcome.GetError());
176 EXPECT_EQ(delete_outcome.GetResult().GetSuccessful().size(), 1);
177}
178
179UTEST_F(SqsJsonClient, SendReceiveMessageAttributes) {
180 auto client = MakeClient();
181 const auto queue_url = CreateQueue(*client, "json-client-attrs");
182 ASSERT_FALSE(queue_url.empty());
183
184 sqs_model::SendMessageRequest send_request;
185 send_request.SetQueueUrl(queue_url);
186 send_request.SetMessageBody("message-with-attributes");
187 send_request.AddMessageAttributes(
188 "stringAttr",
189 sqs_model::MessageAttributeValue{}.WithDataType("String").WithStringValue("string-value")
190 );
191
192 const unsigned char binary_value[] = {'b', 'i', 'n'};
193 send_request.AddMessageAttributes(
194 "binaryAttr",
195 sqs_model::MessageAttributeValue{}
196 .WithDataType("Binary")
197 .WithBinaryValue(Aws::Utils::ByteBuffer{binary_value, sizeof(binary_value)})
198 );
199
200 const auto send_outcome = RunWhenQueueIsReady([&] { return client->SendMessage(send_request); });
201 ASSERT_TRUE(send_outcome.IsSuccess()) << GetErrorMessage(send_outcome.GetError());
202
203 sqs_model::ReceiveMessageRequest receive_request;
204 receive_request.SetQueueUrl(queue_url);
205 receive_request.SetMaxNumberOfMessages(1);
206 receive_request.SetWaitTimeSeconds(5);
207 receive_request.AddMessageAttributeNames("All");
208
209 const auto receive_outcome = client->ReceiveMessage(receive_request);
210 ASSERT_TRUE(receive_outcome.IsSuccess()) << GetErrorMessage(receive_outcome.GetError());
211 ASSERT_EQ(receive_outcome.GetResult().GetMessages().size(), 1);
212
213 const auto& attributes = receive_outcome.GetResult().GetMessages()[0].GetMessageAttributes();
214 EXPECT_EQ(attributes.at("stringAttr").GetStringValue(), "string-value");
215 EXPECT_EQ(attributes.at("binaryAttr").GetBinaryValue().GetLength(), sizeof(binary_value));
216}
217
218UTEST_F(SqsJsonClient, SendMessageBatch) {
219 auto client = MakeClient();
220 const auto queue_url = CreateQueue(*client, "json-client-batch");
221 ASSERT_FALSE(queue_url.empty());
222
223 sqs_model::SendMessageBatchRequest request;
224 request.SetQueueUrl(queue_url);
225 request.AddEntries(sqs_model::SendMessageBatchRequestEntry{}.WithId("0").WithMessageBody("batch-body-0"));
226 request.AddEntries(sqs_model::SendMessageBatchRequestEntry{}.WithId("1").WithMessageBody("batch-body-1"));
227
228 const auto outcome = RunWhenQueueIsReady([&] { return client->SendMessageBatch(request); });
229 ASSERT_TRUE(outcome.IsSuccess()) << GetErrorMessage(outcome.GetError());
230 EXPECT_EQ(outcome.GetResult().GetSuccessful().size(), 2);
231 EXPECT_EQ(outcome.GetResult().GetFailed().size(), 0);
232}
233
234USERVER_NAMESPACE_END