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

   1 package org.arvados.sdk;
   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     assertEquals("Expected kind to be user", "arvados#pipelineTemplate", response.get("kind"));
 261     String uuid = (String)response.get("uuid");
 262     assertNotNull("Expected uuid for pipeline template", uuid);
 263
 264     // get the pipeline
 265     params = new HashMap<String, Object>();
 266     params.put("uuid", uuid);
 267     response = arv.call("pipeline_templates", "get", params);
 268
 269     assertEquals("Expected kind to be user", "arvados#pipelineTemplate", response.get("kind"));
 270     assertEquals("Expected uuid for pipeline template", uuid, response.get("uuid"));
 271
 272     // delete the object
 273     params = new HashMap<String, Object>();
 274     params.put("uuid", uuid);
 275     response = arv.call("pipeline_templates", "delete", params);
 276   }
 277
 278   /**
 279    * Test users.list api
 280    * @throws Exception
 281    */
 282   @Test
 283   public void testArvadosWithTokenPassed() throws Exception {
 284     String token = System.getenv().get("ARVADOS_API_TOKEN");
 285     String host = System.getenv().get("ARVADOS_API_HOST");
 286     String hostInsecure = System.getenv().get("ARVADOS_API_HOST_INSECURE");
 287
 288     Arvados arv = new Arvados("arvados", "v1", token, host, hostInsecure);
 289
 290     Map<String, Object> params = new HashMap<String, Object>();
 291
 292     Map response = arv.call("users", "list", params);
 293     assertEquals("Expected kind to be users.list", "arvados#userList", response.get("kind"));
 294   }
 295
 296   /**
 297    * Test users.list api
 298    * @throws Exception
 299    */
 300   @Test
 301   public void testCallUsersListWithLimit() throws Exception {
 302     Arvados arv = new Arvados("arvados", "v1");
 303
 304     Map<String, Object> params = new HashMap<String, Object>();
 305
 306     Map response = arv.call("users", "list", params);
 307     assertEquals("Expected users.list in response", "arvados#userList", response.get("kind"));
 308
 309     List items = (List)response.get("items");
 310     assertNotNull("expected users list items", items);
 311     assertTrue("expected at least one item in users list", items.size()>0);
 312
 313     int numUsersListItems = items.size();
 314
 315     // make the request again with limit
 316     params = new HashMap<String, Object>();
 317     params.put("limit", numUsersListItems-1);
 318
 319     response = arv.call("users", "list", params);
 320
 321     assertEquals("Expected kind to be users.list", "arvados#userList", response.get("kind"));
 322
 323     items = (List)response.get("items");
 324     assertNotNull("expected users list items", items);
 325     assertTrue("expected at least one item in users list", items.size()>0);
 326
 327     int numUsersListItems2 = items.size();
 328     assertEquals ("Got more users than requested", numUsersListItems-1, numUsersListItems2);
 329   }
 330
 331   @Test
 332   public void testGetLinksWithFilters() throws Exception {
 333     Arvados arv = new Arvados("arvados", "v1");
 334
 335     Map<String, Object> params = new HashMap<String, Object>();
 336
 337     Map response = arv.call("links", "list", params);
 338     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 339
 340     String[][] filters = new String[1][];
 341     String[] condition = new String[3];
 342     condition[0] = "name";
 343     condition[1] = "=";
 344     condition[2] = "can_manage";
 345     filters[0] = condition;
 346     params.put("filters", filters);
 347
 348     response = arv.call("links", "list", params);
 349
 350     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 351     assertFalse("Expected no can_manage in response", response.toString().contains("\"name\":\"can_manage\""));
 352   }
 353
 354   @Test
 355   public void testGetLinksWithFiltersAsList() throws Exception {
 356     Arvados arv = new Arvados("arvados", "v1");
 357
 358     Map<String, Object> params = new HashMap<String, Object>();
 359
 360     Map response = arv.call("links", "list", params);
 361     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 362
 363     List<List> filters = new ArrayList<List>();
 364     List<String> condition = new ArrayList<String>();
 365     condition.add("name");
 366     condition.add("is_a");
 367     condition.add("can_manage");
 368     filters.add(condition);
 369     params.put("filters", filters);
 370
 371     response = arv.call("links", "list", params);
 372
 373     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 374     assertFalse("Expected no can_manage in response", response.toString().contains("\"name\":\"can_manage\""));
 375   }
 376
 377   @Test
 378   public void testGetLinksWithTimestampFilters() throws Exception {
 379     Arvados arv = new Arvados("arvados", "v1");
 380
 381     Map<String, Object> params = new HashMap<String, Object>();
 382
 383     Map response = arv.call("links", "list", params);
 384     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 385
 386     // get links created "tomorrow". Expect none in response
 387     Calendar calendar = new GregorianCalendar();
 388     calendar.setTime(new Date());
 389     calendar.add(Calendar.DAY_OF_MONTH, 1);
 390
 391     Object[][] filters = new Object[1][];
 392     Object[] condition = new Object[3];
 393     condition[0] = "created_at";
 394     condition[1] = ">";
 395     condition[2] = calendar.get(Calendar.YEAR) + "-" + (calendar.get(Calendar.MONTH)+1) + "-" + calendar.get(Calendar.DAY_OF_MONTH);
 396     filters[0] = condition;
 397     params.put("filters", filters);
 398
 399     response = arv.call("links", "list", params);
 400
 401     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 402     int items_avail = ((BigDecimal)response.get("items_available")).intValue();
 403     assertEquals("Expected zero links", items_avail, 0);
 404   }
 405
 406   @Test
 407   public void testGetLinksWithWhereClause() throws Exception {
 408     Arvados arv = new Arvados("arvados", "v1");
 409
 410     Map<String, Object> params = new HashMap<String, Object>();
 411
 412     Map<String, String> where = new HashMap<String, String>();
 413     where.put("where", "updated_at > '2014-05-01'");
 414
 415     params.put("where", where);
 416
 417     Map response = arv.call("links", "list", params);
 418
 419     assertEquals("Expected links.list in response", "arvados#linkList", response.get("kind"));
 420   }
 421
 422   @Test
 423   public void testGetAvailableResources() throws Exception {
 424     Arvados arv = new Arvados("arvados", "v1");
 425     Set<String> resources = arv.getAvailableResourses();
 426     assertNotNull("Expected resources", resources);
 427     assertTrue("Excected users in resrouces", resources.contains("users"));
 428   }
 429
 430   @Test
 431   public void testGetAvailableMethodsResources() throws Exception {
 432     Arvados arv = new Arvados("arvados", "v1");
 433     Set<String> methods = arv.getAvailableMethodsForResourse("users");
 434     assertNotNull("Expected resources", methods);
 435     assertTrue("Excected create method for users", methods.contains("create"));
 436   }
 437
 438   @Test
 439   public void testGetAvailableParametersForUsersGetMethod() throws Exception {
 440     Arvados arv = new Arvados("arvados", "v1");
 441     Map<String,List<String>> parameters = arv.getAvailableParametersForMethod("users", "get");
 442     assertNotNull("Expected parameters", parameters);
 443     assertTrue("Excected uuid parameter for get method for users", parameters.get("required").contains("uuid"));
 444   }
 445
 446   @Test
 447   public void testGetAvailableParametersForUsersCreateMethod() throws Exception {
 448     Arvados arv = new Arvados("arvados", "v1");
 449     Map<String,List<String>> parameters = arv.getAvailableParametersForMethod("users", "create");
 450     assertNotNull("Expected parameters", parameters);
 451     assertTrue("Excected user parameter for get method for users", parameters.get("required").contains("user"));
 452   }
 453
 454   @Test
 455   public void testGetAvailableParametersForUsersListMethod() throws Exception {
 456     Arvados arv = new Arvados("arvados", "v1");
 457     Map<String,List<String>> parameters = arv.getAvailableParametersForMethod("users", "list");
 458     assertNotNull("Expected parameters", parameters);
 459     assertTrue("Excected no required parameter for list method for users", parameters.get("required").size() == 0);
 460     assertTrue("Excected some optional parameters for list method for users", parameters.get("optional").contains("filters"));
 461   }
 462
 463 }