[jbpm-commits] JBoss JBPM SVN: r3678 - in jbpm3/trunk/modules/identity/src: main/java/org/jbpm/identity/assignment and 7 other directories.
do-not-reply at jboss.org
do-not-reply at jboss.org
Mon Jan 19 18:36:52 EST 2009
Author: alex.guizar at jboss.com
Date: 2009-01-19 18:36:52 -0500 (Mon, 19 Jan 2009)
New Revision: 3678
Modified:
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Entity.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Group.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Membership.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/User.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/assignment/ExpressionAssignmentHandler.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySchema.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySession.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/PermissionUserType.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/AuthenticatedUser.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityLoginModule.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityPolicy.java
jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/xml/IdentityXmlParser.java
jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/MembershipTest.java
jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java
jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/GroupDbTest.java
jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java
jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/xml/IdentityXmlParsingTest.java
Log:
generalize identity module
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Entity.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Entity.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Entity.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,9 +21,10 @@
*/
package org.jbpm.identity;
-import java.io.*;
-import java.security.*;
-import java.util.*;
+import java.io.Serializable;
+import java.security.Permission;
+import java.util.HashSet;
+import java.util.Set;
/**
* common supertype for users, groups and memberships
@@ -36,7 +37,7 @@
long id = 0;
protected String name = null;
/* permissions is a set of java.security.Permission's */
- protected Set permissions = null;
+ protected Set<Permission> permissions = null;
// constructors /////////////////////////////////////////////////////////////
@@ -47,7 +48,7 @@
this.name = name;
}
- public Entity(String name, Set permissions) {
+ public Entity(String name, Set<Permission> permissions) {
this.name = name;
this.permissions = permissions;
}
@@ -55,10 +56,10 @@
// permissions //////////////////////////////////////////////////////////////
public void addPermission(Permission permission) {
- if (permissions==null) permissions = new HashSet();
+ if (permissions==null) permissions = new HashSet<Permission>();
permissions.add(permission);
}
- public Set getPermissions() {
+ public Set<Permission> getPermissions() {
return permissions;
}
public void removePermission(Permission permission) {
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Group.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Group.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Group.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,25 +21,22 @@
*/
package org.jbpm.identity;
-import java.util.*;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
/**
- * group of users.
- *
- * <p>The group type allows for the distinction of
- * hierarchical groups, security roles and others.
+ * group of users.
+ * <p>
+ * The group type allows for the distinction of hierarchical groups, security roles and others.
* </p>
- *
* <p>
- * Following name convention is recommended for
- * assigning group types :
+ * Following name convention is recommended for assigning group types :
* <ul>
- * <li><b>hierarchy</b>: for hierarchical groups
- * like teams, business units and companies.</li>
- * <li><b>security-role</b>: for j2ee and servlet
- * security roles like admin, user, ...</li>
+ * <li><b>hierarchy</b>: for hierarchical groups like teams, business units and companies.</li>
+ * <li><b>security-role</b>: for j2ee and servlet security roles like admin, user, ...</li>
* </ul>
- * </p>
+ * </p>
*/
public class Group extends Entity {
@@ -47,8 +44,8 @@
protected String type = null;
protected Group parent = null;
- protected Set children = null;
- protected Set memberships = null;
+ protected Set<Group> children = null;
+ protected Set<Membership> memberships = null;
public Group() {
}
@@ -63,67 +60,81 @@
}
public void addMembership(Membership membership) {
- if (memberships==null) memberships = new HashSet();
+ if (memberships == null)
+ memberships = new HashSet<Membership>();
memberships.add(membership);
membership.setGroup(this);
}
-
+
public void addChild(Group child) {
- if (children==null) children = new HashSet();
+ if (children == null)
+ children = new HashSet<Group>();
children.add(child);
child.setParent(this);
}
-
- public Set getUsers() {
- Set users = new HashSet();
- if(memberships!=null) {
- Iterator iter = memberships.iterator();
- while (iter.hasNext()) {
- Membership membership = (Membership) iter.next();
+
+ public Set<User> getUsers() {
+ Set<User> users;
+ if (memberships != null) {
+ users = new HashSet<User>();
+ for (Membership membership : memberships) {
users.add(membership.getUser());
}
}
+ else {
+ users = Collections.emptySet();
+ }
return users;
}
- public Set getUsersForMembershipRole(String membershipRole) {
- Set users = new HashSet();
- if(memberships!=null) {
- Iterator iter = memberships.iterator();
- while (iter.hasNext()) {
- Membership membership = (Membership) iter.next();
- if (membershipRole.equals(membership.getRole())){
+ public Set<User> getUsersForMembershipRole(String membershipRole) {
+ Set<User> users;
+ if (memberships != null) {
+ users = new HashSet<User>();
+ for (Membership membership : memberships) {
+ if (membershipRole.equals(membership.getRole())) {
users.add(membership.getUser());
}
}
}
+ else {
+ users = Collections.emptySet();
+ }
return users;
}
public long getId() {
return id;
}
- public Set getMemberships() {
+
+ public Set<Membership> getMemberships() {
return memberships;
}
- public Set getChildren() {
+
+ public Set<Group> getChildren() {
return children;
}
+
public Group getParent() {
return parent;
}
+
public String getType() {
return type;
}
+
public void setType(String type) {
this.type = type;
}
- public void setChildren(Set children) {
+
+ public void setChildren(Set<Group> children) {
this.children = children;
}
- public void setMemberships(Set memberships) {
+
+ public void setMemberships(Set<Membership> memberships) {
this.memberships = memberships;
}
+
public void setParent(Group parent) {
this.parent = parent;
}
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Membership.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Membership.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/Membership.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,16 +21,14 @@
*/
package org.jbpm.identity;
-import java.io.*;
-
/**
* one association between user and a group.
* The name of the membership represents the role-name that
- * the user fullfills in the group.
- * A membership can be a position in an organisation, therefor
+ * the user fulfills in the group.
+ * A membership can be a position in an organisation, therefore
* permissions can be associated with a membership.
* The name of the membership can be used as the role name. Meaning
- * which role does the user fullfill in the group.
+ * which role does the user fulfill in the group.
*/
public class Membership extends Entity {
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/User.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/User.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/User.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,8 +21,10 @@
*/
package org.jbpm.identity;
-import java.security.*;
-import java.util.*;
+import java.security.Principal;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
/**
* user or a system.
@@ -30,11 +32,11 @@
public class User extends Entity implements Principal {
private static final long serialVersionUID = 1L;
-
+
protected String password = null;
protected String email = null;
- protected Set memberships = null;
-
+ protected Set<Membership> memberships = null;
+
public User() {
}
@@ -43,51 +45,60 @@
}
public void addMembership(Membership membership) {
- if (memberships==null) memberships = new HashSet();
+ if (memberships == null)
+ memberships = new HashSet<Membership>();
memberships.add(membership);
membership.setUser(this);
}
-
- public Set getGroupsForGroupType(String groupType) {
- Set groups = new HashSet();
- if(memberships!=null) {
- Iterator iter = memberships.iterator();
- while (iter.hasNext()) {
- Membership membership = (Membership) iter.next();
+
+ public Set<Group> getGroupsForGroupType(String groupType) {
+ Set<Group> groups;
+ if (memberships != null) {
+ groups = new HashSet<Group>();
+ for (Membership membership : memberships) {
if (groupType.equals(membership.getGroup().getType())) {
groups.add(membership.getGroup());
}
}
}
+ else {
+ groups = Collections.emptySet();
+ }
return groups;
}
- public Set getGroupsForMembershipRole(String membershipRole) {
- Set groups = new HashSet();
- if(memberships!=null) {
- Iterator iter = memberships.iterator();
- while (iter.hasNext()) {
- Membership membership = (Membership) iter.next();
+ public Set<Group> getGroupsForMembershipRole(String membershipRole) {
+ Set<Group> groups;
+ if (memberships != null) {
+ groups = new HashSet<Group>();
+ for (Membership membership : memberships) {
if (membershipRole.equals(membership.getRole())) {
groups.add(membership.getGroup());
}
}
}
+ else {
+ groups = Collections.emptySet();
+ }
return groups;
}
public void setPassword(String password) {
this.password = password;
}
+
public String getPassword() {
return password;
}
- public Set getMemberships() {
+
+ public Set<Membership> getMemberships() {
return memberships;
}
+
public String getEmail() {
return email;
}
+
public void setEmail(String email) {
this.email = email;
}
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/assignment/ExpressionAssignmentHandler.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/assignment/ExpressionAssignmentHandler.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/assignment/ExpressionAssignmentHandler.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -166,11 +166,11 @@
&& (term.endsWith(")")) ) {
String groupType = term.substring(6,term.length()-1).trim();
User user = (User) entity;
- Set groups = user.getGroupsForGroupType(groupType);
- if (groups.size()==0) {
+ Set<Group> groups = user.getGroupsForGroupType(groupType);
+ if (groups.isEmpty()) {
throw new ExpressionAssignmentException("no groups for group-type '"+groupType+"'");
}
- entity = (Entity) groups.iterator().next();
+ entity = groups.iterator().next();
} else if ( (term.startsWith("member("))
&& (term.endsWith(")")) ) {
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySchema.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySchema.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySchema.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,30 +21,39 @@
*/
package org.jbpm.identity.hibernate;
-import java.io.*;
-import java.lang.reflect.*;
-import java.sql.*;
-import java.util.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Iterator;
import java.util.List;
+import java.util.Properties;
-import org.apache.commons.logging.*;
-import org.hibernate.cfg.*;
-import org.hibernate.connection.*;
-import org.hibernate.dialect.*;
-import org.hibernate.engine.*;
-import org.hibernate.mapping.*;
-import org.hibernate.tool.hbm2ddl.*;
-import org.hibernate.util.*;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.cfg.Settings;
+import org.hibernate.connection.ConnectionProvider;
+import org.hibernate.dialect.Dialect;
+import org.hibernate.engine.Mapping;
+import org.hibernate.mapping.ForeignKey;
+import org.hibernate.mapping.Table;
+import org.hibernate.tool.hbm2ddl.SchemaExport;
+import org.hibernate.util.JDBCExceptionReporter;
import org.jbpm.JbpmException;
public class IdentitySchema {
private static final String IDENTITY_TABLE_PREFIX = "JBPM_ID_";
-
+
Configuration configuration = null;
- Properties properties = null;
- Dialect dialect = null;
- Mapping mapping = null;
+ Settings settings;
String[] createSql = null;
String[] dropSql = null;
String[] cleanSql = null;
@@ -55,154 +64,150 @@
public IdentitySchema(Configuration configuration) {
this.configuration = configuration;
- this.properties = configuration.getProperties();
- this.dialect = Dialect.getDialect(properties);
- try {
- // get the mapping field via reflection :-(
- Field mappingField = Configuration.class.getDeclaredField("mapping");
- mappingField.setAccessible(true);
- this.mapping = (Mapping) mappingField.get(configuration);
- } catch (Exception e) {
- throw new JbpmException("couldn't get the hibernate mapping", e);
- }
+ this.settings = configuration.buildSettings();
}
// scripts lazy initializations /////////////////////////////////////////////
-
+
public String[] getCreateSql() {
- if (createSql==null) {
- createSql = configuration.generateSchemaCreationScript(dialect);
+ if (createSql == null) {
+ createSql = configuration.generateSchemaCreationScript(settings.getDialect());
}
return createSql;
}
-
+
public String[] getDropSql() {
- if (dropSql==null) {
- dropSql = configuration.generateDropSchemaScript(dialect);
+ if (dropSql == null) {
+ dropSql = configuration.generateDropSchemaScript(settings.getDialect());
}
return dropSql;
}
-
+
public String[] getCleanSql() {
- if (cleanSql==null) {
+ if (cleanSql == null) {
// loop over all foreign key constraints
- List dropForeignKeysSql = new ArrayList();
- List createForeignKeysSql = new ArrayList();
- Iterator iter = configuration.getTableMappings();
- while ( iter.hasNext() ) {
- Table table = ( Table ) iter.next();
- if ( table.isPhysicalTable() ) {
- Iterator subIter = table.getForeignKeyIterator();
- while ( subIter.hasNext() ) {
- ForeignKey fk = ( ForeignKey ) subIter.next();
- if ( fk.isPhysicalConstraint() ) {
+ Dialect dialect = settings.getDialect();
+ String catalog = settings.getDefaultCatalogName();
+ String schema = settings.getDefaultSchemaName();
+ Mapping mapping = configuration.buildMapping();
+
+ List<String> dropForeignKeysSql = new ArrayList<String>();
+ List<String> createForeignKeysSql = new ArrayList<String>();
+ Iterator<?> iter = configuration.getTableMappings();
+ while (iter.hasNext()) {
+ Table table = (Table) iter.next();
+ if (table.isPhysicalTable()) {
+ Iterator<?> subIter = table.getForeignKeyIterator();
+ while (subIter.hasNext()) {
+ ForeignKey fk = (ForeignKey) subIter.next();
+ if (fk.isPhysicalConstraint()) {
// collect the drop key constraint
- dropForeignKeysSql.add( fk.sqlDropString(
- dialect,
- properties.getProperty(Environment.DEFAULT_CATALOG),
- properties.getProperty(Environment.DEFAULT_SCHEMA) ) );
- createForeignKeysSql.add( fk.sqlCreateString(
- dialect,
- mapping,
- properties.getProperty(Environment.DEFAULT_CATALOG),
- properties.getProperty(Environment.DEFAULT_SCHEMA) ) );
+ dropForeignKeysSql.add(fk.sqlDropString(dialect, catalog, schema));
+ createForeignKeysSql.add(fk.sqlCreateString(dialect, mapping, catalog, schema));
}
}
}
}
- List deleteSql = new ArrayList();
+ List<String> deleteSql = new ArrayList<String>();
iter = configuration.getTableMappings();
while (iter.hasNext()) {
Table table = (Table) iter.next();
- deleteSql.add("delete from "+table.getName());
+ deleteSql.add("delete from " + table.getName());
}
- List cleanSqlList = new ArrayList();
- cleanSqlList.addAll(dropForeignKeysSql);
+ List<String> cleanSqlList = dropForeignKeysSql;
cleanSqlList.addAll(deleteSql);
cleanSqlList.addAll(createForeignKeysSql);
-
- cleanSql = (String[]) cleanSqlList.toArray(new String[cleanSqlList.size()]);
+
+ cleanSql = cleanSqlList.toArray(new String[cleanSqlList.size()]);
}
return cleanSql;
}
// runtime table detection //////////////////////////////////////////////////
-
+
public boolean hasIdentityTables() {
- return (getIdentityTables().size()>0);
+ return (getIdentityTables().size() > 0);
}
- public List getIdentityTables() {
+ public List<String> getIdentityTables() {
// delete all the data in the jbpm tables
- List jbpmTableNames = new ArrayList();
+ List<String> jbpmTableNames = new ArrayList<String>();
try {
createConnection();
ResultSet resultSet = connection.getMetaData().getTables("", "", null, null);
- while(resultSet.next()) {
+ while (resultSet.next()) {
String tableName = resultSet.getString("TABLE_NAME");
- if ( (tableName!=null)
- && (tableName.length()>5)
- && (IDENTITY_TABLE_PREFIX.equalsIgnoreCase(tableName.substring(0,5))) ) {
+ if ((tableName != null)
+ && (tableName.length() > 5)
+ && (IDENTITY_TABLE_PREFIX.equalsIgnoreCase(tableName.substring(0, 5)))) {
jbpmTableNames.add(tableName);
}
}
- } catch (SQLException e) {
+ }
+ catch (SQLException e) {
throw new JbpmException("couldn't get the jbpm table names");
- } finally {
+ }
+ finally {
closeConnection();
}
return jbpmTableNames;
}
-
+
// script execution methods /////////////////////////////////////////////////
-
+
public void dropSchema() {
- execute( getDropSql() );
+ execute(getDropSql());
}
public void createSchema() {
- execute( getCreateSql() );
+ execute(getCreateSql());
}
public void cleanSchema() {
- execute( getCleanSql() );
+ execute(getCleanSql());
}
public void saveSqlScripts(String dir, String prefix) {
try {
new File(dir).mkdirs();
- saveSqlScript(dir+"/"+prefix+".drop.sql", getDropSql());
- saveSqlScript(dir+"/"+prefix+".create.sql", getCreateSql());
- saveSqlScript(dir+"/"+prefix+".clean.sql", getCleanSql());
- new SchemaExport(configuration)
- .setDelimiter(getSqlDelimiter())
- .setOutputFile(dir+"/"+prefix+".drop.create.sql")
- .create(true, false);
- } catch (IOException e) {
+ saveSqlScript(dir + "/" + prefix + ".drop.sql", getDropSql());
+ saveSqlScript(dir + "/" + prefix + ".create.sql", getCreateSql());
+ saveSqlScript(dir + "/" + prefix + ".clean.sql", getCleanSql());
+ new SchemaExport(configuration).setDelimiter(getSqlDelimiter()).setOutputFile(dir
+ + "/"
+ + prefix
+ + ".drop.create.sql").create(true, false);
+ }
+ catch (IOException e) {
throw new JbpmException("couldn't generate scripts", e);
}
}
// main /////////////////////////////////////////////////////////////////////
-
+
public static void main(String[] args) {
if (args == null || args.length == 0) {
syntax();
- } else if ("create".equalsIgnoreCase(args[0])) {
+ }
+ else if ("create".equalsIgnoreCase(args[0])) {
new IdentitySchema(IdentitySessionFactory.createConfiguration()).createSchema();
- } else if ("drop".equalsIgnoreCase(args[0])) {
+ }
+ else if ("drop".equalsIgnoreCase(args[0])) {
new IdentitySchema(IdentitySessionFactory.createConfiguration()).dropSchema();
- } else if ("clean".equalsIgnoreCase(args[0])) {
+ }
+ else if ("clean".equalsIgnoreCase(args[0])) {
new IdentitySchema(IdentitySessionFactory.createConfiguration()).cleanSchema();
- } else if ("scripts".equalsIgnoreCase(args[0]) && args.length == 3) {
+ }
+ else if ("scripts".equalsIgnoreCase(args[0]) && args.length == 3) {
new IdentitySchema(IdentitySessionFactory.createConfiguration()).saveSqlScripts(args[1], args[2]);
- } else {
+ }
+ else {
syntax();
}
}
-
+
private static void syntax() {
System.err.println("syntax:");
System.err.println("IdentitySchema create");
@@ -214,39 +219,41 @@
private void saveSqlScript(String fileName, String[] sql) throws FileNotFoundException {
FileOutputStream fileOutputStream = new FileOutputStream(fileName);
PrintStream printStream = new PrintStream(fileOutputStream);
- for (int i=0; i<sql.length; i++) {
- printStream.println(sql[i]+getSqlDelimiter());
+ for (int i = 0; i < sql.length; i++) {
+ printStream.println(sql[i] + getSqlDelimiter());
}
}
-
+
// sql script execution /////////////////////////////////////////////////////
public void execute(String[] sqls) {
String sql = null;
- String showSqlText = properties.getProperty("hibernate.show_sql");
- boolean showSql = ("true".equalsIgnoreCase(showSqlText));
+ boolean showSql = settings.isShowSqlEnabled();
try {
createConnection();
statement = connection.createStatement();
-
- for (int i=0; i<sqls.length; i++) {
+
+ for (int i = 0; i < sqls.length; i++) {
sql = sqls[i];
- String delimitedSql = sql+getSqlDelimiter();
-
- if (showSql) log.debug(delimitedSql);
+ String delimitedSql = sql + getSqlDelimiter();
+
+ if (showSql)
+ log.debug(delimitedSql);
statement.executeUpdate(delimitedSql);
}
-
- } catch (SQLException e) {
- throw new JbpmException("couldn't execute sql '"+sql+"'", e);
- } finally {
+
+ }
+ catch (SQLException e) {
+ throw new JbpmException("couldn't execute sql '" + sql + "'", e);
+ }
+ finally {
closeConnection();
}
}
private void closeConnection() {
- if (statement!=null) {
+ if (statement != null) {
try {
statement.close();
}
@@ -254,9 +261,9 @@
log.debug("couldn't close jdbc statement", e);
}
}
- if (connection!=null) {
+ if (connection != null) {
try {
- JDBCExceptionReporter.logWarnings( connection.getWarnings() );
+ JDBCExceptionReporter.logWarnings(connection.getWarnings());
connection.clearWarnings();
connectionProvider.closeConnection(connection);
connectionProvider.close();
@@ -268,29 +275,30 @@
}
private void createConnection() throws SQLException {
- connectionProvider = ConnectionProviderFactory.newConnectionProvider(properties);
+ connectionProvider = settings.getConnectionProvider();
connection = connectionProvider.getConnection();
- if ( !connection.getAutoCommit() ) {
+ if (!connection.getAutoCommit()) {
connection.commit();
connection.setAutoCommit(true);
}
}
-
+
public Properties getProperties() {
- return properties;
+ return configuration.getProperties();
}
// sql delimiter ////////////////////////////////////////////////////////////
-
+
private static String sqlDelimiter = null;
+
private synchronized String getSqlDelimiter() {
- if (sqlDelimiter==null) {
- sqlDelimiter = properties.getProperty("jbpm.sql.delimiter", ";");
+ if (sqlDelimiter == null) {
+ sqlDelimiter = getProperties().getProperty("jbpm.sql.delimiter", ";");
}
return sqlDelimiter;
}
// logger ///////////////////////////////////////////////////////////////////
-
+
private static final Log log = LogFactory.getLog(IdentitySchema.class);
}
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySession.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySession.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/IdentitySession.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -25,234 +25,193 @@
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
+import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
-import org.jbpm.db.JbpmSession;
+import org.hibernate.criterion.Projections;
+import org.hibernate.criterion.Restrictions;
+import org.jbpm.JbpmContext;
+import org.jbpm.JbpmException;
import org.jbpm.identity.Entity;
import org.jbpm.identity.Group;
import org.jbpm.identity.Membership;
import org.jbpm.identity.User;
import org.jbpm.identity.assignment.ExpressionSession;
import org.jbpm.identity.security.IdentityService;
+import org.jbpm.util.CollectionUtil;
-public class IdentitySession implements IdentityService, ExpressionSession
-{
+public class IdentitySession implements IdentityService, ExpressionSession {
private static final Log log = LogFactory.getLog(IdentitySession.class);
Session session;
private Transaction transaction;
- public IdentitySession(Session session)
- {
+ public IdentitySession(Session session) {
this.session = session;
}
- public IdentitySession()
- {
- JbpmSession currentJbpmSession = JbpmSession.getCurrentJbpmSession();
- if ((currentJbpmSession == null) || (currentJbpmSession.getSession() == null) || (!currentJbpmSession.getSession().isOpen()))
- {
- throw new RuntimeException("no active JbpmSession to create an identity session");
+ public IdentitySession() {
+ JbpmContext jbpmContext = JbpmContext.getCurrentJbpmContext();
+ if ((jbpmContext == null)
+ || (jbpmContext.getSession() == null)
+ || (!jbpmContext.getSession().isOpen())) {
+ throw new RuntimeException("no active JbpmContext to create an identity session");
}
- session = currentJbpmSession.getSession();
+ session = jbpmContext.getSession();
}
// IdentityService methods //////////////////////////////////////////////////
- public Object verify(String userName, String pwd)
- {
- Object userId = null;
- Query query = session.createQuery("select user.id " + "from org.jbpm.identity.User as user where user.name = :userName and user.password = :password");
+ public Long verify(String userName, String pwd) {
+ Query query = session.createQuery("select user.id "
+ + "from org.jbpm.identity.User as user where user.name = :userName and user.password = :password");
query.setString("userName", userName);
query.setString("password", pwd);
- userId = (Long)query.uniqueResult();
- return userId;
+ return (Long) query.uniqueResult();
}
- public User getUserById(Object userId)
- {
- return (User)session.load(User.class, (Long)userId);
+ public User getUserById(Object userId) {
+ return (User) session.load(User.class, (Long) userId);
}
// transaction convenience methods //////////////////////////////////////////
- public Session getSession()
- {
+ public Session getSession() {
return session;
}
- public Transaction getTransaction()
- {
+ public Transaction getTransaction() {
return transaction;
}
- public void beginTransaction()
- {
- try
- {
+ public void beginTransaction() {
+ try {
transaction = session.beginTransaction();
}
- catch (HibernateException e)
- {
+ catch (HibernateException e) {
log.error(e);
- throw new RuntimeException("couldn't begin a transaction", e);
+ throw new JbpmException("could not begin transaction", e);
}
}
- public void commitTransaction()
- {
- if (transaction == null)
- {
- throw new RuntimeException("can't commit : no transaction started");
+ public void commitTransaction() {
+ if (transaction == null) {
+ throw new RuntimeException("cannot commit : no transaction started");
}
- try
- {
+ try {
session.flush();
transaction.commit();
}
- catch (HibernateException e)
- {
+ catch (HibernateException e) {
log.error(e);
- throw new RuntimeException("couldn't commit transaction", e);
+ throw new JbpmException("could not commit transaction", e);
}
transaction = null;
}
- public void rollbackTransaction()
- {
- if (transaction == null)
- {
- throw new RuntimeException("can't rollback : no transaction started");
+ public void rollbackTransaction() {
+ if (transaction == null) {
+ throw new RuntimeException("cannot rollback : no transaction started");
}
- try
- {
+ try {
transaction.rollback();
}
- catch (HibernateException e)
- {
+ catch (HibernateException e) {
log.error(e);
- throw new RuntimeException("couldn't rollback transaction", e);
+ throw new JbpmException("could not rollback transaction", e);
}
transaction = null;
}
- public void commitTransactionAndClose()
- {
+ public void commitTransactionAndClose() {
commitTransaction();
close();
}
- public void rollbackTransactionAndClose()
- {
+ public void rollbackTransactionAndClose() {
rollbackTransaction();
close();
}
- public void close()
- {
- try
- {
+ public void close() {
+ try {
session.close();
}
- catch (HibernateException e)
- {
+ catch (HibernateException e) {
log.error(e);
- throw new RuntimeException("couldn't close the hibernate connection", e);
+ throw new JbpmException("could not close hibernate session", e);
}
}
// identity methods /////////////////////////////////////////////////////////
- public void saveUser(User user)
- {
+ public void saveUser(User user) {
session.save(user);
}
- public void saveGroup(Group group)
- {
+ public void saveGroup(Group group) {
session.save(group);
}
- public void saveEntity(Entity entity)
- {
+ public void saveEntity(Entity entity) {
session.save(entity);
}
- public void saveMembership(Membership membership)
- {
+ public void saveMembership(Membership membership) {
session.save(membership);
}
- public User loadUser(long userId)
- {
- return (User)session.load(User.class, new Long(userId));
+ public User loadUser(long userId) {
+ return (User) session.load(User.class, new Long(userId));
}
- public Group loadGroup(long groupId)
- {
- return (Group)session.load(Group.class, new Long(groupId));
+ public Group loadGroup(long groupId) {
+ return (Group) session.load(Group.class, new Long(groupId));
}
- public void deleteGroup(Group group)
- {
+ public void deleteGroup(Group group) {
session.delete(group);
}
-
- public void deleteUser(User user)
- {
+
+ public void deleteUser(User user) {
session.delete(user);
}
-
- public User getUserByName(String userName)
- {
- User user = null;
- Query query = session.createQuery("select u " + "from org.jbpm.identity.User as u " + "where u.name = :userName");
- query.setString("userName", userName);
- List users = query.list();
- if ((users != null) && (users.size() > 0))
- {
- user = (User)users.get(0);
- }
- return user;
+
+ public User getUserByName(String userName) {
+ Criteria criteria = session.createCriteria(User.class).add(Restrictions.eq("name", userName));
+ List<User> users = CollectionUtil.checkList(criteria.list(), User.class);
+ return users.isEmpty() ? null : users.get(0);
}
- public Group getGroupByName(String groupName)
- {
- Group group = null;
- Query query = session.createQuery("select g " + "from org.jbpm.identity.Group as g " + "where g.name = :groupName");
- query.setString("groupName", groupName);
- List groups = query.list();
- if ((groups != null) && (groups.size() > 0))
- {
- group = (Group)groups.get(0);
- }
- return group;
+ public Group getGroupByName(String groupName) {
+ Criteria criteria = session.createCriteria(Group.class).add(Restrictions.eq("name", groupName));
+ List<Group> groups = CollectionUtil.checkList(criteria.list(), Group.class);
+ return groups.isEmpty() ? null : groups.get(0);
}
- public List getUsers()
- {
- Query query = session.createQuery("select u " + "from org.jbpm.identity.User as u");
- return query.list();
+ public List<User> getUsers() {
+ Criteria criteria = session.createCriteria(User.class);
+ return CollectionUtil.checkList(criteria.list(), User.class);
}
- public List getGroupNamesByUserAndGroupType(String userName, String groupType)
- {
- Query query = session.createQuery("select membership.group.name from org.jbpm.identity.Membership as membership where membership.user.name = :userName "
- + " and membership.group.type = :groupType");
- query.setString("userName", userName);
- query.setString("groupType", groupType);
- return query.list();
+ public List<String> getGroupNamesByUserAndGroupType(String userName, String groupType) {
+ Criteria criteria = session.createCriteria(Membership.class)
+ .createAlias("user", "u")
+ .createAlias("group", "g")
+ .add(Restrictions.eq("u.name", userName))
+ .add(Restrictions.eq("g.type", groupType))
+ .setProjection(Projections.property("g.name"));
+ return CollectionUtil.checkList(criteria.list(), String.class);
}
- public User getUserByGroupAndRole(String groupName, String role)
- {
- User user = null;
- Query query = session.createQuery("select m.user " + "from org.jbpm.identity.Membership as m where m.group.name = :groupName and m.role = :role");
- query.setString("groupName", groupName);
- query.setString("role", role);
- user = (User)query.uniqueResult();
- return user;
+ public User getUserByGroupAndRole(String groupName, String role) {
+ Criteria criteria = session.createCriteria(Membership.class)
+ .add(Restrictions.eq("role", role))
+ .createAlias("group", "g")
+ .add(Restrictions.eq("g.name", groupName))
+ .setProjection(Projections.property("user"));
+ return (User) criteria.uniqueResult();
}
}
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/PermissionUserType.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/PermissionUserType.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/hibernate/PermissionUserType.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -36,34 +36,40 @@
public class PermissionUserType implements CompositeUserType {
- private static final String[] PROPERTY_NAMES = new String[]{"class", "name", "actions"};
+ private static final String[] PROPERTY_NAMES = new String[] { "class", "name", "actions" };
+
public String[] getPropertyNames() {
return PROPERTY_NAMES;
}
- private static final Type[] PROPERTY_TYPES = new Type[]{Hibernate.STRING, Hibernate.STRING, Hibernate.STRING};
+ private static final Type[] PROPERTY_TYPES = new Type[] { Hibernate.STRING, Hibernate.STRING,
+ Hibernate.STRING };
+
public Type[] getPropertyTypes() {
return PROPERTY_TYPES;
}
public Object getPropertyValue(Object component, int property) throws HibernateException {
Permission permission = (Permission) component;
- if (property==0) {
+ if (property == 0) {
return permission.getClass().getName();
- } else if (property==1) {
+ }
+ else if (property == 1) {
return permission.getName();
- } else if (property==2) {
+ }
+ else if (property == 2) {
return permission.getActions();
- } else {
- throw new IllegalArgumentException("illegal permission property '"+property+"'");
}
+ else {
+ throw new IllegalArgumentException("illegal permission property '" + property + "'");
+ }
}
- public void setPropertyValue(Object arg0, int arg1, Object arg2) throws HibernateException {
+ public void setPropertyValue(Object component, int property, Object value) throws HibernateException {
throw new UnsupportedOperationException("setting properties on a permission is not allowed");
}
- public Class returnedClass() {
+ public Class<?> returnedClass() {
return Permission.class;
}
@@ -74,31 +80,44 @@
public int hashCode(Object permission) throws HibernateException {
return permission.hashCode();
}
-
- private static final Class[] NAME_ACTIOS_CONSTRUCTOR_PARAMETER_TYPES = new Class[]{String.class, String.class};
- public Object nullSafeGet(ResultSet resultSet, String[] names, SessionImplementor session, Object owner) throws HibernateException, SQLException {
- Object permission = null;
+
+ private static final Class<?>[] NAME_ACTIOS_CONSTRUCTOR_PARAMETER_TYPES = new Class[] {
+ String.class, String.class };
+
+ public Object nullSafeGet(ResultSet resultSet, String[] names, SessionImplementor session,
+ Object owner) throws HibernateException, SQLException {
+ Permission permission = null;
String className = resultSet.getString(names[0]);
String name = resultSet.getString(names[1]);
String actions = resultSet.getString(names[2]);
-
+
try {
// TODO optimize performance by caching the constructors
- Class permissionClass = PermissionUserType.class.getClassLoader().loadClass(className);
- Constructor constructor = permissionClass.getDeclaredConstructor(NAME_ACTIOS_CONSTRUCTOR_PARAMETER_TYPES);
- permission = constructor.newInstance(new Object[]{name, actions});
- } catch (Exception e) {
- throw new HibernateException("couldn't create permission from database record ["+className+"|"+name+"|"+actions+"]. Does the permission class have a (String name,String actions) constructor ?", e);
+ Class<? extends Permission> permissionClass = PermissionUserType.class.getClassLoader()
+ .loadClass(className)
+ .asSubclass(Permission.class);
+ Constructor<? extends Permission> constructor = permissionClass.getDeclaredConstructor(NAME_ACTIOS_CONSTRUCTOR_PARAMETER_TYPES);
+ permission = constructor.newInstance(new Object[] { name, actions });
}
-
+ catch (Exception e) {
+ throw new HibernateException("couldn't create permission from database record ["
+ + className
+ + "|"
+ + name
+ + "|"
+ + actions
+ + "]. Does the permission class have a (String name,String actions) constructor ?", e);
+ }
+
return permission;
}
- public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index, SessionImplementor session) throws HibernateException, SQLException {
+ public void nullSafeSet(PreparedStatement preparedStatement, Object value, int index,
+ SessionImplementor session) throws HibernateException, SQLException {
Permission permission = (Permission) value;
preparedStatement.setString(index, permission.getClass().getName());
- preparedStatement.setString(index+1, permission.getName());
- preparedStatement.setString(index+2, permission.getActions());
+ preparedStatement.setString(index + 1, permission.getName());
+ preparedStatement.setString(index + 2, permission.getActions());
}
public Object deepCopy(Object permission) throws HibernateException {
@@ -109,15 +128,18 @@
return false;
}
- public Serializable disassemble(Object value, SessionImplementor session) throws HibernateException {
+ public Serializable disassemble(Object value, SessionImplementor session)
+ throws HibernateException {
return (Serializable) value;
}
- public Object assemble(Serializable cached, SessionImplementor session, Object owner) throws HibernateException {
+ public Object assemble(Serializable cached, SessionImplementor session, Object owner)
+ throws HibernateException {
return cached;
}
- public Object replace(Object original, Object target, SessionImplementor session, Object owner) throws HibernateException {
+ public Object replace(Object original, Object target, SessionImplementor session, Object owner)
+ throws HibernateException {
return original;
}
}
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/AuthenticatedUser.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/AuthenticatedUser.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/AuthenticatedUser.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,17 +21,17 @@
*/
package org.jbpm.identity.security;
-import org.jbpm.identity.*;
+import org.jbpm.identity.User;
public class AuthenticatedUser {
- static ThreadLocal authenticatedUser = new ThreadLocal();
+ static ThreadLocal<User> authenticatedUser = new ThreadLocal<User>();
static void setAuthenticatedUser(User user){
authenticatedUser.set(user);
}
public User getAuthenticatedUser() {
- return (User) authenticatedUser.get();
+ return authenticatedUser.get();
}
}
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityLoginModule.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityLoginModule.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityLoginModule.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -30,27 +30,28 @@
import org.jbpm.identity.*;
/**
- * jaas login module that, in case of successfull verification, adds the
- * {@link org.jbpm.identity.User} as a principal to the subject. In case
- * of successfull verification, the {@link Username} and {@link Password}
- * will be associated as public and private credentials respectively.
+ * jaas login module that, in case of successful verification, adds the
+ * {@link org.jbpm.identity.User} as a principal to the subject. In case of successful verification,
+ * the {@link Username} and {@link Password} will be associated as public and private credentials
+ * respectively.
*/
public class IdentityLoginModule implements LoginModule {
-
+
Subject subject = null;
CallbackHandler callbackHandler = null;
- Map sharedState = null;
- Map options = null;
-
+ Map<String, ?> sharedState = null;
+ Map<String, ?> options = null;
+
/**
* @inject
*/
IdentityService identityService = null;
-
+
Object validatedUserId = null;
String validatedPwd = null;
- public void initialize(Subject subject, CallbackHandler callbackHandler, Map sharedState, Map options) {
+ public void initialize(Subject subject, CallbackHandler callbackHandler,
+ Map<String, ?> sharedState, Map<String, ?> options) {
this.subject = subject;
this.callbackHandler = callbackHandler;
this.sharedState = sharedState;
@@ -58,13 +59,13 @@
}
public boolean login() throws LoginException {
-
// get userName and password
NameCallback nameCallback = new NameCallback(null);
- PasswordCallback passwordCallback = new PasswordCallback(null,false);
+ PasswordCallback passwordCallback = new PasswordCallback(null, false);
try {
- callbackHandler.handle(new Callback[]{nameCallback, passwordCallback});
- } catch (IOException e) {
+ callbackHandler.handle(new Callback[] { nameCallback, passwordCallback });
+ }
+ catch (IOException e) {
LoginException loginException = new LoginException("callback failed");
loginException.initCause(e);
throw loginException;
@@ -75,18 +76,19 @@
}
String userName = nameCallback.getName();
String pwd = new String(passwordCallback.getPassword());
-
+
// validate the userName and password with the injected identity session
Object userId = identityService.verify(userName, pwd);
- boolean success = (userId!=null);
+ boolean success = (userId != null);
// if userName matched the given password
if (success) {
- // save the user id and the password in the
- // private state of this loginmodule
+ // save the user id and the password in the
+ // private state of this login module
validatedUserId = userId;
- validatedPwd = pwd;
- } else {
+ validatedPwd = pwd;
+ }
+ else {
validatedUserId = null;
validatedPwd = null;
}
@@ -95,17 +97,16 @@
}
public boolean commit() throws LoginException {
-
User user = identityService.getUserById(validatedUserId);
- if (user==null) {
- throw new LoginException("no user for validated user id '"+validatedUserId);
+ if (user == null) {
+ throw new LoginException("no user for validated user id '" + validatedUserId);
}
-
+
// update the subject
subject.getPrincipals().add(user);
subject.getPrivateCredentials().add(new Username(user.getName()));
subject.getPrivateCredentials().add(new Password(validatedPwd));
-
+
// and update the authenticated user
AuthenticatedUser.setAuthenticatedUser(user);
@@ -117,7 +118,7 @@
}
public boolean logout() throws LoginException {
- if(subject!= null){
+ if (subject != null) {
// TODO can we clear all or should this login module only clear the user it
// has added to the set of principals in the commit ?
subject.getPrincipals().clear();
@@ -127,7 +128,7 @@
// and update the authenticated user
AuthenticatedUser.setAuthenticatedUser(null);
-
+
callbackHandler = null;
sharedState = null;
options = null;
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityPolicy.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityPolicy.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/security/IdentityPolicy.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,23 +21,29 @@
*/
package org.jbpm.identity.security;
-import java.security.*;
-import java.util.*;
+import java.security.AllPermission;
+import java.security.CodeSource;
+import java.security.Permission;
+import java.security.PermissionCollection;
+import java.security.Permissions;
+import java.security.Policy;
+import java.security.Principal;
+import java.security.ProtectionDomain;
+
import org.jbpm.identity.Entity;
/**
- * a java.security.Policy implementation that in combination with the
- * IdentityLoginModule enforces the secirity permissions modelled as
- * in the package org.jbpm.identity.
+ * a java.security.Policy implementation that in combination with the IdentityLoginModule enforces
+ * the security permissions modelled as in the package org.jbpm.identity.
*/
public class IdentityPolicy extends Policy {
-
+
public static final PermissionCollection ALL_PERMISSIONSCOLLECTION = new Permissions();
static {
ALL_PERMISSIONSCOLLECTION.add(new AllPermission());
ALL_PERMISSIONSCOLLECTION.setReadOnly();
}
-
+
public void refresh() {
}
@@ -46,29 +52,29 @@
// checks are only based on *who* is running the code.
return ALL_PERMISSIONSCOLLECTION;
}
-
+
public PermissionCollection getPermissions(ProtectionDomain domain) {
PermissionCollection permissionCollection = new Permissions();
-
+
Principal[] principals = domain.getPrincipals();
// if there are principals
- if (principals!=null) {
+ if (principals != null) {
// loop over the principals
- for (int i=0; i<principals.length; i++) {
+ for (Principal principal : principals) {
// if the principal is a org.jbpm.identity.Entity
- if (Entity.class.isAssignableFrom(principals[i].getClass())) {
+ if (Entity.class.isAssignableFrom(principal.getClass())) {
// add all the identity's permissions to the set of permissions.
- Iterator iter = ((Entity)principals[i]).getPermissions().iterator();
- while (iter.hasNext()) {
- permissionCollection.add((Permission) iter.next());
+ Entity entity = (Entity) principal;
+ for (Permission permission : entity.getPermissions()) {
+ permissionCollection.add(permission);
}
}
}
}
-
+
return super.getPermissions(domain);
}
-
+
public boolean implies(ProtectionDomain domain, Permission permission) {
return getPermissions(domain).implies(permission);
}
Modified: jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/xml/IdentityXmlParser.java
===================================================================
--- jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/xml/IdentityXmlParser.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/main/java/org/jbpm/identity/xml/IdentityXmlParser.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -24,7 +24,6 @@
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -37,13 +36,14 @@
import org.jbpm.identity.Membership;
import org.jbpm.identity.User;
import org.jbpm.util.ClassLoaderUtil;
+import org.jbpm.util.CollectionUtil;
public class IdentityXmlParser {
-
- List entities = new ArrayList();
- Map users = new HashMap();
- Map groups = new HashMap();
+ List<Entity> entities = new ArrayList<Entity>();
+ Map<String, User> users = new HashMap<String, User>();
+ Map<String, Group> groups = new HashMap<String, Group>();
+
public static Entity[] parseEntitiesResource(String resource) {
return new IdentityXmlParser().parse(resource);
}
@@ -60,27 +60,30 @@
Document document;
try {
document = new SAXReader().read(inputStream);
- } catch (DocumentException e) {
- throw new RuntimeException("couldn't parse identities from stream '"+inputStream+"'");
}
+ catch (DocumentException e) {
+ throw new RuntimeException("couldn't parse identities from stream '" + inputStream + "'");
+ }
Element identitiesRootElement = document.getRootElement();
-
- readUsers(identitiesRootElement.elements("user"));
- readGroups(identitiesRootElement.elements("group"));
- readParentGroups(identitiesRootElement.elements("group"));
- readMemberships(identitiesRootElement.elements("membership"));
- return (Entity[]) entities.toArray(new Entity[entities.size()]);
+ readUsers(checkElements(identitiesRootElement.elements("user")));
+ readGroups(checkElements(identitiesRootElement.elements("group")));
+ readParentGroups(checkElements(identitiesRootElement.elements("group")));
+ readMemberships(checkElements(identitiesRootElement.elements("membership")));
+
+ return entities.toArray(new Entity[entities.size()]);
}
- private void readUsers(List userElements) {
- Iterator iter = userElements.iterator();
- while (iter.hasNext()) {
- Element userElement = (Element) iter.next();
+ private static List<Element> checkElements(List<?> elements) {
+ return CollectionUtil.checkList(elements, Element.class);
+ }
+
+ private void readUsers(List<Element> userElements) {
+ for (Element userElement : userElements) {
String name = userElement.attributeValue("name");
String email = userElement.attributeValue("email");
String password = userElement.attributeValue("password");
-
+
User user = new User(name);
user.setEmail(email);
user.setPassword(password);
@@ -89,13 +92,11 @@
}
}
- private void readGroups(List groupElements) {
- Iterator iter = groupElements.iterator();
- while (iter.hasNext()) {
- Element groupElement = (Element) iter.next();
+ private void readGroups(List<Element> groupElements) {
+ for (Element groupElement : groupElements) {
String name = groupElement.attributeValue("name");
String type = groupElement.attributeValue("type");
-
+
Group group = new Group(name);
group.setType(type);
entities.add(group);
@@ -103,40 +104,39 @@
}
}
- private void readParentGroups(List groupElements) {
- Iterator iter = groupElements.iterator();
- while (iter.hasNext()) {
- Element groupElement = (Element) iter.next();
+ private void readParentGroups(List<Element> groupElements) {
+ for (Element groupElement : groupElements) {
String childName = groupElement.attributeValue("name");
String parentName = groupElement.attributeValue("parent");
-
- if (parentName!=null) {
- Group parent = (Group) groups.get(parentName);
- if (parent==null) throw new RuntimeException("unexisting parent group '"+parentName+"'");
- Group child = (Group) groups.get(childName);
-
+
+ if (parentName != null) {
+ Group parent = groups.get(parentName);
+ if (parent == null)
+ throw new RuntimeException("unexisting parent group '" + parentName + "'");
+
+ Group child = groups.get(childName);
parent.addChild(child);
}
}
}
- private void readMemberships(List membershipElements) {
- Iterator iter = membershipElements.iterator();
- while (iter.hasNext()) {
- Element membershipElement = (Element) iter.next();
- String role = membershipElement.attributeValue("role");
+ private void readMemberships(List<Element> membershipElements) {
+ for (Element membershipElement : membershipElements) {
String userName = membershipElement.attributeValue("user");
- User user = (User) users.get(userName);
- if (user==null) throw new RuntimeException("unexisting membership user '"+userName+"'");
+ User user = users.get(userName);
+ if (user == null)
+ throw new RuntimeException("unexisting membership user '" + userName + "'");
+
String groupName = membershipElement.attributeValue("group");
- Group group = (Group) groups.get(groupName);
- if (group==null) throw new RuntimeException("unexisting membership group '"+groupName+"'");
-
+ Group group = groups.get(groupName);
+ if (group == null)
+ throw new RuntimeException("unexisting membership group '" + groupName + "'");
+
Membership membership = new Membership();
- membership.setRole(role);
+ membership.setRole(membershipElement.attributeValue("role"));
group.addMembership(membership);
user.addMembership(membership);
-
+
entities.add(membership);
}
}
Modified: jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/MembershipTest.java
===================================================================
--- jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/MembershipTest.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/MembershipTest.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -21,9 +21,9 @@
*/
package org.jbpm.identity;
-import java.util.*;
+import java.util.Set;
-import junit.framework.*;
+import junit.framework.TestCase;
public class MembershipTest extends TestCase {
@@ -33,8 +33,8 @@
Group marketingTeam = new Group("marketing team", "hierarchy");
Membership.create(john, "mgr", qaTeam);
Membership.create(john, "mgr", marketingTeam);
-
- Set groups = john.getGroupsForGroupType("hierarchy");
+
+ Set<Group> groups = john.getGroupsForGroupType("hierarchy");
assertEquals(2, groups.size());
assertEquals(2, groups.size());
assertTrue(containsGroup(groups, "qa team"));
@@ -47,12 +47,12 @@
Group marketingTeam = new Group("marketing team", "hierarchy");
Membership.create(john, "mgr", qaTeam);
Membership.create(john, "mgr", marketingTeam);
-
- Set groups = john.getGroupsForGroupType("non-existing-group-type");
+
+ Set<Group> groups = john.getGroupsForGroupType("non-existing-group-type");
assertNotNull(groups);
assertEquals(0, groups.size());
}
-
+
public void testGetGroupsForRole() {
User john = new User("johndoe");
Group qaTeam = new Group("qa team", "hierarchy");
@@ -61,18 +61,18 @@
Membership.create(john, "mgr", qaTeam);
Membership.create(john, "mgr", marketingTeam);
Membership.create(john, "member", nozems);
-
- Set groups = john.getGroupsForMembershipRole("mgr");
+
+ Set<Group> groups = john.getGroupsForMembershipRole("mgr");
assertEquals(2, groups.size());
}
-
+
public void testGetUsersInRole() {
User john = new User("johndoe");
Group qaTeam = new Group("qa team", "hierarchy");
Group marketingTeam = new Group("marketing team", "hierarchy");
Membership.create(john, "mgr", qaTeam);
Membership.create(john, "mgr", marketingTeam);
-
+
assertEquals(1, qaTeam.getUsersForMembershipRole("mgr").size());
assertSame(john, qaTeam.getUsersForMembershipRole("mgr").iterator().next());
assertEquals(1, marketingTeam.getUsersForMembershipRole("mgr").size());
@@ -80,15 +80,14 @@
}
public void testGetNoUsersInRole() {
- Set users = new Group().getUsersForMembershipRole("buzz");
+ Set<User> users = new Group().getUsersForMembershipRole("buzz");
assertNotNull(users);
assertEquals(0, users.size());
}
- public boolean containsGroup(Set groups, String groupName) {
- Iterator iter = groups.iterator();
- while (iter.hasNext()) {
- if( groupName.equals(((Group)iter.next()).getName())) {
+ public boolean containsGroup(Set<Group> groups, String groupName) {
+ for (Group group : groups) {
+ if (groupName.equals(group.getName())) {
return true;
}
}
Modified: jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java
===================================================================
--- jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/assignment/ExpressionAssignmentHandlerTest.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -35,8 +35,7 @@
import org.jbpm.taskmgmt.exe.SwimlaneInstance;
import org.jbpm.taskmgmt.exe.TaskInstance;
-public class ExpressionAssignmentHandlerTest extends IdentityDbTestCase
-{
+public class ExpressionAssignmentHandlerTest extends IdentityDbTestCase {
ExpressionAssignmentHandler expressionAssignmentHandler;
TaskInstance assignable = new TaskInstance();
@@ -47,9 +46,9 @@
Membership membershipJohn, membershipBill;
Group hellsangels;
User john, bill;
-
- public void setUp() throws Exception
- {
+
+ @Override
+ protected void setUp() throws Exception {
super.setUp();
expressionAssignmentHandler = new ExpressionAssignmentHandler();
setUpProcessInstance();
@@ -59,8 +58,7 @@
}
@Override
- protected void tearDown() throws Exception
- {
+ protected void tearDown() throws Exception {
deleteUser(john.getId());
deleteUser(bill.getId());
deleteGroup(hellsangels.getId());
@@ -68,8 +66,7 @@
super.tearDown();
}
- private void setUpUserData()
- {
+ private void setUpUserData() {
john = new User("john");
bill = new User("bill");
hellsangels = new Group("hellsangels", "hierarchy");
@@ -83,30 +80,26 @@
identitySession.saveMembership(membershipBill);
}
- private void setUpProcessInstance()
- {
+ private void setUpProcessInstance() {
processDefinition = ProcessDefinition.parseXmlString("<process-definition/>");
graphSession.saveProcessDefinition(processDefinition);
processInstance = new ProcessInstance(processDefinition);
jbpmContext.save(processInstance);
}
-
+
@Override
- protected void newTransaction()
- {
+ protected void newTransaction() {
super.newTransaction();
executionContext = new ExecutionContext(processInstance.getRootToken());
}
-
- public void testFirstTermPrevious()
- {
+
+ public void testFirstTermPrevious() {
expressionAssignmentHandler.expression = "previous";
expressionAssignmentHandler.assign(assignable, executionContext);
assertEquals("bill", assignable.getActorId());
}
- public void testFirstTermSwimlane()
- {
+ public void testFirstTermSwimlane() {
expressionAssignmentHandler.expression = "swimlane(boss)";
SwimlaneInstance swimlaneInstance = new SwimlaneInstance(new Swimlane("boss"));
swimlaneInstance.setActorId("john");
@@ -115,30 +108,25 @@
assertEquals("john", assignable.getActorId());
}
- public void testFirstTermSwimlaneUnexisting()
- {
+ public void testFirstTermSwimlaneUnexisting() {
expressionAssignmentHandler.expression = "swimlane(sillywoman)";
- try
- {
+ try {
expressionAssignmentHandler.assign(assignable, executionContext);
fail("expected exception");
}
- catch (ExpressionAssignmentException e)
- {
+ catch (ExpressionAssignmentException e) {
// OK
}
}
- public void testFirstTermVariableString()
- {
+ public void testFirstTermVariableString() {
expressionAssignmentHandler.expression = "variable(actoridstringvariable)";
processInstance.getContextInstance().setVariable("actoridstringvariable", "john");
expressionAssignmentHandler.assign(assignable, executionContext);
assertEquals("john", assignable.getActorId());
}
- public void testFirstTermVariableUser()
- {
+ public void testFirstTermVariableUser() {
expressionAssignmentHandler.expression = "variable(uservariable)";
User john = identitySession.getUserByName("john");
processInstance.getContextInstance().setVariable("uservariable", john);
@@ -146,115 +134,95 @@
assertEquals("john", assignable.getActorId());
}
- public void testFirstTermVariableGroup()
- {
+ public void testFirstTermVariableGroup() {
expressionAssignmentHandler.expression = "variable(groupvariable)";
Group hellsangels = identitySession.getGroupByName("hellsangels");
processInstance.getContextInstance().setVariable("groupvariable", hellsangels);
expressionAssignmentHandler.assign(assignable, executionContext);
- Set pooledActors = assignable.getPooledActors();
- PooledActor pooledActor = (PooledActor)pooledActors.iterator().next();
+ Set<PooledActor> pooledActors = assignable.getPooledActors();
+ PooledActor pooledActor = pooledActors.iterator().next();
assertEquals("hellsangels", pooledActor.getActorId());
}
- public void testFirstTermVariableUnexisting()
- {
+ public void testFirstTermVariableUnexisting() {
expressionAssignmentHandler.expression = "variable(unexistingvariablename)";
- try
- {
+ try {
expressionAssignmentHandler.assign(assignable, executionContext);
fail("expected exception");
}
- catch (ExpressionAssignmentException e)
- {
+ catch (ExpressionAssignmentException e) {
// OK
}
}
- public void testFirstTermUser()
- {
+ public void testFirstTermUser() {
expressionAssignmentHandler.expression = "user(john)";
expressionAssignmentHandler.assign(assignable, executionContext);
assertEquals("john", assignable.getActorId());
}
- public void testFirstTermUserUnexisting()
- {
+ public void testFirstTermUserUnexisting() {
expressionAssignmentHandler.expression = "user(idontexist)";
- try
- {
+ try {
expressionAssignmentHandler.assign(assignable, executionContext);
fail("expected exception");
}
- catch (ExpressionAssignmentException e)
- {
+ catch (ExpressionAssignmentException e) {
// OK
}
}
- public void testFirstTermGroup()
- {
+ public void testFirstTermGroup() {
expressionAssignmentHandler.expression = "group(hellsangels)";
expressionAssignmentHandler.assign(assignable, executionContext);
- Set pooledActors = assignable.getPooledActors();
- PooledActor pooledActor = (PooledActor)pooledActors.iterator().next();
+ Set<PooledActor> pooledActors = assignable.getPooledActors();
+ PooledActor pooledActor = pooledActors.iterator().next();
assertEquals("hellsangels", pooledActor.getActorId());
}
- public void testFirstTermGroupUnexisting()
- {
+ public void testFirstTermGroupUnexisting() {
expressionAssignmentHandler.expression = "group(wedontexist)";
- try
- {
+ try {
expressionAssignmentHandler.assign(assignable, executionContext);
fail("expected exception");
}
- catch (ExpressionAssignmentException e)
- {
+ catch (ExpressionAssignmentException e) {
// OK
}
}
- public void testWrongFirstTerm()
- {
+ public void testWrongFirstTerm() {
expressionAssignmentHandler.expression = "wrong-first-term";
- try
- {
+ try {
expressionAssignmentHandler.assign(assignable, executionContext);
fail("expected exception");
}
- catch (ExpressionAssignmentException e)
- {
+ catch (ExpressionAssignmentException e) {
// OK
}
}
- public void testNextTermGroup()
- {
+ public void testNextTermGroup() {
expressionAssignmentHandler.expression = "user(john) --> group(hierarchy)";
expressionAssignmentHandler.assign(assignable, executionContext);
- Set pooledActors = assignable.getPooledActors();
- PooledActor pooledActor = (PooledActor)pooledActors.iterator().next();
+ Set<PooledActor> pooledActors = assignable.getPooledActors();
+ PooledActor pooledActor = pooledActors.iterator().next();
assertEquals("hellsangels", pooledActor.getActorId());
}
- public void testNextTermMember()
- {
+ public void testNextTermMember() {
expressionAssignmentHandler.expression = "group(hellsangels) --> member(leaderofthegang)";
expressionAssignmentHandler.assign(assignable, executionContext);
assertEquals("john", assignable.getActorId());
}
- public void testWrongNextTerm()
- {
+ public void testWrongNextTerm() {
expressionAssignmentHandler.expression = "user(john) --> wrong-second-term";
- try
- {
+ try {
expressionAssignmentHandler.assign(assignable, executionContext);
fail("expected exception");
}
- catch (ExpressionAssignmentException e)
- {
+ catch (ExpressionAssignmentException e) {
// OK
}
}
Modified: jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/GroupDbTest.java
===================================================================
--- jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/GroupDbTest.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/GroupDbTest.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -32,19 +32,17 @@
import org.jbpm.identity.Membership;
import org.jbpm.identity.User;
-public class GroupDbTest extends IdentityDbTestCase
-{
- public void testGroup()
- {
+public class GroupDbTest extends IdentityDbTestCase {
+
+ public void testGroup() {
Group group = new Group("people with read hair");
group = saveAndReload(group);
assertEquals("people with read hair", group.getName());
-
+
deleteGroup(group.getId());
}
- public void testGroupMemberships()
- {
+ public void testGroupMemberships() {
Group chicagoBulls = new Group("chicago bulls");
User tyson = new User("tyson");
User eddy = new User("eddy");
@@ -58,7 +56,7 @@
chicagoBulls = saveAndReload(chicagoBulls);
assertEquals(4, chicagoBulls.getUsers().size());
-
+
deleteGroup(chicagoBulls.getId());
deleteUser(tyson.getId());
deleteUser(eddy.getId());
@@ -66,8 +64,7 @@
deleteUser(chris.getId());
}
- public void testGroupPermissions()
- {
+ public void testGroupPermissions() {
Group chicagoBulls = new Group("chicago bulls");
chicagoBulls.addPermission(new SocketPermission("basket", "connect"));
chicagoBulls.addPermission(new FilePermission("ticket", "write"));
@@ -75,12 +72,11 @@
chicagoBulls = saveAndReload(chicagoBulls);
assertEquals(2, chicagoBulls.getPermissions().size());
-
+
deleteGroup(chicagoBulls.getId());
}
- public void testGroups()
- {
+ public void testGroups() {
Group clowns = new Group("clowns");
identitySession.saveGroup(clowns);
@@ -88,12 +84,11 @@
clowns = identitySession.loadGroup(clowns.getId());
assertEquals("clowns", clowns.getName());
-
+
deleteGroup(clowns.getId());
}
- public void testGroupChildren()
- {
+ public void testGroupChildren() {
Group clowns = new Group("clowns");
clowns.addChild(new Group("cowboys"));
clowns.addChild(new Group("indians"));
@@ -103,20 +98,20 @@
clowns = identitySession.loadGroup(clowns.getId());
assertEquals("clowns", clowns.getName());
- Set children = clowns.getChildren();
+ Set<Group> children = clowns.getChildren();
assertNotNull(children);
assertEquals(2, children.size());
- Set childNames = new HashSet();
- Iterator iter = children.iterator();
- Group child = (Group)iter.next();
+ Set<String> childNames = new HashSet<String>();
+ Iterator<Group> iter = children.iterator();
+ Group child = iter.next();
assertEquals("clowns", child.getParent().getName());
childNames.add(child.getName());
- child = (Group)iter.next();
+ child = iter.next();
assertEquals("clowns", child.getParent().getName());
childNames.add(child.getName());
- Set expectedChildNames = new HashSet();
+ Set<String> expectedChildNames = new HashSet<String>();
expectedChildNames.add("cowboys");
expectedChildNames.add("indians");
Modified: jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java
===================================================================
--- jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/hibernate/UserDbTest.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -23,7 +23,7 @@
import java.net.NetPermission;
import java.security.AllPermission;
-import java.util.Iterator;
+import java.security.Permission;
import java.util.Set;
import org.jbpm.identity.Group;
@@ -31,11 +31,9 @@
import org.jbpm.identity.Membership;
import org.jbpm.identity.User;
-public class UserDbTest extends IdentityDbTestCase
-{
+public class UserDbTest extends IdentityDbTestCase {
- public void testUser()
- {
+ public void testUser() {
User user = new User("johndoe");
user = saveAndReload(user);
assertEquals("johndoe", user.getName());
@@ -43,8 +41,7 @@
deleteUser(user.getId());
}
- public void testUserMemberships()
- {
+ public void testUserMemberships() {
User john = new User("johndoe");
Group qaTeam = new Group("qa team", "hierarchy");
Group marketingTeam = new Group("marketing team", "hierarchy");
@@ -53,7 +50,7 @@
john = saveAndReload(john);
- Set groups = john.getGroupsForGroupType("hierarchy");
+ Set<Group> groups = john.getGroupsForGroupType("hierarchy");
assertEquals(2, groups.size());
assertEquals(2, groups.size());
@@ -65,48 +62,39 @@
deleteUser(john.getId());
}
- public void testUserPermissions()
- {
+ public void testUserPermissions() {
User user = new User("johndoe");
user.addPermission(new NetPermission("connect", "9001"));
user.addPermission(new AllPermission("all", "everything"));
user = saveAndReload(user);
- Set permissions = user.getPermissions();
+ Set<Permission> permissions = user.getPermissions();
assertNotNull(permissions);
assertEquals(2, permissions.size());
deleteUser(user.getId());
}
- public void testVerifyWrongUser()
- {
+ public void testVerifyWrongUser() {
assertNull(identitySession.verify("unexisting-user", "wrong password"));
}
- public void testVerifyValidPwd()
- {
+ public void testVerifyValidPwd() {
User user = new User("johndoe");
user.setPassword("johnspwd");
user = saveAndReload(user);
- try
- {
- assertEquals(user.getId(), identitySession.verify("johndoe", "johnspwd"));
+ try {
+ assertEquals(user.getId(), identitySession.verify("johndoe", "johnspwd").longValue());
}
- finally
- {
+ finally {
deleteUser(user.getId());
}
}
- private boolean containsGroup(Set groups, String groupName)
- {
- Iterator iter = groups.iterator();
- while (iter.hasNext())
- {
- if (groupName.equals(((Group)iter.next()).getName()))
- {
+ private boolean containsGroup(Set<Group> groups, String groupName) {
+ for (Group group : groups) {
+ if (groupName.equals(group.getName())) {
return true;
}
}
Modified: jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/xml/IdentityXmlParsingTest.java
===================================================================
--- jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/xml/IdentityXmlParsingTest.java 2009-01-19 16:01:20 UTC (rev 3677)
+++ jbpm3/trunk/modules/identity/src/test/java/org/jbpm/identity/xml/IdentityXmlParsingTest.java 2009-01-19 23:36:52 UTC (rev 3678)
@@ -26,45 +26,47 @@
import junit.framework.TestCase;
import org.jbpm.identity.Group;
+import org.jbpm.identity.Membership;
import org.jbpm.identity.User;
public class IdentityXmlParsingTest extends TestCase {
-
+
IdentityXmlParser identityXmlParser;
-
- public void setUp() {
+
+ protected void setUp() {
identityXmlParser = new IdentityXmlParser();
identityXmlParser.parse("org/jbpm/identity/xml/identity.xml");
}
public void testUser() {
- User sampleManager = (User) identityXmlParser.users.get("manager");
+ User sampleManager = identityXmlParser.users.get("manager");
assertEquals("manager", sampleManager.getName());
assertEquals("sample.manager at sample.domain", sampleManager.getEmail());
assertEquals("manager", sampleManager.getPassword());
}
public void testGroup() {
- Group bananalovers = (Group) identityXmlParser.groups.get("bananalovers");
+ Group bananalovers = identityXmlParser.groups.get("bananalovers");
assertEquals("bananalovers", bananalovers.getName());
assertEquals("fruitpreference", bananalovers.getType());
}
public void testGroupParent() {
- Group residents = (Group) identityXmlParser.groups.get("residents");
- Group bananalovers = (Group) identityXmlParser.groups.get("bananalovers");
+ Group residents = identityXmlParser.groups.get("residents");
+ Group bananalovers = identityXmlParser.groups.get("bananalovers");
assertSame(residents, bananalovers.getParent());
assertEquals(1, residents.getChildren().size());
assertSame(bananalovers, residents.getChildren().iterator().next());
}
public void testUserMembership() {
- User sampleManager = (User) identityXmlParser.users.get("manager");
- Group bananalovers = (Group) identityXmlParser.groups.get("bananalovers");
- Set sampleManagersMemberships = sampleManager.getMemberships();
+ User sampleManager = identityXmlParser.users.get("manager");
+ Group bananalovers = identityXmlParser.groups.get("bananalovers");
+ Set<Membership> sampleManagersMemberships = sampleManager.getMemberships();
assertEquals(1, sampleManagersMemberships.size());
- Set bananaloversMemberships = bananalovers.getMemberships();
+ Set<Membership> bananaloversMemberships = bananalovers.getMemberships();
assertEquals(1, bananaloversMemberships.size());
- assertSame(bananaloversMemberships.iterator().next(), sampleManagersMemberships.iterator().next());
+ assertSame(bananaloversMemberships.iterator().next(), sampleManagersMemberships.iterator()
+ .next());
}
}
More information about the jbpm-commits
mailing list