How to use

createModule

method

in

org.drools.repository.RulesRepository

/**
 * Adds a module to the repository.
 *
 * @param name        what to name the node added
 * @param description what description to use for the node
 * @return a ModuleItem, encapsulating the created node
 * @throws RulesRepositoryException
 */
public ModuleItem createModule(String name,
                 String description) throws RulesRepositoryException {
  //TODO: As we are moving towards a generic repository, create a module that is default to drools_package format
  //may not be correct.
  return createModule(name,
      description,
      ModuleItem.MODULE_FORMAT,
      null,
      "Initial");
}

/**
 * Adds a module to the repository.
 *
 * @param name        what to name the node added
 * @param description what description to use for the node
 * @param format      module format.
 * @return a ModuleItem, encapsulating the created node
 * @throws RulesRepositoryException
 */
public ModuleItem createModule(String name,
                 String description,
                 String format) throws RulesRepositoryException {
  return createModule(name,
      description,
      format,
      null,
      "Initial");
}

/**
 * Adds a module to the repository.
 *
 * @param name        what to name the node added
 * @param description what description to use for the node
 * @return a ModuleItem, encapsulating the created node
 * @throws RulesRepositoryException
 */
public ModuleItem createModule(String name,
                 String description) throws RulesRepositoryException {
  //TODO: As we are moving towards a generic repository, create a module that is default to drools_package format
  //may not be correct.
  return createModule(name,
      description,
      ModuleItem.MODULE_FORMAT,
      null,
      "Initial");
}

/**
 * This will return or create the default module for assets that have no
 * home yet.
 */
public ModuleItem loadDefaultModule() throws RulesRepositoryException {
  Node folderNode = this.getAreaNode(MODULE_AREA);
  try {
    if (folderNode.hasNode(DEFAULT_PACKAGE)) {
      return loadModule(DEFAULT_PACKAGE);
    } else {
      return createModule(DEFAULT_PACKAGE,
          "");
    }
  } catch (RepositoryException e) {
    throw new RulesRepositoryException(e);
  }
}

/**
 * This will return or create the default module for assets that have no
 * home yet.
 */
public ModuleItem loadDefaultModule() throws RulesRepositoryException {
  Node folderNode = this.getAreaNode(MODULE_AREA);
  try {
    if (folderNode.hasNode(DEFAULT_PACKAGE)) {
      return loadModule(DEFAULT_PACKAGE);
    } else {
      return createModule(DEFAULT_PACKAGE,
          "");
    }
  } catch (RepositoryException e) {
    throw new RulesRepositoryException(e);
  }
}

/**
 * @return an Iterator which will provide RulePackageItem's. This will show
 *         aLL the modules, only returning latest versions, by default.
 */
public ModuleIterator listModules() {
  Node folderNode = this.getAreaNode(MODULE_AREA);
  try {
    synchronized (RulesRepository.class) {
      if (!folderNode.hasNode(DEFAULT_PACKAGE)) {
        createModule(DEFAULT_PACKAGE,
            "The default rule package");
        folderNode = this.getAreaNode(MODULE_AREA);
      }
    }
    return new ModuleIterator(this,
        folderNode.getNodes());
  } catch (RepositoryException e) {
    throw new RulesRepositoryException(e);
  }
}

@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());
  }
}

@Test
public void testListPackages() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem item = repo.createModule( "testListPackages1", "lalalala" );
  assertNotNull(item.getCreator());
  item.updateStringProperty( "goo", "whee" );
  assertEquals("goo", item.getStringProperty( "whee" ));
  assertFalse(item.getCreator().equals( "" ));
  List list = iteratorToList( repo.listModules() );
  int prevSize = list.size();
  repo.createModule( "testListPackages2", "abc" );
  list = iteratorToList( repo.listModules() );
  assertEquals(prevSize + 1, list.size());
}

@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 testAddAssetTrailingWhitespace() {
  ModuleItem pkg = getRepo().createModule("testAddAssetTrailingWhitespace","desc");
  pkg.addAsset("wee ", "");
  assertNotNull(pkg.loadAsset("wee"));
}

@Test
public void testToString() {
  ModuleItem rulePackageItem1 = getRepo().createModule("testToStringPackage", "desc");
  AssetItem ruleItem1 = rulePackageItem1.addAsset("testToStringPackage", "test lhs content" );
  ruleItem1.updateContent( "test lhs content" );
  assertNotNull(rulePackageItem1.toString());
}

@Test
public void testGetWithSpaces() throws Exception {
  RulesRepository repo = RepositorySessionUtil.getRepository();
  ModuleItem pkg = repo.createModule("testRestGetSpaces", "", ModuleItem.MODULE_FORMAT);
  AssetItem ass = pkg.addAsset("some space", "");
  ass.updateFormat("drl");
  ass.checkin("hey");
  RestAPI api = new RestAPI(repo);
  api.setAssetValidator(new AssetValidator());
  String url = "packages/testRestGetSpaces";
  Response res = api.get(url);
  ByteArrayOutputStream out = new ByteArrayOutputStream();
  res.writeData(out);
  assertTrue(new String(out.toByteArray()).indexOf("\\ ") > -1);
  url = "packages/testRestGetSpaces/some space.drl";
  res = api.get(url);
  assertNotNull(res.lastModified);
}

@Test
public void testFormatOtherThanDroolsPackage() {
  ModuleItem rulePackageItem1 = getRepo().createModule(
      "testFormatOtherThanDroolsPackage", "woot");
  assertNotNull(rulePackageItem1);
  // PACKAGE_FORMAT is the default module format
  assertEquals(ModuleItem.MODULE_FORMAT, rulePackageItem1.getFormat());
  rulePackageItem1.updateFormat("soaservice");
  ModuleItem item = getRepo().loadModule(
      "testFormatOtherThanDroolsPackage");
  assertEquals("soaservice", item.getFormat());
}

@Test
public void testPackageRemove() throws Exception {
  RulesRepository repo = getRepo();
  ModuleItem p = repo.createModule("removeMe", "");
  AssetItem a = p.addAsset("Whee", "");
  a.updateContent("yeah");
  a.checkin("la");
  p.addAsset("Waa", "");
  repo.save();
  ModuleItem pkgNested = p.createSubModule("NestedGoodness");
  assertNotNull(pkgNested);
  int n = iteratorToList(repo.listModules()).size();
  p = repo.loadModule("removeMe");
  p.remove();
  repo.save();
  int n_ = iteratorToList(repo.listModules()).size();
  assertEquals(n - 1, n_);
}

@Test
public void testDublinCoreProperties() {
  ModuleItem pkg = getRepo().createModule( "testDublinCore", "wa" );
  AssetItem ruleItem = pkg.addAsset( "testDublinCoreProperties", "yeah yeah yeah" );
  ruleItem.updateCoverage( "b" );
  assertEquals("b",ruleItem.getCoverage());
  ruleItem.checkin( "woo" );
  pkg = getRepo().loadModule( "testDublinCore" );
  ruleItem = (AssetItem) pkg.getAssets().next();
  assertEquals("b", ruleItem.getCoverage());
  assertEquals("", ruleItem.getExternalRelation());
  assertEquals("", ruleItem.getExternalSource());
}

@Test
public void testGetFormatAndUpToDate() {
  ModuleItem rulePackageItem1 = getRepo().createModule("testGetFormat",
      "woot");
  assertNotNull(rulePackageItem1);
  assertEquals(ModuleItem.MODULE_FORMAT, rulePackageItem1.getFormat());
  assertFalse(rulePackageItem1.isBinaryUpToDate());
  rulePackageItem1.updateBinaryUpToDate(true);
  assertTrue(rulePackageItem1.isBinaryUpToDate());
  rulePackageItem1.updateBinaryUpToDate(false);
  assertFalse(rulePackageItem1.isBinaryUpToDate());
}

@Test
public void testMiscProperties() {
  ModuleItem item = getRepo().createModule( "testHeader", "ya" );
  updateHeader( "new header", item );
  item.updateExternalURI( "boo" );
  getRepo().save();
  assertEquals("new header", getHeader(item));
  item = getRepo().loadModule("testHeader");
  assertEquals("new header", getHeader(item));
  assertEquals("boo", item.getExternalURI());
}

@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 testIgnoreState() throws Exception {
  ModuleItem pack = getRepo().createModule( "package testIgnoreState", "foo" );
  getRepo().createState( "x" );
  AssetItem rule1 = pack.addAsset( "rule number 1", "yeah man" );
  rule1.updateState( "x" );
  rule1.checkin( "version0" );
  AssetItem rule2 = pack.addAsset( "rule number 2", "no way" );
  rule2.updateState( "x" );
  rule2.checkin( "version0" );
  AssetItem rule3 = pack.addAsset( "rule number 3", "yes way" );
  getRepo().createState( "disabled" );
  rule3.updateState( "disabled" );
  rule3.checkin( "version0" );
  getRepo().save();
  Iterator result = pack.getAssetsWithStatus( getRepo().getState( "x" ), getRepo().getState( "disabled" ) );
  List l = iteratorToList( result );
  assertEquals(2, l.size());
}