How to use

containsAsset

method

in

org.drools.repository.ModuleItem

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

private void migratePackage(ModuleItem pkg) {
  if (!pkg.containsAsset("drools")) {
    AssetItem asset = pkg.addAsset("drools", "");
    asset.updateFormat("package");
    asset.updateContent(pkg.getStringProperty(ModuleItem.HEADER_PROPERTY_NAME));
    asset.checkin("");
  }
}

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

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

private void migratePackage(ModuleItem pkg) {
  if (!pkg.containsAsset("drools")) {
    AssetItem asset = pkg.addAsset("drools", "");
    asset.updateFormat("package");
    asset.updateContent(pkg.getStringProperty(ModuleItem.HEADER_PROPERTY_NAME));
    asset.checkin("");
  }
}

@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 testUpdateDroolsHeaderAndDoesNotExist() {
  ModuleItem packageItem = mock( ModuleItem.class );
  AssetItem assetItem = mock( AssetItem.class );
  when( packageItem.containsAsset( "drools" ) ).thenReturn( false );
  when( packageItem.addAsset( "drools",
                "" ) ).thenReturn( assetItem );
  DroolsHeader.updateDroolsHeader( "expected",
                   packageItem );
  verify( packageItem ).addAsset( "drools",
                  "" );
  verify( assetItem ).updateFormat( "package" );
  verify( assetItem ).updateContent( "expected" );
  verify( assetItem ).checkin( "" );
}

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

@Test
public void testImportExportWithShareableNodes() throws Exception {
  RulesRepository repo = getRepo();
  AssetItem item = repo.loadDefaultModule().addAsset("testImportExportShareableNodeOriginal", "desc");
  item.updateContent("la");
  ModuleItem.ensureMixinType(item, "mix:shareable");
  ModuleItem source = repo.createModule("testImportExportShareableNodesPackage", "desc");
  repo.save();
  source.checkout();
  Session session = item.getNode().getSession();
  Workspace workspace = session.getWorkspace();
  String path = "/drools:repository/drools:package_area/testImportExportShareableNodesPackage/assets/testImportExportShareableNodeShared";
  workspace.clone(workspace.getName(), item.getNode().getPath(), path, false);
  repo.save();
  byte[] repository_backup;
  ByteArrayOutputStream bout = new ByteArrayOutputStream();
  repo.exportRepositoryToStream(bout);
  repository_backup = bout.toByteArray();
  assertNotNull(repository_backup);
  repo.importRulesRepositoryFromStream(new ByteArrayInputStream(
      repository_backup));
  assertTrue(repo.containsModule("testImportExportShareableNodesPackage"));
  assertTrue(repo.loadModule("testImportExportShareableNodesPackage").containsAsset("testImportExportShareableNodeOriginal"));
}

@Test
public void testMigrate() throws Exception {
  RulesRepository repo = getRepo();
  Session sess = repo.getSession();
  sess.getRootNode().getNode(RulesRepository.RULES_REPOSITORY_NAME).getNode("drools.package.migrated").remove();
  sess.save();
  MigrateDroolsPackage mig = new MigrateDroolsPackage();
  ModuleItem pkg = repo.createModule("testMigratePackage", "");
  pkg.updateStringProperty("some header", ModuleItem.HEADER_PROPERTY_NAME);
  sess.save();
  repo.createModuleSnapshot("testMigratePackage", "SNAP1");
  repo.createModuleSnapshot("testMigratePackage", "SNAP2");
  assertTrue(mig.needsMigration(repo));
  mig.migrate(repo);
  assertFalse(repo.getSession().hasPendingChanges());
  assertFalse(mig.needsMigration(repo));
  pkg = repo.loadModule("testMigratePackage");
  assertTrue(pkg.containsAsset("drools"));
  AssetItem as = pkg.loadAsset("drools");
  assertEquals("some header", as.getContent());
  pkg = repo.loadModuleSnapshot("testMigratePackage", "SNAP1");
  assertTrue(pkg.containsAsset("drools"));
  as = pkg.loadAsset("drools");
  assertEquals("some header", as.getContent());
  pkg = repo.loadModuleSnapshot("testMigratePackage", "SNAP2");
  assertTrue(pkg.containsAsset("drools"));
  as = pkg.loadAsset("drools");
  assertEquals("some header", as.getContent());
}