/** * Print a debug message with the JSON representation of the SourceRecord. * * @param record the source record; may not be null */ public static void debug(SourceRecord record) { Testing.debug(SchemaUtil.asDetailedString(record)); }
protected void storeDocuments(String dbName, String collectionName, String pathOnClasspath) { primary().execute("storing documents", mongo -> { Testing.debug("Storing in '" + dbName + "." + collectionName + "' documents loaded from from '" + pathOnClasspath + "'"); MongoDatabase db1 = mongo.getDatabase(dbName); MongoCollection<Document> coll = db1.getCollection(collectionName); coll.drop(); storeDocuments(coll, pathOnClasspath); }); }
private void applyCommand(Document record, ConsumerCompletion result) { if (isCommand(record)) { Testing.debug("applying command: " + SchemaUtil.asString(record)); String command = record.getString(CONTROL_KEY); if (CONTROL_RESTART.equalsIgnoreCase(command)) { // We're supposed to restart the connector, so stop it ... result.restartRequested(); String msg = "Stopping connector after record as requested"; Testing.debug(msg); throw new StopConnectorException(msg); } else if (CONTROL_STOP.equalsIgnoreCase(command)) { // We're supposed to restart the connector, so stop it ... result.stop(); String msg = "Stopping connector after record as requested"; Testing.debug(msg); throw new StopConnectorException(msg); } } }
protected void appendCommand(Path results, Document command) throws IOException { assertThat(command).isNotNull(); assertThat(Files.exists(results)).isTrue(); Array arrayOfDocuments = readResults(results.toFile()); arrayOfDocuments.add(command); try (OutputStream stream = new FileOutputStream(results.toFile())) { ArrayWriter.prettyWriter().write(arrayOfDocuments, stream); } if (Testing.Debug.isEnabled()) { String content = IoUtil.read(results.toFile()); Testing.debug("expected results file '" + results + "' after appending command:"); Testing.debug(content); } }
GtidSet replicaGtidSet = null; while (true) { Testing.debug("Checking replica's GTIDs and comparing to master's..."); replicaGtidSet = readAvailableGtidSet(replica); Testing.debug("Replica's GTIDs are caught up to the master's."); sw.stop(); return; Testing.debug("Waiting for replica's GTIDs to catch up to master's..."); Thread.sleep(100);
Testing.debug("Consumed record " + recordsConsumed + " / " + numberOfRecords + " (" + (numberOfRecords - recordsConsumed) + " more)"); debug(record);
@Test public void stringTypes() throws Exception { Testing.debug("Inserted"); final SourceRecords records = consumeRecordsByTopic(EXPECTED_RECORD_COUNT); List<SourceRecord> testTableRecords = records.recordsForTopic("server1.dbo.type_string"); assertThat(testTableRecords).hasSize(1); // insert VerifyRecord.isValidRead(testTableRecords.get(0)); Struct after = (Struct) ((Struct)testTableRecords.get(0).value()).get("after"); assertRecord(after, EXPECTED_STRING); }
@Test public void otherTypes() throws Exception { Testing.debug("Inserted"); final SourceRecords records = consumeRecordsByTopic(EXPECTED_RECORD_COUNT); List<SourceRecord> testTableRecords = records.recordsForTopic("server1.dbo.type_xml"); assertThat(testTableRecords).hasSize(1); // insert VerifyRecord.isValidRead(testTableRecords.get(0)); Struct after = (Struct) ((Struct)testTableRecords.get(0).value()).get("after"); assertRecord(after, EXPECTED_XML); }
@Test public void intTypes() throws Exception { Testing.debug("Inserted"); final SourceRecords records = consumeRecordsByTopic(EXPECTED_RECORD_COUNT); List<SourceRecord> testTableRecords = records.recordsForTopic("server1.dbo.type_int"); assertThat(testTableRecords).hasSize(1); // insert VerifyRecord.isValidRead(testTableRecords.get(0)); Struct after = (Struct) ((Struct)testTableRecords.get(0).value()).get("after"); assertRecord(after, EXPECTED_INT); }
@Test public void fpTypes() throws Exception { Testing.debug("Inserted"); final SourceRecords records = consumeRecordsByTopic(EXPECTED_RECORD_COUNT); List<SourceRecord> testTableRecords = records.recordsForTopic("server1.dbo.type_fp"); assertThat(testTableRecords).hasSize(1); // insert VerifyRecord.isValidRead(testTableRecords.get(0)); Struct after = (Struct) ((Struct)testTableRecords.get(0).value()).get("after"); assertRecord(after, EXPECTED_FP); }
@Test public void dateTimeTypes() throws Exception { Testing.debug("Inserted"); final SourceRecords records = consumeRecordsByTopic(EXPECTED_RECORD_COUNT); List<SourceRecord> testTableRecords = records.recordsForTopic("server1.dbo.type_time"); assertThat(testTableRecords).hasSize(1); // insert VerifyRecord.isValidRead(testTableRecords.get(0)); Struct after = (Struct) ((Struct)testTableRecords.get(0).value()).get("after"); assertRecord(after, EXPECTED_DATE_TIME); }
@Test public void shouldStartServerAndRemoveData() throws Exception { Testing.debug("Running 1"); server.startup(); server.onEachDirectory(this::assertValidDataDirectory); server.shutdown(true); server.onEachDirectory(this::assertDoesNotExist); }
@Test public void shouldStartServerAndLeaveData() throws Exception { Testing.debug("Running 2"); server.startup(); server.onEachDirectory(this::assertValidDataDirectory); server.shutdown(false); server.onEachDirectory(this::assertValidDataDirectory); }
@Test @SkipLongRunning public void shouldStartClusterAndAllowProducersAndConsumersToUseIt() throws Exception { Testing.Debug.enable(); final String topicName = "topicA"; final CountDownLatch completion = new CountDownLatch(2); final int numMessages = 100; final AtomicLong messagesRead = new AtomicLong(0); // Start a cluster and create a topic ... cluster.addBrokers(1).startup(); cluster.createTopics(topicName); // Consume messages asynchronously ... Stopwatch sw = Stopwatch.reusable().start(); cluster.useTo().consumeIntegers(topicName, numMessages, 10, TimeUnit.SECONDS, completion::countDown, (key, value) -> { messagesRead.incrementAndGet(); return true; }); // Produce some messages asynchronously ... cluster.useTo().produceIntegers(topicName, numMessages, 1, completion::countDown); // Wait for both to complete ... if (completion.await(10, TimeUnit.SECONDS)) { sw.stop(); Testing.debug("Both consumer and producer completed normally in " + sw.durations()); } else { Testing.debug("Consumer and/or producer did not completed normally"); } assertThat(messagesRead.get()).isEqualTo(numMessages); }
Testing.debug("Stopped connector"); };
private void assertGeomRecord(Struct value) { Struct after = value.getStruct(Envelope.FieldName.AFTER); Integer i = after.getInt32("id"); Testing.debug(after); assertThat(i).isNotNull(); if (i == 1) { // INSERT INTO dbz_507_geometry VALUES (1, ST_GeomFromText('POINT(1 1)', 4326), ST_GeomFromText('LINESTRING(0 0, 1 1)', 3187), ST_GeomFromText('POLYGON((0 0, 1 1, 1 0, 0 0))'), ST_GeomFromText('GEOMETRYCOLLECTION(POINT(1 1), LINESTRING(0 0, 1 1))', 4326)); assertThat(after.getStruct("geom").getInt32("srid")).isEqualTo(4326); assertThat(DatatypeConverter.printHexBinary(after.getStruct("geom").getBytes("wkb"))).isEqualTo("0101000000000000000000F03F000000000000F03F"); assertThat(after.getStruct("linestring").getInt32("srid")).isEqualTo(3187); assertThat(DatatypeConverter.printHexBinary(after.getStruct("linestring").getBytes("wkb"))).isEqualTo("01020000000200000000000000000000000000000000000000000000000000F03F000000000000F03F"); assertThat(after.getStruct("polygon").getInt32("srid")).isEqualTo(null); assertThat(DatatypeConverter.printHexBinary(after.getStruct("polygon").getBytes("wkb"))).isEqualTo("0103000000010000000400000000000000000000000000000000000000000000000000F03F000000000000F03F000000000000F03F000000000000000000000000000000000000000000000000"); assertThat(after.getStruct("collection").getInt32("srid")).isEqualTo(4326); assertThat(DatatypeConverter.printHexBinary(after.getStruct("collection").getBytes("wkb"))).isEqualTo("0107000000020000000101000000000000000000F03F000000000000F03F01020000000200000000000000000000000000000000000000000000000000F03F000000000000F03F"); } else if (i == 2) { // INSERT INTO dbz_507_geometry VALUES (2, ST_GeomFromText('LINESTRING(0 0, 1 1)'), NULL, NULL, NULL); assertThat(after.getStruct("geom").getInt32("srid")).isEqualTo(null); assertThat(DatatypeConverter.printHexBinary(after.getStruct("geom").getBytes("wkb"))).isEqualTo("01020000000200000000000000000000000000000000000000000000000000F03F000000000000F03F"); assertThat(after.getStruct("linestring")).isNull(); assertThat(after.getStruct("polygon")).isNull(); assertThat(after.getStruct("collection")).isNull(); } }
private void assertPoint(Struct value) { Struct after = value.getStruct(Envelope.FieldName.AFTER); Integer i = after.getInt32("id"); Testing.debug(after); assertThat(i).isNotNull(); Double expectedX = after.getFloat64("expected_x"); Double expectedY = after.getFloat64("expected_y"); Integer expectedSrid = after.getInt32("expected_srid"); if (after.getStruct("point") != null) { Double actualX = after.getStruct("point").getFloat64("x"); Double actualY = after.getStruct("point").getFloat64("y"); Integer actualSrid = after.getStruct("point").getInt32("srid"); //Validate the values databaseDifferences.geometryAssertPoints(expectedX, expectedY, actualX, actualY); assertThat(actualSrid).isEqualTo(expectedSrid); //Test WKB Point point = (Point) WkbGeometryReader.readGeometry(new ByteReader((byte[]) after.getStruct("point") .get("wkb"))); databaseDifferences.geometryAssertPoints(expectedX, expectedY, point.getX(), point.getY()); } else if (expectedX != null) { Assert.fail("Got a null geometry but didn't expect to"); } }