@Test public void shouldParseHostStringWithAddressForOneReplicaSet() { sets = ReplicaSets.parse("myReplicaSet/localhost:27017"); assertThat(sets.replicaSetCount()).isEqualTo(1); assertThat(sets.hosts()).isEqualTo("myReplicaSet/localhost:27017"); rs = sets.all().get(0); assertThat(rs.hasReplicaSetName()).isTrue(); assertThat(rs.isStandaloneServer()).isFalse(); assertThat(rs.replicaSetName()).isEqualTo("myReplicaSet"); assertThat(rs.shardName()).isNull(); ServerAddress expected = new ServerAddress("localhost", 27017); assertThat(rs.addresses().size()).isEqualTo(1); assertThat(rs.addresses()).containsOnly(expected); }
private void validateFieldDef(Field expected) { ConfigDef configDef = connector.config(); assertThat(configDef.names()).contains(expected.name()); ConfigDef.ConfigKey key = configDef.configKeys().get(expected.name()); assertThat(key).isNotNull(); assertThat(key.name).isEqualTo(expected.name()); assertThat(key.displayName).isEqualTo(expected.displayName()); assertThat(key.importance).isEqualTo(expected.importance()); assertThat(key.documentation).isEqualTo(expected.description()); assertThat(key.type).isEqualTo(expected.type()); assertThat(key.defaultValue).isEqualTo(expected.defaultValue()); assertThat(key.dependents).isEqualTo(expected.dependents()); assertThat(key.width).isNotNull(); assertThat(key.group).isNotNull(); assertThat(key.orderInGroup).isGreaterThan(0); assertThat(key.validator).isNull(); assertThat(key.recommender).isNull(); } }
config.forEachMatchingFieldNameWithInteger("column\\.truncate\\.to\\.(\\d+)\\.chars",(value,n)->{ counter.incrementAndGet(); assertThat(value).isEqualTo(Integer.toString(n) + "-chars"); }); assertThat(counter.get()).isEqualTo(2); config.forEachMatchingFieldNameWithInteger("column.mask.with.(\\d+).chars",(value,n)->{ counter.incrementAndGet(); assertThat(value).isEqualTo(Integer.toString(n) + "-mask"); }); assertThat(counter.get()).isEqualTo(2); config.forEachMatchingFieldName("column.mask.with.(\\d+).chars",(name,value)->{ counter.incrementAndGet(); assertThat(name).startsWith("column.mask.with."); assertThat(name).endsWith(".chars"); assertThat(value).endsWith("-mask"); }); assertThat(counter.get()).isEqualTo(2); config.forEachMatchingFieldName("column.*",(name,value)->{ counter.incrementAndGet(); assertThat(name).startsWith("column."); assertThat(name).endsWith(".chars"); assertThat(value).isNotNull(); }); assertThat(counter.get()).isEqualTo(6);
@Test public void shouldHaveToStringMethod() { String msg = table.toString(); assertThat(msg).isNotNull(); assertThat(msg).isNotEmpty(); }
protected void assertVariable(String name, String expectedValue) { String actualValue = parser.systemVariables().getVariable(name); if (expectedValue == null) { assertThat(actualValue).isNull(); } else { assertThat(actualValue).isEqualToIgnoringCase(expectedValue); } }
protected void assertEnumType( String content, String expression ) { DataType type = parser.parse(text(content), null); assertThat(type).isNotNull(); assertThat(type.jdbcType()).isEqualTo(Types.CHAR); assertThat(type.name()).isEqualTo("ENUM"); assertThat(type.length()).isEqualTo(-1); assertThat(type.expression()).isEqualTo(expression); }
@Test public void shouldLogPerformance() throws Exception { repository.findByCreditCardsNumber("123456789"); assertThat(appender.events).hasSize(1); assertThat(appender.events.get(0).getLevel()).isEqualTo(Level.INFO); assertThat((String) appender.events.get(0).getMessage()) .startsWith("StopWatch 'AccountRepository.findByCreditCardsNumber': running time (millis) = "); }
@Test public void shouldRegisterPayback() { PaybackConfirmation confirmation = bookKeeper.registerPaybackFor(purchase); assertThat(confirmation.getNumber()).isNotNull(); assertThat(confirmation.getIncome().getAmount()).isEqualTo(Money.of(EUR, 6L)); assertThat(confirmation.getIncome().getDistributions()).hasSize(2); assertThat(confirmation.getIncome().getDistribution("Glock").getAmount()).isEqualTo(Money.of(EUR, 3L)); assertThat(confirmation.getIncome().getDistribution("M60").getAmount()).isEqualTo(Money.of(EUR, 3L)); } }
@Test public void shouldParseMultipleStatementsWithDefaultDatabase() { parser.setCurrentSchema("mydb"); String ddl = "CREATE TABLE foo ( " + System.lineSeparator() + " c1 INTEGER NOT NULL, " + System.lineSeparator() + " c2 VARCHAR(22) " + System.lineSeparator() + "); " + System.lineSeparator() + "-- This is a comment" + System.lineSeparator() + "DROP TABLE foo;" + System.lineSeparator(); parser.parse(ddl, tables); assertThat(tables.size()).isEqualTo(0); // table created and dropped changes.groupEventsByDatabase((dbName, list) -> { assertThat(dbName).isEqualTo("mydb"); assertThat(list.size()).isEqualTo(2); assertThat(list.get(0).type()).isEqualTo(EventType.CREATE_TABLE); assertThat(list.get(1).type()).isEqualTo(EventType.DROP_TABLE); }); }
RecordsForCollection records = recordMakers.forCollection(collectionId); records.recordEvent(event, 1002); assertThat(produced.size()).isEqualTo(1); SourceRecord record = produced.get(0); assertThat((operationHeader).hasNext()).isTrue(); assertThat(operationHeader.next().value().toString()).isEqualTo(Envelope.Operation.UPDATE.code()); assertThat(key.schema()).isSameAs(transformed.keySchema()); assertThat(key.schema().field("id").schema()).isEqualTo(SchemaBuilder.OPTIONAL_STRING_SCHEMA); assertThat(key.get("id")).isEqualTo(objId.toString()); assertThat(value.schema().field("id").schema()).isEqualTo(SchemaBuilder.OPTIONAL_STRING_SCHEMA); assertThat(value.schema().field("name").schema()).isEqualTo(SchemaBuilder.OPTIONAL_STRING_SCHEMA); assertThat(value.schema().fields()).hasSize(2);
@Test public void should_generate_pdf_link_with_custom_url() throws Exception { goToPage("export/custom_pdf_url"); assertThat(find("div.dandelion_dataTables_export")).hasSize(1); assertThat(find("div.dandelion_dataTables_export").findFirst("a").getText()).isEqualTo("PDF"); assertThat(find("div.dandelion_dataTables_export").findFirst("a").getAttribute("onclick")).isEqualTo("ddl_dt_launch_export_PDF();"); String js = getConfigurationFromPage("export/custom_pdf_url").getContent(); assertThat(js).contains("function ddl_dt_launch_export_PDF(){window.location='/context/customPdfUrl?' + $.param(oTable_myTableId.oApi._fnAjaxParameters(oTable_myTableId.fnSettings()));};"); }
@Test public void shouldReturnOffsetForUnusedReplicaName() { assertThat(source.hasOffset(REPLICA_SET_NAME)).isEqualTo(false); Map<String, ?> offset = source.lastOffset(REPLICA_SET_NAME); assertThat(offset.get(SourceInfo.TIMESTAMP)).isEqualTo(0); assertThat(offset.get(SourceInfo.ORDER)).isEqualTo(0); assertThat(offset.get(SourceInfo.OPERATION_ID)).isNull(); BsonTimestamp ts = source.lastOffsetTimestamp(REPLICA_SET_NAME); assertThat(ts.getTime()).isEqualTo(0); assertThat(ts.getInc()).isEqualTo(0); Struct struct = source.lastOffsetStruct(REPLICA_SET_NAME,new CollectionId(REPLICA_SET_NAME,"dbA","collectA")); assertThat(struct.getInt32(SourceInfo.TIMESTAMP)).isEqualTo(0); assertThat(struct.getInt32(SourceInfo.ORDER)).isEqualTo(0); assertThat(struct.getInt64(SourceInfo.OPERATION_ID)).isNull(); assertThat(struct.getString(SourceInfo.NAMESPACE)).isEqualTo("dbA.collectA"); assertThat(struct.getString(SourceInfo.REPLICA_SET_NAME)).isEqualTo(REPLICA_SET_NAME); assertThat(struct.getString(SourceInfo.SERVER_NAME)).isEqualTo("serverX"); assertThat(struct.getBoolean(SourceInfo.INITIAL_SYNC)).isNull(); assertThat(source.hasOffset(REPLICA_SET_NAME)).isEqualTo(false); }
SourceRecords records = consumeRecordsByTopic(numCreateDatabase + numCreateTables + numInserts); stopConnector(); assertThat(records).isNotNull(); List<SourceRecord> dmls = records.recordsForTopic(DATABASE.topicForTable("dbz_254_binary_column_test")); assertThat(dmls).hasSize(4); assertThat(encodeToBase64String((ByteBuffer) after.get("file_uuid"))).isEqualTo("ZRrtCDkPSJOy8TaSPnt0AA=="); assertThat(encodeToBase64String((ByteBuffer) after.get("file_uuid"))).isEqualTo("ZRrtCDkPSJOy8TaSPnt0qw=="); assertThat(encodeToBase64String((ByteBuffer) after.get("file_uuid"))).isEqualTo("ZRrtCDkPSJOy8TaSPnt0AA=="); assertThat(encodeToBase64String((ByteBuffer) after.get("file_uuid"))).isEqualTo("AAAAAAAAAAAAAAAAAAAAAA==");
@Test public void shouldUseFiltersForAlterTable() { parser = new MysqlDdlParserWithSimpleTestListener(listener, TableFilter.fromPredicate(x -> !x.table().contains("ignored"))); final String ddl = "CREATE TABLE ok (id int primary key, val smallint);" + System.lineSeparator() + "ALTER TABLE ignored ADD COLUMN(x tinyint)" + System.lineSeparator() + "ALTER TABLE ok ADD COLUMN(y tinyint)"; parser.parse(ddl, tables); assertThat(((MysqlDdlParserWithSimpleTestListener)parser).getParsingExceptionsFromWalker()).isEmpty(); assertThat(tables.size()).isEqualTo(1); final Table t1 = tables.forTable(null, null, "ok"); assertThat(t1.columns()).hasSize(3); final Column c1 = t1.columns().get(0); final Column c2 = t1.columns().get(1); final Column c3 = t1.columns().get(2); assertThat(c1.name()).isEqualTo("id"); assertThat(c1.typeName()).isEqualTo("INT"); assertThat(c2.name()).isEqualTo("val"); assertThat(c2.typeName()).isEqualTo("SMALLINT"); assertThat(c3.name()).isEqualTo("y"); assertThat(c3.typeName()).isEqualTo("TINYINT"); }
public EventAssert ddlContains( String expected) { assertThat(actual.statement()).contains(expected); return this; }
@Test public void shouldTruncateStrings() { converter = new TruncateStrings(5).create(column); assertThat(converter.convert("1234567890").toString()).isEqualTo("12345"); assertThat(converter.convert("123456").toString()).isEqualTo("12345"); assertThat(converter.convert("12345").toString()).isEqualTo("12345"); assertThat(converter.convert("1234").toString()).isEqualTo("1234"); assertThat(converter.convert("123").toString()).isEqualTo("123"); assertThat(converter.convert("12").toString()).isEqualTo("12"); assertThat(converter.convert("1").toString()).isEqualTo("1"); assertThat(converter.convert(null)).isNull(); }
@Test public void shouldCreateColumnWithAllFieldsSetToDefaults() { Column column = editor.create(); assertThat(column.name()).isNull(); assertThat(column.typeName()).isNull(); assertThat(column.jdbcType()).isEqualTo(Types.INTEGER); assertThat(column.length()).isEqualTo(-1); Assert.assertFalse(column.scale().isPresent()); assertThat(column.position()).isEqualTo(1); assertThat(column.isOptional()).isTrue(); assertThat(column.isAutoIncremented()).isFalse(); assertThat(column.isGenerated()).isFalse(); }
protected void assertTableIncluded(String fullyQualifiedTableName) { TableId tableId = TableId.parse(fullyQualifiedTableName); TableSchema tableSchema = mysql.schemaFor(tableId); assertThat(tableSchema).isNotNull(); assertThat(tableSchema.keySchema().name()).isEqualTo(SchemaNameAdjuster.validFullname(SERVER_NAME + "." + fullyQualifiedTableName + ".Key")); assertThat(tableSchema.valueSchema().name()).isEqualTo(SchemaNameAdjuster.validFullname(SERVER_NAME + "." + fullyQualifiedTableName + ".Value")); }
@Test public void shouldBuildWithSimpleOptionalTypesForBeforeAndAfter() { Envelope env = Envelope.defineSchema() .withName("someName") .withRecord(Schema.OPTIONAL_STRING_SCHEMA) .withSource(Schema.OPTIONAL_INT64_SCHEMA) .build(); assertThat(env.schema()).isNotNull(); assertThat(env.schema().name()).isEqualTo("someName"); assertThat(env.schema().doc()).isNull(); assertThat(env.schema().version()).isNull(); assertOptionalField(env, Envelope.FieldName.AFTER, Schema.OPTIONAL_STRING_SCHEMA); assertOptionalField(env, Envelope.FieldName.BEFORE, Schema.OPTIONAL_STRING_SCHEMA); assertOptionalField(env, Envelope.FieldName.SOURCE, Schema.OPTIONAL_INT64_SCHEMA); assertRequiredField(env, Envelope.FieldName.OPERATION, Schema.STRING_SCHEMA); }
protected void assertSameGtidSet(String pathToField, Object actual, Object expected) { assertThat(actual).isInstanceOf(String.class); assertThat(expected).isInstanceOf(String.class); GtidSet actualGtidSet = new GtidSet((String) actual); GtidSet expectedGtidSet = new GtidSet((String) expected); assertThat(actualGtidSet.toString()).isEqualTo(expectedGtidSet.toString()); } }