/** Tests the maximum persistent search limit imposed by the server. */ @Test public void testMaxPSearch() throws Exception { TestCaseUtils.initializeTestBackend(true); // Modify the configuration to allow only 1 concurrent persistent search. InternalClientConnection conn = getRootConnection(); LDAPAttribute attr = new LDAPAttribute("ds-cfg-max-psearches", "1"); ArrayList<RawModification> mods = new ArrayList<>(); mods.add(new LDAPModification(ModificationType.REPLACE, attr)); ModifyOperation modifyOperation = conn.processModify(ByteString.valueOf("cn=config"), mods); assertEquals(modifyOperation.getResultCode(), ResultCode.SUCCESS); // Create a persistent search request. Set<PersistentSearchChangeType> changeTypes = EnumSet.of(ADD, DELETE, MODIFY, MODIFY_DN); SearchRequest request = newSearchRequest(DN.valueOf("o=test"), SearchScope.BASE_OBJECT) .setTypesOnly(true) .addAttribute("cn") .addControl(new PersistentSearchControl(changeTypes, true, true)); final InternalSearchOperation search = conn.processSearch(request); Thread t = new Thread( new Runnable() { @Override public void run() { try { search.run(); } catch (Exception ex) { } } }, "Persistent Search Test"); t.start(); t.join(2000); // Create a persistent search request. final String[] args = { "-D", "cn=Directory Manager", "-w", "password", "-h", "127.0.0.1", "-p", String.valueOf(TestCaseUtils.getServerLdapPort()), "-b", "o=test", "-s", "sub", "-C", "ps:add:true:true", "--noPropertiesFile", "(objectClass=*)" }; assertEquals(LDAPSearch.mainSearch(args, false, true, null, System.err), 11); // cancel the persisting persistent search. search.cancel(new CancelRequest(true, LocalizableMessage.EMPTY)); }
/** * Tests DataType class to ensure data sent in is the same as data received All tests are executed * via a Simple Statements Counters are the only datatype not tested within the entirety of the * suite. There is, however, an isolated test case that needs to be implemented. All statements and * sample data is easily exportable via the print_*() methods. */ public class DataTypeTest extends CCMBridge.PerClassSingleNodeCluster { private static final Set<DataType> DATA_TYPE_PRIMITIVES = DataType.allPrimitiveTypes(); private static final Set<DataType.Name> DATA_TYPE_NON_PRIMITIVE_NAMES = EnumSet.of(DataType.Name.MAP, DataType.Name.SET, DataType.Name.LIST); private static final String PRIMITIVE_INSERT_FORMAT = "INSERT INTO %1$s (k, v) VALUES (%2$s, %2$s);"; private static final String BASIC_SELECT_FORMAT = "SELECT k, v FROM %1$s;"; private static final String COLLECTION_INSERT_FORMAT = "INSERT INTO %1$s (k, v) VALUES (%2$s, %3$s);"; private static final String MAP_INSERT_FORMAT = "INSERT INTO %1$s (k, v) VALUES (%3$s, {%2$s: %3$s});"; private static final HashMap<DataType, Object> SAMPLE_DATA = getSampleData(); private static final HashMap<DataType, Object> SAMPLE_COLLECTIONS = getSampleCollections(); private static final Collection<String> PRIMITIVE_INSERT_STATEMENTS = getPrimitiveInsertStatements(); private static final HashMap<DataType, String> PRIMITIVE_SELECT_STATEMENTS = getPrimitiveSelectStatements(); private static final Collection<String> COLLECTION_INSERT_STATEMENTS = getCollectionInsertStatements(); private static final HashMap<DataType, String> COLLECTION_SELECT_STATEMENTS = getCollectionSelectStatements(); private static boolean exclude(DataType t) { return t.getName() == DataType.Name.COUNTER; } /** Generates the table definitions that will be used in testing */ @Override protected Collection<String> getTableDefinitions() { ArrayList<String> tableDefinitions = new ArrayList<String>(); // Create primitive data type definitions for (DataType dataType : DATA_TYPE_PRIMITIVES) { if (exclude(dataType)) continue; tableDefinitions.add( String.format("CREATE TABLE %1$s (k %2$s PRIMARY KEY, v %1$s)", dataType, dataType)); } // Create collection data type definitions for (DataType.Name dataTypeName : DATA_TYPE_NON_PRIMITIVE_NAMES) { // Create MAP data type definitions if (dataTypeName == DataType.Name.MAP) { for (DataType typeArgument1 : DATA_TYPE_PRIMITIVES) { if (exclude(typeArgument1)) continue; for (DataType typeArgument2 : DATA_TYPE_PRIMITIVES) { if (exclude(typeArgument2)) continue; tableDefinitions.add( String.format( "CREATE TABLE %1$s_%2$s_%3$s (k %3$s PRIMARY KEY, v %1$s<%2$s, %3$s>)", dataTypeName, typeArgument1, typeArgument2)); } } // Create SET and LIST data type definitions } else { for (DataType typeArgument : DATA_TYPE_PRIMITIVES) { if (exclude(typeArgument)) continue; tableDefinitions.add( String.format( "CREATE TABLE %1$s_%2$s (k %2$s PRIMARY KEY, v %1$s<%2$s>)", dataTypeName, typeArgument)); } } } return tableDefinitions; } /** Generates the sample data that will be used in testing */ private static HashMap<DataType, Object> getSampleData() { HashMap<DataType, Object> sampleData = new HashMap<DataType, Object>(); for (DataType dataType : DATA_TYPE_PRIMITIVES) { switch (dataType.getName()) { case ASCII: sampleData.put(dataType, new String("ascii")); break; case BIGINT: sampleData.put(dataType, Long.MAX_VALUE); break; case BLOB: ByteBuffer bb = ByteBuffer.allocate(58); bb.putShort((short) 0xCAFE); bb.flip(); sampleData.put(dataType, bb); break; case BOOLEAN: sampleData.put(dataType, Boolean.TRUE); break; case COUNTER: // Not supported in an insert statement break; case DECIMAL: sampleData.put(dataType, new BigDecimal("12.3E+7")); break; case DOUBLE: sampleData.put(dataType, Double.MAX_VALUE); break; case FLOAT: sampleData.put(dataType, Float.MAX_VALUE); break; case INET: try { sampleData.put(dataType, InetAddress.getByName("123.123.123.123")); } catch (java.net.UnknownHostException e) { } break; case INT: sampleData.put(dataType, Integer.MAX_VALUE); break; case TEXT: sampleData.put(dataType, new String("text")); break; case TIMESTAMP: sampleData.put(dataType, new Date(872835240000L)); break; case TIMEUUID: sampleData.put(dataType, UUID.fromString("FE2B4360-28C6-11E2-81C1-0800200C9A66")); break; case UUID: sampleData.put(dataType, UUID.fromString("067e6162-3b6f-4ae2-a171-2470b63dff00")); break; case VARCHAR: sampleData.put(dataType, new String("varchar")); break; case VARINT: sampleData.put(dataType, new BigInteger(Integer.toString(Integer.MAX_VALUE) + "000")); break; default: throw new RuntimeException("Missing handling of " + dataType); } } return sampleData; } /** Generates the sample collections that will be used in testing */ private static HashMap<DataType, Object> getSampleCollections() { HashMap<DataType, Object> sampleCollections = new HashMap<DataType, Object>(); HashMap<DataType, Object> setAndListCollection; HashMap<DataType, HashMap<DataType, Object>> mapCollection; for (DataType.Name dataTypeName : DATA_TYPE_NON_PRIMITIVE_NAMES) { switch (dataTypeName) { case LIST: for (DataType typeArgument : DATA_TYPE_PRIMITIVES) { if (exclude(typeArgument)) continue; List<Object> list = new ArrayList<Object>(); for (int i = 0; i < 5; i++) { list.add(SAMPLE_DATA.get(typeArgument)); } setAndListCollection = new HashMap<DataType, Object>(); setAndListCollection.put(typeArgument, list); sampleCollections.put(DataType.list(typeArgument), setAndListCollection); } break; case SET: for (DataType typeArgument : DATA_TYPE_PRIMITIVES) { if (exclude(typeArgument)) continue; Set<Object> set = new HashSet<Object>(); for (int i = 0; i < 5; i++) { set.add(SAMPLE_DATA.get(typeArgument)); } setAndListCollection = new HashMap<DataType, Object>(); setAndListCollection.put(typeArgument, set); sampleCollections.put(DataType.set(typeArgument), setAndListCollection); } break; case MAP: for (DataType typeArgument1 : DATA_TYPE_PRIMITIVES) { if (exclude(typeArgument1)) continue; for (DataType typeArgument2 : DATA_TYPE_PRIMITIVES) { if (exclude(typeArgument2)) continue; HashMap<DataType, Object> map = new HashMap<DataType, Object>(); map.put(typeArgument1, SAMPLE_DATA.get(typeArgument2)); mapCollection = new HashMap<DataType, HashMap<DataType, Object>>(); mapCollection.put(typeArgument1, map); sampleCollections.put(DataType.map(typeArgument1, typeArgument2), mapCollection); } } break; default: throw new RuntimeException("Missing handling of " + dataTypeName); } } return sampleCollections; } /** Helper method to stringify SAMPLE_DATA for simple insert statements */ private static String helperStringifiedData(DataType dataType) { String value = SAMPLE_DATA.get(dataType).toString(); switch (dataType.getName()) { case BLOB: value = "0xCAFE"; break; case INET: InetAddress v1 = (InetAddress) SAMPLE_DATA.get(dataType); value = String.format("'%s'", v1.getHostAddress()); break; case TIMESTAMP: Date v2 = (Date) SAMPLE_DATA.get(dataType); value = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").format(v2); case ASCII: case TEXT: case VARCHAR: value = String.format("'%s'", value); break; default: break; } return value; } /** Generates the insert statements that will be used in testing */ private static Collection<String> getPrimitiveInsertStatements() { ArrayList<String> insertStatements = new ArrayList<String>(); for (DataType dataType : SAMPLE_DATA.keySet()) { String value = helperStringifiedData(dataType); insertStatements.add(String.format(PRIMITIVE_INSERT_FORMAT, dataType, value)); } return insertStatements; } /** Generates the select statements that will be used in testing */ private static HashMap<DataType, String> getPrimitiveSelectStatements() { HashMap<DataType, String> selectStatements = new HashMap<DataType, String>(); for (DataType dataType : SAMPLE_DATA.keySet()) { selectStatements.put(dataType, String.format(BASIC_SELECT_FORMAT, dataType)); } return selectStatements; } /** Helper method to generate table names in the form of: DataType_TypeArgument[_TypeArgument] */ private static String helperGenerateTableName(DataType dataType) { String tableName = dataType.getName().toString(); for (DataType typeArgument : dataType.getTypeArguments()) tableName += "_" + typeArgument; return tableName; } /** Generates the insert statements that will be used in testing */ @SuppressWarnings("unchecked") private static Collection<String> getCollectionInsertStatements() { ArrayList<String> insertStatements = new ArrayList<String>(); String tableName; String key; String value; for (DataType dataType : SAMPLE_COLLECTIONS.keySet()) { HashMap<DataType, Object> sampleValueMap = (HashMap<DataType, Object>) SAMPLE_COLLECTIONS.get(dataType); // Create tableName in form of: DataType_TypeArgument[_TypeArgument] tableName = helperGenerateTableName(dataType); if (dataType.getName() == DataType.Name.MAP) { List<DataType> typeArgument = dataType.getTypeArguments(); key = helperStringifiedData(typeArgument.get(0)); value = helperStringifiedData(typeArgument.get(1)); insertStatements.add(String.format(MAP_INSERT_FORMAT, tableName, key, value)); } else if (dataType.getName() == DataType.Name.LIST) { DataType typeArgument = sampleValueMap.keySet().iterator().next(); key = helperStringifiedData(typeArgument); // Create the value to be a list of the same 5 elements value = "["; for (int i = 0; i < 5; i++) value += key + ','; value = value.substring(0, value.length() - 1) + ']'; insertStatements.add(String.format(COLLECTION_INSERT_FORMAT, tableName, key, value)); } else { DataType typeArgument = sampleValueMap.keySet().iterator().next(); key = helperStringifiedData(typeArgument); value = '{' + key + '}'; insertStatements.add(String.format(COLLECTION_INSERT_FORMAT, tableName, key, value)); } } return insertStatements; } /** Generates the select statements that will be used in testing */ private static HashMap<DataType, String> getCollectionSelectStatements() { HashMap<DataType, String> selectStatements = new HashMap<DataType, String>(); String tableName; for (DataType dataType : SAMPLE_COLLECTIONS.keySet()) { tableName = helperGenerateTableName(dataType); selectStatements.put(dataType, String.format(BASIC_SELECT_FORMAT, tableName)); } return selectStatements; } /** Test simple statement inserts for all primitive data types */ public void primitiveInsertTest() throws Throwable { ResultSet rs; for (String execute_string : PRIMITIVE_INSERT_STATEMENTS) { rs = session.execute(execute_string); assertTrue(rs.isExhausted()); } assertEquals(SAMPLE_DATA.size(), 15); assertEquals(PRIMITIVE_INSERT_STATEMENTS.size(), SAMPLE_DATA.size()); } /** Validate simple statement selects for all primitive data types */ public void primitiveSelectTest() throws Throwable { String execute_string; Object value; Row row; for (DataType dataType : PRIMITIVE_SELECT_STATEMENTS.keySet()) { execute_string = PRIMITIVE_SELECT_STATEMENTS.get(dataType); row = session.execute(execute_string).one(); value = SAMPLE_DATA.get(dataType); assertEquals(TestUtils.getValue(row, "k", dataType), value); assertEquals(TestUtils.getValue(row, "v", dataType), value); } assertEquals(SAMPLE_DATA.size(), 15); assertEquals(PRIMITIVE_SELECT_STATEMENTS.keySet().size(), SAMPLE_DATA.size()); } /** Test simple statement inserts and selects for all primitive data types */ @Test(groups = "long") public void primitiveTests() throws Throwable { primitiveInsertTest(); primitiveSelectTest(); } /** Test simple statement inserts for all collection data types */ public void collectionInsertTest() throws Throwable { ResultSet rs; for (String execute_string : COLLECTION_INSERT_STATEMENTS) { rs = session.execute(execute_string); assertTrue(rs.isExhausted()); } assertEquals(SAMPLE_COLLECTIONS.size(), 255); assertEquals(COLLECTION_INSERT_STATEMENTS.size(), SAMPLE_COLLECTIONS.size()); } /** Test simple statement selects for all collection data types */ @SuppressWarnings("unchecked") public void collectionSelectTest() throws Throwable { HashMap<DataType, Object> sampleValueMap; String execute_string; DataType typeArgument1; DataType typeArgument2; Row row; for (DataType dataType : COLLECTION_SELECT_STATEMENTS.keySet()) { execute_string = COLLECTION_SELECT_STATEMENTS.get(dataType); row = session.execute(execute_string).one(); sampleValueMap = (HashMap<DataType, Object>) SAMPLE_COLLECTIONS.get(dataType); typeArgument1 = dataType.getTypeArguments().get(0); if (dataType.getName() == DataType.Name.MAP) { typeArgument2 = dataType.getTypeArguments().get(1); // Create a copy of the map that is being expected HashMap<DataType, Object> sampleMap = (HashMap<DataType, Object>) sampleValueMap.get(typeArgument1); Object mapKey = SAMPLE_DATA.get(sampleMap.keySet().iterator().next()); Object mapValue = sampleMap.values().iterator().next(); HashMap<Object, Object> expectedMap = new HashMap<Object, Object>(); expectedMap.put(mapKey, mapValue); assertEquals(TestUtils.getValue(row, "k", typeArgument2), SAMPLE_DATA.get(typeArgument2)); assertEquals(TestUtils.getValue(row, "v", dataType), expectedMap); } else { Object expectedValue = sampleValueMap.get(typeArgument1); assertEquals(TestUtils.getValue(row, "k", typeArgument1), SAMPLE_DATA.get(typeArgument1)); assertEquals(TestUtils.getValue(row, "v", dataType), expectedValue); } } assertEquals(SAMPLE_COLLECTIONS.size(), 255); assertEquals(COLLECTION_SELECT_STATEMENTS.keySet().size(), SAMPLE_COLLECTIONS.size()); } /** Test simple statement inserts and selects for all collection data types */ @Test(groups = "long") public void collectionTest() throws Throwable { collectionInsertTest(); collectionSelectTest(); } // The two following tests a really unit tests, but since the whole uses // CCMBridge.PerClassSingleNodeCluster, they'll still spawn a cluster even // you execute only them, so we keep them in the "long" group. We could // move them in another class but not sure where honestly (one could argue // that it would make more sense to move all the *other* tests to some // DataTypeIntegrationTest class). @Test(groups = "long") public void serializeDeserializeTest() { for (DataType dt : DataType.allPrimitiveTypes()) { if (exclude(dt)) continue; Object value = TestUtils.getFixedValue(dt); assertEquals(dt.deserialize(dt.serialize(value)), value); } try { DataType.bigint().serialize(4); fail("This should not have worked"); } catch (InvalidTypeException e) { /* That's what we want */ } try { ByteBuffer badValue = ByteBuffer.allocate(4); DataType.bigint().deserialize(badValue); fail("This should not have worked"); } catch (InvalidTypeException e) { /* That's what we want */ } } @Test(groups = "long") public void serializeDeserializeCollectionsTest() { List<String> l = Arrays.asList("foo", "bar"); DataType dt = DataType.list(DataType.text()); assertEquals(dt.deserialize(dt.serialize(l)), l); try { DataType.list(DataType.bigint()).serialize(l); fail("This should not have worked"); } catch (InvalidTypeException e) { /* That's what we want */ } } /** Prints the table definitions that will be used in testing (for exporting purposes) */ @Test(groups = "doc") public void printTableDefinitions() { String objective = "Table Definitions"; System.out.println(String.format("Printing %s...", objective)); // Prints the full list of table definitions for (String definition : getTableDefinitions()) { System.out.println(definition); } System.out.println(String.format("\nEnd of %s\n\n", objective)); } /** Prints the sample data that will be used in testing (for exporting purposes) */ @Test(groups = "doc") public void printSampleData() { String objective = "Sample Data"; System.out.println(String.format("Printing %s...", objective)); for (DataType dataType : SAMPLE_DATA.keySet()) { Object sampleValue = SAMPLE_DATA.get(dataType); System.out.println(String.format("%1$-10s %2$s", dataType, sampleValue)); } System.out.println(String.format("\nEnd of %s\n\n", objective)); } /** Prints the sample collections that will be used in testing (for exporting purposes) */ @Test(groups = "doc") @SuppressWarnings("unchecked") public void printSampleCollections() { String objective = "Sample Collections"; System.out.println(String.format("Printing %s...", objective)); for (DataType dataType : SAMPLE_COLLECTIONS.keySet()) { HashMap<DataType, Object> sampleValueMap = (HashMap<DataType, Object>) SAMPLE_COLLECTIONS.get(dataType); if (dataType.getName() == DataType.Name.MAP) { DataType typeArgument = sampleValueMap.keySet().iterator().next(); HashMap<DataType, Object> sampleMap = (HashMap<DataType, Object>) sampleValueMap.get(typeArgument); Object mapKey = SAMPLE_DATA.get(typeArgument); Object mapValue = sampleMap.get(typeArgument); System.out.println(String.format("%1$-30s {%2$s : %3$s}", dataType, mapKey, mapValue)); } else { DataType typeArgument = sampleValueMap.keySet().iterator().next(); Object sampleValue = sampleValueMap.get(typeArgument); System.out.println(String.format("%1$-30s %2$s", dataType, sampleValue)); } } System.out.println(String.format("\nEnd of %s\n\n", objective)); } /** Prints the simple insert statements that will be used in testing (for exporting purposes) */ @Test(groups = "doc") public void printPrimitiveInsertStatements() { String objective = "Primitive Insert Statements"; System.out.println(String.format("Printing %s...", objective)); for (String execute_string : PRIMITIVE_INSERT_STATEMENTS) { System.out.println(execute_string); } System.out.println(String.format("\nEnd of %s\n\n", objective)); } /** Prints the simple select statements that will be used in testing (for exporting purposes) */ @Test(groups = "doc") public void printPrimitiveSelectStatements() { String objective = "Primitive Select Statements"; System.out.println(String.format("Printing %s...", objective)); for (String execute_string : PRIMITIVE_SELECT_STATEMENTS.values()) { System.out.println(execute_string); } System.out.println(String.format("\nEnd of %s\n\n", objective)); } /** Prints the simple insert statements that will be used in testing (for exporting purposes) */ @Test(groups = "doc") public void printCollectionInsertStatements() { String objective = "Collection Insert Statements"; System.out.println(String.format("Printing %s...", objective)); for (String execute_string : COLLECTION_INSERT_STATEMENTS) { System.out.println(execute_string); } System.out.println(String.format("\nEnd of %s\n\n", objective)); } /** Prints the simple insert statements that will be used in testing (for exporting purposes) */ @Test(groups = "doc") public void printCollectionSelectStatements() { String objective = "Collection Select Statements"; System.out.println(String.format("Printing %s...", objective)); for (String execute_string : COLLECTION_SELECT_STATEMENTS.values()) { System.out.println(execute_string); } System.out.println(String.format("\nEnd of %s\n\n", objective)); } }