io.vertx.core.cli.annotations.Description Java Examples

@Disabled("Will be fixed in the new PR.")
@Description("As a member of team A, I can write to topics starting with 'x-' and " +
        "as a member of team B can read from topics starting with 'x-'")
@Test
@Order(5)
void testTeamAWriteToTopicStartingWithXAndTeamBReadFromTopicStartingWithX() {
    // only write means that Team A can not create new topic 'x-.*'
    String topicName = TOPIC_X + "-example";

    KafkaTopicResource.topic(CLUSTER_NAME, topicName).done();

    teamAOauthKafkaClient.setTopicName(topicName);

    assertThat(teamAOauthKafkaClient.sendMessagesTls(), is(MESSAGE_COUNT));

    teamBOauthKafkaClient.setTopicName(topicName);
    teamBOauthKafkaClient.setConsumerGroup("x_consumer_group_b");

    assertThat(teamBOauthKafkaClient.receiveMessagesTls(), is(MESSAGE_COUNT));
}
 

@Description("As a member of team B, I should be able to write and read from topics that starts with b-")
@Test
@Order(4)
void testTeamBWriteToTopic() {
    LOGGER.info("Sending {} messages to broker with topic name {}", MESSAGE_COUNT, TOPIC_NAME);

    // Producer will not produce messages because authorization topic will failed. Team A can write only to topic starting with 'x-'
    assertThrows(WaitException.class, () -> teamBOauthKafkaClient.sendMessagesTls(Constants.GLOBAL_CLIENTS_EXCEPT_ERROR_TIMEOUT));

    LOGGER.info("Sending {} messages to broker with topic name {}", MESSAGE_COUNT, TOPIC_B);
    teamBOauthKafkaClient.setTopicName(TOPIC_B);

    teamBOauthKafkaClient.verifyProducedAndConsumedMessages(
        teamBOauthKafkaClient.sendMessagesTls(),
        teamBOauthKafkaClient.receiveMessagesTls()
    );
}
 

@Option(longName = "output", shortName = "o", argName = "output-file")
@Description("Optional: If set, the generated json will be saved here. Otherwise, it's printed on the console.")
public void setOutputFile(String output) {
    outputFile = new File(output);
    if(outputFile.exists()) {
        if(!outputFile.isFile()) {
            log.error("'{}' is not a valid file location", outputFile);
        }
    } else {
        try {
            if(!outputFile.createNewFile()) {
                log.error("'{}' is not a valid file location", outputFile);
            }
        } catch (Exception exception) {
            log.error("Error while creating file: '{}'", outputFile, exception);
        }
    }
}
 

@Option(longName = "pipeline", shortName = "p", argName = "config", required = true)
@Description("A comma-separated list of sequence/graph pipeline steps to create boilerplate configuration from. " +
        "For sequences, allowed values are: " +
        "[crop_grid, crop_fixed_grid, dl4j, draw_bounding_box, draw_fixed_grid, draw_grid, " +
        "draw_segmentation, extract_bounding_box, camera_frame_capture, video_frame_capture" +
        "image_to_ndarray, logging, ssd_to_bounding_box, samediff, show_image, tensorflow]. " +
        "For graphs, the list item should be in the format '<output>=<type>(<inputs>)' or " +
        "'[outputs]=switch(<inputs>)' for switches. The pre-defined root input is named, 'input'. " +
        "Examples are ==> " +
        "Pipeline step: 'a=tensorflow(input),b=dl4j(input)' " +
        "Merge Step: 'c=merge(a,b)' " +
        "Switch Step (int): '[d1,d2,d3]=switch(int,select,input)' " +
        "Switch Step (string): '[d1,d2,d3]=switch(string,select,x:1,y:2,z:3,input)'" +
        "Any Step: 'e=any(d1,d2,d3)' " +
        "See the examples above for more usage information.")
public void setPipeline(String pipelineString) {
    this.pipelineString = pipelineString;
}
 

@Option(longName = "output", shortName = "o", argName = "output-file")
@Description("Optional: If set, the generated json/yaml will be saved here. Otherwise, it's printed on the console.")
public void setOutputFile(String output) {
    outputFile = new File(output);
    if(outputFile.exists()) {
        if(!outputFile.isFile()) {
            System.out.format("'%s' is not a valid file location%n", outputFile);
            System.exit(1);
        }
    } else {
        try {
            if(!outputFile.createNewFile()) {
                System.out.format("'%s' is not a valid file location%n", outputFile);
                System.exit(1);
            }
        } catch (Exception exception) {
            System.out.format("Error while creating file: '%s'%n", outputFile);
            exception.printStackTrace();
            System.exit(1);
        }
    }
}
 

@Option(longName = "header", acceptMultipleValues = true)
@Description("add an header formatted as header_name:header_value")
public void setHeaders(List<String> headers) {
  for (String header : headers) {
    Matcher matcher = HEADER_PATTERN.matcher(header);
    if (!matcher.matches()) {
      throw new IllegalArgumentException("Invalid header value, use: --header foo:bar");
    }
    options.addHeader(matcher.group(1), matcher.group(2));
  }
}
 

@Description(
        "As an oauth producer, I should be able to produce messages to the kafka broker\n" +
        "As an oauth consumer, I should be able to consumer messages from the kafka broker.")
@Test
void testProducerConsumer() {
    oauthExternalKafkaClient.setClusterName(CLUSTER_NAME);

    oauthExternalKafkaClient.verifyProducedAndConsumedMessages(
        oauthExternalKafkaClient.sendMessagesPlain(),
        oauthExternalKafkaClient.receiveMessagesPlain()
    );
}
 

@Description("As a member of team A, I should be able to read and write to all topics starting with a-")
@Test
@Order(1)
void smokeTestForClients() {
    teamAOauthKafkaClient.verifyProducedAndConsumedMessages(
        teamAOauthKafkaClient.sendMessagesTls(),
        teamAOauthKafkaClient.receiveMessagesTls()
    );
}
 

@Description(
        "As an oauth producer, I am able to produce messages to the kafka broker\n" +
        "As an oauth consumer, I am able to consumer messages from the kafka broker using encrypted communication")
@Test
void testProducerConsumer() {
    oauthExternalKafkaClientTls.verifyProducedAndConsumedMessages(
        oauthExternalKafkaClientTls.sendMessagesTls(),
        oauthExternalKafkaClientTls.receiveMessagesTls()
    );
}
 

@Option(longName = "protocol", shortName = "pr")
@Description("Protocol to use with the server. Allowed values are [http, grpc, mqtt]")
public void setYaml(String protocol) {
    try {
        this.protocol = ServerProtocol.valueOf(protocol.toUpperCase());
    } catch (Exception exception) {
        System.out.format("Protocol can only be one of %s. Given %s%n",
                Arrays.toString(ServerProtocol.values()), protocol);
        exception.printStackTrace();
        System.exit(1);
    }
}
 

@Option(longName = "timeout")
@Description("the send timeout")
public void setTimeout(long timeout) {
  options.setSendTimeout(timeout);
}
 

@Argument(index = 1, argName = "keys")
@Description("the keys to get")
public void setKeys(List<String> keys) {
  this.keys = keys;
}
 

@Option(longName = "reply", flag = true)
@Description("wait for a reply and print it on the console")
public void setReply(boolean reply) {
  this.reply = reply;
}
 

@Argument(index = 0, argName = "dir", required = false)
@Description("the new working dir")
public void setDir(String dir) {
  this.dir = dir;
}
 

@Argument(index = 0, argName = "map", required = false)
@Description("the name of the map to get from")
public void setMap(String map) {
  this.map = map;
}
 

@Argument(index = 0, argName = "id")
@Description("the verticle id")
public void setId(String id) {
  this.id = id;
}
 

@Option(shortName = "l", flag = true)
@Description("list in long format")
public void setEll(boolean ell) {
  this.ell = ell;
}
 

@Option(longName = "type")
@Description("the object type")
public void setType(ObjectType type) {
  this.type = type;
}
 

@Option(longName = "verbose", flag = true)
@Description("verbose output")
public void setVerbose(boolean verbose) {
  this.verbose = verbose;
}
 

@Argument(index = 0, argName = "file", required = false)
@Description("the file to list")
@DefaultValue(".")
public void setFile(String file) {
  this.file = file;
}
 

@Argument(index = 1, argName = "keys", required = false)
@Description("the keys to get")
public void setKeys(List<String> keys) {
  this.keys = keys;
}
 

@Option(longName = "all", shortName = "a", required = false)
@Description("include files that begins with .")
public void setAll(boolean all) {
  this.all = all;
}
 

@Argument(index = 0, argName = "map")
@Description("the name of the map to get from")
public void setMap(String map) {
  this.map = map;
}
 

@Argument(index = 1, argName = "key", required = false)
@Description("the key to put")
public void setKey(String key) {
  this.key = key;
}
 

@Argument(index =  0, argName = "address")
@Description("the bus address destination")
public void setAddresses(List<String> addresses) {
  this.addresses = addresses;
}
 

@Option(longName = "verbose", flag = true)
@Description("verbose output")
public void setVerbose(boolean verbose) {
  this.verbose = verbose;
}
 

@Option(longName = "local", flag = true)
@Description("subscribe to a local address")
public void setLocal(boolean local) {
  this.local = local;
}
 

@Option(longName = "test", argName = "test")
@Description("Select one or several tests to run")
public void setTest(String test) {
  this.test = test;
}
 

@Option(longName = "report", argName = "report")
@Description("Report the execution to a file in JUnit XML format")
public void setReport(boolean report) {
  // Todo report dir ????
  this.report = report;
}
 

@Option(longName = "timeout", argName = "timeout")
@Description("Set the test suite timeout in millis")
public void setTimeout(long timeout) {
  this.timeout = timeout;
}