Workspace/Siman-Common/src/test/splat/service/TestProjectSettingsService.java

   1 /*****************************************************************************
   2  * Company         OPEN CASCADE
   3  * Application     SIMAN
   4  * File            $Id$
   5  * Creation date   12 Oct 2012
   6  * @author         $Author$
   7  * @version        $Revision$
   8  *****************************************************************************/
   9 package test.splat.service;
  10
  11 import java.io.FileNotFoundException;
  12 import java.io.IOException;
  13 import java.sql.SQLException;
  14 import java.util.List;
  15
  16 import org.splat.dal.bo.som.KnowledgeElementType;
  17 import org.splat.dal.bo.som.Scenario;
  18 import org.splat.dal.bo.som.SimulationContextType;
  19 import org.splat.dal.dao.som.Database;
  20 import org.splat.log.AppLogger;
  21 import org.splat.service.DocumentTypeService;
  22 import org.splat.service.KnowledgeElementTypeService;
  23 import org.splat.service.SimulationContextService;
  24 import org.splat.service.technical.ProjectSettingsService;
  25 import org.splat.service.technical.StepsConfigService;
  26 import org.splat.service.technical.ProjectSettingsService.Step;
  27 import org.springframework.beans.factory.annotation.Autowired;
  28 import org.springframework.beans.factory.annotation.Qualifier;
  29 import org.springframework.dao.DuplicateKeyException;
  30 import org.testng.Assert;
  31 import org.testng.annotations.Test;
  32
  33 import test.splat.common.BaseTest;
  34
  35 /**
  36  * Test class for ProjectService.
  37  *
  38  * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
  39  *
  40  */
  41 public class TestProjectSettingsService extends BaseTest {
  42
  43         /**
  44          * Logger for the class.
  45          */
  46         private static final AppLogger LOG = AppLogger
  47                         .getLogger(TestProjectSettingsService.class);
  48
  49         /**
  50          * The ProjectSettingsService. Later injected by Spring.
  51          */
  52         @Autowired
  53         @Qualifier("projectSettings")
  54         private transient ProjectSettingsService _projectSettings;
  55
  56         /**
  57          * The StepsConfigService. Later injected by Spring.
  58          */
  59         @Autowired
  60         @Qualifier("stepsConfigService")
  61         private transient StepsConfigService _stepsConfigService;
  62
  63         /**
  64          * The DocumentTypeService. Later injected by Spring.
  65          */
  66         @Autowired
  67         @Qualifier("documentTypeService")
  68         private transient DocumentTypeService _documentTypeService;
  69
  70         /**
  71          * The KnowledgeElementTypeService. Later injected by Spring.
  72          */
  73         @Autowired
  74         @Qualifier("knowledgeElementTypeService")
  75         private transient KnowledgeElementTypeService _knowledgeElementTypeService;
  76
  77         /**
  78          * The DocumentTypeService. Later injected by Spring.
  79          */
  80         @Autowired
  81         @Qualifier("simulationContextService")
  82         private transient SimulationContextService _simulationContextService;
  83
  84         /**
  85          * Test of loading document mappings to file formats from customization XML file.<BR>
  86          * <B>Description :</B> <BR>
  87          * <i>Load customization and check the result.</i><BR>
  88          * <B>Action : </B><BR>
  89          * <i>1. call the method for som.xml</i><BR>
  90          * <i>2. call the method for a xml without mappings.</i><BR>
  91          * <i>3. call the method for a not existing file.</i><BR>
  92          * <B>Test data : </B><BR>
  93          * <i>test/som.xml</i><BR>
  94          * <i>test/som-without-mappings.xml</i><BR>
  95          * <i>not existing xxx.xml</i><BR>
  96          *
  97          * <B>Outcome results:</B><BR>
  98          * <i>
  99          * <ul>
 100          * <li>doImport() must return true for mapped formats<BR>
 101          * </li>
 102          * <li>doImport() must always return false<BR>
 103          * </li>
 104          * <li>Exception is thrown<BR>
 105          * </li>
 106          * </ul>
 107          * </i>
 108          *
 109          * @throws IOException
 110          *             if configuration loading is failed
 111          * @throws SQLException
 112          *             if configuration loading is failed
 113          */
 114         @Test
 115         public void testLoadMappings() throws IOException, SQLException {
 116                 LOG.debug(">>>>> BEGIN testLoadMappings()()");
 117                 startNestedTransaction();
 118                 // ////// Load good workflow customization
 119                 /*
 120                  * geometry: brep model: med loads: c3m results: med
 121                  */
 122                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 123                 try {
 124                         _projectSettings.configure("classpath:test/som.xml");
 125                 } catch (FileNotFoundException e) {
 126                         Assert.fail("Can't find configuration file: ", e);
 127                 }
 128                 List<Step> steps = _stepsConfigService.getStepsOf(Scenario.class);
 129                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 130                 Assert.assertTrue(_projectSettings.doImport("geometry", "brep"));
 131                 Assert.assertTrue(_projectSettings.doImport("model", "med"));
 132                 Assert.assertTrue(_projectSettings.doImport("loads", "c3m"));
 133                 Assert.assertTrue(_projectSettings.doImport("results", "med"));
 134
 135                 // ////// Load workflow customization with empty mappings
 136                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 137                 try {
 138                         _projectSettings.configure("classpath:test/som-without-mappings.xml");
 139                 } catch (FileNotFoundException e) {
 140                         Assert.fail("Can't find configuration file: ", e);
 141                 }
 142                 steps = _stepsConfigService.getStepsOf(Scenario.class);
 143                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 144                 Assert.assertFalse(_projectSettings.doImport("geometry", "brep"));
 145                 Assert.assertFalse(_projectSettings.doImport("model", "med"));
 146                 Assert.assertFalse(_projectSettings.doImport("loads", "c3m"));
 147                 Assert.assertFalse(_projectSettings.doImport("results", "med"));
 148
 149                 // ////// Load workflow customization from not existing file
 150                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 151                 try {
 152                         _projectSettings.configure("classpath:test/xxx.xml");
 153                         Assert
 154                                         .fail("Customization loading must fail for not existing configuration file.");
 155                 } catch (FileNotFoundException e) {
 156                         LOG.debug("Configuration file must not be found.", e);
 157                 }
 158
 159                 rollbackNestedTransaction();
 160                 LOG.debug(">>>>> END testLoadMappings()()");
 161         }
 162
 163         /**
 164          * Test of loading file formats mappings to document types from customization XML file.<BR>
 165          * <B>Description :</B> <BR>
 166          * <i>Load customization and check the result.</i><BR>
 167          * <B>Action : </B><BR>
 168          * <i>1. call the method for som.xml</i><BR>
 169          * <i>2. call the method for a xml without mappings.</i><BR>
 170          * <i>3. call the method for a not existing file.</i><BR>
 171          * <B>Test data : </B><BR>
 172          * <i>test/som.xml</i><BR>
 173          * <i>test/som-without-mappings.xml</i><BR>
 174          * <i>not existing xxx.xml</i><BR>
 175          *
 176          * <B>Outcome results:</B><BR>
 177          * <i>
 178          * <ul>
 179          * <li>Following mappings must be loaded:<BR/>
 180          * <ul>
 181          * <li>step 1
 182          * <ul>
 183          * <li>pdf: requirements</li>
 184          * <li>doc: specification</li>
 185          * <!-- Microsoft Word 2003 and earlier -->
 186          * <li>docx: specification</li>
 187          * <!-- Microsoft Word 2007 and later -->
 188          * <li>xml: specification</li>
 189          * <!-- Microsoft Word 2007 Open XML -->
 190          * </ul>
 191          * </li>
 192          * <li>step 2
 193          * <ul>
 194          * <li>doc: design</li>
 195          * <li>docx: design</li>
 196          * <li>xml: design</li>
 197          * </ul>
 198          * </li>
 199          * <li>step 3
 200          * <ul>
 201          * <li>doc: memorandum</li>
 202          * <li>docx: memorandum</li>
 203          * <li>xml: memorandum</li>
 204          * <li>sldprt: geometry</li>
 205          * <!-- SolidWorks Part -->
 206          * <li>sldasm: geometry</li>
 207          * <!-- SolidWorks Assembly -->
 208          * <li>part: geometry</li>
 209          * <!-- GEOM Part -->
 210          * <li>py: geometry</li>
 211          * <!-- GEOM Python script -->
 212          * </ul>
 213          * </li>
 214          * <li>step 4
 215          * <ul>
 216          * <li>doc: memorandum</li>
 217          * <li>docx: memorandum</li>
 218          * <li>xml: memorandum</li>
 219          * <li>med: model</li>
 220          * <li>py: model</li>
 221          * <!-- SMESH Python script -->
 222          * </ul>
 223          * </li>
 224          * </ul>
 225          * </li>
 226          * <li>getDefaultDocumentType must always return null<BR>
 227          * </li>
 228          * <li>Exception is thrown<BR>
 229          * </li>
 230          * </ul>
 231          * </i>
 232          *
 233          * @throws IOException
 234          *             if configuration loading is failed
 235          * @throws SQLException
 236          *             if configuration loading is failed
 237          */
 238         @Test
 239         public void testLoadDefaultDocTypes() throws IOException, SQLException {
 240                 LOG.debug(">>>>> BEGIN testLoadDefaultDocTypes()");
 241                 startNestedTransaction();
 242                 // ////// Load good workflow customization
 243                 /*
 244                  * geometry: brep model: med loads: c3m results: med
 245                  */
 246                 Database.getInstance().reset();
 247                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 248                 try {
 249                         _projectSettings.configure("classpath:test/som.xml");
 250                 } catch (FileNotFoundException e) {
 251                         Assert.fail("Can't find configuration file: ", e);
 252                 }
 253                 Assert.assertTrue(_documentTypeService.selectAllTypes().size() > 0,
 254                                 "No document types are created.");
 255                 List<Step> steps = _stepsConfigService.getStepsOf(Scenario.class);
 256                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 257
 258                 for (Step step : steps) {
 259                         List<String> defTypes = _projectSettings.getDefaultFormats(step);
 260                         Assert.assertNotNull(defTypes,
 261                                         "getDefaultFormats must always return not null list:");
 262                         switch (step.getNumber()) {
 263                                 case 1:
 264                                         Assert.assertEquals(defTypes.size(), 4);
 265                                         Assert.assertNotNull(_projectSettings
 266                                                         .getDefaultDocumentType(step, "pdf"));
 267                                         Assert.assertEquals(_projectSettings
 268                                                         .getDefaultDocumentType(step, "pdf").getName(),
 269                                                         "requirements");
 270                                         Assert.assertNotNull(_projectSettings
 271                                                         .getDefaultDocumentType(step, "doc"));
 272                                         Assert.assertEquals(_projectSettings
 273                                                         .getDefaultDocumentType(step, "doc").getName(),
 274                                                         "specification");
 275                                         Assert.assertNotNull(_projectSettings
 276                                                         .getDefaultDocumentType(step, "docx"));
 277                                         Assert.assertEquals(_projectSettings
 278                                                         .getDefaultDocumentType(step, "docx").getName(),
 279                                                         "specification");
 280                                         Assert.assertNotNull(_projectSettings
 281                                                         .getDefaultDocumentType(step, "xml"));
 282                                         Assert.assertEquals(_projectSettings
 283                                                         .getDefaultDocumentType(step, "xml").getName(),
 284                                                         "specification");
 285                                         break;
 286                                 case 2:
 287                                         Assert.assertEquals(defTypes.size(), 3);
 288                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 289                                                         step, "pdf"));
 290                                         Assert.assertNotNull(_projectSettings
 291                                                         .getDefaultDocumentType(step, "doc"));
 292                                         Assert.assertEquals(_projectSettings
 293                                                         .getDefaultDocumentType(step, "doc").getName(),
 294                                                         "design");
 295                                         Assert.assertNotNull(_projectSettings
 296                                                         .getDefaultDocumentType(step, "docx"));
 297                                         Assert.assertEquals(_projectSettings
 298                                                         .getDefaultDocumentType(step, "docx").getName(),
 299                                                         "design");
 300                                         Assert.assertNotNull(_projectSettings
 301                                                         .getDefaultDocumentType(step, "xml"));
 302                                         Assert.assertEquals(_projectSettings
 303                                                         .getDefaultDocumentType(step, "xml").getName(),
 304                                                         "design");
 305                                         break;
 306                                 case 3:
 307                                         Assert.assertEquals(defTypes.size(), 8);
 308                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 309                                                         step, "pdf"));
 310                                         Assert.assertNotNull(_projectSettings
 311                                                         .getDefaultDocumentType(step, "sldprt"));
 312                                         Assert.assertEquals(_projectSettings
 313                                                         .getDefaultDocumentType(step, "sldprt").getName(),
 314                                                         "geometry");
 315                                         Assert.assertNotNull(_projectSettings
 316                                                         .getDefaultDocumentType(step, "sldasm"));
 317                                         Assert.assertEquals(_projectSettings
 318                                                         .getDefaultDocumentType(step, "sldasm").getName(),
 319                                                         "geometry");
 320                                         Assert.assertNotNull(_projectSettings
 321                                                         .getDefaultDocumentType(step, "part"));
 322                                         Assert.assertEquals(_projectSettings
 323                                                         .getDefaultDocumentType(step, "part").getName(),
 324                                                         "geometry");
 325                                         Assert.assertNotNull(_projectSettings
 326                                                         .getDefaultDocumentType(step, "py"));
 327                                         Assert.assertEquals(_projectSettings
 328                                                         .getDefaultDocumentType(step, "py").getName(),
 329                                                         "geometry");
 330                                         Assert.assertNotNull(_projectSettings
 331                                                         .getDefaultDocumentType(step, "brep"));
 332                                         Assert.assertEquals(_projectSettings
 333                                                         .getDefaultDocumentType(step, "brep").getName(),
 334                                                         "geometry");
 335                                         Assert.assertNotNull(_projectSettings
 336                                                         .getDefaultDocumentType(step, "doc"));
 337                                         Assert.assertEquals(_projectSettings
 338                                                         .getDefaultDocumentType(step, "doc").getName(),
 339                                                         "memorandum");
 340                                         Assert.assertNotNull(_projectSettings
 341                                                         .getDefaultDocumentType(step, "docx"));
 342                                         Assert.assertEquals(_projectSettings
 343                                                         .getDefaultDocumentType(step, "docx").getName(),
 344                                                         "memorandum");
 345                                         Assert.assertNotNull(_projectSettings
 346                                                         .getDefaultDocumentType(step, "xml"));
 347                                         Assert.assertEquals(_projectSettings
 348                                                         .getDefaultDocumentType(step, "xml").getName(),
 349                                                         "memorandum");
 350                                         break;
 351                                 case 4:
 352                                         Assert.assertEquals(defTypes.size(), 5);
 353                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 354                                                         step, "pdf"));
 355                                         Assert.assertNotNull(_projectSettings
 356                                                         .getDefaultDocumentType(step, "med"));
 357                                         Assert.assertEquals(_projectSettings
 358                                                         .getDefaultDocumentType(step, "med").getName(),
 359                                                         "model");
 360                                         Assert.assertNotNull(_projectSettings
 361                                                         .getDefaultDocumentType(step, "py"));
 362                                         Assert.assertEquals(_projectSettings
 363                                                         .getDefaultDocumentType(step, "py").getName(),
 364                                                         "model");
 365                                         Assert.assertNotNull(_projectSettings
 366                                                         .getDefaultDocumentType(step, "doc"));
 367                                         Assert.assertEquals(_projectSettings
 368                                                         .getDefaultDocumentType(step, "doc").getName(),
 369                                                         "memorandum");
 370                                         Assert.assertNotNull(_projectSettings
 371                                                         .getDefaultDocumentType(step, "docx"));
 372                                         Assert.assertEquals(_projectSettings
 373                                                         .getDefaultDocumentType(step, "docx").getName(),
 374                                                         "memorandum");
 375                                         Assert.assertNotNull(_projectSettings
 376                                                         .getDefaultDocumentType(step, "xml"));
 377                                         Assert.assertEquals(_projectSettings
 378                                                         .getDefaultDocumentType(step, "xml").getName(),
 379                                                         "memorandum");
 380                                         break;
 381                                 default:
 382                                         Assert.assertEquals(defTypes.size(), 0);
 383                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 384                                                         step, "pdf"));
 385                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 386                                                         step, "doc"));
 387                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 388                                                         step, "docx"));
 389                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 390                                                         step, "xml"));
 391                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 392                                                         step, "sldprt"));
 393                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 394                                                         step, "sldasm"));
 395                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 396                                                         step, "part"));
 397                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 398                                                         step, "py"));
 399                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 400                                                         step, "med"));
 401                         }
 402                 }
 403
 404                 // ////// Load workflow customization with empty mappings
 405                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 406                 try {
 407                         _projectSettings.configure("classpath:test/som-without-mappings.xml");
 408                 } catch (FileNotFoundException e) {
 409                         Assert.fail("Can't find configuration file: ", e);
 410                 }
 411                 steps = _stepsConfigService.getStepsOf(Scenario.class);
 412                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 413                 for (Step step : steps) {
 414                         List<String> defTypes = _projectSettings.getDefaultFormats(step);
 415                         Assert.assertNotNull(defTypes,
 416                                         "getDefaultFormats must always return not null list:");
 417                         Assert.assertEquals(defTypes.size(), 0);
 418                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 419                                         "pdf"));
 420                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 421                                         "doc"));
 422                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 423                                         "docx"));
 424                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 425                                         "xml"));
 426                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 427                                         "sldprt"));
 428                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 429                                         "sldasm"));
 430                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 431                                         "part"));
 432                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 433                                         "py"));
 434                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 435                                         "med"));
 436                 }
 437
 438                 // ////// Load workflow customization from not existing file
 439                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 440                 try {
 441                         _projectSettings.configure("classpath:test/xxx.xml");
 442                         Assert
 443                                         .fail("Customization loading must fail for not existing configuration file.");
 444                 } catch (FileNotFoundException e) {
 445                         LOG.debug("Configuration file must not be found.", e);
 446                 }
 447
 448                 rollbackNestedTransaction();
 449                 LOG.debug(">>>>> END testLoadDefaultDocTypes()");
 450         }
 451
 452         /**
 453          * Test of repeated database configuration method (dynamic reconfiguration).<BR>
 454          * The problem - duplication of the simer user admin role. <B>Description :</B> <BR>
 455          * <i>Load customization twice and check the result.</i><BR>
 456          * <B>Action : </B><BR>
 457          * <i>1. call the method twice for som.xml</i><BR>
 458          * <B>Test data : </B><BR>
 459          * <i>test/som.xml</i><BR>
 460          *
 461          * <B>Outcome results:</B><BR>
 462          * <i>
 463          * <ul>
 464          * <li>step must be configured<BR>
 465          * </li>
 466          * </ul>
 467          * </i>
 468          *
 469          * @throws IOException
 470          *             if configuration loading is failed
 471          * @throws SQLException
 472          *             if configuration loading is failed
 473          */
 474         @Test
 475         public void testConfigure() throws IOException, SQLException {
 476                 LOG.debug(">>>>> BEGIN testConfigure()");
 477                 startNestedTransaction();
 478                 // ///////////////////////////////////////////////////
 479                 // ////// Load good workflow customization
 480                 getHibernateTemplate().clear();
 481                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 482                 Database.getInstance().reset();
 483                 try {
 484                         _projectSettings.configure("classpath:test/som.xml");
 485                 } catch (FileNotFoundException e) {
 486                         Assert.fail("Can't find configuration file: ", e);
 487                 }
 488
 489                 getHibernateTemplate().flush();
 490                 List<Step> steps = _stepsConfigService.getStepsOf(Scenario.class);
 491                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 492                 KnowledgeElementType ucase = _knowledgeElementTypeService.selectType("usecase");
 493                 Assert.assertNotNull(ucase, "Knowledge type 'usecase' must be created in the database.");
 494                 SimulationContextType prodtype = _simulationContextService.selectType("product");
 495                 Assert.assertNotNull(prodtype, "Simulation context type 'product' must be created in the database.");
 496
 497                 // /////////////////////////////////////////////////////////
 498                 // ////// Test reconfiguration attempt
 499                 Database.getInstance().reset();
 500                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 501                 try {
 502                         _projectSettings.configure("classpath:test/som.xml");
 503                 } catch (FileNotFoundException e) {
 504                         Assert.fail("Can't find configuration file: ", e);
 505                 }
 506                 steps = _stepsConfigService.getStepsOf(Scenario.class);
 507                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 508                 ucase = _knowledgeElementTypeService.selectType("usecase");
 509                 Assert.assertNotNull(ucase, "Knowledge type 'usecase' must be created in the database.");
 510                 prodtype = _simulationContextService.selectType("product");
 511                 Assert.assertNotNull(prodtype, "Simulation context type 'product' must be created in the database.");
 512
 513                 try {
 514                         /*
 515                          * The next call to flush() must not throw the following exception: org.springframework.dao.DuplicateKeyException: a different
 516                          * object with the same identifier value was already associated with the session: [org.splat.dal.bo.kernel.Role#simer]; nested
 517                          * exception is org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated
 518                          * with the session: [org.splat.dal.bo.kernel.Role#simer] at
 519                          * org.springframework.orm.hibernate3.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:662) at
 520                          * org.springframework.orm.hibernate3.HibernateAccessor.convertHibernateAccessException(HibernateAccessor.java:412) at
 521                          * org.springframework.orm.hibernate3.HibernateTemplate.doExecute(HibernateTemplate.java:411) at
 522                          * org.springframework.orm.hibernate3.HibernateTemplate.executeWithNativeSession(HibernateTemplate.java:374) at
 523                          * org.springframework.orm.hibernate3.HibernateTemplate.flush(HibernateTemplate.java:881)
 524                          */
 525                         getHibernateTemplate().flush();
 526                 } catch (DuplicateKeyException dke) {
 527                         Assert.fail(
 528                                         "User creation failed during the database reconfiguration: "
 529                                                         + dke.getMessage(), dke);
 530                 }
 531
 532                 rollbackNestedTransaction();
 533                 LOG.debug(">>>>> END testConfigure()");
 534         }
 535
 536         /**
 537          * Test of repeated database configuration method (dynamic reconfiguration).<BR>
 538          * The problem - duplication of the simer user admin role. <B>Description :</B> <BR>
 539          * <i>Load customization twice and check the result.</i><BR>
 540          * <B>Action : </B><BR>
 541          * <i>1. call the method twice for som.xml</i><BR>
 542          * <B>Test data : </B><BR>
 543          * <i>test/som.xml</i><BR>
 544          *
 545          * <B>Outcome results:</B><BR>
 546          * <i>
 547          * <ul>
 548          * <li>step must be configured<BR>
 549          * </li>
 550          * </ul>
 551          * </i>
 552          *
 553          * @throws IOException
 554          *             if configuration loading is failed
 555          * @throws SQLException
 556          *             if configuration loading is failed
 557          */
 558         @Test
 559         public void testDatabaseInitialize() throws IOException, SQLException {
 560                 LOG.debug(">>>>> BEGIN testDatabaseInitialize()");
 561                 startNestedTransaction();
 562                 // ///////////////////////////////////////////////////
 563                 // ////// Load good workflow customization
 564                 getHibernateTemplate().bulkUpdate("delete from User");
 565                 getHibernateTemplate().bulkUpdate("delete from Role");
 566                 getHibernateTemplate().flush();
 567                 Database.getInstance().reset();
 568                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 569                 try {
 570                         _projectSettings.configure("classpath:test/som.xml");
 571                 } catch (FileNotFoundException e) {
 572                         Assert.fail("Can't find configuration file: ", e);
 573                 }
 574                 try {
 575                         /*
 576                          * The next call to flush() must not throw the following exception: org.springframework.dao.DuplicateKeyException: a different
 577                          * object with the same identifier value was already associated with the session: [org.splat.dal.bo.kernel.Role#simer]; nested
 578                          * exception is org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated
 579                          * with the session: [org.splat.dal.bo.kernel.Role#simer] at
 580                          * org.springframework.orm.hibernate3.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:662) at
 581                          * org.springframework.orm.hibernate3.HibernateAccessor.convertHibernateAccessException(HibernateAccessor.java:412) at
 582                          * org.springframework.orm.hibernate3.HibernateTemplate.doExecute(HibernateTemplate.java:411) at
 583                          * org.springframework.orm.hibernate3.HibernateTemplate.executeWithNativeSession(HibernateTemplate.java:374) at
 584                          * org.springframework.orm.hibernate3.HibernateTemplate.flush(HibernateTemplate.java:881)
 585                          */
 586                         Database.getInstance().initialize();
 587                         getHibernateTemplate().flush();
 588                 } catch (DuplicateKeyException dke) {
 589                         Assert.fail(
 590                                         "User creation failed during the database reconfiguration: "
 591                                                         + dke.getMessage(), dke);
 592                 }
 593
 594                 KnowledgeElementType ucase = _knowledgeElementTypeService.selectType("usecase");
 595                 Assert.assertNotNull(ucase, "Knowledge type 'usecase' must be created in the database.");
 596                 SimulationContextType prodtype = _simulationContextService.selectType("product");
 597                 Assert.assertNotNull(prodtype, "Simulation context type 'product' must be created in the database.");
 598
 599                 rollbackNestedTransaction();
 600                 LOG.debug(">>>>> END testDatabaseInitialize()");
 601         }
 602 }