import com.redhat.lightblue.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的package包/类
@Test
public void testTranslate_ObjectType() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{});

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

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

    assertNotNull(document);

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

import com.redhat.lightblue.util.JsonDoc; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_Date() throws JSONException{
    Attribute keyAttribute = new Attribute("key", "20150109201731.570Z");

    //Note in and out data are formatted differently
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            keyAttribute
    });

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

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

    assertNotNull(document);

    String lbDate = Constants.getDateFormat().format(keyAttribute.getValueAsDate());
    JSONAssert.assertEquals(
            "{\"key\":\"" + lbDate + "\",\"dn\":\"uid=john.doe,dc=example,dc=com\"}",
            document.toString(),
            true);
}
 

import com.redhat.lightblue.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_String() throws JSONException{
    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("uid", "john.doe")
    });

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

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

    assertNotNull(document);

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

import com.redhat.lightblue.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_DoubleType() 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", DoubleType.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.util.JsonDoc; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_UIDType() throws JSONException{
    String uuid = UUID.randomUUID().toString();

    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("key", uuid)
    });

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

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

    assertNotNull(document);

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

import com.redhat.lightblue.util.JsonDoc; //导入依赖的package包/类
@Test
public void testTranslate_SimpleField_BinaryType() throws Exception{
    byte[] bite = new byte[]{1, 2, 3, 'a', 'b', 'c'};

    SearchResultEntry result = new SearchResultEntry(-1, "uid=john.doe,dc=example,dc=com", new Attribute[]{
            new Attribute("key", bite)
    });

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

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

    JsonNode keyNode = jsonDocument.get(new Path("key"));
    assertEquals(bite, keyNode.binaryValue());

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

import com.redhat.lightblue.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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.util.JsonDoc; //导入依赖的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");
}