KiCad PCB EDA Suite
Loading...
Searching...
No Matches
test_api_tasks.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation, either version 3 of the License, or (at your
9 * option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program. If not, see <https://www.gnu.org/licenses/>.
18 */
19
20#include <memory>
21#include <stdexcept>
22#include <string>
23
24#include <boost/test/unit_test.hpp>
25
28#include <api/common/commands/editor_commands.pb.h>
29#include <api/common/envelope.pb.h>
30#include <api/common/tasks.pb.h>
31
32
33namespace
34{
35
40class TEST_TASK : public API_TASK
41{
42public:
43 enum class BEHAVIOR
44 {
46 REPORT_FAILED,
47 REPORT_CANCELLED,
48 THROW_STD,
49 THROW_UNKNOWN
50 };
51
52 explicit TEST_TASK( BEHAVIOR aBehavior ) :
53 m_behavior( aBehavior )
54 {
55 }
56
57 void Run() override
58 {
59 ++m_runCount;
60
61 switch( m_behavior )
62 {
63 case BEHAVIOR::COMPLETE:
64 break;
65
66 case BEHAVIOR::REPORT_FAILED:
67 m_state = kiapi::common::tasks::TS_FAILED;
68 m_errorMessage = "reported failure";
69 break;
70
71 case BEHAVIOR::REPORT_CANCELLED:
72 m_state = kiapi::common::tasks::TS_CANCELLED;
73 m_errorMessage = "reported cancellation";
74 break;
75
76 case BEHAVIOR::THROW_STD:
77 throw std::runtime_error( "boom" );
78
79 case BEHAVIOR::THROW_UNKNOWN:
80 throw 42;
81 }
82 }
83
84 void FillStatus( kiapi::common::tasks::TaskStatusResponse& aStatus ) const override
85 {
86 if( m_state != kiapi::common::tasks::TS_UNKNOWN )
87 aStatus.set_state( m_state );
88
89 if( !m_errorMessage.empty() )
90 aStatus.set_error_message( m_errorMessage );
91 }
92
93 int RunCount() const { return m_runCount; }
94
95private:
96 BEHAVIOR m_behavior;
97 int m_runCount = 0;
98 kiapi::common::tasks::TaskState m_state = kiapi::common::tasks::TS_UNKNOWN;
99 std::string m_errorMessage;
100};
101
102
103kiapi::common::ApiRequest makeGetTaskStatusRequest( const std::string& aToken )
104{
105 kiapi::common::tasks::GetTaskStatus command;
106 command.mutable_token()->set_value( aToken );
107
108 kiapi::common::ApiRequest request;
109 request.mutable_header()->set_client_name( "kicad.qa" );
110 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
111
112 return request;
113}
114
115} // namespace
116
117
118BOOST_AUTO_TEST_SUITE( ApiTasks )
119
120
121BOOST_AUTO_TEST_CASE( StartTaskEnforcesSingleFlight )
122{
124
125 // Run anything left over by an earlier test so the first StartTask cannot be rejected
126 scheduler.Pump();
127
128 auto first = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::COMPLETE );
129 std::optional<std::string> firstToken = scheduler.StartTask( first, "first" );
130 BOOST_REQUIRE( firstToken.has_value() );
131 BOOST_CHECK( scheduler.AnyTaskRunning() );
132
133 // The run event has not been pumped, so the first task is still running
134 auto second = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::COMPLETE );
135 BOOST_CHECK( !scheduler.StartTask( second, "second" ).has_value() );
136
137 scheduler.Pump();
138 BOOST_CHECK( !scheduler.AnyTaskRunning() );
139 BOOST_CHECK_EQUAL( second->RunCount(), 0 );
140
141 auto status = scheduler.GetStatus( *firstToken );
142 BOOST_REQUIRE( status.has_value() );
143 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_COMPLETED );
144}
145
146
147BOOST_AUTO_TEST_CASE( TaskExceptionIsReportedAndDoesNotBlockScheduler )
148{
150 scheduler.Pump();
151
152 auto throwing = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::THROW_STD );
153 std::optional<std::string> token = scheduler.StartTask( throwing, "throwing" );
154 BOOST_REQUIRE( token.has_value() );
155
156 scheduler.Pump();
157
158 auto status = scheduler.GetStatus( *token );
159 BOOST_REQUIRE( status.has_value() );
160 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_FAILED );
161 BOOST_CHECK_EQUAL( status->error_message(), "boom" );
162 BOOST_CHECK_EQUAL( throwing->RunCount(), 1 );
163 BOOST_CHECK( !scheduler.AnyTaskRunning() );
164
165 // A failed task must not leave the scheduler permanently busy
166 auto following = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::COMPLETE );
167 std::optional<std::string> followingToken = scheduler.StartTask( following, "following" );
168 BOOST_REQUIRE( followingToken.has_value() );
169
170 scheduler.Pump();
171
172 auto followingStatus = scheduler.GetStatus( *followingToken );
173 BOOST_REQUIRE( followingStatus.has_value() );
174 BOOST_CHECK_EQUAL( followingStatus->state(), kiapi::common::tasks::TS_COMPLETED );
175}
176
177
178BOOST_AUTO_TEST_CASE( TaskUnknownExceptionIsReportedAsFailure )
179{
181 scheduler.Pump();
182
183 auto throwing = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::THROW_UNKNOWN );
184 std::optional<std::string> token = scheduler.StartTask( throwing, "throwing" );
185 BOOST_REQUIRE( token.has_value() );
186
187 scheduler.Pump();
188
189 auto status = scheduler.GetStatus( *token );
190 BOOST_REQUIRE( status.has_value() );
191 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_FAILED );
192 BOOST_CHECK( !status->error_message().empty() );
193}
194
195
196BOOST_AUTO_TEST_CASE( TaskReportedFailureIsPreserved )
197{
199 scheduler.Pump();
200
201 auto task = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::REPORT_FAILED );
202 std::optional<std::string> token = scheduler.StartTask( task, "reported" );
203 BOOST_REQUIRE( token.has_value() );
204
205 scheduler.Pump();
206
207 auto status = scheduler.GetStatus( *token );
208 BOOST_REQUIRE( status.has_value() );
209 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_FAILED );
210 BOOST_CHECK_EQUAL( status->error_message(), "reported failure" );
211}
212
213
214BOOST_AUTO_TEST_CASE( TaskReportedCancellationIsPreserved )
215{
217 scheduler.Pump();
218
219 auto task = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::REPORT_CANCELLED );
220 std::optional<std::string> token = scheduler.StartTask( task, "cancelled" );
221 BOOST_REQUIRE( token.has_value() );
222
223 scheduler.Pump();
224
225 auto status = scheduler.GetStatus( *token );
226 BOOST_REQUIRE( status.has_value() );
227 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_CANCELLED );
228 BOOST_CHECK_EQUAL( status->error_message(), "reported cancellation" );
229}
230
231
232BOOST_AUTO_TEST_CASE( FinishedTaskRecordsAreEvicted )
233{
235 scheduler.Pump();
236
237 std::string firstToken;
238 std::string lastToken;
239
240 for( size_t i = 0; i < API_TASK_SCHEDULER::MAX_FINISHED_TASKS + 1; ++i )
241 {
242 auto task = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::COMPLETE );
243 std::optional<std::string> token = scheduler.StartTask( task, "eviction" );
244 BOOST_REQUIRE( token.has_value() );
245
246 if( firstToken.empty() )
247 firstToken = *token;
248
249 lastToken = *token;
250 scheduler.Pump();
251 }
252
253 // The oldest record has been evicted; the newest is still retrievable
254 BOOST_CHECK( !scheduler.GetStatus( firstToken ).has_value() );
255 BOOST_CHECK( scheduler.GetFinishedTask( firstToken ) == nullptr );
256
257 auto lastStatus = scheduler.GetStatus( lastToken );
258 BOOST_REQUIRE( lastStatus.has_value() );
259 BOOST_CHECK_EQUAL( lastStatus->state(), kiapi::common::tasks::TS_COMPLETED );
260 BOOST_CHECK( scheduler.GetFinishedTask( lastToken ) != nullptr );
261}
262
263
264BOOST_AUTO_TEST_CASE( GetTaskStatusHandlerReportsLifecycle )
265{
267 scheduler.Pump();
268
269 API_HANDLER_COMMON handler;
270 BOOST_REQUIRE( handler.CanHandle( std::string( kiapi::common::tasks::GetTaskStatus().GetTypeName() ) ) );
271
272 auto task = std::make_shared<TEST_TASK>( TEST_TASK::BEHAVIOR::COMPLETE );
273 std::optional<std::string> token = scheduler.StartTask( task, "status" );
274 BOOST_REQUIRE( token.has_value() );
275
276 kiapi::common::ApiRequest runningRequest = makeGetTaskStatusRequest( *token );
277 API_RESULT runningResult = handler.Handle( runningRequest );
278 BOOST_REQUIRE( runningResult.has_value() );
279
280 kiapi::common::tasks::TaskStatusResponse runningStatus;
281 BOOST_REQUIRE( runningResult->message().UnpackTo( &runningStatus ) );
282 BOOST_CHECK_EQUAL( runningStatus.state(), kiapi::common::tasks::TS_RUNNING );
283
284 scheduler.Pump();
285
286 kiapi::common::ApiRequest completedRequest = makeGetTaskStatusRequest( *token );
287 API_RESULT completedResult = handler.Handle( completedRequest );
288 BOOST_REQUIRE( completedResult.has_value() );
289
290 kiapi::common::tasks::TaskStatusResponse completedStatus;
291 BOOST_REQUIRE( completedResult->message().UnpackTo( &completedStatus ) );
292 BOOST_CHECK_EQUAL( completedStatus.state(), kiapi::common::tasks::TS_COMPLETED );
293}
294
295
296BOOST_AUTO_TEST_CASE( GetTaskStatusHandlerRejectsUnknownToken )
297{
298 API_HANDLER_COMMON handler;
299
300 kiapi::common::ApiRequest request =
301 makeGetTaskStatusRequest( "deadbeef-0000-0000-0000-000000000000" );
302 API_RESULT result = handler.Handle( request );
303
304 BOOST_REQUIRE( !result.has_value() );
305 BOOST_CHECK_EQUAL( result.error().status(), kiapi::common::ApiStatusCode::AS_BAD_REQUEST );
306}
307
308
tl::expected< ApiResponse, ApiResponseStatus > API_RESULT
Definition api_handler.h:44
bool CanHandle(const std::string &aTypeName) const
Definition api_handler.h:73
API_RESULT Handle(ApiRequest &aMsg)
Attempt to handle the given API request, if a handler exists in this class for the message.
For now, a single process-wide task runner, and one task at a time.
std::shared_ptr< API_TASK > GetFinishedTask(const std::string &aToken) const
Look up a task that has finished, for result retrieval.
std::optional< kiapi::common::tasks::TaskStatusResponse > GetStatus(const std::string &aToken) const
Get a snapshot of the task's current status.
void Pump()
Run the current task to completion, synchronously.
static API_TASK_SCHEDULER & Instance()
static constexpr size_t MAX_FINISHED_TASKS
std::optional< std::string > StartTask(const std::shared_ptr< API_TASK > &aTask, const wxString &aDescription)
Register a new task and begin running it.
BOOST_AUTO_TEST_CASE(HorizontalAlignment)
BOOST_AUTO_TEST_CASE(StartTaskEnforcesSingleFlight)
BOOST_AUTO_TEST_SUITE(CadstarPartParser)
BOOST_CHECK(res.column_datatype(0)==SQL_NUMERIC||res.column_datatype(0)==SQL_DECIMAL)
BOOST_CHECK_EQUAL(std::any_cast< std::string >(rows[0].at("val")), "12345678901234567.89")
BOOST_REQUIRE(res.columns()==1)
BOOST_AUTO_TEST_SUITE_END()
wxString result
Test unit parsing edge cases and error handling.