wamblee.org Git - utils/blob - security/src/test/java/org/wamblee/security/authorization/hibernate/PersistentAuthorizationServiceTest.java

   1 /*
   2  * Copyright 2005 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.wamblee.security.authorization.hibernate;
  17
  18 import org.apache.log4j.Logger;
  19
  20 import org.hibernate.cfg.Configuration;
  21
  22 import org.hibernate.dialect.MySQL5Dialect;
  23 import org.hibernate.dialect.MySQL5InnoDBDialect;
  24
  25 import org.hibernate.tool.hbm2ddl.SchemaExport;
  26
  27 import org.springframework.orm.hibernate3.HibernateTemplate;
  28
  29 import org.wamblee.general.BeanKernel;
  30
  31 import org.wamblee.security.authorization.AuthorizationService;
  32 import org.wamblee.security.authorization.AuthorizationServiceTest;
  33 import org.wamblee.security.authorization.TestUserAccessor;
  34
  35 import org.wamblee.system.adapters.ClassConfiguration;
  36 import org.wamblee.system.adapters.ClassConfigurationTest;
  37 import org.wamblee.system.adapters.DefaultContainer;
  38 import org.wamblee.system.adapters.ObjectConfiguration;
  39 import org.wamblee.system.components.DatabaseComponentFactory;
  40 import org.wamblee.system.core.Scope;
  41 import org.wamblee.system.spring.component.DatabaseTesterComponent;
  42 import org.wamblee.system.spring.component.DatasourceComponent;
  43
  44 import org.wamblee.usermgt.UserAccessor;
  45 import org.wamblee.usermgt.hibernate.AuthorizationComponent;
  46 import org.wamblee.usermgt.hibernate.HibernateUserAdministrationTest;
  47 import org.wamblee.usermgt.hibernate.UserAdministrationComponent;
  48
  49 import java.sql.SQLException;
  50
  51
  52 /**
  53  * Unit test for the persistent authorization service.
  54  *
  55  * @author Erik Brakkee
  56  */
  57 public class PersistentAuthorizationServiceTest extends AuthorizationServiceTest {
  58     /**
  59      * DOCUMENT ME!
  60      */
  61     private static final Logger LOGGER = Logger.getLogger(PersistentAuthorizationServiceTest.class);
  62
  63     /**
  64      * DOCUMENT ME!
  65      */
  66     private static final String SERVICE_TABLE = "AUTHORIZATION_SERVICE";
  67
  68     /**
  69      * DOCUMENT ME!
  70      */
  71     private static final String RULES_TABLE = "AUTHORIZATION_RULES";
  72
  73     /**
  74      * DOCUMENT ME!
  75      */
  76     private static final String SERVICE_RULES_TABLE = "AUTHORIZATION_SERVICE_RULES";
  77
  78     /**
  79      * DOCUMENT ME!
  80      */
  81     private static final String OPERATIONCOND_TABLE = "OPERATION_CONDITIONS";
  82
  83     /**
  84      * DOCUMENT ME!
  85      */
  86     private static final String PATHCOND_TABLE = "PATH_CONDITIONS";
  87
  88     /**
  89      * DOCUMENT ME!
  90      */
  91     private static final String USERCOND_TABLE = "USER_CONDITIONS";
  92
  93     /**
  94      * DOCUMENT ME!
  95      */
  96     private DefaultContainer container;
  97
  98     /**
  99      * DOCUMENT ME!
 100      */
 101     private Scope scope;
 102
 103     /**
 104      * DOCUMENT ME!
 105      */
 106     private DatabaseTesterComponent databaseTester;
 107
 108     /**
 109      * DOCUMENT ME!
 110      */
 111     private UserAccessor userAccessor;
 112
 113     /**
 114      * DOCUMENT ME!
 115      */
 116     private HibernateTemplate hibernateTemplate;
 117
 118     /**
 119      * DOCUMENT ME!
 120      */
 121     private AuthorizationService authorizationService;
 122
 123     /**
 124      * DOCUMENT ME!
 125      *
 126      * @throws Exception DOCUMENT ME!
 127      */
 128     @Override
 129     protected void setUp() throws Exception {
 130         container = new DefaultContainer("top");
 131         DatabaseComponentFactory.addDatabaseConfig(container);
 132         container.addComponent(new DatasourceComponent("datasource"));
 133
 134         ClassConfiguration useraccessorConfig = new ClassConfiguration(TestUserAccessor.class);
 135         useraccessorConfig.getObjectConfig().getSetterConfig().initAllSetters();
 136         container.addComponent("userAccessor", useraccessorConfig);
 137         container.addComponent(new AuthorizationComponent("authorization", true));
 138
 139         ClassConfiguration dbtesterConfig = new ClassConfiguration(DatabaseTesterComponent.class);
 140         dbtesterConfig.getObjectConfig().getSetterConfig().initAllSetters();
 141         container.addComponent("databaseTester", dbtesterConfig);
 142
 143         ObjectConfiguration config = new ObjectConfiguration(PersistentAuthorizationServiceTest.class);
 144         config.getSetterConfig().clear().add("setUserAccessor")
 145         .add("setDatabaseTester").add("setHibernateTemplate")
 146         .add("setAuthorizationService");
 147         container.addComponent("testcase", this, config);
 148
 149         scope = container.start();
 150
 151         databaseTester.cleanDatabase();
 152
 153         super.setUp();
 154     }
 155
 156     /**
 157      * DOCUMENT ME!
 158      *
 159      * @param aDatabaseTester DOCUMENT ME!
 160      */
 161     public void setDatabaseTester(DatabaseTesterComponent aDatabaseTester) {
 162         databaseTester = aDatabaseTester;
 163     }
 164
 165     /**
 166      * DOCUMENT ME!
 167      *
 168      * @param aUserAccessor DOCUMENT ME!
 169      */
 170     public void setUserAccessor(UserAccessor aUserAccessor) {
 171         userAccessor = aUserAccessor;
 172     }
 173
 174     /**
 175      * DOCUMENT ME!
 176      *
 177      * @param aHibernateTemplate DOCUMENT ME!
 178      */
 179     public void setHibernateTemplate(HibernateTemplate aHibernateTemplate) {
 180         hibernateTemplate = aHibernateTemplate;
 181     }
 182
 183     /**
 184      * DOCUMENT ME!
 185      *
 186      * @param aAuthorizationService DOCUMENT ME!
 187      */
 188     public void setAuthorizationService(
 189         AuthorizationService aAuthorizationService) {
 190         authorizationService = aAuthorizationService;
 191     }
 192
 193     /*
 194      * (non-Javadoc)
 195      *
 196      * @see
 197      * org.wamblee.security.authorization.AuthorizationServiceTest#createService
 198      * ()
 199      */
 200     /**
 201      * DOCUMENT ME!
 202      *
 203      * @return DOCUMENT ME!
 204      */
 205     @Override
 206     protected AuthorizationService createService() {
 207         PersistentAuthorizationService service = new PersistentAuthorizationService("DEFAULT",
 208                 hibernateTemplate, createUserAccessor(), 10000);
 209
 210         return service;
 211     }
 212
 213     /*
 214      * (non-Javadoc)
 215      *
 216      * @see
 217      * org.wamblee.security.authorization.AuthorizationServiceTest#checkRuleCount
 218      * (int)
 219      */
 220     /**
 221      * DOCUMENT ME!
 222      *
 223      * @param aCount DOCUMENT ME!
 224      *
 225      * @throws RuntimeException DOCUMENT ME!
 226      */
 227     @Override
 228     protected void checkRuleCount(int aCount) {
 229         try {
 230             assertEquals(1, databaseTester.getTableSize(SERVICE_TABLE));
 231             assertEquals(aCount, databaseTester.getTableSize(RULES_TABLE));
 232             assertEquals(aCount,
 233                 databaseTester.getTableSize(SERVICE_RULES_TABLE));
 234             assertEquals(aCount, databaseTester.getTableSize(USERCOND_TABLE));
 235             assertEquals(aCount, databaseTester.getTableSize(PATHCOND_TABLE));
 236             assertEquals(aCount,
 237                 databaseTester.getTableSize(OPERATIONCOND_TABLE));
 238         } catch (SQLException e) {
 239             throw new RuntimeException(e);
 240         }
 241     }
 242
 243     /**
 244      * DOCUMENT ME!
 245      */
 246     public void testSchemaExport() {
 247         Configuration config = new Configuration();
 248
 249         for (String mappingFile : new AuthorizationMappingFiles()) {
 250             config.addResource(mappingFile);
 251         }
 252
 253         config.setProperty("hibernate.dialect",
 254             MySQL5InnoDBDialect.class.getName());
 255
 256         SchemaExport exporter = new SchemaExport(config);
 257         exporter.setOutputFile("target/mysql5.schema.sql");
 258         exporter.create(true, false);
 259     }
 260
 261     /**
 262      * DOCUMENT ME!
 263      */
 264     public void testPerformance() {
 265         PersistentAuthorizationService service = (PersistentAuthorizationService) getService();
 266
 267         int                            n       = 1000;
 268         long                           time    = System.currentTimeMillis();
 269
 270         for (int i = 0; i < n; i++) {
 271             testFirstRuleGrants();
 272             resetTestRules();
 273             testSecondRuleDenies();
 274             resetTestRules();
 275             testThirdRuleGrants();
 276             resetTestRules();
 277             testNoRulesSupportResource();
 278         }
 279
 280         LOGGER.info("Executed " + (4 * n) + " authorization checks in "
 281             + ((float) (System.currentTimeMillis() - time) / (float) 1000)
 282             + " seconds.");
 283     }
 284 }