How to use

getName

method

in

org.drools.repository.ModuleItem

/**
 * Set this to indicate if the binary is up to date, or not.
 */
public void updateBinaryUpToDate(boolean status) {
  try {
    checkIsUpdateable();
    this.checkout();
    node.setProperty(BINARY_UP_TO_DATE,
        status);
  } catch (RepositoryException e) {
    log.error("fail to update drools:binaryUpToDate of " + getName(),
        e);
  }
}

/**
 * Set this to indicate if the binary is up to date, or not.
 */
public void updateBinaryUpToDate(boolean status) {
  try {
    checkIsUpdateable();
    this.checkout();
    node.setProperty(BINARY_UP_TO_DATE,
        status);
  } catch (RepositoryException e) {
    log.error("fail to update drools:binaryUpToDate of " + getName(),
        e);
  }
}

/**
 * Return true if the binary is "up to date".
 *
 * @return
 */
public boolean isBinaryUpToDate() {
  try {
    return this.node.hasProperty(BINARY_UP_TO_DATE) && node.getProperty(BINARY_UP_TO_DATE).getBoolean();
  } catch (RepositoryException e) {
    log.error("fail to get drools:binaryUpToDate of " + getName(),
        e);
    throw new RulesRepositoryException(e);
  }
}

/**
 * Return true if the binary is "up to date".
 *
 * @return
 */
public boolean isBinaryUpToDate() {
  try {
    return this.node.hasProperty(BINARY_UP_TO_DATE) && node.getProperty(BINARY_UP_TO_DATE).getBoolean();
  } catch (RepositoryException e) {
    log.error("fail to get drools:binaryUpToDate of " + getName(),
        e);
    throw new RulesRepositoryException(e);
  }
}

private void setUpPackageItem() {
  packageItem = mock( ModuleItem.class );
  when( packageItem.getName() ).thenReturn( "mock" );
}

/**
 * This will permanently delete this module.
 */
public void remove() {
  checkIsUpdateable();
  try {
    log.info("USER:" + getCurrentUserName() + " REMOVEING module [" + getName() + "]");
    this.node.remove();
  } catch (RepositoryException e) {
    throw new RulesRepositoryException("Was not able to delete module.",
        e);
  }
}

/**
 * This will permanently delete this module.
 */
public void remove() {
  checkIsUpdateable();
  try {
    log.info("USER:" + getCurrentUserName() + " REMOVEING module [" + getName() + "]");
    this.node.remove();
  } catch (RepositoryException e) {
    throw new RulesRepositoryException("Was not able to delete module.",
        e);
  }
}

public void migrate(RulesRepository repo) throws RepositoryException {
  log.info("AUTO MIGRATION: Performing drools.package migration...");
  ModuleIterator pkgs = repo.listModules();
  boolean performed = false;
  while(pkgs.hasNext()) {
    performed = true;
    ModuleItem pkg = (ModuleItem) pkgs.next();
    migratePackage(pkg);
    String[] snaps = repo.listModuleSnapshots(pkg.getName());
    if (snaps != null) {
      for (int i = 0; i < snaps.length; i++) {
        ModuleItem snap = repo.loadModuleSnapshot(pkg.getName(), snaps[i]);
        migratePackage(snap);
      }
    }
  }
  if (performed) {
    repo.getSession().getRootNode().getNode(RulesRepository.RULES_REPOSITORY_NAME).addNode("drools.package.migrated", "nt:folder");
    repo.save();
    log.info("AUTO MIGRATION: drools.package migration completed.");
  }
}

public void migrate(RulesRepository repo) throws RepositoryException {
  log.info("AUTO MIGRATION: Performing drools.package migration...");
  ModuleIterator pkgs = repo.listModules();
  boolean performed = false;
  while(pkgs.hasNext()) {
    performed = true;
    ModuleItem pkg = (ModuleItem) pkgs.next();
    migratePackage(pkg);
    String[] snaps = repo.listModuleSnapshots(pkg.getName());
    if (snaps != null) {
      for (int i = 0; i < snaps.length; i++) {
        ModuleItem snap = repo.loadModuleSnapshot(pkg.getName(), snaps[i]);
        migratePackage(snap);
      }
    }
  }
  if (performed) {
    repo.getSession().getRootNode().getNode(RulesRepository.RULES_REPOSITORY_NAME).addNode("drools.package.migrated", "nt:folder");
    repo.save();
    log.info("AUTO MIGRATION: drools.package migration completed.");
  }
}

@Test
public void testRulePackageItem() throws Exception {
  RulesRepository repo = getRepo();
  //calls constructor
  ModuleItem rulePackageItem1 = repo.createModule("testRulePackage", "desc");
  assertNotNull(rulePackageItem1);
  assertEquals("testRulePackage", rulePackageItem1.getName());
  Iterator it = getRepo().listModules();
  assertTrue(it.hasNext());
  while (it.hasNext()) {
    ModuleItem pack = (ModuleItem) it.next();
    if (pack.getName().equals( "testRulePackage" )) {
      return;
    }
  }
  fail("should have picked up the testRulePackage but didnt.");
}

@Test
public void testListPackages() {
  RulesRepository rulesRepository = getRepo();
  rulesRepository.createModule( "testListPackages",
                  "desc" );
  assertTrue( rulesRepository.containsModule( "testListPackages" ) );
  assertFalse( rulesRepository.containsModule( "XXXXXXX" ) );
  Iterator it = rulesRepository.listModules();
  assertTrue( it.hasNext() );
  boolean found = false;
  //listPackages() should not return the global area even though the global area is a package.
  boolean foundGlobalArea = false;
  while ( it.hasNext() ) {
    ModuleItem element = (ModuleItem) it.next();
    if ( element.getName().equals( "testListPackages" ) ) {
      found = true;
    }
    
    if ( element.getName().equals(RulesRepository.GLOBAL_AREA) ) {
      foundGlobalArea = true;
    }
   }
  assertTrue( found );
  assertFalse( foundGlobalArea );
}

@Test
public void testGetPackageItem() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem def = repo.loadDefaultModule();
  AssetItem asset = repo.loadDefaultModule().addAsset("testPackageItem", "test content");
  ModuleItem pkg = asset.getModule();
  assertEquals(def.getName(), pkg.getName());
  assertEquals(def.getUUID(), pkg.getUUID());
}

@Test
public void testDefaultPackage() throws Exception {
  RulesRepository repo = getRepo();
  Iterator it = repo.listModules();
  boolean foundDefault = false;
  while ( it.hasNext() ) {
    ModuleItem item = (ModuleItem) it.next();
    if ( item.getName().equals( RulesRepository.DEFAULT_PACKAGE ) ) {
      foundDefault = true;
    }
  }
  assertTrue( foundDefault );
  ModuleItem def = repo.loadDefaultModule();
  assertNotNull( def );
  assertEquals( RulesRepository.DEFAULT_PACKAGE,
         def.getName() );
  String userId = repo.getSession().getUserID();
  assertNotNull( userId );
  assertFalse( userId.equals( "" ) );
  MigrateDroolsPackage mig = new MigrateDroolsPackage();
  assertFalse( mig.needsMigration( repo ) );
  assertTrue( repo.initialized );
}

@Test
public void testGetPackageItemHistorical() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem pkg = repo.createModule("testGetPackageItemHistorical", "");
  AssetItem asset = pkg.addAsset("whee", "");
  asset.checkin("");
  assertNotNull(asset.getModule());
  repo.createModuleSnapshot(pkg.getName(), "SNAP");
  ModuleItem pkg_ = repo.loadModuleSnapshot(pkg.getName(), "SNAP");
  AssetItem asset_ = pkg_.loadAsset("whee");
  ModuleItem pkg__ = asset_.getModule();
  assertTrue(pkg__.isSnapshot());
  assertTrue(pkg_.isSnapshot());
  assertFalse(pkg.isSnapshot());
  assertEquals(pkg.getName(), pkg__.getName());
  asset.updateDescription("yeah !");
  asset.checkin("new");
  asset = pkg.loadAsset("whee");
  assertNotNull(asset.getModule());
  AssetHistoryIterator it = asset.getHistory();
  while(it.hasNext()) {
    AssetItem as = it.next();
    if (as.getVersionNumber() > 0) {
      System.err.println(as.getVersionNumber());
      System.err.println(as.getModuleName());
      assertNotNull(as.getModule());
      assertEquals(pkg.getName(), as.getModule().getName());
    }
  }
}

@Test
public void testDuplicatePackageName() throws Exception {
  ModuleItem pack = getRepo().createModule( "dupePackageTest", "testing for dupe" );
  assertNotNull(pack.getName());
  try {
    getRepo().createModule( "dupePackageTest", "this should fail" );
    fail("Should not be able to add a package of the same name.");
  } catch (RulesRepositoryException e) {
    assertNotNull(e.getMessage());
  }
}

String name = getDefaultPackage().getName();
getRepo().createModuleSnapshot(getDefaultPackage().getName(), "SNAP");
ModuleItem pkgSnap = getRepo().loadModuleSnapshot(getDefaultPackage().getName(), "SNAP");
AssetItem assetSnap = pkgSnap.loadAsset("testGetPackageItemHistoricalForShareableAsset");
ModuleItem pkgSnap1 = assetSnap.getModule();
assertTrue(pkgSnap.isSnapshot());
assertFalse(getDefaultPackage().isSnapshot());
assertEquals(getDefaultPackage().getName(), pkgSnap1.getName());
assertFalse(linkedPkg.isSnapshot());
assertFalse(getDefaultPackage().isSnapshot());
assertEquals(getDefaultPackage().getName(), linkedPkg.getName());

@Test
public void testAssetItemCreation() throws Exception {
    Calendar now = Calendar.getInstance();
    Thread.sleep(500); //MN: need this sleep to get the correct date
    AssetItem ruleItem1 = getDefaultPackage().addAsset("testRuleItem", "test content");
    assertNotNull(ruleItem1);
    assertNotNull(ruleItem1.getNode());
    assertEquals("testRuleItem", ruleItem1.getName());
    assertNotNull(ruleItem1.getCreatedDate());
    assertTrue(now.before( ruleItem1.getCreatedDate() ));
    String packName = getDefaultPackage().getName();
    assertEquals(packName, ruleItem1.getModuleName());
    assertNotNull(ruleItem1.getUUID());
  //try constructing with node of wrong type
  try {
    ModuleItem pitem = getRepo().loadDefaultModule();
    new AssetItem(getRepo(), pitem.getNode());
    fail("Exception not thrown for node of wrong type");
  }
  catch(RulesRepositoryException e) {
    assertNotNull(e.getMessage());
  }
  catch(Exception e) {
    fail("Caught unexpected exception: " + e);
  }
}

@Test
public void testLoadRulePackageItemByUUID() throws Exception {
  ModuleItem rulePackageItem = getRepo().createModule("testLoadRuleRuleItemByUUID", "desc");
  String uuid = null;
    uuid = rulePackageItem.getNode().getUUID();
  rulePackageItem = getRepo().loadModuleByUUID(uuid);
  assertNotNull(rulePackageItem);
  assertEquals("testLoadRuleRuleItemByUUID", rulePackageItem.getName());
  // try loading rule package that was not created
  try {
    rulePackageItem = getRepo().loadModuleByUUID("01010101-0101-0101-0101-010101010101");
    fail("Exception not thrown loading rule package that was not created.");
  } catch (RulesRepositoryException e) {
    // that is OK!
    assertNotNull(e.getMessage());
  }
}

@Test
public void testLoadRulePackageItem() {
  ModuleItem rulePackageItem = getRepo().createModule("testLoadRuleRuleItem", "desc");
  rulePackageItem = getRepo().loadModule("testLoadRuleRuleItem");
  assertNotNull(rulePackageItem);
  assertEquals("testLoadRuleRuleItem", rulePackageItem.getName());
  assertEquals("desc", rulePackageItem.getDescription());
  assertEquals(ModuleItem.MODULE_FORMAT, rulePackageItem.getFormat());
  // try loading rule package that was not created
  try {
    rulePackageItem = getRepo().loadModule("anotherRuleRuleItem");
    fail("Exception not thrown loading rule package that was not created.");
  } catch (RulesRepositoryException e) {
    // that is OK!
    assertNotNull(e.getMessage());
  }
}

@Test 
public void testPackageWorkspaceProperty() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem item = repo.createModule( "testPackageWorkspaceProperty1", "lalalala" );
  getRepo().save();
  
  String[] workspaces = repo.loadModule(item.getName()).getWorkspaces();
  item.removeWorkspace("workspace1");
  
  workspaces = item.getWorkspaces();
  assertEquals(workspaces.length, 0);
  item.addWorkspace("workspace1");
  item.addWorkspace("workspace2");
  item.addWorkspace("workspace1");
  item.addWorkspace("workspace2");
  workspaces = item.getWorkspaces();
  assertEquals(workspaces.length, 2);
  
  item.removeWorkspace("workspace1");
  item.removeWorkspace("workspace3");
  workspaces = item.getWorkspaces();
  assertEquals(workspaces.length, 1);
  assertTrue((workspaces[0]).equals("workspace2"));
}