Instrument Neutral Distributed Interface INDI  2.0.2
TestIndiserverSingleDriver.cpp
Go to the documentation of this file.
1 /*******************************************************************************
2  Copyright(c) 2022 Ludovic Pollet. All rights reserved.
3 
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Library General Public
6  License version 2 as published by the Free Software Foundation.
7 
8  This library is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  Library General Public License for more details.
12 
13  You should have received a copy of the GNU Library General Public License
14  along with this library; see the file COPYING.LIB. If not, write to
15  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
16  Boston, MA 02110-1301, USA.
17 *******************************************************************************/
18 
19 #include <stdexcept>
20 #include <stdio.h>
21 #include <unistd.h>
22 #include <sys/types.h>
23 #include <system_error>
24 
25 #include "gtest/gtest.h"
26 
27 #include "utils.h"
28 
29 #include "SharedBuffer.h"
30 #include "DriverMock.h"
31 #include "IndiServerController.h"
32 #include "IndiClientMock.h"
33 
34 // Repeat blob operation for more stress
35 #define BLOB_REPEAT_COUNT 5
36 
37 TEST(IndiserverSingleDriver, MissingDriver)
38 {
39  DriverMock fakeDriver;
40  IndiServerController indiServer;
41 
42  setupSigPipe();
43 
44  std::string fakeDriverPath = getTestExePath("fakedriver-not-existing");
45 
46  // Start indiserver with one instance, repeat 0
47  indiServer.startDriver(fakeDriverPath);
48  fprintf(stderr, "indiserver started\n");
49 
50  // Exit code 1 is expected when driver stopped
51  indiServer.waitProcessEnd(1);
52 }
53 
54 TEST(IndiserverSingleDriver, ReplyToPing)
55 {
56  DriverMock fakeDriver;
57  IndiServerController indiServer;
58 
59  setupSigPipe();
60 
61  fakeDriver.setup();
62 
63  std::string fakeDriverPath = getTestExePath("fakedriver");
64 
65  // Start indiserver with one instance, repeat 0
66  indiServer.startDriver(fakeDriverPath);
67  fprintf(stderr, "indiserver started\n");
68 
69  fakeDriver.waitEstablish();
70  fprintf(stderr, "fake driver started\n");
71 
72  fakeDriver.cnx.expectXml("<getProperties version='1.7'/>");
73  fprintf(stderr, "getProperties received");
74 
75  // Establish a client & send ping
76  IndiClientMock client;
77  client.connect(indiServer);
78 
79  // Send ping from driver
80  fakeDriver.cnx.send("<pingRequest uid='1'/>\n");
81  fakeDriver.cnx.expectXml("<pingReply uid='1'/>");
82 
83  client.cnx.send("<pingRequest uid='2'/>\n");
84  client.cnx.expectXml("<pingReply uid='2'/>\n");
85 
86  fakeDriver.cnx.send("<pingRequest uid='3'/>\n");
87  fakeDriver.cnx.expectXml("<pingReply uid='3'/>\n");
88 
89  client.cnx.send("<pingRequest uid='4'/>\n");
90  client.cnx.expectXml("<pingReply uid='4'/>\n");
91 
92  fakeDriver.terminateDriver();
93 
94  // Exit code 1 is expected when driver stopped
95  indiServer.waitProcessEnd(1);
96 }
97 
98 
99 static void startFakeDev(IndiServerController &indiServer)
100 {
101  setupSigPipe();
102 
103  std::string fakeDriverPath = getTestExePath("fakedriver");
104 
105  // Start indiserver with one instance, repeat 0
106  indiServer.startDriver(fakeDriverPath);
107  fprintf(stderr, "indiserver started\n");
108 }
109 
110 
111 static void establishDriver(IndiServerController &indiServer, DriverMock &fakeDriver, const std::string & name) {
112  (void)indiServer;
113  fakeDriver.waitEstablish();
114  fprintf(stderr, "fake driver started\n");
115 
116  fakeDriver.cnx.expectXml("<getProperties version='1.7'/>");
117  fprintf(stderr, "getProperties received\n");
118 
119  // Give one props to the driver
120  fakeDriver.cnx.send("<defBLOBVector device='" + name + "' name='testblob' label='test label' group='test_group' state='Idle' perm='ro' timeout='100' timestamp='2018-01-01T00:00:00'>\n");
121  fakeDriver.cnx.send("<defBLOB name='content' label='content'/>\n");
122  fakeDriver.cnx.send("</defBLOBVector>\n");
123 }
124 
125 static void startFakeDev1(IndiServerController &indiServer, DriverMock &fakeDriver)
126 {
127  fakeDriver.setup();
128  startFakeDev(indiServer);
129  establishDriver(indiServer, fakeDriver, "fakeDev1");
130 }
131 
132 static void addDriver(IndiServerController &indiServer, DriverMock &fakeDriver, const std::string & name)
133 {
134  fakeDriver.setup();
135 
136  std::string fakeDriverPath = getTestExePath("fakedriver");
137 
138  indiServer.addDriver(fakeDriverPath);
139 
140  establishDriver(indiServer, fakeDriver, name);
141 }
142 
143 
144 void connectFakeDev1Client(IndiServerController &, DriverMock &fakeDriver, IndiClientMock &indiClient)
145 {
146  fprintf(stderr, "Client asks properties\n");
147  indiClient.cnx.send("<getProperties version='1.7'/>\n");
148  fakeDriver.cnx.expectXml("<getProperties version='1.7'/>");
149 
150  fprintf(stderr, "Driver sends properties\n");
151  fakeDriver.cnx.send("<defBLOBVector device='fakedev1' name='testblob' label='test label' group='test_group' state='Idle' perm='ro' timeout='100' timestamp='2018-01-01T00:00:00'>\n");
152  fakeDriver.cnx.send("<defBLOB name='content' label='content'/>\n");
153  fakeDriver.cnx.send("</defBLOBVector>\n");
154 
155  fprintf(stderr, "Client receive properties\n");
156  indiClient.cnx.expectXml("<defBLOBVector device=\"fakedev1\" name=\"testblob\" label=\"test label\" group=\"test_group\" state=\"Idle\" perm=\"ro\" timeout=\"100\" timestamp=\"2018-01-01T00:00:00\">");
157  indiClient.cnx.expectXml("<defBLOB name=\"content\" label=\"content\"/>");
158  indiClient.cnx.expectXml("</defBLOBVector>");
159 }
160 
161 TEST(IndiserverSingleDriver, DontLeakFds)
162 {
163  DriverMock fakeDriver;
164  IndiServerController indiServer;
165 
166  startFakeDev1(indiServer, fakeDriver);
167 
168  IndiClientMock indiClient;
169 
170  fakeDriver.ping();
171  int fdCountIdle = indiServer.getOpenFdCount();
172 #ifdef ENABLE_INDI_SHARED_MEMORY
173  indiClient.connectUnix(indiServer.getUnixSocketPath());
174  fakeDriver.ping();
175  indiServer.checkOpenFdCount(fdCountIdle + 1, "First unix connection");
176  indiClient.close();
177 
178  // Make sur the server processed the close as well.
179  fakeDriver.ping();
180  indiServer.checkOpenFdCount(fdCountIdle, "First unix connection released");
181 
182  indiClient.connectUnix(indiServer.getUnixSocketPath());
183  fakeDriver.ping();
184  indiServer.checkOpenFdCount(fdCountIdle + 1, "Second unix connection");
185  indiClient.close();
186 
187  fakeDriver.ping();
188  indiServer.checkOpenFdCount(fdCountIdle, "Second unix connection released");
189 
190 #endif // ENABLE_INDI_SHARED_MEMORY
191 
192  indiClient.connectTcp("127.0.0.1", indiServer.getTcpPort());
193  fakeDriver.ping();
194  indiServer.checkOpenFdCount(fdCountIdle + 1, "First tcp connection");
195  indiClient.close();
196 
197  fakeDriver.ping();
198  indiServer.checkOpenFdCount(fdCountIdle, "First tcp connection released");
199 
200  indiClient.connectTcp("127.0.0.1", indiServer.getTcpPort());
201  fakeDriver.ping();
202  indiServer.checkOpenFdCount(fdCountIdle + 1, "Second tcp connection");
203  indiClient.close();
204 
205  fakeDriver.ping();
206  indiServer.checkOpenFdCount(fdCountIdle, "First tcp connection released");
207 }
208 
209 
210 TEST(IndiserverSingleDriver, DontForwardUnaskedBlobDefToClient)
211 {
212  DriverMock fakeDriver;
213  IndiServerController indiServer;
214 
215  startFakeDev1(indiServer, fakeDriver);
216 
217  IndiClientMock indiClient;
218 
219  indiClient.connect(indiServer);
220 
221  connectFakeDev1Client(indiServer, fakeDriver, indiClient);
222 
223  fprintf(stderr, "Driver send new blob value\n");
224  fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
225  fakeDriver.cnx.send("<oneBLOB name='content' size='21' format='.fits' enclen='29'>\n");
226  fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
227  fakeDriver.cnx.send("</oneBLOB>\n");
228  fakeDriver.cnx.send("</setBLOBVector>\n");
229  fakeDriver.ping();
230 
231  fprintf(stderr, "Client don't receive blob\n");
232  indiClient.ping();
233 
234  fakeDriver.terminateDriver();
235  // Exit code 1 is expected when driver stopped
236  indiServer.waitProcessEnd(1);
237 }
238 
239 TEST(IndiserverSingleDriver, DontForwardOtherBlobDefToClient)
240 {
241  DriverMock fakeDriver;
242  IndiServerController indiServer;
243 
244  startFakeDev1(indiServer, fakeDriver);
245 
246  IndiClientMock indiClient;
247 
248  indiClient.connect(indiServer);
249 
250  connectFakeDev1Client(indiServer, fakeDriver, indiClient);
251 
252  fprintf(stderr, "Client ask blobs\n");
253  indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob2'>Also</enableBLOB>\n");
254  indiClient.ping();
255 
256 
257  fprintf(stderr, "Driver send new blob value\n");
258  fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
259  fakeDriver.cnx.send("<oneBLOB name='content' size='21' format='.fits' enclen='29'>\n");
260  fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
261  fakeDriver.cnx.send("</oneBLOB>\n");
262  fakeDriver.cnx.send("</setBLOBVector>\n");
263  fakeDriver.ping();
264 
265  fprintf(stderr, "Client don't receive blob\n");
266  indiClient.ping();
267 
268  fakeDriver.terminateDriver();
269  // Exit code 1 is expected when driver stopped
270  indiServer.waitProcessEnd(1);
271 }
272 
273 TEST(IndiserverSingleDriver, DropMisbehavingDriver)
274 {
275  DriverMock fakeDriver;
276  IndiServerController indiServer;
277 
278  startFakeDev1(indiServer, fakeDriver);
279 
280  IndiClientMock indiClient;
281 
282  indiClient.connect(indiServer);
283 
284  connectFakeDev1Client(indiServer, fakeDriver, indiClient);
285 
286  fprintf(stderr, "Client ask blobs\n");
287  indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
288  indiClient.ping();
289 
290  fprintf(stderr, "Driver send new blob value - without actual attachment\n");
291  fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
292  fakeDriver.cnx.send("<oneBLOB name='content' size='21' format='.fits' attached='true'/>\n");
293  fakeDriver.cnx.send("</setBLOBVector>\n");
294 
295  indiServer.waitProcessEnd(1);
296 }
297 
298 TEST(IndiserverSingleDriver, ForwardBase64BlobToIPClient)
299 {
300  // This tests decoding of base64 by driver
301  DriverMock fakeDriver;
302  IndiServerController indiServer;
303 
304  startFakeDev1(indiServer, fakeDriver);
305 
306  IndiClientMock indiClient;
307 
308  indiClient.connectTcp(indiServer);
309 
310  connectFakeDev1Client(indiServer, fakeDriver, indiClient);
311 
312  fprintf(stderr, "Client ask blobs\n");
313  indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
314  indiClient.ping();
315 
316  fprintf(stderr, "Driver send new blob value\n");
317  fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
318  fakeDriver.cnx.send("<oneBLOB name='content' size='20' format='.fits' enclen='29'>\n");
319  fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
320  fakeDriver.cnx.send("</oneBLOB>\n");
321  fakeDriver.cnx.send("</setBLOBVector>\n");
322  fakeDriver.ping();
323 
324  fprintf(stderr, "Client receive blob\n");
325  indiClient.cnx.allowBufferReceive(true);
326  indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
327  indiClient.cnx.expectXml("<oneBLOB name='content' size='20' format='.fits' enclen='29'>");
328  indiClient.cnx.expect("\nMDEyMzQ1Njc4OTAxMjM0NTY3ODkK");
329  indiClient.cnx.expectXml("</oneBLOB>\n");
330  indiClient.cnx.expectXml("</setBLOBVector>");
331 
332  fakeDriver.terminateDriver();
333  // Exit code 1 is expected when driver stopped
334  indiServer.waitProcessEnd(1);
335 }
336 
337 
338 TEST(IndiserverSingleDriver, SnoopDriverPropertie)
339 {
340  // This tests snooping simple property from driver to driver
341  DriverMock fakeDriver;
342  IndiServerController indiServer;
343  indiServer.setFifo(true);
344  startFakeDev1(indiServer, fakeDriver);
345 
346  DriverMock snoopDriver;
347  addDriver(indiServer, snoopDriver, "snoopDriver");
348 
349  fakeDriver.ping();
350  snoopDriver.ping();
351 
352  snoopDriver.cnx.send("<getProperties version='1.7' device='fakedev1' name='testnumber1'/>\n");
353 
354  snoopDriver.ping();
355  fakeDriver.ping();
356 
357  fakeDriver.cnx.send("<defNumberVector device='fakedev1' name='testnumber1' label='test label' group='test_group' state='Idle' perm='rw' timeout='100' timestamp='2018-01-01T00:00:00'>\n");
358  fakeDriver.cnx.send("<defNumber name='content' label='content' min='0' max='100' step='1'>50</defNumber>\n");
359  fakeDriver.cnx.send("</defNumberVector>\n");
360 
361  snoopDriver.cnx.expectXml("<defNumberVector device='fakedev1' name='testnumber1' label='test label' group='test_group' state='Idle' perm='rw' timeout='100' timestamp='2018-01-01T00:00:00'>");
362  snoopDriver.cnx.expectXml("<defNumber name='content' label='content' min='0' max='100' step='1'>");
363  snoopDriver.cnx.expect("\n50");
364  snoopDriver.cnx.expectXml("</defNumber>");
365  snoopDriver.cnx.expectXml("</defNumberVector>");
366 
367  fakeDriver.terminateDriver();
368  snoopDriver.terminateDriver();
369 
370  indiServer.kill();
371  indiServer.join();
372 }
373 
374 
375 #define DUMMY_BLOB_SIZE 64
376 
377 #ifdef ENABLE_INDI_SHARED_MEMORY
378 
379 TEST(IndiserverSingleDriver, ForwardBase64BlobToUnixClient)
380 {
381  // This tests decoding of base64 by driver
382  DriverMock fakeDriver;
383  IndiServerController indiServer;
384 
385  startFakeDev1(indiServer, fakeDriver);
386 
387  IndiClientMock indiClient;
388 
389  indiClient.connectUnix(indiServer);
390 
391  connectFakeDev1Client(indiServer, fakeDriver, indiClient);
392 
393  fprintf(stderr, "Client ask blobs\n");
394  indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
395  indiClient.ping();
396 
397  fprintf(stderr, "Driver send new blob value\n");
398  fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
399  fakeDriver.cnx.send("<oneBLOB name='content' size='20' format='.fits' enclen='29'>\n");
400  fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
401  fakeDriver.cnx.send("</oneBLOB>\n");
402  fakeDriver.cnx.send("</setBLOBVector>\n");
403  fakeDriver.ping();
404 
405  fprintf(stderr, "Client receive blob\n");
406  indiClient.cnx.allowBufferReceive(true);
407  indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
408  indiClient.cnx.expectXml("<oneBLOB name='content' size='20' format='.fits' attached='true'/>");
409  indiClient.cnx.expectXml("</setBLOBVector>");
410 
411  SharedBuffer receivedFd;
412  indiClient.cnx.expectBuffer(receivedFd);
413  indiClient.cnx.allowBufferReceive(false);
414 
415  EXPECT_GE( receivedFd.getSize(), 20);
416 
417  fakeDriver.terminateDriver();
418  // Exit code 1 is expected when driver stopped
419  indiServer.waitProcessEnd(1);
420 }
421 
422 void driverSendAttachedBlob(DriverMock &fakeDriver, ssize_t size)
423 {
424  fprintf(stderr, "Driver send new blob value as attachment\n");
425 
426  // Allocate more memory than asked (simulate kernel BSD kernel rounding up)
427  ssize_t physical_size=0x10000;
428  if (physical_size < size) {
429  physical_size = size;
430  }
431 
432  // The attachment must be done before EOF
433  SharedBuffer fd;
434  fd.allocate(physical_size);
435 
436  char * buffer = (char*)malloc(physical_size);
437  for(auto i = 0; i < physical_size; ++i)
438  {
439  buffer[i] = {(char)('0' + (i % 10))};
440  }
441  fd.write(buffer, 0, physical_size);
442  free(buffer);
443 
444  fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
445  fakeDriver.cnx.send("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits' attached='true'/>\n", fd);
446  fakeDriver.cnx.send("</setBLOBVector>");
447 
448  fd.release();
449 
450 /*#else
451  fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
452  fakeDriver.cnx.send("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits'>\n");
453  fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDE=\n");
454  fakeDriver.cnx.send("</oneBLOB>\n");
455  fakeDriver.cnx.send("</setBLOBVector>");
456 #endif
457 */
458 
459  fakeDriver.ping();
460 }
461 
462 TEST(IndiserverSingleDriver, ForwardAttachedBlobToUnixClient)
463 {
464  // This tests attached blob pass through
465  DriverMock fakeDriver;
466  IndiServerController indiServer;
467 
468  startFakeDev1(indiServer, fakeDriver);
469 
470  IndiClientMock indiClient;
471 
472  indiClient.connectUnix(indiServer);
473 
474  connectFakeDev1Client(indiServer, fakeDriver, indiClient);
475 
476  fprintf(stderr, "Client ask blobs\n");
477  indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
478  // This ping ensures enableBLOB is handled before the blob is received
479 
480  for(int i = 0; i < BLOB_REPEAT_COUNT; ++i) {
481  indiClient.ping();
482 
483 
484  ssize_t size = 32;
485  driverSendAttachedBlob(fakeDriver, size);
486 
487  // Now receive on client side
488  fprintf(stderr, "Client receive blob\n");
489  indiClient.cnx.allowBufferReceive(true);
490  indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
491  indiClient.cnx.expectXml("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits' attached='true'/>");
492  indiClient.cnx.expectXml("</setBLOBVector>");
493 
494  SharedBuffer receivedFd;
495  indiClient.cnx.expectBuffer(receivedFd);
496  indiClient.cnx.allowBufferReceive(false);
497 
498  EXPECT_GE( receivedFd.getSize(), size);
499  }
500 
501  fakeDriver.terminateDriver();
502  // Exit code 1 is expected when driver stopped
503  indiServer.waitProcessEnd(1);
504 }
505 
506 TEST(IndiserverSingleDriver, ForwardAttachedBlobToIPClient)
507 {
508  // This tests base64 encoding by server
509  DriverMock fakeDriver;
510  IndiServerController indiServer;
511 
512  startFakeDev1(indiServer, fakeDriver);
513 
514  IndiClientMock indiClient;
515 
516  indiClient.connectTcp(indiServer);
517 
518  connectFakeDev1Client(indiServer, fakeDriver, indiClient);
519 
520  fprintf(stderr, "Client ask blobs\n");
521  indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
522 
523  for(int i = 0; i < BLOB_REPEAT_COUNT; ++i) {
524  indiClient.ping();
525 
526  ssize_t size = 32;
527  driverSendAttachedBlob(fakeDriver, size);
528 
529  // Now receive on client side
530  fprintf(stderr, "Client receive blob\n");
531  indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
532  indiClient.cnx.expectXml("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits'>");
533  // FIXME: get this from size
534  indiClient.cnx.expect("\nMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDE=");
535  indiClient.cnx.expectXml("</oneBLOB>");
536  indiClient.cnx.expectXml("</setBLOBVector>");
537  }
538  fakeDriver.terminateDriver();
539  // Exit code 1 is expected when driver stopped
540  indiServer.waitProcessEnd(1);
541 }
542 
543 
544 TEST(IndiserverSingleDriver, ForwardAttachedBlobToDriver)
545 {
546  // This tests attached blob pass through
547  DriverMock fakeDriver;
548  IndiServerController indiServer;
549  indiServer.setFifo(true);
550  startFakeDev1(indiServer, fakeDriver);
551 
552  DriverMock snoopDriver;
553  addDriver(indiServer, snoopDriver, "snoopDriver");
554 
555  fakeDriver.ping();
556  snoopDriver.ping();
557 
558  snoopDriver.cnx.send("<getProperties version='1.7' device='fakedev1' name='testblob'/>\n");
559  snoopDriver.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
560  snoopDriver.ping();
561 
562  ssize_t size = 32;
563  driverSendAttachedBlob(fakeDriver, size);
564 
565 #if 0
566  // Until proper support by drivers, indiserver converts to base64 for that path
567  snoopDriver.cnx.allowBufferReceive(true);
568  snoopDriver.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
569  snoopDriver.cnx.expectXml("<oneBLOB name='content' size='32' format='.fits' attached='true'/>\n");
570  snoopDriver.cnx.expectXml("</setBLOBVector>");
571 
572  SharedBuffer receivedFd;
573  snoopDriver.cnx.expectBuffer(receivedFd);
574  snoopDriver.cnx.allowBufferReceive(false);
575  EXPECT_GE( receivedFd.getSize(), 32);
576 #else
577  snoopDriver.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
578  snoopDriver.cnx.expectXml("<oneBLOB name='content' size='32' format='.fits'>\n");
579  snoopDriver.cnx.expect("\nMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDE=");
580  snoopDriver.cnx.expectXml("</oneBLOB>\n");
581  snoopDriver.cnx.expectXml("</setBLOBVector>");
582 #endif
583 
584  fakeDriver.terminateDriver();
585  snoopDriver.terminateDriver();
586  // fakeSnooper.terminateDriver();
587  // Exit code 1 is expected when driver stopped
588  indiServer.kill();
589  indiServer.join();
590 }
591 
592 
593 #endif
TEST
TEST(IndiserverSingleDriver, MissingDriver)
Definition: TestIndiserverSingleDriver.cpp:37
BLOB_REPEAT_COUNT
#define BLOB_REPEAT_COUNT
Definition: TestIndiserverSingleDriver.cpp:35
connectFakeDev1Client
void connectFakeDev1Client(IndiServerController &, DriverMock &fakeDriver, IndiClientMock &indiClient)
Definition: TestIndiserverSingleDriver.cpp:144
ConnectionMock::allowBufferReceive
void allowBufferReceive(bool state)
Definition: ConnectionMock.cpp:67
ConnectionMock::expectBuffer
void expectBuffer(SharedBuffer &fd)
Definition: ConnectionMock.cpp:139
ConnectionMock::expect
void expect(const std::string &content)
Definition: ConnectionMock.cpp:150
ConnectionMock::send
void send(const std::string &content)
Definition: ConnectionMock.cpp:268
ConnectionMock::expectXml
void expectXml(const std::string &xml)
Definition: ConnectionMock.cpp:241
DriverMock::ping
void ping()
Definition: DriverMock.cpp:68
DriverMock::terminateDriver
void terminateDriver()
Definition: DriverMock.cpp:56
DriverMock::cnx
ConnectionMock cnx
Definition: DriverMock.h:50
DriverMock::waitEstablish
void waitEstablish()
Definition: DriverMock.cpp:49
DriverMock::setup
void setup()
Definition: DriverMock.cpp:44
IndiClientMock::connectUnix
void connectUnix(const IndiServerController &server)
Definition: IndiClientMock.cpp:51
IndiClientMock::connectTcp
void connectTcp(const IndiServerController &server)
Definition: IndiClientMock.cpp:56
IndiClientMock::cnx
ConnectionMock cnx
Definition: IndiClientMock.h:35
IndiClientMock::connect
void connect(const IndiServerController &server)
Definition: IndiClientMock.cpp:42
IndiServerController::addDriver
void addDriver(const std::string &path)
Definition: IndiServerController.cpp:74
IndiServerController::getUnixSocketPath
std::string getUnixSocketPath() const
Definition: IndiServerController.cpp:95
IndiServerController::startDriver
void startDriver(const std::string &driver)
Definition: IndiServerController.cpp:54
ProcessController::checkOpenFdCount
void checkOpenFdCount(int expected, const std::string &msg)
Definition: ProcessController.cpp:52
ProcessController::waitProcessEnd
void waitProcessEnd(int expectedExitCode)
Definition: ProcessController.cpp:101
SharedBuffer::getSize
ssize_t getSize() const
Definition: SharedBuffer.h:39
fd
int fd
Definition: intelliscope.c:43
Aux::buffer
std::vector< uint8_t > buffer
Definition: celestronauxpacket.h:38
nlohmann::to_string
NLOHMANN_BASIC_JSON_TPL_DECLARATION std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j)
user-defined to_string function for JSON values
Definition: json.h:23613
getTestExePath
std::string getTestExePath(const std::string &str)
Definition: utils.cpp:340
setupSigPipe
void setupSigPipe()
Definition: utils.cpp:37
Generated on Sat May 13 2023 14:24:24 for Instrument Neutral Distributed Interface INDI by doxygen 1.9.1