test/unit/voldemort/server/rest/RestServerProtocolTests.java

   1 package voldemort.server.rest;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.fail;
   5
   6 import java.io.BufferedReader;
   7 import java.io.IOException;
   8 import java.io.InputStreamReader;
   9 import java.io.OutputStream;
  10 import java.net.HttpURLConnection;
  11 import java.net.URL;
  12
  13 import org.apache.commons.codec.binary.Base64;
  14 import org.apache.log4j.Logger;
  15 import org.junit.AfterClass;
  16 import org.junit.BeforeClass;
  17 import org.junit.Test;
  18
  19 import voldemort.coordinator.CoordinatorUtils;
  20 import voldemort.server.VoldemortConfig;
  21 import voldemort.server.VoldemortServer;
  22 import voldemort.versioning.VectorClock;
  23
  24 public class RestServerProtocolTests {
  25
  26     private static String storeNameStr;
  27     private static String key1;
  28     private static String urlStr;
  29     private static String value1;
  30     private static String contentType;
  31     private static long timeOut, originTime;
  32     private static int routingType;
  33     private static VectorClock vectorClock;
  34     private static String eTag;
  35     private static VoldemortServer server;
  36     private static VoldemortConfig config;
  37     private static Logger logger = Logger.getLogger(RestServerProtocolTests.class);
  38
  39     /*
  40      * TODO REST-Server: Hard coded storeName and urlStr. They must be retrieved
  41      * from config
  42      */
  43
  44     @BeforeClass
  45     public static void oneTimeSetUp() {
  46         storeNameStr = "test";
  47         urlStr = "http://localhost:8081/";
  48         config = VoldemortConfig.loadFromVoldemortHome("config/single_node_cluster/");
  49         key1 = "The longest key ";
  50         vectorClock = new VectorClock();
  51         vectorClock.incrementVersion(config.getNodeId(), System.currentTimeMillis());
  52         eTag = CoordinatorUtils.getSerializedVectorClock(vectorClock);
  53         value1 = "The longest value";
  54         timeOut = 1000L;
  55         contentType = "text";
  56         originTime = System.currentTimeMillis();
  57         routingType = 2;
  58         server = new VoldemortServer(config);
  59         if(!server.isStarted())
  60             server.start();
  61         System.out.println("********************Starting REST Server********************");
  62     }
  63
  64     @AfterClass
  65     public static void oneTimeCleanUp() {
  66         if(server != null && server.isStarted()) {
  67             server.stop();
  68         }
  69     }
  70
  71     public HttpURLConnection doPut(String url,
  72                                    String key,
  73                                    String value,
  74                                    String storeName,
  75                                    String originTime,
  76                                    String timeOut,
  77                                    String routingType,
  78                                    String vectorClock,
  79                                    String ContentType,
  80                                    String contentLength) throws IOException {
  81
  82         HttpURLConnection conn = createConnection(url,
  83                                                   key,
  84                                                   storeName,
  85                                                   originTime,
  86                                                   timeOut,
  87                                                   routingType,
  88                                                   "POST");
  89         conn.setDoOutput(true);
  90         if(vectorClock != null) {
  91             conn.setRequestProperty(RestMessageHeaders.X_VOLD_VECTOR_CLOCK, vectorClock);
  92         }
  93         if(ContentType != null) {
  94             conn.setRequestProperty("Content-Type", ContentType);
  95         }
  96         if(contentLength != null) {
  97             conn.setRequestProperty("Content-Length", contentLength);
  98         }
  99
 100         if(value != null) {
 101             OutputStream out = conn.getOutputStream();
 102             out.write(value.getBytes());
 103             out.close();
 104         }
 105         return conn;
 106     }
 107
 108     public HttpURLConnection doDelete(String url,
 109                                       String key,
 110                                       String storeName,
 111                                       String originTime,
 112                                       String timeOut,
 113                                       String routingType,
 114                                       String vectorClock) throws IOException {
 115         HttpURLConnection conn = createConnection(url,
 116                                                   key,
 117                                                   storeName,
 118                                                   originTime,
 119                                                   timeOut,
 120                                                   routingType,
 121                                                   "DELETE");
 122         if(vectorClock != null) {
 123             conn.setRequestProperty(RestMessageHeaders.X_VOLD_VECTOR_CLOCK, vectorClock);
 124         }
 125         return conn;
 126
 127     }
 128
 129     public HttpURLConnection doGet(String url,
 130                                    String key,
 131                                    String storeName,
 132                                    String originTime,
 133                                    String timeOut,
 134                                    String routingType) throws IOException {
 135
 136         HttpURLConnection conn = createConnection(url,
 137                                                   key,
 138                                                   storeName,
 139                                                   originTime,
 140                                                   timeOut,
 141                                                   routingType,
 142                                                   "GET");
 143         return conn;
 144     }
 145
 146     /**
 147      * Creates a basic put/get/delete request with common required headers.
 148      *
 149      * @param urlString
 150      * @param key
 151      * @param storeName
 152      * @param originTime
 153      * @param timeOut
 154      * @param routingType
 155      * @param method
 156      * @return
 157      * @throws IOException
 158      */
 159     public HttpURLConnection createConnection(String urlString,
 160                                               String key,
 161                                               String storeName,
 162                                               String originTime,
 163                                               String timeOut,
 164                                               String routingType,
 165                                               String method) throws IOException {
 166
 167         HttpURLConnection conn = null;
 168         URL url;
 169         String urlStr = urlString;
 170         String base64Key = "";
 171         if(storeName != null) {
 172             urlStr += storeName + "/";
 173         }
 174         if(key != null) {
 175             base64Key = new String(Base64.encodeBase64(key.getBytes()));
 176             url = new URL(urlStr + base64Key);
 177         } else {
 178             url = new URL(urlStr);
 179         }
 180         conn = (HttpURLConnection) url.openConnection();
 181         conn.setRequestMethod(method);
 182         conn.setDoInput(true);
 183
 184         if(originTime != null) {
 185             conn.setRequestProperty(RestMessageHeaders.X_VOLD_REQUEST_ORIGIN_TIME_MS,
 186                                     String.valueOf(originTime));
 187         }
 188         if(timeOut != null) {
 189             conn.setRequestProperty(RestMessageHeaders.X_VOLD_REQUEST_TIMEOUT_MS,
 190                                     String.valueOf(timeOut));
 191         }
 192         if(routingType != null) {
 193             conn.setRequestProperty(RestMessageHeaders.X_VOLD_ROUTING_TYPE_CODE,
 194                                     String.valueOf(routingType));
 195         }
 196         return conn;
 197
 198     }
 199
 200     public void readErrorMessageFromResponse(HttpURLConnection conn) throws IOException {
 201         BufferedReader bufferedReader;
 202         bufferedReader = new BufferedReader(new InputStreamReader(conn.getErrorStream()));
 203         StringBuilder stringBuilder = new StringBuilder();
 204         String line;
 205         while((line = bufferedReader.readLine()) != null) {
 206             stringBuilder.append(line);
 207         }
 208         bufferedReader.close();
 209         logger.info(stringBuilder.toString());
 210     }
 211
 212     @Test
 213     public void testMissingRoutingType() {
 214         logger.info("********** Testing missing routing type **********");
 215         HttpURLConnection conn = null;
 216         int responseCode = -1;
 217         try {
 218             conn = doPut(urlStr,
 219                          key1,
 220                          value1,
 221                          storeNameStr,
 222                          String.valueOf(originTime),
 223                          String.valueOf(timeOut),
 224                          null,
 225                          eTag,
 226                          contentType,
 227                          String.valueOf(value1.getBytes().length));
 228
 229             responseCode = conn.getResponseCode();
 230             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 231             readErrorMessageFromResponse(conn);
 232         } catch(IOException e1) {
 233             e1.printStackTrace();
 234         }
 235         assertEquals(responseCode, 400);
 236         conn.disconnect();
 237     }
 238
 239     @Test
 240     public void testInvalidRoutingType() {
 241         logger.info("********** Testing invalid routing type **********");
 242         HttpURLConnection conn = null;
 243         int responseCode = -1;
 244         try {
 245             conn = doGet(urlStr,
 246                          key1,
 247                          storeNameStr,
 248                          String.valueOf(originTime),
 249                          String.valueOf(timeOut),
 250                          String.valueOf(6));
 251
 252             responseCode = conn.getResponseCode();
 253             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 254             readErrorMessageFromResponse(conn);
 255         } catch(IOException e1) {
 256             e1.printStackTrace();
 257         }
 258         assertEquals(responseCode, 400);
 259         conn.disconnect();
 260     }
 261
 262     @Test
 263     public void testNonNumberRoutingType() {
 264         logger.info("********** Testing non number Routing Type **********");
 265         HttpURLConnection conn = null;
 266         int responseCode = -1;
 267         try {
 268             conn = doDelete(urlStr,
 269                             key1,
 270                             storeNameStr,
 271                             String.valueOf(originTime),
 272                             String.valueOf(timeOut),
 273                             "asdfa",
 274                             eTag);
 275
 276             responseCode = conn.getResponseCode();
 277             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 278             readErrorMessageFromResponse(conn);
 279         } catch(IOException e1) {
 280             e1.printStackTrace();
 281         }
 282         assertEquals(responseCode, 400);
 283         conn.disconnect();
 284     }
 285
 286     @Test
 287     public void testMissingTimeOut() {
 288         logger.info("********** Testing missing time out **********");
 289         HttpURLConnection conn = null;
 290         int responseCode = -1;
 291         try {
 292             conn = doPut(urlStr,
 293                          key1,
 294                          value1,
 295                          storeNameStr,
 296                          String.valueOf(originTime),
 297                          null,
 298                          String.valueOf(routingType),
 299                          eTag,
 300                          contentType,
 301                          String.valueOf(value1.getBytes().length));
 302             responseCode = conn.getResponseCode();
 303             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 304             readErrorMessageFromResponse(conn);
 305         } catch(IOException e) {
 306             e.printStackTrace();
 307         }
 308         assertEquals(responseCode, 400);
 309         conn.disconnect();
 310     }
 311
 312     @Test
 313     public void testNonNumberTimeOut() {
 314         logger.info("********** Testing non number time out **********");
 315         HttpURLConnection conn = null;
 316         int responseCode = -1;
 317         try {
 318             conn = doGet(urlStr,
 319                          key1,
 320                          storeNameStr,
 321                          String.valueOf(originTime),
 322                          "asdfasdf",
 323                          String.valueOf(routingType));
 324             responseCode = conn.getResponseCode();
 325             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 326             readErrorMessageFromResponse(conn);
 327         } catch(IOException e) {
 328             e.printStackTrace();
 329         }
 330         assertEquals(responseCode, 400);
 331         conn.disconnect();
 332     }
 333
 334     @Test
 335     public void testMissingTimeStamp() {
 336         logger.info("********** Testing missing time stamp **********");
 337         HttpURLConnection conn = null;
 338         int responseCode = -1;
 339         try {
 340             conn = doDelete(urlStr,
 341                             key1,
 342                             storeNameStr,
 343                             null,
 344                             String.valueOf(timeOut),
 345                             String.valueOf(routingType),
 346                             eTag);
 347             responseCode = conn.getResponseCode();
 348             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 349             readErrorMessageFromResponse(conn);
 350         } catch(IOException e) {
 351             e.printStackTrace();
 352         }
 353         assertEquals(responseCode, 400);
 354         conn.disconnect();
 355     }
 356
 357     @Test
 358     public void testNonNumberTimeStamp() {
 359         logger.info("********** Testing non number time out **********");
 360         HttpURLConnection conn = null;
 361         int responseCode = -1;
 362         try {
 363             conn = doPut(urlStr,
 364                          key1,
 365                          value1,
 366                          storeNameStr,
 367                          "asdfasdf",
 368                          String.valueOf(timeOut),
 369                          String.valueOf(routingType),
 370                          eTag,
 371                          contentType,
 372                          String.valueOf(value1.getBytes().length));
 373             responseCode = conn.getResponseCode();
 374             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 375             readErrorMessageFromResponse(conn);
 376         } catch(IOException e) {
 377             e.printStackTrace();
 378         }
 379         assertEquals(responseCode, 400);
 380         conn.disconnect();
 381     }
 382
 383     @Test
 384     public void testMissingKey() {
 385         logger.info("********** Testing missing key **********");
 386         HttpURLConnection conn = null;
 387         int responseCode = -1;
 388         try {
 389             conn = doGet(urlStr,
 390                          null,
 391                          storeNameStr,
 392                          String.valueOf(originTime),
 393                          String.valueOf(timeOut),
 394                          String.valueOf(routingType));
 395             responseCode = conn.getResponseCode();
 396             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 397             readErrorMessageFromResponse(conn);
 398         } catch(IOException e) {
 399             e.printStackTrace();
 400         }
 401         assertEquals(responseCode, 400);
 402         conn.disconnect();
 403     }
 404
 405     @Test
 406     public void testMissingStoreName() {
 407         logger.info("********** Testing missing store name **********");
 408         HttpURLConnection conn = null;
 409         int responseCode = -1;
 410         try {
 411             conn = doDelete(urlStr,
 412                             key1,
 413                             null,
 414                             String.valueOf(originTime),
 415                             String.valueOf(timeOut),
 416                             String.valueOf(routingType),
 417                             eTag);
 418             responseCode = conn.getResponseCode();
 419             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 420             readErrorMessageFromResponse(conn);
 421         } catch(IOException e) {
 422             e.printStackTrace();
 423         }
 424         assertEquals(responseCode, 400);
 425         conn.disconnect();
 426     }
 427
 428     @Test
 429     public void testInvalidStoreName() {
 430         logger.info("********** Testing invalid store name **********");
 431         HttpURLConnection conn = null;
 432         int responseCode = -1;
 433         try {
 434             conn = doGet(urlStr,
 435                          key1,
 436                          "blahblah",
 437                          String.valueOf(originTime),
 438                          String.valueOf(timeOut),
 439                          String.valueOf(routingType));
 440             responseCode = conn.getResponseCode();
 441             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 442             readErrorMessageFromResponse(conn);
 443         } catch(IOException e) {
 444             e.printStackTrace();
 445         }
 446         assertEquals(responseCode, 400);
 447         conn.disconnect();
 448     }
 449
 450     @Test
 451     public void testMissingVectorClock() {
 452         logger.info("********** Testing missing vector clock **********");
 453         HttpURLConnection conn = null;
 454         int responseCode = -1;
 455         try {
 456             conn = doPut(urlStr,
 457                          key1,
 458                          value1,
 459                          storeNameStr,
 460                          String.valueOf(originTime),
 461                          String.valueOf(timeOut),
 462                          String.valueOf(routingType),
 463                          null,
 464                          contentType,
 465                          String.valueOf(value1.getBytes().length));
 466             responseCode = conn.getResponseCode();
 467             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 468             readErrorMessageFromResponse(conn);
 469         } catch(IOException e) {
 470             e.printStackTrace();
 471         }
 472         assertEquals(responseCode, 400);
 473         conn.disconnect();
 474     }
 475
 476     @Test
 477     public void testInvalidVectorClock() {
 478         logger.info("********** Testing invalid  vector clock **********");
 479         HttpURLConnection conn = null;
 480         int responseCode = -1;
 481         try {
 482             conn = doDelete(urlStr,
 483                             key1,
 484                             storeNameStr,
 485                             String.valueOf(originTime),
 486                             String.valueOf(timeOut),
 487                             String.valueOf(routingType),
 488                             "gvkjhgvlj");
 489             responseCode = conn.getResponseCode();
 490             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 491             readErrorMessageFromResponse(conn);
 492         } catch(IOException e) {
 493             e.printStackTrace();
 494         }
 495         assertEquals(responseCode, 400);
 496         conn.disconnect();
 497     }
 498
 499     @Test
 500     public void testGetWithNonExistingKey() {
 501         logger.info("********** Testing get with non existing key **********");
 502         HttpURLConnection conn = null;
 503         int responseCode = -1;
 504         try {
 505             conn = doGet(urlStr,
 506                          "non existing key",
 507                          storeNameStr,
 508                          String.valueOf(originTime),
 509                          String.valueOf(timeOut),
 510                          String.valueOf(routingType));
 511             responseCode = conn.getResponseCode();
 512             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 513             readErrorMessageFromResponse(conn);
 514         } catch(IOException e) {
 515             e.printStackTrace();
 516         }
 517         assertEquals(responseCode, 404);
 518         conn.disconnect();
 519     }
 520
 521     @Test
 522     public void testGetAllWithNonExistingKey() {
 523         logger.info("********** Testing get all with all non existing keys **********");
 524         HttpURLConnection conn = null;
 525         int responseCode = -1;
 526         try {
 527             conn = doGet(urlStr,
 528                          "non existing key1, non existing key2",
 529                          storeNameStr,
 530                          String.valueOf(originTime),
 531                          String.valueOf(timeOut),
 532                          String.valueOf(routingType));
 533             responseCode = conn.getResponseCode();
 534             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 535             readErrorMessageFromResponse(conn);
 536         } catch(IOException e) {
 537             e.printStackTrace();
 538         }
 539         assertEquals(responseCode, 404);
 540         conn.disconnect();
 541     }
 542
 543     @Test
 544     public void testObsoleteVersionException() throws IOException {
 545         logger.info("********** Testing obsolete version exception **********");
 546
 547         // setUP
 548         deleteKeysCreated(key1, eTag);
 549
 550         HttpURLConnection conn = null;
 551         int responseCode = -1;
 552         try {
 553             conn = doPut(urlStr,
 554                          key1,
 555                          value1,
 556                          storeNameStr,
 557                          String.valueOf(originTime),
 558                          String.valueOf(timeOut),
 559                          String.valueOf(routingType),
 560                          eTag,
 561                          contentType,
 562                          String.valueOf(value1.getBytes().length));
 563             responseCode = conn.getResponseCode();
 564             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 565             if(responseCode != 200 && responseCode != 201) {
 566                 fail("Initial put failed");
 567             } else {
 568                 conn.disconnect();
 569                 conn = doPut(urlStr,
 570                              key1,
 571                              value1,
 572                              storeNameStr,
 573                              String.valueOf(originTime),
 574                              String.valueOf(timeOut),
 575                              String.valueOf(routingType),
 576                              eTag,
 577                              contentType,
 578                              String.valueOf(value1.getBytes().length));
 579                 responseCode = conn.getResponseCode();
 580                 logger.info("Response Code: " + responseCode + " Message: "
 581                             + conn.getResponseMessage());
 582                 readErrorMessageFromResponse(conn);
 583             }
 584         } catch(IOException e) {
 585             e.printStackTrace();
 586         }
 587         assertEquals(responseCode, 412);
 588         conn.disconnect();
 589
 590         // cleanup
 591         deleteKeysCreated(key1, eTag);
 592     }
 593
 594     @Test
 595     public void testDeleteWithNonExistingKey() {
 596         logger.info("********** Testing delete non existing key **********");
 597         HttpURLConnection conn = null;
 598         int responseCode = -1;
 599         try {
 600             conn = doDelete(urlStr,
 601                             "non existing key",
 602                             storeNameStr,
 603                             String.valueOf(originTime),
 604                             String.valueOf(timeOut),
 605                             String.valueOf(routingType),
 606                             eTag);
 607             responseCode = conn.getResponseCode();
 608             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 609             readErrorMessageFromResponse(conn);
 610
 611         } catch(IOException e) {
 612             e.printStackTrace();
 613         }
 614         assertEquals(responseCode, 404);
 615         conn.disconnect();
 616     }
 617
 618     @Test
 619     public void testDeleteLowerVersion() throws IOException {
 620         logger.info("********** Testing delete lower version **********");
 621         // setup
 622         deleteKeysCreated(key1, eTag);
 623
 624         HttpURLConnection conn = null;
 625         int responseCode = -1;
 626         String eTag2 = null;
 627         try {
 628             conn = doPut(urlStr,
 629                          key1,
 630                          value1,
 631                          storeNameStr,
 632                          String.valueOf(originTime),
 633                          String.valueOf(timeOut),
 634                          String.valueOf(routingType),
 635                          eTag,
 636                          contentType,
 637                          String.valueOf(value1.getBytes().length));
 638             responseCode = conn.getResponseCode();
 639             logger.info("Response Code: " + responseCode + " Message: " + conn.getResponseMessage());
 640             conn.disconnect();
 641             if(responseCode != 200 && responseCode != 201) {
 642                 fail("Initial put failed");
 643             } else {
 644                 VectorClock vc = vectorClock.incremented(config.getNodeId(),
 645                                                          System.currentTimeMillis());
 646                 eTag2 = CoordinatorUtils.getSerializedVectorClock(vc);
 647                 String value2 = "The next longest value";
 648                 conn = doPut(urlStr,
 649                              key1,
 650                              value2,
 651                              storeNameStr,
 652                              String.valueOf(originTime),
 653                              String.valueOf(timeOut),
 654                              String.valueOf(routingType),
 655                              eTag2,
 656                              contentType,
 657                              String.valueOf(value2.getBytes().length));
 658                 responseCode = conn.getResponseCode();
 659                 logger.info("Response Code: " + responseCode + " Message: "
 660                             + conn.getResponseMessage());
 661                 conn.disconnect();
 662                 if(responseCode != 201) {
 663                     fail("Second put failed");
 664                 } else {
 665                     conn = doDelete(urlStr,
 666                                     key1,
 667                                     storeNameStr,
 668                                     String.valueOf(originTime),
 669                                     String.valueOf(timeOut),
 670                                     String.valueOf(routingType),
 671                                     eTag);
 672                     responseCode = conn.getResponseCode();
 673                     logger.info("Response Code: " + responseCode + " Message: "
 674                                 + conn.getResponseMessage());
 675                     readErrorMessageFromResponse(conn);
 676                 }
 677             }
 678         } catch(IOException e) {
 679             e.printStackTrace();
 680         }
 681         assertEquals(responseCode, 404);
 682         conn.disconnect();
 683
 684         // cleanUP specific to this test case
 685         deleteKeysCreated(key1, eTag);
 686         deleteKeysCreated(key1, eTag2);
 687
 688     }
 689
 690     // cleanup method
 691     public void deleteKeysCreated(String key, String eTag) throws IOException {
 692         HttpURLConnection conn = null;
 693         conn = doDelete(urlStr,
 694                         key,
 695                         storeNameStr,
 696                         String.valueOf(originTime),
 697                         String.valueOf(timeOut),
 698                         String.valueOf(routingType),
 699                         eTag);
 700         conn.getResponseCode();
 701         conn.disconnect();
 702     }
 703 }