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.ProjectSettingsService.Step;
  26 import org.splat.service.technical.StepsConfigService;
  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                                 case 6:
 382                                         Assert.assertEquals(defTypes.size(), 2);
 383                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 384                                                         step, "pdf"));
 385                                         Assert.assertNull(_projectSettings
 386                                                         .getDefaultDocumentType(step, "med"));
 387                                         Assert.assertNotNull(_projectSettings
 388                                                         .getDefaultDocumentType(step, "py"));
 389                                         Assert.assertEquals(_projectSettings
 390                                                         .getDefaultDocumentType(step, "py").getName(),
 391                                                         "visualisation");
 392                                         Assert.assertNotNull(_projectSettings
 393                                                         .getDefaultDocumentType(step, "srd"));
 394                                         Assert.assertEquals(_projectSettings
 395                                                         .getDefaultDocumentType(step, "srd").getName(),
 396                                                         "coparisonResult");
 397                                         break;
 398                                 case 7:
 399                                         Assert.assertEquals(defTypes.size(), 1);
 400                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 401                                                         step, "pdf"));
 402                                         Assert.assertNull(_projectSettings
 403                                                         .getDefaultDocumentType(step, "med"));
 404                                         Assert.assertNull(_projectSettings
 405                                                         .getDefaultDocumentType(step, "py"));
 406                                         Assert.assertNotNull(_projectSettings
 407                                                         .getDefaultDocumentType(step, "xml"));
 408                                         Assert.assertEquals(_projectSettings
 409                                                         .getDefaultDocumentType(step, "xml").getName(),
 410                                                         "schema");
 411                                         break;
 412                                 default:
 413                                         Assert.assertEquals(defTypes.size(), 0);
 414                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 415                                                         step, "pdf"));
 416                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 417                                                         step, "doc"));
 418                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 419                                                         step, "docx"));
 420                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 421                                                         step, "xml"));
 422                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 423                                                         step, "sldprt"));
 424                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 425                                                         step, "sldasm"));
 426                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 427                                                         step, "part"));
 428                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 429                                                         step, "py"));
 430                                         Assert.assertNull(_projectSettings.getDefaultDocumentType(
 431                                                         step, "med"));
 432                         }
 433                 }
 434
 435                 // ////// Load workflow customization with empty mappings
 436                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 437                 try {
 438                         _projectSettings.configure("classpath:test/som-without-mappings.xml");
 439                 } catch (FileNotFoundException e) {
 440                         Assert.fail("Can't find configuration file: ", e);
 441                 }
 442                 steps = _stepsConfigService.getStepsOf(Scenario.class);
 443                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 444                 for (Step step : steps) {
 445                         List<String> defTypes = _projectSettings.getDefaultFormats(step);
 446                         Assert.assertNotNull(defTypes,
 447                                         "getDefaultFormats must always return not null list:");
 448                         Assert.assertEquals(defTypes.size(), 0);
 449                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 450                                         "pdf"));
 451                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 452                                         "doc"));
 453                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 454                                         "docx"));
 455                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 456                                         "xml"));
 457                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 458                                         "sldprt"));
 459                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 460                                         "sldasm"));
 461                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 462                                         "part"));
 463                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 464                                         "py"));
 465                         Assert.assertNull(_projectSettings.getDefaultDocumentType(step,
 466                                         "med"));
 467                 }
 468
 469                 // ////// Load workflow customization from not existing file
 470                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 471                 try {
 472                         _projectSettings.configure("classpath:test/xxx.xml");
 473                         Assert
 474                                         .fail("Customization loading must fail for not existing configuration file.");
 475                 } catch (FileNotFoundException e) {
 476                         LOG.debug("Configuration file must not be found.", e);
 477                 }
 478
 479                 rollbackNestedTransaction();
 480                 LOG.debug(">>>>> END testLoadDefaultDocTypes()");
 481         }
 482
 483         /**
 484          * Test of repeated database configuration method (dynamic reconfiguration).<BR>
 485          * The problem - duplication of the simer user admin role. <B>Description :</B> <BR>
 486          * <i>Load customization twice and check the result.</i><BR>
 487          * <B>Action : </B><BR>
 488          * <i>1. call the method twice for som.xml</i><BR>
 489          * <B>Test data : </B><BR>
 490          * <i>test/som.xml</i><BR>
 491          *
 492          * <B>Outcome results:</B><BR>
 493          * <i>
 494          * <ul>
 495          * <li>step must be configured<BR>
 496          * </li>
 497          * </ul>
 498          * </i>
 499          *
 500          * @throws IOException
 501          *             if configuration loading is failed
 502          * @throws SQLException
 503          *             if configuration loading is failed
 504          */
 505         @Test
 506         public void testConfigure() throws IOException, SQLException {
 507                 LOG.debug(">>>>> BEGIN testConfigure()");
 508                 startNestedTransaction();
 509                 // ///////////////////////////////////////////////////
 510                 // ////// Load good workflow customization
 511                 getHibernateTemplate().clear();
 512                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 513                 Database.getInstance().reset();
 514                 try {
 515                         _projectSettings.configure("classpath:test/som.xml");
 516                 } catch (FileNotFoundException e) {
 517                         Assert.fail("Can't find configuration file: ", e);
 518                 }
 519
 520                 getHibernateTemplate().flush();
 521                 List<Step> steps = _stepsConfigService.getStepsOf(Scenario.class);
 522                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 523                 KnowledgeElementType ucase = _knowledgeElementTypeService.selectType("usecase");
 524                 Assert.assertNotNull(ucase, "Knowledge type 'usecase' must be created in the database.");
 525                 SimulationContextType prodtype = _simulationContextService.selectType("product");
 526                 Assert.assertNotNull(prodtype, "Simulation context type 'product' must be created in the database.");
 527
 528                 // /////////////////////////////////////////////////////////
 529                 // ////// Test reconfiguration attempt
 530                 Database.getInstance().reset();
 531                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 532                 try {
 533                         _projectSettings.configure("classpath:test/som.xml");
 534                 } catch (FileNotFoundException e) {
 535                         Assert.fail("Can't find configuration file: ", e);
 536                 }
 537                 steps = _stepsConfigService.getStepsOf(Scenario.class);
 538                 Assert.assertTrue(steps.size() > 0, "No steps are created.");
 539                 ucase = _knowledgeElementTypeService.selectType("usecase");
 540                 Assert.assertNotNull(ucase, "Knowledge type 'usecase' must be created in the database.");
 541                 prodtype = _simulationContextService.selectType("product");
 542                 Assert.assertNotNull(prodtype, "Simulation context type 'product' must be created in the database.");
 543
 544                 try {
 545                         /*
 546                          * The next call to flush() must not throw the following exception: org.springframework.dao.DuplicateKeyException: a different
 547                          * object with the same identifier value was already associated with the session: [org.splat.dal.bo.kernel.Role#simer]; nested
 548                          * exception is org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated
 549                          * with the session: [org.splat.dal.bo.kernel.Role#simer] at
 550                          * org.springframework.orm.hibernate3.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:662) at
 551                          * org.springframework.orm.hibernate3.HibernateAccessor.convertHibernateAccessException(HibernateAccessor.java:412) at
 552                          * org.springframework.orm.hibernate3.HibernateTemplate.doExecute(HibernateTemplate.java:411) at
 553                          * org.springframework.orm.hibernate3.HibernateTemplate.executeWithNativeSession(HibernateTemplate.java:374) at
 554                          * org.springframework.orm.hibernate3.HibernateTemplate.flush(HibernateTemplate.java:881)
 555                          */
 556                         getHibernateTemplate().flush();
 557                 } catch (DuplicateKeyException dke) {
 558                         Assert.fail(
 559                                         "User creation failed during the database reconfiguration: "
 560                                                         + dke.getMessage(), dke);
 561                 }
 562
 563                 rollbackNestedTransaction();
 564                 LOG.debug(">>>>> END testConfigure()");
 565         }
 566
 567         /**
 568          * Test of repeated database configuration method (dynamic reconfiguration).<BR>
 569          * The problem - duplication of the simer user admin role. <B>Description :</B> <BR>
 570          * <i>Load customization twice and check the result.</i><BR>
 571          * <B>Action : </B><BR>
 572          * <i>1. call the method twice for som.xml</i><BR>
 573          * <B>Test data : </B><BR>
 574          * <i>test/som.xml</i><BR>
 575          *
 576          * <B>Outcome results:</B><BR>
 577          * <i>
 578          * <ul>
 579          * <li>step must be configured<BR>
 580          * </li>
 581          * </ul>
 582          * </i>
 583          *
 584          * @throws IOException
 585          *             if configuration loading is failed
 586          * @throws SQLException
 587          *             if configuration loading is failed
 588          */
 589         @Test
 590         public void testDatabaseInitialize() throws IOException, SQLException {
 591                 LOG.debug(">>>>> BEGIN testDatabaseInitialize()");
 592                 startNestedTransaction();
 593                 // ///////////////////////////////////////////////////
 594                 // ////// Load good workflow customization
 595                 getHibernateTemplate().bulkUpdate("delete from User");
 596                 getHibernateTemplate().bulkUpdate("delete from Role");
 597                 getHibernateTemplate().flush();
 598                 Database.getInstance().reset();
 599                 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
 600                 try {
 601                         _projectSettings.configure("classpath:test/som.xml");
 602                 } catch (FileNotFoundException e) {
 603                         Assert.fail("Can't find configuration file: ", e);
 604                 }
 605                 try {
 606                         /*
 607                          * The next call to flush() must not throw the following exception: org.springframework.dao.DuplicateKeyException: a different
 608                          * object with the same identifier value was already associated with the session: [org.splat.dal.bo.kernel.Role#simer]; nested
 609                          * exception is org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated
 610                          * with the session: [org.splat.dal.bo.kernel.Role#simer] at
 611                          * org.springframework.orm.hibernate3.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:662) at
 612                          * org.springframework.orm.hibernate3.HibernateAccessor.convertHibernateAccessException(HibernateAccessor.java:412) at
 613                          * org.springframework.orm.hibernate3.HibernateTemplate.doExecute(HibernateTemplate.java:411) at
 614                          * org.springframework.orm.hibernate3.HibernateTemplate.executeWithNativeSession(HibernateTemplate.java:374) at
 615                          * org.springframework.orm.hibernate3.HibernateTemplate.flush(HibernateTemplate.java:881)
 616                          */
 617                         Database.getInstance().initialize();
 618                         getHibernateTemplate().flush();
 619                 } catch (DuplicateKeyException dke) {
 620                         Assert.fail(
 621                                         "User creation failed during the database reconfiguration: "
 622                                                         + dke.getMessage(), dke);
 623                 }
 624
 625                 KnowledgeElementType ucase = _knowledgeElementTypeService.selectType("usecase");
 626                 Assert.assertNotNull(ucase, "Knowledge type 'usecase' must be created in the database.");
 627                 SimulationContextType prodtype = _simulationContextService.selectType("product");
 628                 Assert.assertNotNull(prodtype, "Simulation context type 'product' must be created in the database.");
 629
 630                 rollbackNestedTransaction();
 631                 LOG.debug(">>>>> END testDatabaseInitialize()");
 632         }
 633 }