Added tests for new MonitorData class

Jean-Noël Rouvignac

10.21.2016 f7a98b019d743f118b93112235d1b8916c854343

Added tests for new MonitorData class

 opendj-server-legacy/src/main/java/org/opends/server/api/MonitorData.java

@@ -33,6 +33,7 @@
import org.forgerock.opendj.ldap.schema.CoreSchema;
import org.forgerock.opendj.ldap.schema.Syntax;
import org.opends.server.types.Attribute;
import org.opends.server.types.Attribute.RemoveOnceSwitchingAttributes;
import org.opends.server.types.AttributeBuilder;
import org.opends.server.types.Attributes;
import org.opends.server.types.PublicAPI;
@@ -159,6 +160,8 @@
   * @param attrValues
   *          the attribute values
   */
  @RemoveOnceSwitchingAttributes(comment = "once using the non immutable SDK's Attribute class, "
      + "we can incrementally build an attribute by using the add(String attrName, Object attrValue) method")
  public void add(String attrName, Collection<?> attrValues)
  {
    AttributeBuilder builder = new AttributeBuilder(attrName);

 opendj-server-legacy/src/main/java/org/opends/server/types/Attribute.java

@@ -45,6 +45,13 @@
    mayInvoke = true)
public interface Attribute extends Iterable<ByteString>
{
  /** Marks code that can be removed once we are switching from server's to SDK's {@code Attribute}. */
  public @interface RemoveOnceSwitchingAttributes
  {
    /** Free-form comment. */
    String comment() default "";
  }

  /**
   * Indicates whether this attribute has any value(s) that are
   * approximately equal to the provided value.

 opendj-server-legacy/src/main/java/org/opends/server/types/AttributeBuilder.java

@@ -40,6 +40,7 @@
import org.forgerock.util.Reject;
import org.forgerock.util.Utils;
import org.opends.server.core.DirectoryServer;
import org.opends.server.types.Attribute.RemoveOnceSwitchingAttributes;
import org.opends.server.util.CollectionUtils;

/**
@@ -97,6 +98,7 @@
    mayInstantiate = true,
    mayExtend = false,
    mayInvoke = true)
@RemoveOnceSwitchingAttributes
public final class AttributeBuilder implements Iterable<ByteString>
{


 opendj-server-legacy/src/main/java/org/opends/server/types/Attributes.java

@@ -26,6 +26,7 @@

import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.schema.AttributeType;
import org.opends.server.types.Attribute.RemoveOnceSwitchingAttributes;

/**
 * This class contains various methods for manipulating
@@ -49,6 +50,7 @@
 * {@link AttributeBuilder} should be used in order to incrementally
 * construct multi-valued attributes.
 */
@RemoveOnceSwitchingAttributes
public final class Attributes
{


 opendj-server-legacy/src/test/java/org/opends/server/api/MonitorDataTestCase.java

New file
@@ -0,0 +1,199 @@
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2016 ForgeRock AS.
 */
package org.opends.server.api;

import static org.opends.server.schema.SchemaConstants.*;
import static org.testng.Assert.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.assertj.core.api.Assertions;
import org.forgerock.i18n.LocalizableMessageBuilder;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.DN;
import org.forgerock.opendj.ldap.schema.AttributeType;
import org.forgerock.opendj.ldap.schema.Syntax;
import org.opends.server.TestCaseUtils;
import org.opends.server.types.Attribute;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

/** Tests for {@link MonitorData} class. */
@SuppressWarnings("javadoc")
public class MonitorDataTestCase extends APITestCase
{
  @BeforeClass
  public void setUp() throws Exception
  {
    TestCaseUtils.startFakeServer();
  }

  @AfterClass
  public void tearDown()
  {
    TestCaseUtils.shutdownFakeServer();
  }

  @Test
  public void verifyInferredAttributeSyntaxes() throws Exception
  {
    final MonitorData attrs = new MonitorData();
    attrs.add("string", "this is a string");
    attrs.add("bytestring", ByteString.valueOfUtf8("this is a string"));
    attrs.add("int", 1);
    attrs.add("long", 1L);
    attrs.add("float", 1f);
    attrs.add("double", 1d);
    attrs.add("boolean", true);
    attrs.add("dn", DN.valueOf("cn=test"));
    attrs.add("uuid", DN.valueOf("cn=test").toUUID());
    attrs.add("date", new Date());
    attrs.add("calender", Calendar.getInstance());
    attrs.add("other", 'a');

    assertSyntaxes(attrs);
    assertEquals(attrs.size(), 12);
  }

  private void assertSyntaxes(final MonitorData attrs)
  {
    for (Attribute attr : attrs)
    {
      final AttributeType attrType = attr.getAttributeDescription().getAttributeType();
      final Syntax syntax = attrType.getSyntax();

      switch (attrType.getNameOrOID())
      {
      case "int":
      case "long":
        assertSyntax(attr, syntax, SYNTAX_INTEGER_OID);
        continue;

      case "string":
      case "bytestring":
      case "float":
      case "double":
      case "other":
        assertSyntax(attr, syntax, SYNTAX_DIRECTORY_STRING_OID);
        continue;

      case "boolean":
        assertSyntax(attr, syntax, SYNTAX_BOOLEAN_OID);
        continue;

      case "dn":
        assertSyntax(attr, syntax, SYNTAX_DN_OID);
        continue;

      case "date":
      case "calender":
        assertSyntax(attr, syntax, SYNTAX_GENERALIZED_TIME_OID);
        continue;

      case "uuid":
        assertSyntax(attr, syntax, SYNTAX_UUID_OID);
        continue;

      default:
        fail("Untested type: \"" + attrType.getNameOrOID() + "\"");
      }
    }
  }

  private void assertSyntax(Attribute attr, final Syntax syntax, String syntaxOid)
  {
    assertEquals(syntax.getOID(), syntaxOid, "For attribute: " + attr);

    final LocalizableMessageBuilder invalidReason = new LocalizableMessageBuilder();
    final ByteString firstAttrValue = attr.iterator().next();
    final boolean result = syntax.valueIsAcceptable(firstAttrValue, invalidReason);
    assertTrue(result, "For attribute: " + attr + " expected value to be acceptable, but got:" + invalidReason);
  }

  @Test
  public void addBean() throws Exception
  {
    class MyBean
    {
      // converted to attributes
      public int getint() { return 1; }
      public long getlong() { return 1; }
      public String getstring() { return "this is a test"; }
      public boolean isboolean() { return true; }

      // not converted to attributes
      public DN getAnother() { return DN.valueOf("cn=test"); }
      public DN isAnother() { return getAnother(); }
    }

    final MonitorData attrs = new MonitorData();
    attrs.addBean(new MyBean(), "");
    assertSyntaxes(attrs);

    List<String> names = new ArrayList<>();
    for (Attribute attr : attrs)
    {
      names.add(attr.getAttributeDescription().getAttributeType().getNameOrOID());
    }
    Assertions.assertThat(names).containsOnly("int", "long", "string", "boolean");
    assertEquals(attrs.size(), names.size());
  }

  @Test
  public void addCollectionOfValues() throws Exception
  {
    final MonitorData attrs = new MonitorData();
    attrs.add("string", Arrays.asList("this", "is", "a", "test"));

    final Iterator<Attribute> it = attrs.iterator();
    assertTrue(it.hasNext());
    final Attribute attr = it.next();
    assertEquals(attr.getAttributeDescription().getAttributeType().getNameOrOID(), "string");
    Assertions.assertThat(attr).containsExactly(bs("this"), bs("is"), bs("a"), bs("test"));
    assertFalse(it.hasNext());
  }

  private ByteString bs(String s)
  {
    return ByteString.valueOfUtf8(s);
  }

  @Test
  public void addIfNotNull() throws Exception
  {
    final MonitorData attrs = new MonitorData();

    attrs.addIfNotNull("string", null);
    assertEquals(attrs.size(), 0);
    final Iterator<Attribute> it1 = attrs.iterator();
    assertFalse(it1.hasNext());

    attrs.addIfNotNull("string", "this is a test");
    assertEquals(attrs.size(), 1);
    final Iterator<Attribute> it2 = attrs.iterator();
    assertTrue(it2.hasNext());
    final Attribute attr = it2.next();
    assertEquals(attr.getAttributeDescription().getAttributeType().getNameOrOID(), "string");
    Assertions.assertThat(attr).containsExactly(bs("this is a test"));
    assertFalse(it2.hasNext());
  }
}