Added users options to DBCreateOptions

src/main/java/com/arangodb/model/DBCreateOptions.java

@@ -20,18 +20,38 @@
 
 package com.arangodb.model;
 
+import java.util.Collection;
+
 /**
  * @author Mark Vollmary
  */
 public class DBCreateOptions {
 
+    private Collection<DatabaseUsersOptions> users;
     private String name;
     private DatabaseOptions options;
 
     public DBCreateOptions() {
         super();
     }
 
+    public Collection<DatabaseUsersOptions> getUsers() {
+        return users;
+    }
+
+    /**
+     * @param users array of user objects to initially create for the new database.
+     *              User information will not be changed for users that already exist.
+     *              If users is not specified or does not contain any users, a default user
+     *              root will be created with an empty string password. This ensures that the
+     *              new database will be accessible after it is created.
+     * @return options
+     */
+    public DBCreateOptions users(final Collection<DatabaseUsersOptions> users) {
+        this.users = users;
+        return this;
+    }
+
     public String getName() {
         return name;
     }

src/main/java/com/arangodb/model/DatabaseUsersOptions.java

@@ -0,0 +1,90 @@
+/*
+ * DISCLAIMER
+ *
+ * Copyright 2016 ArangoDB GmbH, Cologne, Germany
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ */
+
+package com.arangodb.model;
+
+import java.util.Map;
+
+/**
+ * @author Michele Rastelli
+ */
+public class DatabaseUsersOptions {
+
+    private String username;
+    private Map<String, Object> extra;
+    private String passwd;
+    private Boolean active;
+
+    public String getUsername() {
+        return username;
+    }
+
+    /**
+     * @param username Login name of the user to be created
+     * @return options
+     */
+    public DatabaseUsersOptions username(final String username) {
+        this.username = username;
+        return this;
+    }
+
+    public Map<String, Object> getExtra() {
+        return extra;
+    }
+
+    /**
+     * @param extra extra user information. The data contained in extra
+     *              will be stored for the user but not be interpreted further by ArangoDB.
+     * @return options
+     */
+    public DatabaseUsersOptions extra(final Map<String, Object> extra) {
+        this.extra = extra;
+        return this;
+    }
+
+    public String getPasswd() {
+        return passwd;
+    }
+
+    /**
+     * @param passwd The user password as a string. If not specified, it will default to an empty string.
+     * @return options
+     */
+    public DatabaseUsersOptions passwd(final String passwd) {
+        this.passwd = passwd;
+        return this;
+    }
+
+    public Boolean getActive() {
+        return active;
+    }
+
+    /**
+     * @param active A flag indicating whether the user account should be activated or not.
+     *               The default value is true. If set to false, the user won't be able to
+     *               log into the database.
+     * @return options
+     */
+    public DatabaseUsersOptions active(final Boolean active) {
+        this.active = active;
+        return this;
+    }
+
+}

src/test/java/com/arangodb/ArangoDBTest.java

@@ -83,105 +83,146 @@ public static void shutdown() {
 
     @Parameters
     public static List<ArangoDB> builders() {
-		return BaseTest.arangos;
-	}
+        return BaseTest.arangos;
+    }
 
-	public ArangoDBTest(final ArangoDB arangoDB) {
-		super();
-		this.arangoDB = arangoDB;
-		db1 = arangoDB.db(DB1);
-		db2 = arangoDB.db(DB2);
-	}
+    public ArangoDBTest(final ArangoDB arangoDB) {
+        super();
+        this.arangoDB = arangoDB;
+        db1 = arangoDB.db(DB1);
+        db2 = arangoDB.db(DB2);
+    }
 
-	private boolean isEnterprise() {
-		return arangoDB.getVersion().getLicense() == License.ENTERPRISE;
-	}
+    private boolean isEnterprise() {
+        return arangoDB.getVersion().getLicense() == License.ENTERPRISE;
+    }
 
-	private boolean isCluster() {
-		return arangoDB.getRole() == ServerRole.COORDINATOR;
-	}
+    private boolean isCluster() {
+        return arangoDB.getRole() == ServerRole.COORDINATOR;
+    }
 
-	private boolean isAtLeastVersion(final int major, final int minor) {
+    private boolean isAtLeastVersion(final int major, final int minor) {
         return TestUtils.isAtLeastVersion(arangoDB.getVersion().getVersion(), major, minor, 0);
-	}
-
-	@Test
-	public void getVersion() {
-		final ArangoDBVersion version = arangoDB.getVersion();
-		assertThat(version, is(notNullValue()));
-		assertThat(version.getServer(), is(notNullValue()));
-		assertThat(version.getVersion(), is(notNullValue()));
-	}
-
-	@Test
-	public void createAndDeleteDatabase() {
-		final String dbName = "testDB-" + UUID.randomUUID().toString();
-		final Boolean resultCreate = arangoDB.createDatabase(dbName);
-		assertThat(resultCreate, is(true));
-		final Boolean resultDelete = arangoDB.db(dbName).drop();
-		assertThat(resultDelete, is(true));
-	}
-
-	@Test
-	public void createDatabaseWithOptions() {
-		assumeTrue(isCluster());
-		assumeTrue(isAtLeastVersion(3, 6));
-		final String dbName = "testDB-" + UUID.randomUUID().toString();
-		final Boolean resultCreate = arangoDB.createDatabase(new DBCreateOptions()
-				.name(dbName)
-				.options(new DatabaseOptions()
-						.writeConcern(2)
-						.replicationFactor(2)
-						.sharding("")
-				)
-		);
-		assertThat(resultCreate, is(true));
-
-		DatabaseEntity info = arangoDB.db(dbName).getInfo();
-		assertThat(info.getReplicationFactor(), is(2));
-		assertThat(info.getWriteConcern(), is(2));
-		assertThat(info.getSharding(), is(""));
-		assertThat(info.getSatellite(), nullValue());
-
-		final Boolean resultDelete = arangoDB.db(dbName).drop();
-		assertThat(resultDelete, is(true));
-	}
-
-	@Test
+    }
+
+    @Test
+    public void getVersion() {
+        final ArangoDBVersion version = arangoDB.getVersion();
+        assertThat(version, is(notNullValue()));
+        assertThat(version.getServer(), is(notNullValue()));
+        assertThat(version.getVersion(), is(notNullValue()));
+    }
+
+    @Test
+    public void createAndDeleteDatabase() {
+        final String dbName = "testDB-" + UUID.randomUUID().toString();
+        final Boolean resultCreate = arangoDB.createDatabase(dbName);
+        assertThat(resultCreate, is(true));
+        final Boolean resultDelete = arangoDB.db(dbName).drop();
+        assertThat(resultDelete, is(true));
+    }
+
+    @Test
+    public void createDatabaseWithOptions() {
+        assumeTrue(isCluster());
+        assumeTrue(isAtLeastVersion(3, 6));
+        final String dbName = "testDB-" + UUID.randomUUID().toString();
+        final Boolean resultCreate = arangoDB.createDatabase(new DBCreateOptions()
+                .name(dbName)
+                .options(new DatabaseOptions()
+                        .writeConcern(2)
+                        .replicationFactor(2)
+                        .sharding("")
+                )
+        );
+        assertThat(resultCreate, is(true));
+
+        DatabaseEntity info = arangoDB.db(dbName).getInfo();
+        assertThat(info.getReplicationFactor(), is(2));
+        assertThat(info.getWriteConcern(), is(2));
+        assertThat(info.getSharding(), is(""));
+        assertThat(info.getSatellite(), nullValue());
+
+        final Boolean resultDelete = arangoDB.db(dbName).drop();
+        assertThat(resultDelete, is(true));
+    }
+
+    @Test
 	public void createDatabaseWithOptionsSatellite() {
-		assumeTrue(isCluster());
-		assumeTrue(isEnterprise());
-		assumeTrue(isAtLeastVersion(3, 6));
-
-		final String dbName = "testDB-" + UUID.randomUUID().toString();
-		final Boolean resultCreate = arangoDB.createDatabase(new DBCreateOptions()
-				.name(dbName)
-				.options(new DatabaseOptions()
-						.writeConcern(2)
-						.satellite(true)
-						.sharding("")
-				)
-		);
-		assertThat(resultCreate, is(true));
-
-		DatabaseEntity info = arangoDB.db(dbName).getInfo();
-		assertThat(info.getReplicationFactor(), nullValue());
-		assertThat(info.getSatellite(), is(true));
-		assertThat(info.getWriteConcern(), is(2));
-		assertThat(info.getSharding(), is(""));
-
-		final Boolean resultDelete = arangoDB.db(dbName).drop();
-		assertThat(resultDelete, is(true));
-	}
-
-	@Test
-	public void getDatabases() {
-		Collection<String> dbs = arangoDB.getDatabases();
-		assertThat(dbs, is(notNullValue()));
-		assertThat(dbs.size(), is(greaterThan(0)));
-		assertThat(dbs.contains("_system"), is(true));
-		assertThat(dbs, hasItem(DB1));
-	}
+        assumeTrue(isCluster());
+        assumeTrue(isEnterprise());
+        assumeTrue(isAtLeastVersion(3, 6));
+
+        final String dbName = "testDB-" + UUID.randomUUID().toString();
+        final Boolean resultCreate = arangoDB.createDatabase(new DBCreateOptions()
+                .name(dbName)
+                .options(new DatabaseOptions()
+                        .writeConcern(2)
+                        .satellite(true)
+                        .sharding("")
+                )
+        );
+        assertThat(resultCreate, is(true));
+
+        DatabaseEntity info = arangoDB.db(dbName).getInfo();
+        assertThat(info.getReplicationFactor(), nullValue());
+        assertThat(info.getSatellite(), is(true));
+        assertThat(info.getWriteConcern(), is(2));
+        assertThat(info.getSharding(), is(""));
+
+        final Boolean resultDelete = arangoDB.db(dbName).drop();
+        assertThat(resultDelete, is(true));
+    }
+
+    @Test
+    public void createDatabaseWithUsers() {
+        final String dbName = "testDB-" + UUID.randomUUID().toString();
+        final Map<String, Object> extra = Collections.singletonMap("key", "value");
+        final Boolean resultCreate = arangoDB.createDatabase(new DBCreateOptions()
+                .name(dbName)
+                .users(Collections.singletonList(new DatabaseUsersOptions()
+                        .active(true)
+                        .username("testUser")
+                        .passwd("testPasswd")
+                        .extra(extra)
+                ))
+        );
+        assertThat(resultCreate, is(true));
+
+        DatabaseEntity info = arangoDB.db(dbName).getInfo();
+        assertThat(info.getName(), is(dbName));
+
+        Optional<UserEntity> retrievedUserOptional = arangoDB.getUsers().stream()
+                .filter(it -> it.getUser().equals("testUser"))
+                .findFirst();
+        assertThat(retrievedUserOptional.isPresent(), is(true));
+
+        UserEntity retrievedUser = retrievedUserOptional.get();
+        assertThat(retrievedUser.getActive(), is(true));
+        assertThat(retrievedUser.getExtra(), is(extra));
+
+        ArangoDB arangoDBTestUser = new ArangoDB.Builder()
+                .user("testUser")
+                .password("testPasswd")
+                .build();
+
+        // check if testUser has been created and can access the created db
+        ArangoCollection collection = arangoDBTestUser.db(dbName).collection("col-" + UUID.randomUUID().toString());
+        collection.create();
+        arangoDBTestUser.shutdown();
+
+        final Boolean resultDelete = arangoDB.db(dbName).drop();
+        assertThat(resultDelete, is(true));
+    }
+
+    @Test
+    public void getDatabases() {
+        Collection<String> dbs = arangoDB.getDatabases();
+        assertThat(dbs, is(notNullValue()));
+        assertThat(dbs.size(), is(greaterThan(0)));
+        assertThat(dbs.contains("_system"), is(true));
+        assertThat(dbs, hasItem(DB1));
+    }
 
     @Test
     public void getAccessibleDatabases() {