Best Java code snippets using org.drools.repository.ModuleItem.loadAsset (Showing top 20 results out of 315)

@Test
public void testGetDroolsHeaderAndDoesNotExist() {
  ModuleItem packageItem = mock( ModuleItem.class );
  AssetItem assetItem = mock( AssetItem.class );
  when( packageItem.containsAsset( "drools" ) ).thenReturn( false );
  when( packageItem.loadAsset( "drools" ) ).thenReturn( assetItem );
  assertEquals( DroolsHeader.getDroolsHeader( packageItem ),
         "" );
  verify( packageItem,
      never() ).loadAsset( "drools" );
  verify( assetItem,
      never() ).getContent();
}

@Test
public void testGetDroolsHeaderAndExists() {
  ModuleItem packageItem = mock( ModuleItem.class );
  AssetItem assetItem = mock( AssetItem.class );
  when( packageItem.containsAsset( "drools" ) ).thenReturn( true );
  when( packageItem.loadAsset( "drools" ) ).thenReturn( assetItem );
  when( assetItem.getContent() ).thenReturn( "content" );
  assertEquals( DroolsHeader.getDroolsHeader( packageItem ),
         "content" );
  verify( packageItem ).loadAsset( "drools" );
  verify( assetItem ).getContent();
}

@Test
public void testUpdateDroolsHeaderAndExists() {
  ModuleItem packageItem = mock( ModuleItem.class );
  AssetItem assetItem = mock( AssetItem.class );
  when( packageItem.containsAsset( "drools" ) ).thenReturn( true );
  when( packageItem.loadAsset( "drools" ) ).thenReturn( assetItem );
  DroolsHeader.updateDroolsHeader( "expected",
                   packageItem );
  verify( assetItem ).updateContent( "expected" );
  verify( assetItem ).checkin( "" );
}

public static String getHeader(ModuleItem pkg) {
  if (pkg.containsAsset("drools")) {
    return pkg.loadAsset("drools").getContent();
  } else {
    return "";
  }
}

/**
 * Load a specific asset by name.
 */
public AssetItem loadAsset(String name, long versionNumber) {
  AssetItem asset = loadAsset(name);
  AssetHistoryIterator it = asset.getHistory();
  while (it.hasNext()) {
    AssetItem historical = it.next();
    long version = historical.getVersionNumber();
    if (version == versionNumber) {
      return historical;
    }
  }
  throw new RulesRepositoryException(
      "Unable to load asset [" + name + "] with version[" + versionNumber + "]");
}

/**
 * Load a specific asset by name.
 */
public AssetItem loadAsset(String name, long versionNumber) {
  AssetItem asset = loadAsset(name);
  AssetHistoryIterator it = asset.getHistory();
  while (it.hasNext()) {
    AssetItem historical = it.next();
    long version = historical.getVersionNumber();
    if (version == versionNumber) {
      return historical;
    }
  }
  throw new RulesRepositoryException(
      "Unable to load asset [" + name + "] with version[" + versionNumber + "]");
}

public static void updateHeader(String h, ModuleItem pkg) {
  pkg.checkout();
  AssetItem as = null;
  if (pkg.containsAsset("drools")) {
    as = pkg.loadAsset("drools");
  } else {
    as = pkg.addAsset("drools", "");
  }
  as.updateContent(h);
  //as.checkin("");
}

@Test
public void testGetDroolsHeaderImports() {
  final String header = "import smurf.Pupa \n"
               + "import smurf.Brains \n"
               + "global Brains b \n"
               + "global Pupa p \n"
               + "//Something else";
  ModuleItem packageItem = mock( ModuleItem.class );
  AssetItem assetItem = mock( AssetItem.class );
  when( packageItem.containsAsset( "drools" ) ).thenReturn( true );
  when( packageItem.loadAsset( "drools" ) ).thenReturn( assetItem );
  when( assetItem.getContent() ).thenReturn( header );
  final String actual = DroolsHeader.getDroolsHeader( packageItem );
  assertEquals( header,
           actual );
  final String imports = DroolsHeader.getPackageHeaderImports( actual );
  assertNotNull( imports );
  assertTrue( imports.indexOf( "import smurf.Pupa" ) != -1 );
  assertTrue( imports.indexOf( "import smurf.Brains" ) != -1 );
  final String globals = DroolsHeader.getPackageHeaderGlobals( actual );
  assertNotNull( globals );
  assertTrue( globals.indexOf( "global Brains b" ) != -1 );
  assertTrue( globals.indexOf( "global Pupa p" ) != -1 );
  final String misc = DroolsHeader.getPackageHeaderMiscellaneous( actual );
  assertNotNull( misc );
  assertTrue( misc.indexOf( "//Something else" ) != -1 );
}

@Test
public void testAddAssetTrailingWhitespace() {
  ModuleItem pkg = getRepo().createModule("testAddAssetTrailingWhitespace","desc");
  pkg.addAsset("wee ", "");
  assertNotNull(pkg.loadAsset("wee"));
}

@Test
public void testLoadArchivedAsset() throws Exception {
  
  RulesRepository repo = RepositorySessionUtil.getRepository();
  
  AssetItem itemAdd = repo.loadDefaultModule().addAsset( "testArchiveBooleanFlag", "yeah" );
  itemAdd.archiveItem( true );
  AssetItem item = repo.loadDefaultModule().loadAsset( "testArchiveBooleanFlag" );
  System.out.println( item );
  assertTrue( item.isArchived() );
}

@Test
public void testUpdateCategories() {
  getRepo().loadCategory( "/" ).addCategory( "testUpdateCategoriesOnAsset", "la" );
  getRepo().loadCategory( "/" ).addCategory( "testUpdateCategoriesOnAsset2", "la" );
  AssetItem item = getRepo().loadDefaultModule().addAsset( "testUpdateCategoriesOnAsset", "huhuhu" );
  String[] cats = new String[] {"testUpdateCategoriesOnAsset", "testUpdateCategoriesOnAsset2"};
  item.updateCategoryList( cats );
  item.checkin( "aaa" );
  item = getRepo().loadDefaultModule().loadAsset( "testUpdateCategoriesOnAsset" );
  assertEquals(2, item.getCategories().size());
  for ( Iterator iter = item.getCategories().iterator(); iter.hasNext(); ) {
    CategoryItem cat = (CategoryItem) iter.next();
    assertTrue(cat.getName().startsWith( "testUpdateCategoriesOnAsset" ));
  }
}

@Test
public void testShareableNodes() throws Exception {
  RulesRepository repo = getRepo();
  AssetItem item = repo.loadDefaultModule().addAsset("testShareableNodeOriginal", "desc");
  item.updateContent("la");
  item.getNode().addMixin("mix:shareable");
  ModuleItem source = repo.createModule("testShareableNodesPackage", "desc");
  repo.save();
  source.checkout();
  Session session = repo.getSession();
  Workspace workspace = session.getWorkspace();
  String path = "/drools:repository/drools:package_area/testShareableNodesPackage/assets/testShareableNodeShared";
  workspace.clone(workspace.getName(), item.getNode().getPath(), path, false);
  repo.save();
  AssetItem originalItem = repo.loadDefaultModule().loadAsset("testShareableNodeOriginal");
  AssetItem sharedItem = repo.loadModule("testShareableNodesPackage").loadAsset("testShareableNodeShared");
  assertTrue( originalItem.getContent().equals("la"));
  assertTrue( sharedItem.getContent().equals("la"));
  originalItem.remove();
}

@Test
public void testUpdateCategoriesForShareableAsset() {
  getRepo().loadCategory("/").addCategory("testUpdateCategoriesForShareableAssetTag1", "la");
  getRepo().loadCategory("/").addCategory("testUpdateCategoriesForShareableAssetTag2", "la");
  AssetItem asset = getRepo().loadGlobalArea().addAsset("testUpdateCategoriesForShareableAsset", "desc");
  AssetItem linkedAsset = getDefaultPackage().addAssetImportedFromGlobalArea(asset.getName());
  String[] cats = new String[] {"testUpdateCategoriesForShareableAssetTag1", "testUpdateCategoriesForShareableAssetTag2"};
  linkedAsset.updateCategoryList(cats);
  linkedAsset.checkin("aaa");
  asset = getRepo().loadGlobalArea().loadAsset("testUpdateCategoriesForShareableAsset");
  assertEquals(2, asset.getCategories().size());
  for (Iterator iter = asset.getCategories().iterator(); iter.hasNext();) {
    CategoryItem cat = (CategoryItem)iter.next();
    assertTrue(cat.getName().startsWith("testUpdateCategoriesForShareableAssetTag"));
  }
}

@Test
public void testRemoveShareableAsset() throws Exception {
  AssetItem asset = loadGlobalArea().addAsset("testRemoveShareableAssetAsset", "desc");
  asset.updateContent("la");
  asset.checkin("initial");
  AssetItem linkedAsset = getDefaultPackage().addAssetImportedFromGlobalArea(asset.getName());
  linkedAsset.updateContent("laa");
  linkedAsset.checkin("second");
  // REVISIT: the shared asset can not be removed unless no asset refers to it.
  // asset.remove();
  linkedAsset.remove();
  try {
    AssetItem linkedAsset1 = getDefaultPackage().loadAsset("testRemoveShareableAssetAsset");
    fail("Did not get expected exception");
  } catch (RulesRepositoryException e) {
  }
  AssetItem asset1 = loadGlobalArea().loadAsset("testRemoveShareableAssetAsset");
  assertTrue(asset.getUUID().equals(asset1.getUUID()));
}

item = loadGlobalArea().loadAsset("testSearchSharedAssetByFormat");
assertEquals("testSearchSharedAssetByFormat", item.getFormat());

@Test
public void testRemoveCategoryUneeded() {
  RulesRepository repo = getRepo();
  repo.loadCategory("/").addCategory("testRemoveCat", "a");
  AssetItem as = repo.loadDefaultModule().addAsset("testRemoveCategory", "a", "testRemoveCat", "drl");
  as.checkin("a");
  as.updateCategoryList(new String[] {});
  as.checkin("a");
  as = repo.loadDefaultModule().loadAsset("testRemoveCategory");
  assertEquals(0, as.getCategories().size());
  repo.loadCategory("testRemoveCat").remove();
  repo.save();
}

@Test
public void testBinaryAsset() throws Exception {
  AssetItem item = getRepo().loadDefaultModule().addAsset( "testBinaryAsset", "yeah" );
  String data = "abc 123";
  ByteArrayInputStream in = new ByteArrayInputStream(data.getBytes());
  item.updateBinaryContentAttachment( in );
  item.updateBinaryContentAttachmentFileName( "x.x" );
  in.close();
  assertEquals(data, item.getContent());
  assertFalse(item.getNode().hasProperty( AssetItem.CONTENT_PROPERTY_NAME ));
  assertTrue(item.getNode().hasProperty( AssetItem.CONTENT_PROPERTY_BINARY_NAME ));
  item.checkin( "lalalala" );
  assertTrue(item.isBinary());
  item = getRepo().loadDefaultModule().loadAsset( "testBinaryAsset" );
  InputStream in2 = item.getBinaryContentAttachment();
  assertNotNull(in2);
  byte[] data2 = item.getBinaryContentAsBytes();
  assertEquals(data, new String(data2));
  assertEquals("x.x", item.getBinaryContentAttachmentFileName());
  assertTrue(item.isBinary());
  item.updateContent("qed");
  item.checkin("");
  item = getRepo().loadAssetByUUID(item.getUUID());
  assertEquals("qed", item.getContent());
}

@Test
public void testGetAssetItemWithSpecifiedVersion() throws Exception {
  AssetItem ruleItem1 = getRepo().loadDefaultModule().addAsset("testGetAssetItemWithSpecifiedVersion", "test description");
  ruleItem1.checkin( "version0" );
  ruleItem1 = getRepo().loadAssetByUUID( ruleItem1.getUUID() );
  ruleItem1.updateContent( "wo" );
  ruleItem1.checkin( "version1" );
  ruleItem1 = getRepo().loadAssetByUUID( ruleItem1.getUUID() );
  ruleItem1.updateContent( "ya" );
  ruleItem1.checkin( "version2" );
  AssetItem assetItemVersion1 = getRepo().loadDefaultModule().loadAsset("testGetAssetItemWithSpecifiedVersion", 1);
  assertEquals("", assetItemVersion1.getContent());
  assertEquals(1, assetItemVersion1.getVersionNumber());
  
  AssetItem assetItemVersion2 = getRepo().loadDefaultModule().loadAsset("testGetAssetItemWithSpecifiedVersion", 2);
  assertEquals("wo", assetItemVersion2.getContent());
  assertEquals(2, assetItemVersion2.getVersionNumber());
  
  AssetItem assetItemVersion3 = getRepo().loadDefaultModule().loadAsset("testGetAssetItemWithSpecifiedVersion", 3);
  assertEquals("ya", assetItemVersion3.getContent());
  assertEquals(3, assetItemVersion3.getVersionNumber());
}

@Test
public void testDublinCorePropertiesForShareableAsset() {
  AssetItem asset = getRepo().loadGlobalArea().addAsset("testDublinCorePropertiesForShareableAsset", "desc");
  asset.checkin("version0");
  AssetItem linkedAsset = getDefaultPackage().addAssetImportedFromGlobalArea(asset.getName());
  linkedAsset.updateCoverage("b");
  assertEquals("b", linkedAsset.getCoverage());
  linkedAsset.checkin("woo");
  linkedAsset = getDefaultPackage().loadAsset("testDublinCorePropertiesForShareableAsset");
  assertEquals("b", linkedAsset.getCoverage());
  assertEquals("", linkedAsset.getExternalRelation());
  assertEquals("", linkedAsset.getExternalSource());
  linkedAsset = getRepo().loadGlobalArea().loadAsset("testDublinCorePropertiesForShareableAsset");
  assertEquals("b", linkedAsset.getCoverage());
  assertEquals("", linkedAsset.getExternalRelation());
  assertEquals("", linkedAsset.getExternalSource());
}

@Test
public void testGetRules() {
  ModuleItem rulePackageItem1 = getRepo().createModule("testGetRules", "desc");
  assertFalse(rulePackageItem1.containsAsset("goober"));
  AssetItem ruleItem1 = rulePackageItem1.addAsset("testGetRules", "desc" );
  ruleItem1.updateContent( "test lhs content" );
  assertTrue(rulePackageItem1.containsAsset( "testGetRules" ));
  assertFalse(rulePackageItem1.containsAsset( "XXXXYYYYZZZZ" ));
  List rules = iteratorToList(rulePackageItem1.getAssets());
  assertNotNull(rules);
  assertEquals(1, rules.size());
  assertEquals("testGetRules", ((AssetItem)rules.get(0)).getName());
  AssetItem ruleItem2 = rulePackageItem1.addAsset("testGetRules2", "desc" );
  ruleItem2.updateContent( "test lhs content" );
  rules = iteratorToList(rulePackageItem1.getAssets());
  assertNotNull(rules);
  assertEquals(2, rules.size());
  //now lets test loading rule
  AssetItem loaded = rulePackageItem1.loadAsset( "testGetRules" );
  assertNotNull(loaded);
  assertEquals("testGetRules", loaded.getName());
  assertEquals("desc", loaded.getDescription());
}