KiCad PCB EDA Suite
Loading...
Searching...
No Matches
test_api_handler_pcb.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
17 * along with this program. If not, see <https://www.gnu.org/licenses/>.
18 */
19
20#include <memory>
21#include <vector>
22
23#include <boost/test/unit_test.hpp>
24
25#include <wx/filename.h>
26
29
30#include <board.h>
32#include <drc/drc_exclusion.h>
33#include <drc/drc_item.h>
34#include <drc/drc_rule.h>
35#include <pcb_marker.h>
37#include <zone.h>
38#include <zone_filler.h>
39
40#include <api/api_handler_pcb.h>
43#include <api/board/board_commands.pb.h>
44#include <api/board/board_rules.pb.h>
45#include <api/board/board_tasks.pb.h>
46#include <api/common/commands/editor_commands.pb.h>
47#include <api/common/envelope.pb.h>
48#include <api/common/tasks.pb.h>
49#include <api/common/types/base_types.pb.h>
51
52
53namespace
54{
55
57const wxString F_CU_ZONE = wxS( "00000000-0000-0000-0000-00005c07d704" );
58const wxString B_CU_ZONE = wxS( "00000000-0000-0000-0000-00005c07d701" );
59const wxString IN1_CU_ZONE = wxS( "00000000-0000-0000-0000-00005c07d707" );
60const wxString IN2_CU_ZONE = wxS( "00000000-0000-0000-0000-00005c07d70a" );
61
62
63struct API_HANDLER_PCB_FIXTURE
64{
65 SETTINGS_MANAGER m_settingsManager;
66 std::unique_ptr<BOARD> m_board;
67 std::shared_ptr<HEADLESS_PCB_CONTEXT> m_context;
68
69 // The context takes ownership of the board; the returned raw pointer lets the test inspect
70 // zone state after the handler runs.
71 BOARD* loadBoard( const wxString& aRelPath )
72 {
73 KI_TEST::LoadBoard( m_settingsManager, aRelPath, m_board );
74
75 BOARD* board = m_board.get();
76 m_context = std::make_shared<HEADLESS_PCB_CONTEXT>( std::move( m_board ),
77 &m_settingsManager.Prj(), nullptr );
78 return board;
79 }
80
81 kiapi::common::ApiRequest makeRefillRequest( BOARD* aBoard, const std::vector<wxString>& aZoneIds ) const
82 {
83 kiapi::board::commands::RefillZones command;
84 command.mutable_board()->set_type( kiapi::common::types::DocumentType::DOCTYPE_PCB );
85 command.mutable_board()->set_board_filename(
86 wxFileName( aBoard->GetFileName() ).GetFullName().ToStdString() );
87
88 for( const wxString& id : aZoneIds )
89 command.add_zones()->set_value( id.ToStdString() );
90
91 kiapi::common::ApiRequest request;
92 request.mutable_header()->set_client_name( "kicad.qa" );
93 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
94
95 return request;
96 }
97
98 ZONE* zoneByUuid( BOARD* aBoard, const wxString& aUuid ) const
99 {
100 for( ZONE* zone : aBoard->Zones() )
101 {
102 if( zone->m_Uuid.AsString() == aUuid )
103 return zone;
104 }
105
106 return nullptr;
107 }
108
109 void unfillAll( BOARD* aBoard ) const
110 {
111 // Start from a clean slate so a positive IsFilled() result can only come from this fill
112 for( ZONE* zone : aBoard->Zones() )
113 {
114 zone->UnFill();
115 BOOST_REQUIRE( !zone->IsFilled() );
116 }
117 }
118};
119
120
121kiapi::common::ApiRequest makeBeginCommitRequest()
122{
123 // No header, so the pre-11.0 path assumes the PCB editor
124 kiapi::common::commands::BeginCommit command;
125
126 kiapi::common::ApiRequest request;
127 request.mutable_header()->set_client_name( "kicad.qa" );
128 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
129
130 return request;
131}
132
133
134kiapi::common::ApiRequest makeRevertRequest( BOARD* aBoard )
135{
136 kiapi::common::commands::RevertDocument command;
137 command.mutable_document()->set_type( kiapi::common::types::DocumentType::DOCTYPE_PCB );
138 command.mutable_document()->set_board_filename( wxFileName( aBoard->GetFileName() ).GetFullName().ToStdString() );
139
140 kiapi::common::ApiRequest request;
141 request.mutable_header()->set_client_name( "kicad.qa" );
142 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
143
144 return request;
145}
146
147
148kiapi::common::types::DocumentSpecifier makeBoardDocument( const BOARD& aBoard )
149{
150 kiapi::common::types::DocumentSpecifier document;
151 document.set_type( kiapi::common::types::DocumentType::DOCTYPE_PCB );
152 document.set_board_filename( wxFileName( aBoard.GetFileName() ).GetFullName().ToStdString() );
153
154 return document;
155}
156
157
158kiapi::common::ApiRequest makeStartRefillZonesTaskRequest(
159 const BOARD& aBoard, const std::vector<wxString>& aZoneIds = {} )
160{
161 kiapi::board::tasks::StartRefillZonesTask command;
162 *command.mutable_board() = makeBoardDocument( aBoard );
163
164 for( const wxString& id : aZoneIds )
165 command.add_zones()->set_value( id.ToStdString() );
166
167 kiapi::common::ApiRequest request;
168 request.mutable_header()->set_client_name( "kicad.qa" );
169 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
170
171 return request;
172}
173
174
175kiapi::common::ApiRequest makeStartDrcTaskRequest( const BOARD& aBoard, bool aTestSchematicParity = false,
176 bool aRequireZonesFilled = false )
177{
178 kiapi::board::tasks::StartDrcTask command;
179 *command.mutable_board() = makeBoardDocument( aBoard );
180 command.set_test_schematic_parity( aTestSchematicParity );
181 command.set_require_zones_filled( aRequireZonesFilled );
182
183 kiapi::common::ApiRequest request;
184 request.mutable_header()->set_client_name( "kicad.qa" );
185 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
186
187 return request;
188}
189
190
191kiapi::common::ApiRequest makeGetDrcTaskResultRequest( const std::string& aToken )
192{
193 kiapi::board::tasks::GetDrcTaskResult command;
194 command.mutable_token()->set_value( aToken );
195
196 kiapi::common::ApiRequest request;
197 request.mutable_header()->set_client_name( "kicad.qa" );
198 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
199
200 return request;
201}
202
203} // namespace
204
205
206BOOST_FIXTURE_TEST_SUITE( ApiHandlerPcb, API_HANDLER_PCB_FIXTURE )
207
208
209BOOST_AUTO_TEST_CASE( OdbJobRequestMapsVariants )
210{
212 kiapi::board::jobs::RunBoardJobExportODB request;
213 request.add_variant_names( "var1" );
214 request.add_variant_names( "var2" );
215 request.set_variant( "legacy" );
216 request.set_variant_packaging( kiapi::board::jobs::ODBVP_COMBINED );
217 request.set_manufacturer_part_number_column( "MPN" );
219 ApplyOdbJobRequest( request, job );
220 BOOST_REQUIRE_EQUAL( job.m_variantNames.size(), 2u );
221 BOOST_CHECK_EQUAL( job.m_variantNames[0], wxS( "var1" ) );
222 BOOST_CHECK_EQUAL( job.m_variantNames[1], wxS( "var2" ) );
223 BOOST_CHECK( job.m_variantPackaging == PACKAGING::COMBINED );
224 BOOST_CHECK_EQUAL( job.m_colMfgPn, wxString( wxS( "MPN" ) ) );
225
226 kiapi::board::jobs::RunBoardJobExportODB legacyRequest;
227 legacyRequest.set_variant( "legacy" );
228 JOB_EXPORT_PCB_ODB legacyJob;
229 ApplyOdbJobRequest( legacyRequest, legacyJob );
230 BOOST_REQUIRE_EQUAL( legacyJob.m_variantNames.size(), 1u );
231 BOOST_CHECK_EQUAL( legacyJob.m_variantNames[0], wxS( "legacy" ) );
232 BOOST_CHECK( legacyJob.m_variantPackaging == PACKAGING::SEPARATE );
233}
234
235
236BOOST_AUTO_TEST_CASE( OdbJobRequestMapsExportOptions )
237{
238 kiapi::board::jobs::RunBoardJobExportODB request;
239 request.set_origin( kiapi::board::jobs::ODBO_GRID );
240 request.set_product_name( "board product" );
241 request.mutable_content()->set_data_set( kiapi::board::jobs::FDS_ASSEMBLY );
242 request.mutable_content()->set_sections( "KP" );
243 request.mutable_content()->set_net_names( kiapi::board::jobs::FNNP_ANONYMIZE );
244
246 ApplyOdbJobRequest( request, job );
248 BOOST_CHECK_EQUAL( job.m_productName, wxString( wxS( "board product" ) ) );
251 BOOST_CHECK_EQUAL( *job.m_sections, wxString( wxS( "KP" ) ) );
253
254 kiapi::board::jobs::RunBoardJobExportODB legacy;
255 JOB_EXPORT_PCB_ODB defaultJob;
256 ApplyOdbJobRequest( legacy, defaultJob );
260}
261
262
263BOOST_AUTO_TEST_CASE( RefillZonesSubset )
264{
265 BOARD* board = loadBoard( wxS( "issue5830" ) );
266
267 unfillAll( board );
268
269 API_HANDLER_PCB handler( m_context );
270 kiapi::common::ApiRequest request = makeRefillRequest( board, { F_CU_ZONE, IN1_CU_ZONE } );
271 API_RESULT result = handler.Handle( request );
272
273 if( !result.has_value() )
274 {
275 BOOST_FAIL( "RefillZones returned status " << result.error().status() << ": "
276 << result.error().error_message() );
277 }
278
279 BOOST_CHECK_EQUAL( result->status().status(), kiapi::common::ApiStatusCode::AS_OK );
280
281 ZONE* fCu = zoneByUuid( board, F_CU_ZONE );
282 ZONE* bCu = zoneByUuid( board, B_CU_ZONE );
283 ZONE* in1Cu = zoneByUuid( board, IN1_CU_ZONE );
284 ZONE* in2Cu = zoneByUuid( board, IN2_CU_ZONE );
285
286 BOOST_REQUIRE( fCu && bCu && in1Cu && in2Cu );
287
288 // Exactly the requested zones must be filled; the others must be untouched.
289 BOOST_CHECK( fCu->IsFilled() );
290 BOOST_CHECK( in1Cu->IsFilled() );
291 BOOST_CHECK( !bCu->IsFilled() );
292 BOOST_CHECK( !in2Cu->IsFilled() );
293}
294
295
296BOOST_AUTO_TEST_CASE( RefillZonesSubsetRebuildsConnectivity )
297{
298 BOARD* board = loadBoard( wxS( "issue5830" ) );
299
300 unfillAll( board );
301
302 // Baseline ratsnest with every zone empty; the GND planes are unfilled so their pads still
303 // ratsnest together.
304 board->BuildConnectivity();
305 const unsigned baseline = board->GetConnectivity()->GetUnconnectedCount( false );
306 BOOST_REQUIRE_MESSAGE( baseline > 0, "expected an unconnected baseline with zones empty" );
307
308 API_HANDLER_PCB handler( m_context );
309 kiapi::common::ApiRequest request = makeRefillRequest( board, { F_CU_ZONE, IN1_CU_ZONE } );
310 API_RESULT result = handler.Handle( request );
311
312 if( !result.has_value() )
313 {
314 BOOST_FAIL( "RefillZones returned status " << result.error().status() << ": "
315 << result.error().error_message() );
316 }
317
318 const unsigned afterFill = board->GetConnectivity()->GetUnconnectedCount( false );
319
320 // Filling the GND planes bridges GND pads that previously ratsnested, so the unconnected
321 // count drops. Push cleared the ratsnest, so if the handler skipped the connectivity
322 // rebuild this would read zero instead of the reduced-but-nonzero count.
323 BOOST_CHECK_MESSAGE( afterFill > 0, "connectivity was cleared, not rebuilt, after the fill" );
324 BOOST_CHECK_MESSAGE( afterFill < baseline,
325 "filling the GND planes should reduce the unconnected count ("
326 << afterFill << " vs baseline " << baseline << ")" );
327}
328
329
330BOOST_AUTO_TEST_CASE( RefillZonesAllHeadless )
331{
332 BOARD* board = loadBoard( wxS( "issue5830" ) );
333
334 unfillAll( board );
335
336 API_HANDLER_PCB handler( m_context );
337 kiapi::common::ApiRequest request = makeRefillRequest( board, {} );
338 API_RESULT result = handler.Handle( request );
339
340 if( !result.has_value() )
341 {
342 BOOST_FAIL( "RefillZones returned status " << result.error().status() << ": "
343 << result.error().error_message() );
344 }
345
346 BOOST_CHECK_EQUAL( result->status().status(), kiapi::common::ApiStatusCode::AS_OK );
347
348 // With no frame the empty-zones request must fill everything synchronously
349 for( ZONE* zone : board->Zones() )
350 BOOST_CHECK_MESSAGE( zone->IsFilled(), "zone " << zone->m_Uuid.AsStdString() << " not filled" );
351}
352
353
354BOOST_AUTO_TEST_CASE( RefillZonesUnknownIdRejected )
355{
356 BOARD* board = loadBoard( wxS( "issue5830" ) );
357
358 API_HANDLER_PCB handler( m_context );
359 kiapi::common::ApiRequest request =
360 makeRefillRequest( board, { wxS( "deadbeef-0000-0000-0000-000000000000" ) } );
361 API_RESULT result = handler.Handle( request );
362
363 BOOST_REQUIRE( !result.has_value() );
364 BOOST_CHECK_EQUAL( result.error().status(), kiapi::common::ApiStatusCode::AS_BAD_REQUEST );
365}
366
367
368// RevertDocument reloads the board, freeing every item an in-flight client commit points at.
369// The handler must refuse with AS_BUSY while a commit is open, or the pointers dangle
370// (use-after-free). Latent UAF found via #24803.
371BOOST_AUTO_TEST_CASE( RevertDocumentRejectedWithOpenCommit )
372{
373 BOARD* board = loadBoard( wxS( "issue5830" ) );
374
375 API_HANDLER_PCB handler( m_context );
376
377 // Open a client transaction, as a client staging edits would
378 kiapi::common::ApiRequest beginRequest = makeBeginCommitRequest();
379 BOOST_REQUIRE( handler.Handle( beginRequest ).has_value() );
380
381 kiapi::common::ApiRequest request = makeRevertRequest( board );
382 API_RESULT result = handler.Handle( request );
383
384 BOOST_REQUIRE( !result.has_value() );
385 BOOST_CHECK_EQUAL( result.error().status(), kiapi::common::ApiStatusCode::AS_BUSY );
386 BOOST_CHECK( result.error().error_message().find( "commit" ) != std::string::npos );
387}
388
389
390// With no open commit the guard passes; the reload then needs a running editor, so a headless
391// handler reports AS_UNIMPLEMENTED. This confirms the guard does not reject the normal path.
392BOOST_AUTO_TEST_CASE( RevertDocumentWithoutCommitPassesGuard )
393{
394 BOARD* board = loadBoard( wxS( "issue5830" ) );
395
396 API_HANDLER_PCB handler( m_context );
397 kiapi::common::ApiRequest request = makeRevertRequest( board );
398 API_RESULT result = handler.Handle( request );
399
400 BOOST_REQUIRE( !result.has_value() );
401 BOOST_CHECK_EQUAL( result.error().status(), kiapi::common::ApiStatusCode::AS_BAD_REQUEST );
402}
403
404
405/*
406 * Long-running API tasks: StartRefillZonesTask must fill the requested zones via the task
407 * scheduler and report COMPLETED; StartDrcTask must run DRC headlessly and produce a result
408 * retrievable through GetDrcTaskResult.
409 */
410
411BOOST_AUTO_TEST_CASE( StartRefillZonesTaskCompletes )
412{
413 BOARD* board = loadBoard( wxS( "issue5830" ) );
414
415 unfillAll( board );
416
417 API_HANDLER_PCB handler( m_context );
418
419 kiapi::board::tasks::StartRefillZonesTask command;
420 command.mutable_board()->set_type( kiapi::common::types::DocumentType::DOCTYPE_PCB );
421 command.mutable_board()->set_board_filename(
422 wxFileName( board->GetFileName() ).GetFullName().ToStdString() );
423 command.add_zones()->set_value( F_CU_ZONE.ToStdString() );
424 command.add_zones()->set_value( IN1_CU_ZONE.ToStdString() );
425
426 kiapi::common::ApiRequest request;
427 request.mutable_header()->set_client_name( "kicad.qa" );
428 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
429
430 API_RESULT result = handler.Handle( request );
431
432 BOOST_REQUIRE( result.has_value() );
433
434 kiapi::common::tasks::StartTaskResponse response;
435 BOOST_REQUIRE( result->message().UnpackTo( &response ) );
436 BOOST_REQUIRE( !response.token().value().empty() );
437
438 // No event loop here: drain the scheduler synchronously until the task finishes
440
441 auto status = API_TASK_SCHEDULER::Instance().GetStatus( response.token().value() );
442 BOOST_REQUIRE( status.has_value() );
443 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_COMPLETED );
444
445 ZONE* fCu = zoneByUuid( board, F_CU_ZONE );
446 ZONE* in1Cu = zoneByUuid( board, IN1_CU_ZONE );
447 ZONE* bCu = zoneByUuid( board, B_CU_ZONE );
448
449 BOOST_REQUIRE( fCu && in1Cu && bCu );
450 BOOST_CHECK( fCu->IsFilled() );
451 BOOST_CHECK( in1Cu->IsFilled() );
452 BOOST_CHECK( !bCu->IsFilled() );
453}
454
455
456BOOST_AUTO_TEST_CASE( StartRefillZonesTaskUnknownIdRejected )
457{
458 BOARD* board = loadBoard( wxS( "issue5830" ) );
459
460 API_HANDLER_PCB handler( m_context );
461
462 kiapi::board::tasks::StartRefillZonesTask command;
463 command.mutable_board()->set_type( kiapi::common::types::DocumentType::DOCTYPE_PCB );
464 command.mutable_board()->set_board_filename(
465 wxFileName( board->GetFileName() ).GetFullName().ToStdString() );
466 command.add_zones()->set_value( "deadbeef-0000-0000-0000-000000000000" );
467
468 kiapi::common::ApiRequest request;
469 request.mutable_header()->set_client_name( "kicad.qa" );
470 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
471
472 API_RESULT result = handler.Handle( request );
473
474 // Validation happens at request time, before any task starts
475 BOOST_REQUIRE( !result.has_value() );
476 BOOST_CHECK_EQUAL( result.error().status(), kiapi::common::ApiStatusCode::AS_BAD_REQUEST );
477}
478
479
480BOOST_AUTO_TEST_CASE( StartRefillZonesTaskEmptyListFillsAllZones )
481{
482 BOARD* board = loadBoard( wxS( "issue5830" ) );
483
484 unfillAll( board );
485
486 API_HANDLER_PCB handler( m_context );
487
488 // An empty zone list means "all zones", matching the synchronous RefillZones command
489 kiapi::common::ApiRequest request = makeStartRefillZonesTaskRequest( *board );
490 API_RESULT result = handler.Handle( request );
491 BOOST_REQUIRE( result.has_value() );
492
493 kiapi::common::tasks::StartTaskResponse response;
494 BOOST_REQUIRE( result->message().UnpackTo( &response ) );
495 BOOST_REQUIRE( !response.token().value().empty() );
496
498
499 auto status = API_TASK_SCHEDULER::Instance().GetStatus( response.token().value() );
500 BOOST_REQUIRE( status.has_value() );
501 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_COMPLETED );
502
503 for( ZONE* zone : board->Zones() )
504 {
505 if( !zone->GetIsRuleArea() )
506 BOOST_CHECK_MESSAGE( zone->IsFilled(), "zone " << zone->GetZoneName() << " was not filled" );
507 }
508
509 // Headless contexts track modification themselves; the task must report it like the
510 // synchronous command so clients know the board needs saving.
511 kiapi::common::commands::GetDocumentModifiedState stateCommand;
512 *stateCommand.mutable_document() = makeBoardDocument( *board );
513
514 kiapi::common::ApiRequest stateRequest;
515 stateRequest.mutable_header()->set_client_name( "kicad.qa" );
516 BOOST_REQUIRE( stateRequest.mutable_message()->PackFrom( stateCommand ) );
517
518 API_RESULT stateResult = handler.Handle( stateRequest );
519 BOOST_REQUIRE( stateResult.has_value() );
520
521 kiapi::common::commands::GetDocumentModifiedStateResponse state;
522 BOOST_REQUIRE( stateResult->message().UnpackTo( &state ) );
523 BOOST_CHECK_EQUAL( state.state(), kiapi::common::commands::DMS_MODIFIED );
524}
525
526
527BOOST_AUTO_TEST_CASE( StartDrcTaskCompletesWithResults )
528{
529 BOARD* board = loadBoard( wxS( "issue5830" ) );
530
531 API_HANDLER_PCB handler( m_context );
532
533 kiapi::board::tasks::StartDrcTask command;
534 command.mutable_board()->set_type( kiapi::common::types::DocumentType::DOCTYPE_PCB );
535 command.mutable_board()->set_board_filename(
536 wxFileName( board->GetFileName() ).GetFullName().ToStdString() );
537
538 kiapi::common::ApiRequest request;
539 request.mutable_header()->set_client_name( "kicad.qa" );
540 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
541
542 API_RESULT result = handler.Handle( request );
543 BOOST_REQUIRE( result.has_value() );
544
545 kiapi::common::tasks::StartTaskResponse response;
546 BOOST_REQUIRE( result->message().UnpackTo( &response ) );
547 BOOST_REQUIRE( !response.token().value().empty() );
548
550
551 auto status = API_TASK_SCHEDULER::Instance().GetStatus( response.token().value() );
552 BOOST_REQUIRE( status.has_value() );
553 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_COMPLETED );
554
555 // Fetch the result via a GetDrcTaskResult request, like a real client
556 kiapi::board::tasks::GetDrcTaskResult resultRequest;
557 resultRequest.mutable_token()->set_value( response.token().value() );
558
559 kiapi::common::ApiRequest resultApiRequest;
560 resultApiRequest.mutable_header()->set_client_name( "kicad.qa" );
561 BOOST_REQUIRE( resultApiRequest.mutable_message()->PackFrom( resultRequest ) );
562
563 API_RESULT resultResponse = handler.Handle( resultApiRequest );
564 BOOST_REQUIRE( resultResponse.has_value() );
565
566 kiapi::board::tasks::DrcTaskResult drcResult;
567 BOOST_REQUIRE( resultResponse->message().UnpackTo( &drcResult ) );
568
569 // issue5830 has unfilled zones and minimal clearances: DRC must find violations, and
570 // the run must have produced board markers retrievable via the standard item API
571 BOOST_CHECK_GT( drcResult.violations_size(), 0 );
572 BOOST_CHECK_EQUAL( board->Markers().size(), drcResult.violations_size() );
573
574 // Each violation entry must carry a description and a valid error type
575 for( const kiapi::board::DrcMarker& violation : drcResult.violations() )
576 {
577 BOOST_CHECK( !violation.description().empty() );
578 BOOST_CHECK( violation.error_type() != kiapi::board::DrcErrorType::DRCET_UNKNOWN );
579 }
580}
581
582
583BOOST_AUTO_TEST_CASE( GetDrcTaskResultRejectsUnknownToken )
584{
585 loadBoard( wxS( "issue5830" ) );
586
587 API_HANDLER_PCB handler( m_context );
588
589 kiapi::board::tasks::GetDrcTaskResult resultRequest;
590 resultRequest.mutable_token()->set_value( "deadbeef-0000-0000-0000-000000000000" );
591
592 kiapi::common::ApiRequest request;
593 request.mutable_header()->set_client_name( "kicad.qa" );
594 BOOST_REQUIRE( request.mutable_message()->PackFrom( resultRequest ) );
595
596 API_RESULT result = handler.Handle( request );
597
598 BOOST_REQUIRE( !result.has_value() );
599 BOOST_CHECK_EQUAL( result.error().status(), kiapi::common::ApiStatusCode::AS_BAD_REQUEST );
600}
601
602
603BOOST_AUTO_TEST_CASE( StartDrcTaskRequiresFilledZones )
604{
605 BOARD* board = loadBoard( wxS( "issue5830" ) );
606
607 API_HANDLER_PCB handler( m_context );
608
609 auto makeStartRequest = [&]() -> kiapi::common::ApiRequest
610 {
611 kiapi::board::tasks::StartDrcTask command;
612 command.mutable_board()->set_type( kiapi::common::types::DocumentType::DOCTYPE_PCB );
613 command.mutable_board()->set_board_filename(
614 wxFileName( board->GetFileName() ).GetFullName().ToStdString() );
615 command.set_require_zones_filled( true );
616
617 kiapi::common::ApiRequest request;
618 request.mutable_header()->set_client_name( "kicad.qa" );
619 BOOST_REQUIRE( request.mutable_message()->PackFrom( command ) );
620 return request;
621 };
622
623 // Stale zones: unfill everything; the task must refuse to run DRC
624 unfillAll( board );
625
626 kiapi::common::ApiRequest request = makeStartRequest();
627 API_RESULT result = handler.Handle( request );
628 BOOST_REQUIRE( result.has_value() );
629
630 kiapi::common::tasks::StartTaskResponse response;
631 BOOST_REQUIRE( result->message().UnpackTo( &response ) );
632
634
635 auto status = API_TASK_SCHEDULER::Instance().GetStatus( response.token().value() );
636 BOOST_REQUIRE( status.has_value() );
637 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_FAILED );
638 BOOST_CHECK( status->error_message().find( "zone" ) != std::string::npos );
639
640 // Filled zones: the task must now run
641 for( ZONE* zone : board->Zones() )
642 {
643 if( !zone->GetIsRuleArea() )
644 {
645 ZONE_FILLER filler( board, nullptr );
646 std::vector<ZONE*> toFill = { zone };
647 BOOST_REQUIRE( filler.Fill( toFill ) );
648 }
649 }
650
651 kiapi::common::ApiRequest request2 = makeStartRequest();
652 API_RESULT result2 = handler.Handle( request2 );
653 BOOST_REQUIRE( result2.has_value() );
654
655 kiapi::common::tasks::StartTaskResponse response2;
656 BOOST_REQUIRE( result2->message().UnpackTo( &response2 ) );
657
659
660 auto status2 = API_TASK_SCHEDULER::Instance().GetStatus( response2.token().value() );
661 BOOST_REQUIRE( status2.has_value() );
662 BOOST_CHECK_EQUAL( status2->state(), kiapi::common::tasks::TS_COMPLETED );
663}
664
665
666BOOST_AUTO_TEST_CASE( GetDrcTaskResultOnFailedTaskReturnsInternalError )
667{
668 BOARD* board = loadBoard( wxS( "issue5830" ) );
669
670 unfillAll( board );
671
672 API_HANDLER_PCB handler( m_context );
673
674 kiapi::common::ApiRequest startRequest =
675 makeStartDrcTaskRequest( *board, false, true /* requireFilledZones */ );
676 API_RESULT start = handler.Handle( startRequest );
677 BOOST_REQUIRE( start.has_value() );
678
679 kiapi::common::tasks::StartTaskResponse response;
680 BOOST_REQUIRE( start->message().UnpackTo( &response ) );
681
683
684 auto status = API_TASK_SCHEDULER::Instance().GetStatus( response.token().value() );
685 BOOST_REQUIRE( status.has_value() );
686 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_FAILED );
687
688 kiapi::common::ApiRequest resultRequest =
689 makeGetDrcTaskResultRequest( response.token().value() );
690 API_RESULT result = handler.Handle( resultRequest );
691 BOOST_REQUIRE( !result.has_value() );
692 BOOST_CHECK_EQUAL( result.error().status(), kiapi::common::ApiStatusCode::AS_INTERNAL_ERROR );
693 BOOST_CHECK( result.error().error_message().find( "zone" ) != std::string::npos );
694}
695
696
697BOOST_AUTO_TEST_CASE( StartDrcTaskWithParityWithoutKiwayFails )
698{
699 BOARD* board = loadBoard( wxS( "via_off_center" ) );
700
701 // The QA loader reads boards from a stream, which leaves the board without a file name.
702 // Set it so the parity lookup finds the schematic next to this board and reaches the
703 // kiface step; the headless test context has no KIWAY.
704 board->SetFileName( wxString::FromUTF8( KI_TEST::GetPcbnewTestDataDir() )
705 + wxS( "via_off_center.kicad_pcb" ) );
706
707 API_HANDLER_PCB handler( m_context );
708
709 kiapi::common::ApiRequest startRequest =
710 makeStartDrcTaskRequest( *board, true /* testFootprints */, false );
711 API_RESULT start = handler.Handle( startRequest );
712 BOOST_REQUIRE( start.has_value() );
713
714 kiapi::common::tasks::StartTaskResponse response;
715 BOOST_REQUIRE( start->message().UnpackTo( &response ) );
716
718
719 auto status = API_TASK_SCHEDULER::Instance().GetStatus( response.token().value() );
720 BOOST_REQUIRE( status.has_value() );
721 BOOST_CHECK_EQUAL( status->state(), kiapi::common::tasks::TS_FAILED );
722 BOOST_CHECK_MESSAGE( status->error_message().find( "parity tests" ) != std::string::npos,
723 "unexpected error: " << status->error_message() );
724}
725
726
727BOOST_AUTO_TEST_CASE( StartTaskWhileAnotherIsRunningIsRejected )
728{
729 BOARD* board = loadBoard( wxS( "issue5830" ) );
730
731 API_HANDLER_PCB handler( m_context );
732
733 kiapi::common::ApiRequest startRequest = makeStartDrcTaskRequest( *board );
734 API_RESULT first = handler.Handle( startRequest );
735 BOOST_REQUIRE( first.has_value() );
736
737 kiapi::common::tasks::StartTaskResponse response;
738 BOOST_REQUIRE( first->message().UnpackTo( &response ) );
739 BOOST_REQUIRE( !response.token().value().empty() );
740
741 // The DRC run event has not been pumped, so the task is still running
742 kiapi::common::ApiRequest secondRequest =
743 makeStartRefillZonesTaskRequest( *board, { F_CU_ZONE } );
744 API_RESULT second = handler.Handle( secondRequest );
745 BOOST_REQUIRE( !second.has_value() );
746 BOOST_CHECK_EQUAL( second.error().status(), kiapi::common::ApiStatusCode::AS_BUSY );
747
748 // Result queries are served during a task, but report that it is not finished yet
749 kiapi::common::ApiRequest runningRequest =
750 makeGetDrcTaskResultRequest( response.token().value() );
751 API_RESULT runningResult = handler.Handle( runningRequest );
752 BOOST_REQUIRE( !runningResult.has_value() );
753 BOOST_CHECK_EQUAL( runningResult.error().status(), kiapi::common::ApiStatusCode::AS_BUSY );
754
756
757 kiapi::common::ApiRequest finishedRequest =
758 makeGetDrcTaskResultRequest( response.token().value() );
759 API_RESULT finishedResult = handler.Handle( finishedRequest );
760 BOOST_REQUIRE( finishedResult.has_value() );
761}
762
763
764BOOST_AUTO_TEST_CASE( TaskQueriesAllowedDuringTask )
765{
766 loadBoard( wxS( "issue5830" ) );
767
768 API_HANDLER_PCB handler( m_context );
769
770 // Status/result retrieval is safe while a task runs
771 BOOST_CHECK( handler.AllowsDuringTask( std::string( kiapi::board::tasks::GetDrcTaskResult().GetTypeName() ) ) );
772
773 // Starting or mutating commands is not
774 BOOST_CHECK( !handler.AllowsDuringTask( std::string( kiapi::board::tasks::StartDrcTask().GetTypeName() ) ) );
775 BOOST_CHECK( !handler.AllowsDuringTask( std::string( kiapi::board::tasks::StartRefillZonesTask().GetTypeName() ) ) );
776 BOOST_CHECK( !handler.AllowsDuringTask( std::string( kiapi::common::commands::GetItems().GetTypeName() ) ) );
777}
778
779
780BOOST_AUTO_TEST_CASE( DrcExclusionDropsMarkerReportFields )
781{
782 BOARD* board = loadBoard( wxS( "issue5830" ) );
783
784 std::shared_ptr<DRC_ITEM> drcItem = DRC_ITEM::Create( DRCE_CLEARANCE );
785 drcItem->SetItems( KIID( "12345678-1234-1234-1234-123456789abc" ),
786 KIID( "87654321-4321-4321-4321-cba987654321" ) );
787
788 DRC_RULE rule( wxS( "custom clearance" ) );
789 drcItem->SetViolatingRule( &rule );
790
791 PCB_MARKER* marker = new PCB_MARKER( drcItem, VECTOR2I( 1000, 1000 ) );
792 board->Add( marker );
793 marker->SetExcluded( true, "Test exclusion comment" );
794
795 kiapi::board::DrcMarker msg;
796 PCB_MARKER::ToProto( msg, *marker );
797 BOOST_CHECK_EQUAL( msg.violating_rule(), "custom clearance" );
798 BOOST_CHECK( !msg.description().empty() );
799 BOOST_CHECK( msg.excluded() );
800
801 DRC_EXCLUSION exclusion = DRC_EXCLUSION::FromMarker( *marker );
802 const kiapi::board::DrcMarker& canonical = exclusion.ToProto().marker();
803
804 BOOST_CHECK( canonical.violating_rule().empty() );
805 BOOST_CHECK( canonical.description().empty() );
806 BOOST_CHECK_EQUAL( canonical.severity(), kiapi::common::types::RuleSeverity::RS_UNKNOWN );
807 BOOST_CHECK( !canonical.excluded() );
808
809 // Canonicalization is stable across a proto round trip
810 DRC_EXCLUSION roundTripped = DRC_EXCLUSION::FromProto( exclusion.ToProto() );
811 BOOST_CHECK( roundTripped == exclusion );
812
813 const kiapi::board::DrcMarker& roundTrippedMsg = roundTripped.ToProto().marker();
814 BOOST_CHECK( roundTrippedMsg.violating_rule().empty() );
815 BOOST_CHECK( roundTrippedMsg.description().empty() );
816 BOOST_CHECK( !roundTrippedMsg.excluded() );
817}
818
819
tl::expected< ApiResponse, ApiResponseStatus > API_RESULT
Definition api_handler.h:44
void ApplyOdbJobRequest(const RunBoardJobExportODB &aRequest, JOB_EXPORT_PCB_ODB &aJob)
bool AllowsDuringTask(const std::string &aTypeName) const
Definition api_handler.h:81
API_RESULT Handle(ApiRequest &aMsg)
Attempt to handle the given API request, if a handler exists in this class for the message.
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()
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
const ZONES & Zones() const
Definition board.h:469
const wxString & GetFileName() const
Definition board.h:454
Container for an DRC exclusion, which is a PCB_MARKER plus an optional comment.
static DRC_EXCLUSION FromProto(const kiapi::board::DrcExclusion &aMessage)
static DRC_EXCLUSION FromMarker(const PCB_MARKER &aMarker)
const kiapi::board::DrcExclusion & ToProto() const
static std::shared_ptr< DRC_ITEM > Create(int aErrorCode)
Constructs a DRC_ITEM for the given error code.
Definition drc_item.cpp:505
std::optional< wxString > m_sections
Section key that replaces the optional sections of the data set Unset lets the data set select them a...
std::vector< wxString > m_variantNames
VARIANT_PACKAGING m_variantPackaging
Definition kiid.h:46
void SetExcluded(bool aExcluded, const wxString &aComment=wxEmptyString)
Definition marker_base.h:89
static void ToProto(kiapi::board::DrcMarker &aMsg, const PCB_MARKER &aMarker)
bool Fill(const std::vector< ZONE * > &aZones, bool aCheck=false, wxWindow *aParent=nullptr)
Fills the given list of zones.
Handle a list of polygons defining a copper zone.
Definition zone.h:70
bool IsFilled() const
Definition zone.h:306
@ DRCE_CLEARANCE
Definition drc_item.h:52
static std::string ToStdString(const wxString &aStr)
std::string GetPcbnewTestDataDir()
Utility which returns a path to the data directory where the test board files are stored.
void LoadBoard(SETTINGS_MANAGER &aSettingsManager, const wxString &aRelPath, std::unique_ptr< BOARD > &aBoard)
BOOST_AUTO_TEST_CASE(HorizontalAlignment)
BOOST_AUTO_TEST_CASE(OdbJobRequestMapsVariants)
BOOST_CHECK(res.column_datatype(0)==SQL_NUMERIC||res.column_datatype(0)==SQL_DECIMAL)
BOOST_REQUIRE_EQUAL(rows.size(), 1)
BOOST_CHECK_EQUAL(std::any_cast< std::string >(rows[0].at("val")), "12345678901234567.89")
BOOST_REQUIRE_MESSAGE(dc.CacheTableInfo(table, { "part_id", "val" }), dc.GetLastError())
BOOST_REQUIRE(res.columns()==1)
BOOST_AUTO_TEST_SUITE_END()
wxString result
Test unit parsing edge cases and error handling.
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708