import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_BigDecimalType() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("key", String.valueOf(Double.MAX_VALUE))
    });

    EntityMetadata md = fakeEntityMetadata("fakeMetadata",
            new SimpleField("key", BigDecimalType.TYPE)
            );

    JsonDoc document = new ResultTranslatorToJson(factory, md, new TrivialLdapFieldNameTranslator()).translate(result);

    assertNotNull(document);

    JSONAssert.assertEquals(
            "{\"key\":" + String.valueOf(Double.MAX_VALUE) + ",\"dn\":\"uid=john.doe,dc=example,dc=com\"}",
            document.toString(),
            true);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
/**
 * Both the array itself and a count field should be returned even though the count was not asked for.
 * @see #testTranslate_SimpleArrayElement_CountAskedFor()
 */
@Test
public void testTranslate_SimpleArrayElement_CountNotAskedFor() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("objectClass", Arrays.asList("top", "person", "organizationalPerson", "inetOrgPerson"))
    });

    EntityMetadata md = fakeEntityMetadata("fakeMetadata",
            new ArrayField("objectClass", new SimpleArrayElement(StringType.TYPE))
            );

    JsonDoc document = new ResultTranslatorToJson(factory, md, new TrivialLdapFieldNameTranslator()).translate(result);

    assertNotNull(document);

    JSONAssert.assertEquals(
            "{\"objectClass\":[\"top\",\"person\",\"organizationalPerson\",\"inetOrgPerson\"],\"objectClass#\":4,\"dn\":\"uid=john.doe,dc=example,dc=com\"}",
            document.toString(),
            true);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_Boolean() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("key", "true")
    });

    EntityMetadata md = fakeEntityMetadata("fakeMetadata",
            new SimpleField("key", BooleanType.TYPE)
            );

    JsonDoc document = new ResultTranslatorToJson(factory, md, new TrivialLdapFieldNameTranslator()).translate(result);

    assertNotNull(document);

    JSONAssert.assertEquals(
            "{\"key\":true,\"dn\":\"uid=john.doe,dc=example,dc=com\"}",
            document.toString(),
            true);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void testTranslate_AttributeDoesNotExist() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{});

    EntityMetadata md = fakeEntityMetadata("fakeMetadata",
            new SimpleField("absentAttribute", StringType.TYPE)
            );

    JsonDoc document = new ResultTranslatorToJson(factory, md, new TrivialLdapFieldNameTranslator()).translate(result);

    assertNotNull(document);

    JSONAssert.assertEquals(
            "{\"absentAttribute\":null,\"dn\":\"uid=john.doe,dc=example,dc=com\"}",
            document.toString(),
            true);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
/**
 * Essentially the same, but the count is specifically asked for. The only real different is that the count field
 * should be skipped over during processing.
 * @see #testTranslate_SimpleArrayElement_CountNotAskedFor()
 */
@Test
public void testTranslate_SimpleArrayElement_CountAskedFor() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("objectClass", Arrays.asList("top", "person", "organizationalPerson", "inetOrgPerson"))
    });

    EntityMetadata md = fakeEntityMetadata("fakeMetadata",
            new ArrayField("objectClass", new SimpleArrayElement(StringType.TYPE)),
            new SimpleField("objectClass#", IntegerType.TYPE)
            );

    JsonDoc document = new ResultTranslatorToJson(factory, md, new TrivialLdapFieldNameTranslator()).translate(result);

    assertNotNull(document);

    JSONAssert.assertEquals(
            "{\"objectClass\":[\"top\",\"person\",\"organizationalPerson\",\"inetOrgPerson\"],\"objectClass#\":4,\"dn\":\"uid=john.doe,dc=example,dc=com\"}",
            document.toString(),
            true);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_BigIntegerType() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("key", BigInteger.ZERO.toString())
    });

    EntityMetadata md = fakeEntityMetadata("fakeMetadata",
            new SimpleField("key", BigIntegerType.TYPE)
            );

    JsonDoc document = new ResultTranslatorToJson(factory, md, new TrivialLdapFieldNameTranslator()).translate(result);

    assertNotNull(document);

    JSONAssert.assertEquals(
            "{\"key\":" + BigInteger.ZERO + ",\"dn\":\"uid=john.doe,dc=example,dc=com\"}",
            document.toString(),
            true);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
private Projection addArrayIdentities(Projection p,EntityMetadata md) {
    // If an array is included in the projection, make sure its identity is also included
    Map<Path,List<Path>> arrayIdentities=md.getEntitySchema().getArrayIdentities();
    List<Projection> addFields=new ArrayList<>();
    for(Map.Entry<Path,List<Path>> entry:arrayIdentities.entrySet()) {
        Path array=entry.getKey();
        List<Path> identities=new ArrayList<>();
        for(Path x:entry.getValue())
            identities.add(new Path(array,new Path(Path.ANYPATH,x)));
        
        if(isProjected(array,p)) {
            for(Path id:identities) {
                if(!isProjected(id,p)) {
                    addFields.add(new FieldProjection(id,true,true));
                }
            }
        }
    }
    if(!addFields.isEmpty()) {
        LOGGER.debug("Excluded array identities are added to projection:{}",addFields);
        // Need to first add the original projection, then the included fields.
        // This is order sensitive
        return Projection.add(p,new ProjectionList(addFields));
    } else
        return p;
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
/**
 * Compares the pre- and post- documents after they are passed
 * through the watchProjector, and returns the delta
 */
private DocComparator.Difference<JsonNode> compareDocs(EntityMetadata metadata,
                                                       JsonDoc preDoc,
                                                       JsonDoc postDoc,
                                                       Projector watchProjector)
    throws Exception {
    JsonDoc watchedPostDoc = watchProjector.project(postDoc, jsonNodeFactory);
    JsonDoc watchedPreDoc = preDoc == null
        ? new JsonDoc(jsonNodeFactory.objectNode())
        : watchProjector.project(preDoc, jsonNodeFactory);
    
    // Compute diff
    JsonCompare cmp=metadata.getDocComparator();
    LOGGER.debug("Array identities:{}",cmp.getArrayIdentities());
    LOGGER.debug("Pre:{}, Post:{}",watchedPreDoc.getRoot(),watchedPostDoc.getRoot());
    DocComparator.Difference<JsonNode> diff=cmp.
        compareNodes(watchedPreDoc.getRoot(),watchedPostDoc.getRoot());
    LOGGER.debug("Diff: {}",diff);
    return diff;
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldNotCreateNotificationForFindOperations() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode post = loadJsonNode("userdata.json");

    HookConfiguration cfg = NotificationHookConfiguration.watchingEverythingAndIncludingNothing();

    List<HookDoc> docs = new ArrayList<>();
    // Pre doc is null in find ops: see com.redhat.lightblue.hooks.HookManager:73
    HookDoc doc = new HookDoc(md,null,new JsonDoc(post),CRUDOperation.FIND,"me");
    docs.add(doc);

    hook.processHook(md, cfg, docs);

    Assert.assertNull(insertCapturingMediator.capturedInsert);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldNotCreateNotificationIfNothingChangesInWatchedFields() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode pre = loadJsonNode("userdata.json");
    JsonNode post = loadJsonNode("userdata.json");

    HookConfiguration cfg = NotificationHookConfiguration.watchingEverythingAndIncludingNothing();

    List<HookDoc> docs = new ArrayList<>();
    HookDoc doc = new HookDoc(md,new JsonDoc(pre),new JsonDoc(post),CRUDOperation.UPDATE,"me");
    docs.add(doc);

    hook.processHook(md, cfg, docs);

    Assert.assertNull(insertCapturingMediator.capturedInsert);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldNotCreateNotificationsIfSomethingNotWatchedChanged() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode pre = loadJsonNode("userdata.json");

    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'personalInfo','recursive':1}"),
            null,
            false);

    JsonNode post = loadJsonNode("userdata.json");
    JsonDoc.modify(post, new Path("login"), JsonNodeFactory.instance.textNode("blah"), true);

    List<HookDoc> docs= new ArrayList<>();
    HookDoc doc = new HookDoc(md, new JsonDoc(pre), new JsonDoc(post), CRUDOperation.UPDATE, "me");
    docs.add(doc);

    hook.processHook(md,cfg,docs);

    Assert.assertNull(insertCapturingMediator.capturedInsert);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldNotCreateNotificationForInsertWhichDoesNotIncludeAnyWatchedFields() throws Exception {
    EntityMetadata md = getMd("usermd.json");

    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'contactPermissions','recursive':1}"),
            null,
            false);

    JsonNode post = loadJsonNode("userdataWithoutContactPermissions.json");

    List<HookDoc> docs= new ArrayList<>();
    HookDoc doc = new HookDoc(md, null, new JsonDoc(post), CRUDOperation.INSERT, "me");
    docs.add(doc);

    hook.processHook(md,cfg,docs);

    Assert.assertNull(insertCapturingMediator.capturedInsert);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldCaptureWatchedNonContainerNodeChangesInEntityData() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode pre = loadJsonNode("userdata.json");
    JsonNode post = loadJsonNode("userdata.json");
    JsonDoc.modify(post, new Path("sites.0.streetAddress.city"), JsonNodeFactory.instance.textNode("blah"), true);

    List<HookDoc> docs= new ArrayList<>();
    HookDoc doc = new HookDoc(md, new JsonDoc(pre), new JsonDoc(post), CRUDOperation.UPDATE, "me");
    docs.add(doc);
    
    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'sites','recursive':1}"),
            projection("{'field':'sites','recursive':1}"),
            false);

    hook.processHook(md, cfg, docs);
    Assert.assertNotNull(insertCapturingMediator.capturedInsert);
    JsonNode data=insertCapturingMediator.capturedInsert.getEntityData();
    Assert.assertEquals("sites.0.streetAddress.city",data.get("updatedPaths").get(0).asText());
    Assert.assertEquals(1,data.get("updatedPaths").size());
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldOnlyIncludeWhatChangedOfArrayElementIfElementIdentityNotWatched()
        throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode pre = loadJsonNode("userdata.json");
    JsonNode post = loadJsonNode("userdata.json");
    JsonDoc.modify(post, new Path("sites.0.streetAddress.city"), JsonNodeFactory.instance.textNode("blah"), true);

    List<HookDoc> docs= new ArrayList<>();
    HookDoc doc = new HookDoc(md, new JsonDoc(pre), new JsonDoc(post), CRUDOperation.UPDATE, "me");
    docs.add(doc);

    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'sites.*.streetAddress.city','recursive':1}"),
            null,
            false);

    hook.processHook(md, cfg, docs);
    Assert.assertNotNull(insertCapturingMediator.capturedInsert);
    JsonNode data=insertCapturingMediator.capturedInsert.getEntityData();

    Truth.assertThat(
            Iterables.transform(data.get("updatedPaths"), toTextValue()))
            .containsExactly("sites.0.streetAddress.city");
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldCaptureWatchedArrayElementRemovalInRemovedEntityDataAndRemovedElements() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode pre = loadJsonNode("userdata.json");
    JsonNode post = loadJsonNode("userdata.json");
    JsonDoc.modify(post,new Path("sites.1"),null,true);

    List<HookDoc> docs= new ArrayList<>();
    HookDoc doc = new HookDoc(md, new JsonDoc(pre), new JsonDoc(post), CRUDOperation.UPDATE, "me");
    docs.add(doc);
    
    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'sites','recursive':1}"),
            projection("{'field':'sites','recursive':1}"),
            false);

    hook.processHook(md, cfg, docs);        
    JsonNode data=insertCapturingMediator.capturedInsert.getEntityData();
    Assert.assertEquals(1,data.get("removedPaths").size());
    Assert.assertEquals("sites.1",data.get("removedPaths").get(0).asText());

    // Check we also have sites.1 contents
    assertEntityDataValueEquals( (ArrayNode)data.get("removedEntityData"),"sites.1.siteId","2");
    assertEntityDataValueEquals( (ArrayNode)data.get("removedEntityData"),"sites.1.siteType","billing");
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldSetPrivilegedClientIdOnRequest() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode data = loadJsonNode("userdata.json");

    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'*','recursive':1}"), null, false);

    List<HookDoc> docs = new ArrayList<>();
    HookDoc doc = new HookDoc(md,null,new JsonDoc(data),CRUDOperation.INSERT,"me");
    docs.add(doc);

    hook.processHook(md, cfg, docs);

    ClientIdentification clientId = insertCapturingMediator.capturedInsert.getClientId();

    Assert.assertNotNull(clientId);
    Assert.assertTrue(clientId.isUserInRole("some-role-for-notification"));
    Assert.assertTrue(clientId.isUserInRole("lb-notification-insert"));
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldIncludeRemovedEntityDataForModifications() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode pre = loadJsonNode("userdata.json");
    JsonNode post = loadJsonNode("userdata.json");
    JsonDoc.modify(post, new Path("sites.0.streetAddress.city"),
            JsonNodeFactory.instance.textNode("new city"), true);

    List<HookDoc> docs= new ArrayList<>();
    HookDoc doc = new HookDoc(md, new JsonDoc(pre), new JsonDoc(post), CRUDOperation.UPDATE, "me");
    docs.add(doc);

    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'sites','recursive':1}"),
            projection("{'field':'sites','recursive':1}"),
            false);

    hook.processHook(md, cfg, docs);
    JsonNode data=insertCapturingMediator.capturedInsert.getEntityData();
    Assert.assertEquals(0,data.get("removedPaths").size());

    // Check we also have sites.1 contents
    assertEntityDataValueEquals((ArrayNode) data.get("removedEntityData"),
            "sites.0.streetAddress.city", "Denver");
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void shouldCaptureNullsAsNull() throws Exception {
    EntityMetadata md = getMd("usermd.json");
    JsonNode post = loadJsonNode("userdata.json");
    JsonDoc.modify(post, new Path("personalInfo.company"),
            JsonNodeFactory.instance.nullNode(), true);

    List<HookDoc> docs= new ArrayList<>();
    HookDoc doc = new HookDoc(md, null, new JsonDoc(post), CRUDOperation.INSERT, "me");
    docs.add(doc);

    HookConfiguration cfg = new NotificationHookConfiguration(
            projection("{'field':'personalInfo','recursive':1}"),
            projection("{'field':'personalInfo','recursive':1}"),
            false);

    hook.processHook(md, cfg, docs);
    JsonNode data=insertCapturingMediator.capturedInsert.getEntityData();

    // Check we also have sites.1 contents
    assertEntityDataValueEquals((ArrayNode) data.get("entityData"), "personalInfo.company", null);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
private static EntityMetadata generateMetadata(Class classForName, Path metadataJsonPath) {
  if (Files.exists(metadataJsonPath)) {
    println(metadataJsonPath + " already exists, updating...");

    final EntityMetadata existing;

    try {
      JsonNode existingJsonNode = mapper.readTree(Files.readAllBytes(metadataJsonPath));
      existing = parser.parseEntityMetadata(existingJsonNode);
    } catch (Exception e) {
      e.printStackTrace();

      println("Failed to parse existing metadata.");
      println("Generating new metadata instead of updating.");

      return generator.generateMetadata(classForName);
    }

    return generator.updateMetadata(existing, classForName);
  }

  return generator.generateMetadata(classForName);
}
 

import com.redhat.lightblue.metadata.EntityMetadata; //导入依赖的package包/类
@Test
public void updateStatusTest() throws Exception {
    EntityMetadata e2 = new EntityMetadata("testEntity");
    e2.setVersion(new Version("1.1.0", null, "some text blah blah"));
    e2.setStatus(MetadataStatus.ACTIVE);
    e2.setDataStore(new MongoDataStore(null, null, "testCollection"));
    e2.getFields().put(new SimpleField("field1", StringType.TYPE));
    md.createNewMetadata(e2);
    EntityMetadata g = md.getEntityMetadata("testEntity", "1.1.0");
    Assert.assertEquals(MetadataStatus.ACTIVE, g.getStatus());

    md.setMetadataStatus("testEntity", "1.1.0", MetadataStatus.DEPRECATED, "disable testEntity");
    EntityMetadata g1 = md.getEntityMetadata("testEntity", "1.1.0");
    Assert.assertEquals(e2.getVersion().getValue(), g1.getVersion().getValue());
    Assert.assertEquals(MetadataStatus.DEPRECATED, g1.getStatus());
}