sdk/java/src/test/java/org/arvados/sdk/java/ArvadosTest.java

   1 package org.arvados.sdk.java;
   2
   3 import java.io.File;
   4 import java.io.FileInputStream;
   5 import java.math.BigDecimal;
   6 import java.util.ArrayList;
   7 import java.util.Calendar;
   8 import java.util.Date;
   9 import java.util.GregorianCalendar;
  10 import java.util.HashMap;
  11 import java.util.List;
  12 import java.util.Map;
  13 import java.util.Set;
  14
  15 import org.junit.Test;
  16
  17 import static org.junit.Assert.*;
  18
  19 /**
  20  * Unit test for Arvados.
  21  */
  22 public class ArvadosTest {
  23
  24   /**
  25    * Test users.list api
  26    * @throws Exception
  27    */
  28   @Test
  29   public void testCallUsersList() throws Exception {
  30     Arvados arv = new Arvados("arvados", "v1");
  31
  32     Map<String, Object> params = new HashMap<String, Object>();
  33
  34     Map response = arv.call("users", "list", params);
  35     assertEquals("Expected kind to be users.list", "arvados#userList", response.get("kind"));
  36
  37     List items = (List)response.get("items");
  38     assertNotNull("expected users list items", items);
  39     assertTrue("expected at least one item in users list", items.size()>0);
  40
  41     Map firstUser = (Map)items.get(0);
  42     assertNotNull ("Expcted at least one user", firstUser);
  43
  44     assertEquals("Expected kind to be user", "arvados#user", firstUser.get("kind"));
  45     assertNotNull("Expected uuid for first user", firstUser.get("uuid"));
  46   }
  47
  48   /**
  49    * Test users.get <uuid> api
  50    * @throws Exception
  51    */
  52   @Test
  53   public void testCallUsersGet() throws Exception {
  54     Arvados arv = new Arvados("arvados", "v1");
  55
  56     // call user.system and get uuid of this user
  57     Map<String, Object> params = new HashMap<String, Object>();
  58
  59     Map response = arv.call("users", "list", params);
  60
  61     assertNotNull("expected users list", response);
  62     List items = (List)response.get("items");
  63     assertNotNull("expected users list items", items);
  64
  65     Map firstUser = (Map)items.get(0);
  66     String userUuid = (String)firstUser.get("uuid");
  67
  68     // invoke users.get with the system user uuid
  69     params = new HashMap<String, Object>();
  70     params.put("uuid", userUuid);
  71
  72     response = arv.call("users", "get", params);
  73
  74     assertNotNull("Expected uuid for first user", response.get("uuid"));
  75     assertEquals("Expected system user uuid", userUuid, response.get("uuid"));
  76   }
  77
  78   /**
  79    * Test users.create api
  80    * @throws Exception
  81    */
  82   @Test
  83   public void testCreateUser() throws Exception {
  84     Arvados arv = new Arvados("arvados", "v1");
  85
  86     Map<String, Object> params = new HashMap<String, Object>();
  87     params.put("user", "{}");
  88     Map response = arv.call("users", "create", params);
  89
  90     assertEquals("Expected kind to be user", "arvados#user", response.get("kind"));
  91
  92     Object uuid = response.get("uuid");
  93     assertNotNull("Expected uuid for first user", uuid);
  94
  95     // delete the object
  96     params = new HashMap<String, Object>();
  97     params.put("uuid", uuid);
  98     response = arv.call("users", "delete", params);
  99
 100     // invoke users.get with the system user uuid
 101     params = new HashMap<String, Object>();
 102     params.put("uuid", uuid);
 103
 104     Exception caught = null;
 105     try {
 106       arv.call("users", "get", params);
 107     } catch (Exception e) {
 108       caught = e;
 109     }
 110
 111     assertNotNull ("expected exception", caught);
 112     assertTrue ("Expected 404", caught.getMessage().contains("Path not found"));
 113   }
 114
 115   @Test
 116   public void testCreateUserWithMissingRequiredParam() throws Exception {
 117     Arvados arv = new Arvados("arvados", "v1");
 118
 119     Map<String, Object> params = new HashMap<String, Object>();
 120
 121     Exception caught = null;
 122     try {
 123       arv.call("users", "create", params);
 124     } catch (Exception e) {
 125       caught = e;
 126     }
 127
 128     assertNotNull ("expected exception", caught);
 129     assertTrue ("Expected POST method requires content object user",
 130         caught.getMessage().contains("ERROR: POST method requires content object user"));
 131   }
 132
 133   /**
 134    * Test users.create api
 135    * @throws Exception
 136    */
 137   @Test
 138   public void testCreateAndUpdateUser() throws Exception {
 139     Arvados arv = new Arvados("arvados", "v1");
 140
 141     Map<String, Object> params = new HashMap<String, Object>();
 142     params.put("user", "{}");
 143     Map response = arv.call("users", "create", params);
 144
 145     assertEquals("Expected kind to be user", "arvados#user", response.get("kind"));
 146
 147     Object uuid = response.get("uuid");
 148     assertNotNull("Expected uuid for first user", uuid);
 149
 150     // update this user
 151     params = new HashMap<String, Object>();
 152     params.put("user", "{}");
 153     params.put("uuid", uuid);
 154     response = arv.call("users", "update", params);
 155
 156     assertEquals("Expected kind to be user", "arvados#user", response.get("kind"));
 157
 158     uuid = response.get("uuid");
 159     assertNotNull("Expected uuid for first user", uuid);
 160
 161     // delete the object
 162     params = new HashMap<String, Object>();
 163     params.put("uuid", uuid);
 164     response = arv.call("users", "delete", params);
 165   }
 166
 167   /**
 168    * Test unsupported api version api
 169    * @throws Exception
 170    */
 171   @Test
 172   public void testUnsupportedApiName() throws Exception {
 173     Exception caught = null;
 174     try {
 175       Arvados arv = new Arvados("not_arvados", "v1");
 176     } catch (Exception e) {
 177       caught = e;
 178     }
 179
 180     assertNotNull ("expected exception", caught);
 181     assertTrue ("Expected 404 when unsupported api is used", caught.getMessage().contains("404 Not Found"));
 182   }
 183
 184   /**
 185    * Test unsupported api version api
 186    * @throws Exception
 187    */
 188   @Test
 189   public void testUnsupportedVersion() throws Exception {
 190     Exception caught = null;
 191     try {
 192       Arvados arv = new Arvados("arvados", "v2");
 193     } catch (Exception e) {
 194       caught = e;
 195     }
 196
 197     assertNotNull ("expected exception", caught);
 198     assertTrue ("Expected 404 when unsupported version is used", caught.getMessage().contains("404 Not Found"));
 199   }
 200
 201   /**
 202    * Test unsupported api version api
 203    * @throws Exception
 204    */
 205   @Test
 206   public void testCallForNoSuchResrouce() throws Exception {
 207     Arvados arv = new Arvados("arvados", "v1");
 208
 209     Exception caught = null;
 210     try {
 211       arv.call("abcd", "list", null);
 212     } catch (Exception e) {
 213       caught = e;
 214     }
 215
 216     assertNotNull ("expected exception", caught);
 217     assertTrue ("Expected ERROR: 404 not found", caught.getMessage().contains("ERROR: resource not found"));
 218   }
 219
 220   /**
 221    * Test unsupported api version api
 222    * @throws Exception
 223    */
 224   @Test
 225   public void testCallForNoSuchResrouceMethod() throws Exception {
 226     Arvados arv = new Arvados("arvados", "v1");
 227
 228     Exception caught = null;
 229     try {
 230       arv.call("users", "abcd", null);
 231     } catch (Exception e) {
 232       caught = e;
 233     }
 234
 235     assertNotNull ("expected exception", caught);
 236     assertTrue ("Expected ERROR: 404 not found", caught.getMessage().contains("ERROR: method not found"));
 237   }
 238
 239   /**
 240    * Test pipeline_tempates.create api
 241    * @throws Exception
 242    */
 243   @Test
 244   public void testCreateAndGetPipelineTemplate() throws Exception {
 245     Arvados arv = new Arvados("arvados", "v1");
 246
 247     File file = new File(getClass().getResource( "/first_pipeline.json" ).toURI());
 248     byte[] data = new byte[(int)file.length()];
 249     try {
 250       FileInputStream is = new FileInputStream(file);
 251       is.read(data);
 252       is.close();
 253     }catch(Exception e) {
 254       e.printStackTrace();
 255     }
 256
 257     Map<String, Object> params = new HashMap<String, Object>();
 258     params.put("pipeline_template", new String(data));
 259     Map response = arv.call("pipeline_templates", "create", params);
 260
 261     assertEquals("Expected kind to be user", "arvados#pipelineTemplate", response.get("kind"));
 262     String uuid = (String)response.get("uuid");
 263     assertNotNull("Expected uuid for pipeline template", uuid);
 264
 265     // get the pipeline
 266     params = new HashMap<String, Object>();
 267     params.put("uuid", uuid);
 268     response = arv.call("pipeline_templates", "get", params);
 269
 270     assertEquals("Expected kind to be user", "arvados#pipelineTemplate", response.get("kind"));
 271     assertEquals("Expected uuid for pipeline template", uuid, response.get("uuid"));
 272
 273     // delete the object
 274     params = new HashMap<String, Object>();
 275     params.put("uuid", uuid);
 276     response = arv.call("pipeline_templates", "delete", params);
 277   }
 278
 279   /**
 280    * Test users.list api
 281    * @throws Exception
 282    */
 283   @Test
 284   public void testArvadosWithTokenPassed() throws Exception {
 285     String token = System.getenv().get("ARVADOS_API_TOKEN");
 286     String host = System.getenv().get("ARVADOS_API_HOST");
 287     String hostInsecure = System.getenv().get("ARVADOS_API_HOST_INSECURE");
 288
 289     Arvados arv = new Arvados("arvados", "v1", token, host, hostInsecure);
 290
 291     Map<String, Object> params = new HashMap<String, Object>();
 292
 293     Map response = arv.call("users", "list", params);
 294     assertEquals("Expected kind to be users.list", "arvados#userList", response.get("kind"));
 295   }
 296
 297   /**
 298    * Test users.list api
 299    * @throws Exception
 300    */
 301   @Test
 302   public void testCallUsersListWithLimit() throws Exception {
 303     Arvados arv = new Arvados("arvados", "v1");
 304
 305     Map<String, Object> params = new HashMap<String, Object>();
 306
 307     Map response = arv.call("users", "list", params);
 308     assertEquals("Expected users.list in response", "arvados#userList", response.get("kind"));
 309
 310     List items = (List)response.get("items");
 311     assertNotNull("expected users list items", items);
 312     assertTrue("expected at least one item in users list", items.size()>0);
 313
 314     int numUsersListItems = items.size();
 315
 316     // make the request again with limit
 317     params = new HashMap<String, Object>();
 318     params.put("limit", numUsersListItems-1);
 319
 320     response = arv.call("users", "list", params);
 321
 322     assertEquals("Expected kind to be users.list", "arvados#userList", response.get("kind"));
 323
 324     items = (List)response.get("items");
 325     assertNotNull("expected users list items", items);
 326     assertTrue("expected at least one item in users list", items.size()>0);
 327
 328     int numUsersListItems2 = items.size();
 329     assertEquals ("Got more users than requested", numUsersListItems-1, numUsersListItems2);
 330   }
 331
 332   @Test
 333   public void testGetLinksWithFilters() throws Exception {
 334     Arvados arv = new Arvados("arvados", "v1");
 335
 336     Map<String, Object> params = new HashMap<String, Object>();
 337
 338     Map response = arv.call("links", "list", params);
 339     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 340
 341     String[][] filters = new String[1][];
 342     String[] condition = new String[3];
 343     condition[0] = "name";
 344     condition[1] = "=";
 345     condition[2] = "can_manage";
 346     filters[0] = condition;
 347     params.put("filters", filters);
 348
 349     response = arv.call("links", "list", params);
 350
 351     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 352     assertFalse("Expected no can_manage in response", response.toString().contains("\"name\":\"can_manage\""));
 353   }
 354
 355   @Test
 356   public void testGetLinksWithFiltersAsList() throws Exception {
 357     Arvados arv = new Arvados("arvados", "v1");
 358
 359     Map<String, Object> params = new HashMap<String, Object>();
 360
 361     Map response = arv.call("links", "list", params);
 362     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 363
 364     List<List> filters = new ArrayList<List>();
 365     List<String> condition = new ArrayList<String>();
 366     condition.add("name");
 367     condition.add("is_a");
 368     condition.add("can_manage");
 369     filters.add(condition);
 370     params.put("filters", filters);
 371
 372     response = arv.call("links", "list", params);
 373
 374     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 375     assertFalse("Expected no can_manage in response", response.toString().contains("\"name\":\"can_manage\""));
 376   }
 377
 378   @Test
 379   public void testGetLinksWithTimestampFilters() throws Exception {
 380     Arvados arv = new Arvados("arvados", "v1");
 381
 382     Map<String, Object> params = new HashMap<String, Object>();
 383
 384     Map response = arv.call("links", "list", params);
 385     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 386
 387     // get links created "tomorrow". Expect none in response
 388     Calendar calendar = new GregorianCalendar();
 389     calendar.setTime(new Date());
 390     calendar.add(Calendar.DAY_OF_MONTH, 1);
 391
 392     Object[][] filters = new Object[1][];
 393     Object[] condition = new Object[3];
 394     condition[0] = "created_at";
 395     condition[1] = ">";
 396     condition[2] = calendar.get(Calendar.YEAR) + "-" + (calendar.get(Calendar.MONTH)+1) + "-" + calendar.get(Calendar.DAY_OF_MONTH);
 397     filters[0] = condition;
 398     params.put("filters", filters);
 399
 400     response = arv.call("links", "list", params);
 401
 402     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 403     int items_avail = ((BigDecimal)response.get("items_available")).intValue();
 404     assertEquals("Expected zero links", items_avail, 0);
 405   }
 406
 407   @Test
 408   public void testGetLinksWithWhereClause() throws Exception {
 409     Arvados arv = new Arvados("arvados", "v1");
 410
 411     Map<String, Object> params = new HashMap<String, Object>();
 412
 413     Map<String, String> where = new HashMap<String, String>();
 414     where.put("where", "updated_at > '2014-05-01'");
 415
 416     params.put("where", where);
 417
 418     Map response = arv.call("links", "list", params);
 419
 420     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 421   }
 422
 423   @Test
 424   public void testGetAvailableResources() throws Exception {
 425     Arvados arv = new Arvados("arvados", "v1");
 426     Set<String> resources = arv.getAvailableResourses();
 427     assertNotNull("Expected resources", resources);
 428     assertTrue("Excected users in resrouces", resources.contains("users"));
 429   }
 430
 431   @Test
 432   public void testGetAvailableMethodsResources() throws Exception {
 433     Arvados arv = new Arvados("arvados", "v1");
 434     Set<String> methods = arv.getAvailableMethodsForResourse("users");
 435     assertNotNull("Expected resources", methods);
 436     assertTrue("Excected create method for users", methods.contains("create"));
 437   }
 438
 439   @Test
 440   public void testGetAvailableParametersForUsersGetMethod() throws Exception {
 441     Arvados arv = new Arvados("arvados", "v1");
 442     Map<String,List<String>> parameters = arv.getAvailableParametersForMethod("users", "get");
 443     assertNotNull("Expected parameters", parameters);
 444     assertTrue("Excected uuid parameter for get method for users", parameters.get("required").contains("uuid"));
 445   }
 446
 447   @Test
 448   public void testGetAvailableParametersForUsersCreateMethod() throws Exception {
 449     Arvados arv = new Arvados("arvados", "v1");
 450     Map<String,List<String>> parameters = arv.getAvailableParametersForMethod("users", "create");
 451     assertNotNull("Expected parameters", parameters);
 452     assertTrue("Excected user parameter for get method for users", parameters.get("required").contains("user"));
 453   }
 454
 455   @Test
 456   public void testGetAvailableParametersForUsersListMethod() throws Exception {
 457     Arvados arv = new Arvados("arvados", "v1");
 458     Map<String,List<String>> parameters = arv.getAvailableParametersForMethod("users", "list");
 459     assertNotNull("Expected parameters", parameters);
 460     assertTrue("Excected no required parameter for list method for users", parameters.get("required").size() == 0);
 461     assertTrue("Excected some optional parameters for list method for users", parameters.get("optional").contains("filters"));
 462   }
 463
 464 }