src/be/nikiroo/utils/test_code/SerialServerTest.java

   1 package be.nikiroo.utils.test_code;
   2
   3 import java.net.URL;
   4
   5 import be.nikiroo.utils.serial.server.ConnectActionClientObject;
   6 import be.nikiroo.utils.serial.server.ConnectActionClientString;
   7 import be.nikiroo.utils.serial.server.ConnectActionServerObject;
   8 import be.nikiroo.utils.serial.server.ConnectActionServerString;
   9 import be.nikiroo.utils.serial.server.ServerBridge;
  10 import be.nikiroo.utils.serial.server.ServerObject;
  11 import be.nikiroo.utils.serial.server.ServerString;
  12 import be.nikiroo.utils.test.TestCase;
  13 import be.nikiroo.utils.test.TestLauncher;
  14
  15 class SerialServerTest extends TestLauncher {
  16         public SerialServerTest(String[] args) {
  17                 super("SerialServer test", args);
  18
  19                 for (String key : new String[] { null,
  20                                 "some super secret encryption key" }) {
  21                         for (boolean bridge : new Boolean[] { false, true }) {
  22                                 final String skey = (key != null ? "(encrypted)"
  23                                                 : "(plain text)");
  24                                 final String sbridge = (bridge ? " with bridge" : "");
  25
  26                                 addSeries(new SerialServerTest(args, key, skey, bridge,
  27                                                 sbridge, "ServerString"));
  28
  29                                 addSeries(new SerialServerTest(args, key, skey, bridge,
  30                                                 sbridge, new Object() {
  31                                                         @Override
  32                                                         public String toString() {
  33                                                                 return "ServerObject";
  34                                                         }
  35                                                 }));
  36                         }
  37                 }
  38         }
  39
  40         private SerialServerTest(final String[] args, final String key,
  41                         final String skey, final boolean bridge, final String sbridge,
  42                         final String title) {
  43
  44                 super(title + " " + skey + sbridge, args);
  45
  46                 // addTest(new TestCase("Simple connection " + skey) {
  47                 // @Override
  48                 // public void test() throws Exception {
  49                 // final String[] rec = new String[1];
  50                 //
  51                 // ServerString server = new ServerString(this.getName(), 0, key) {
  52                 // @Override
  53                 // protected String onRequest(
  54                 // ConnectActionServerString action, String data)
  55                 // throws Exception {
  56                 // return null;
  57                 // }
  58                 //
  59                 // @Override
  60                 // protected void onError(Exception e) {
  61                 // }
  62                 // };
  63                 //
  64                 // int port = server.getPort();
  65                 // assertEquals("A port should have been assigned", true, port > 0);
  66                 //
  67                 // server.start();
  68                 //
  69                 // ServerBridge br = null;
  70                 // if (bridge) {
  71                 // br = new ServerBridge(0, key, "", port, key);
  72                 // br.setTraceHandler(null);
  73                 //
  74                 // port = br.getPort();
  75                 // assertEquals(
  76                 // "A port should have been assigned to the bridge",
  77                 // true, port > 0);
  78                 //
  79                 // br.start();
  80                 // }
  81                 //
  82                 // try {
  83                 // try {
  84                 // new ConnectActionClientObject(null, port, key) {
  85                 // @Override
  86                 // public void action() throws Exception {
  87                 // rec[0] = "ok";
  88                 // }
  89                 // }.connect();
  90                 // } finally {
  91                 // server.stop();
  92                 // }
  93                 // } finally {
  94                 // if (br != null) {
  95                 // br.stop();
  96                 // }
  97                 // }
  98                 //
  99                 // assertNotNull("The client action was not run", rec[0]);
 100                 // assertEquals("ok", rec[0]);
 101                 // }
 102                 // });
 103
 104                 addTest(new TestCase("Simple exchange " + skey) {
 105                         final String[] sent = new String[1];
 106                         final String[] recd = new String[1];
 107                         final Exception[] err = new Exception[1];
 108
 109                         @Override
 110                         public void test() throws Exception {
 111                                 ServerString server = new ServerString(this.getName(), 0, key) {
 112                                         @Override
 113                                         protected String onRequest(
 114                                                         ConnectActionServerString action, String data)
 115                                                         throws Exception {
 116                                                 sent[0] = data;
 117                                                 return "pong";
 118                                         }
 119
 120                                         @Override
 121                                         protected void onError(Exception e) {
 122                                                 err[0] = e;
 123                                         }
 124                                 };
 125
 126                                 int port = server.getPort();
 127
 128                                 server.start();
 129
 130                                 ServerBridge br = null;
 131                                 if (bridge) {
 132                                         br = new ServerBridge(0, key, "", port, key);
 133                                         br.setTraceHandler(null);
 134                                         port = br.getPort();
 135                                         br.start();
 136                                 }
 137
 138                                 try {
 139                                         try {
 140                                                 new ConnectActionClientString(null, port, key) {
 141                                                         @Override
 142                                                         public void action() throws Exception {
 143                                                                 recd[0] = send("ping");
 144                                                         }
 145                                                 }.connect();
 146                                         } finally {
 147                                                 server.stop();
 148                                         }
 149                                 } finally {
 150                                         if (br != null) {
 151                                                 br.stop();
 152                                         }
 153                                 }
 154
 155                                 if (err[0] != null) {
 156                                         fail("An exception was thrown: " + err[0].getMessage(),
 157                                                         err[0]);
 158                                 }
 159
 160                                 assertEquals("ping", sent[0]);
 161                                 assertEquals("pong", recd[0]);
 162                         }
 163                 });
 164
 165                 addTest(new TestCase("Multiple exchanges " + skey) {
 166                         final String[] sent = new String[3];
 167                         final String[] recd = new String[3];
 168                         final Exception[] err = new Exception[1];
 169
 170                         @Override
 171                         public void test() throws Exception {
 172                                 ServerString server = new ServerString(this.getName(), 0, key) {
 173                                         @Override
 174                                         protected String onRequest(
 175                                                         ConnectActionServerString action, String data)
 176                                                         throws Exception {
 177                                                 sent[0] = data;
 178                                                 action.send("pong");
 179                                                 sent[1] = action.rec();
 180                                                 return "pong2";
 181                                         }
 182
 183                                         @Override
 184                                         protected void onError(Exception e) {
 185                                                 err[0] = e;
 186                                         }
 187                                 };
 188
 189                                 int port = server.getPort();
 190
 191                                 server.start();
 192
 193                                 ServerBridge br = null;
 194                                 if (bridge) {
 195                                         br = new ServerBridge(0, key, "", port, key);
 196                                         br.setTraceHandler(null);
 197                                         port = br.getPort();
 198                                         br.start();
 199                                 }
 200
 201                                 try {
 202                                         try {
 203                                                 new ConnectActionClientString(null, port, key) {
 204                                                         @Override
 205                                                         public void action() throws Exception {
 206                                                                 recd[0] = send("ping");
 207                                                                 recd[1] = send("ping2");
 208                                                         }
 209                                                 }.connect();
 210                                         } finally {
 211                                                 server.stop();
 212                                         }
 213                                 } finally {
 214                                         if (br != null) {
 215                                                 br.stop();
 216                                         }
 217                                 }
 218
 219                                 if (err[0] != null) {
 220                                         fail("An exception was thrown: " + err[0].getMessage(),
 221                                                         err[0]);
 222                                 }
 223
 224                                 assertEquals("ping", sent[0]);
 225                                 assertEquals("pong", recd[0]);
 226                                 assertEquals("ping2", sent[1]);
 227                                 assertEquals("pong2", recd[1]);
 228                         }
 229                 });
 230
 231                 addTest(new TestCase("Multiple call from client " + skey) {
 232                         final String[] sent = new String[3];
 233                         final String[] recd = new String[3];
 234                         final Exception[] err = new Exception[1];
 235
 236                         @Override
 237                         public void test() throws Exception {
 238                                 ServerString server = new ServerString(this.getName(), 0, key) {
 239                                         @Override
 240                                         protected String onRequest(
 241                                                         ConnectActionServerString action, String data)
 242                                                         throws Exception {
 243                                                 sent[Integer.parseInt(data)] = data;
 244                                                 return "" + (Integer.parseInt(data) * 2);
 245                                         }
 246
 247                                         @Override
 248                                         protected void onError(Exception e) {
 249                                                 err[0] = e;
 250                                         }
 251                                 };
 252
 253                                 int port = server.getPort();
 254
 255                                 server.start();
 256
 257                                 ServerBridge br = null;
 258                                 if (bridge) {
 259                                         br = new ServerBridge(0, key, "", port, key);
 260                                         br.setTraceHandler(null);
 261                                         port = br.getPort();
 262                                         br.start();
 263                                 }
 264
 265                                 try {
 266                                         try {
 267                                                 new ConnectActionClientString(null, port, key) {
 268                                                         @Override
 269                                                         public void action() throws Exception {
 270                                                                 for (int i = 0; i < 3; i++) {
 271                                                                         recd[i] = send("" + i);
 272                                                                 }
 273                                                         }
 274                                                 }.connect();
 275                                         } finally {
 276                                                 server.stop();
 277                                         }
 278                                 } finally {
 279                                         if (br != null) {
 280                                                 br.stop();
 281                                         }
 282                                 }
 283
 284                                 if (err[0] != null) {
 285                                         fail("An exception was thrown: " + err[0].getMessage(),
 286                                                         err[0]);
 287                                 }
 288
 289                                 assertEquals("0", sent[0]);
 290                                 assertEquals("0", recd[0]);
 291                                 assertEquals("1", sent[1]);
 292                                 assertEquals("2", recd[1]);
 293                                 assertEquals("2", sent[2]);
 294                                 assertEquals("4", recd[2]);
 295                         }
 296                 });
 297         }
 298
 299         private SerialServerTest(final String[] args, final String key,
 300                         final String skey, final boolean bridge, final String sbridge,
 301                         final Object title) {
 302
 303                 super(title + " " + skey + sbridge, args);
 304
 305                 addTest(new TestCase("Simple connection " + skey) {
 306                         @Override
 307                         public void test() throws Exception {
 308                                 final Object[] rec = new Object[1];
 309
 310                                 ServerObject server = new ServerObject(this.getName(), 0, key) {
 311                                         @Override
 312                                         protected Object onRequest(
 313                                                         ConnectActionServerObject action, Object data)
 314                                                         throws Exception {
 315                                                 return null;
 316                                         }
 317
 318                                         @Override
 319                                         protected void onError(Exception e) {
 320                                         }
 321                                 };
 322
 323                                 int port = server.getPort();
 324                                 assertEquals("A port should have been assigned", true, port > 0);
 325
 326                                 server.start();
 327
 328                                 ServerBridge br = null;
 329                                 if (bridge) {
 330                                         br = new ServerBridge(0, key, "", port, key);
 331                                         br.setTraceHandler(null);
 332                                         port = br.getPort();
 333                                         br.start();
 334                                 }
 335
 336                                 try {
 337                                         try {
 338                                                 new ConnectActionClientObject(null, port, key) {
 339                                                         @Override
 340                                                         public void action() throws Exception {
 341                                                                 rec[0] = true;
 342                                                         }
 343
 344                                                         @Override
 345                                                         protected void onError(Exception e) {
 346                                                         }
 347                                                 }.connect();
 348                                         } finally {
 349                                                 server.stop();
 350                                         }
 351                                 } finally {
 352                                         if (br != null) {
 353                                                 br.stop();
 354                                         }
 355                                 }
 356
 357                                 assertNotNull("The client action was not run", rec[0]);
 358                                 assertEquals(true, (boolean) ((Boolean) rec[0]));
 359                         }
 360                 });
 361
 362                 addTest(new TestCase("Simple exchange " + skey) {
 363                         final Object[] sent = new Object[1];
 364                         final Object[] recd = new Object[1];
 365                         final Exception[] err = new Exception[1];
 366
 367                         @Override
 368                         public void test() throws Exception {
 369                                 ServerObject server = new ServerObject(this.getName(), 0, key) {
 370                                         @Override
 371                                         protected Object onRequest(
 372                                                         ConnectActionServerObject action, Object data)
 373                                                         throws Exception {
 374                                                 sent[0] = data;
 375                                                 return "pong";
 376                                         }
 377
 378                                         @Override
 379                                         protected void onError(Exception e) {
 380                                                 err[0] = e;
 381                                         }
 382                                 };
 383
 384                                 int port = server.getPort();
 385
 386                                 server.start();
 387
 388                                 ServerBridge br = null;
 389                                 if (bridge) {
 390                                         br = new ServerBridge(0, key, "", port, key);
 391                                         br.setTraceHandler(null);
 392                                         port = br.getPort();
 393                                         br.start();
 394                                 }
 395
 396                                 try {
 397                                         try {
 398                                                 new ConnectActionClientObject(null, port, key) {
 399                                                         @Override
 400                                                         public void action() throws Exception {
 401                                                                 recd[0] = send("ping");
 402                                                         }
 403                                                 }.connect();
 404                                         } finally {
 405                                                 server.stop();
 406                                         }
 407                                 } finally {
 408                                         if (br != null) {
 409                                                 br.stop();
 410                                         }
 411                                 }
 412
 413                                 if (err[0] != null) {
 414                                         fail("An exception was thrown: " + err[0].getMessage(),
 415                                                         err[0]);
 416                                 }
 417
 418                                 assertEquals("ping", sent[0]);
 419                                 assertEquals("pong", recd[0]);
 420                         }
 421                 });
 422
 423                 addTest(new TestCase("Multiple exchanges " + skey) {
 424                         final Object[] sent = new Object[3];
 425                         final Object[] recd = new Object[3];
 426                         final Exception[] err = new Exception[1];
 427
 428                         @Override
 429                         public void test() throws Exception {
 430                                 ServerObject server = new ServerObject(this.getName(), 0, key) {
 431                                         @Override
 432                                         protected Object onRequest(
 433                                                         ConnectActionServerObject action, Object data)
 434                                                         throws Exception {
 435                                                 sent[0] = data;
 436                                                 action.send("pong");
 437                                                 sent[1] = action.rec();
 438                                                 return "pong2";
 439                                         }
 440
 441                                         @Override
 442                                         protected void onError(Exception e) {
 443                                                 err[0] = e;
 444                                         }
 445                                 };
 446
 447                                 int port = server.getPort();
 448
 449                                 server.start();
 450
 451                                 ServerBridge br = null;
 452                                 if (bridge) {
 453                                         br = new ServerBridge(0, key, "", port, key);
 454                                         br.setTraceHandler(null);
 455                                         port = br.getPort();
 456                                         br.start();
 457                                 }
 458
 459                                 try {
 460                                         try {
 461                                                 new ConnectActionClientObject(null, port, key) {
 462                                                         @Override
 463                                                         public void action() throws Exception {
 464                                                                 recd[0] = send("ping");
 465                                                                 recd[1] = send("ping2");
 466                                                         }
 467                                                 }.connect();
 468                                         } finally {
 469                                                 server.stop();
 470                                         }
 471                                 } finally {
 472                                         if (br != null) {
 473                                                 br.stop();
 474                                         }
 475                                 }
 476
 477                                 if (err[0] != null) {
 478                                         fail("An exception was thrown: " + err[0].getMessage(),
 479                                                         err[0]);
 480                                 }
 481
 482                                 assertEquals("ping", sent[0]);
 483                                 assertEquals("pong", recd[0]);
 484                                 assertEquals("ping2", sent[1]);
 485                                 assertEquals("pong2", recd[1]);
 486                         }
 487                 });
 488
 489                 addTest(new TestCase("Object array of URLs " + skey) {
 490                         final Object[] sent = new Object[1];
 491                         final Object[] recd = new Object[1];
 492                         final Exception[] err = new Exception[1];
 493
 494                         @Override
 495                         public void test() throws Exception {
 496                                 ServerObject server = new ServerObject(this.getName(), 0, key) {
 497                                         @Override
 498                                         protected Object onRequest(
 499                                                         ConnectActionServerObject action, Object data)
 500                                                         throws Exception {
 501                                                 sent[0] = data;
 502                                                 return new Object[] { "ACK" };
 503                                         }
 504
 505                                         @Override
 506                                         protected void onError(Exception e) {
 507                                                 err[0] = e;
 508                                         }
 509                                 };
 510
 511                                 int port = server.getPort();
 512
 513                                 server.start();
 514
 515                                 ServerBridge br = null;
 516                                 if (bridge) {
 517                                         br = new ServerBridge(0, key, "", port, key);
 518                                         br.setTraceHandler(null);
 519                                         port = br.getPort();
 520                                         br.start();
 521                                 }
 522
 523                                 try {
 524                                         try {
 525                                                 new ConnectActionClientObject(null, port, key) {
 526                                                         @Override
 527                                                         public void action() throws Exception {
 528                                                                 recd[0] = send(new Object[] {
 529                                                                                 "key",
 530                                                                                 new URL(
 531                                                                                                 "https://example.com/from_client"),
 532                                                                                 "https://example.com/from_client" });
 533                                                         }
 534                                                 }.connect();
 535                                         } finally {
 536                                                 server.stop();
 537                                         }
 538                                 } finally {
 539                                         if (br != null) {
 540                                                 br.stop();
 541                                         }
 542                                 }
 543
 544                                 if (err[0] != null) {
 545                                         fail("An exception was thrown: " + err[0].getMessage(),
 546                                                         err[0]);
 547                                 }
 548
 549                                 Object[] sento = (Object[]) (sent[0]);
 550                                 Object[] recdo = (Object[]) (recd[0]);
 551
 552                                 assertEquals("key", sento[0]);
 553                                 assertEquals("https://example.com/from_client",
 554                                                 ((URL) sento[1]).toString());
 555                                 assertEquals("https://example.com/from_client", sento[2]);
 556                                 assertEquals("ACK", recdo[0]);
 557                         }
 558                 });
 559
 560                 addTest(new TestCase("Multiple call from client " + skey) {
 561                         final Object[] sent = new Object[3];
 562                         final Object[] recd = new Object[3];
 563                         final Exception[] err = new Exception[1];
 564
 565                         @Override
 566                         public void test() throws Exception {
 567                                 ServerObject server = new ServerObject(this.getName(), 0, key) {
 568                                         @Override
 569                                         protected Object onRequest(
 570                                                         ConnectActionServerObject action, Object data)
 571                                                         throws Exception {
 572                                                 sent[(Integer) data] = data;
 573                                                 return ((Integer) data) * 2;
 574                                         }
 575
 576                                         @Override
 577                                         protected void onError(Exception e) {
 578                                                 err[0] = e;
 579                                         }
 580                                 };
 581
 582                                 int port = server.getPort();
 583
 584                                 server.start();
 585
 586                                 ServerBridge br = null;
 587                                 if (bridge) {
 588                                         br = new ServerBridge(0, key, "", port, key);
 589                                         br.setTraceHandler(null);
 590                                         port = br.getPort();
 591                                         br.start();
 592                                 }
 593
 594                                 try {
 595                                         try {
 596                                                 new ConnectActionClientObject(null, port, key) {
 597                                                         @Override
 598                                                         public void action() throws Exception {
 599                                                                 for (int i = 0; i < 3; i++) {
 600                                                                         recd[i] = send(i);
 601                                                                 }
 602                                                         }
 603                                                 }.connect();
 604                                         } finally {
 605                                                 server.stop();
 606                                         }
 607                                 } finally {
 608                                         if (br != null) {
 609                                                 br.stop();
 610                                         }
 611                                 }
 612
 613                                 if (err[0] != null) {
 614                                         fail("An exception was thrown: " + err[0].getMessage(),
 615                                                         err[0]);
 616                                 }
 617
 618                                 assertEquals(0, sent[0]);
 619                                 assertEquals(0, recd[0]);
 620                                 assertEquals(1, sent[1]);
 621                                 assertEquals(2, recd[1]);
 622                                 assertEquals(2, sent[2]);
 623                                 assertEquals(4, recd[2]);
 624                         }
 625                 });
 626         }
 627 }