congrats Icon
New! Tabnine Pro 14-day free trial
Start a free trial
Tabnine Logo
ArgumentName
Code IndexAdd Tabnine to your IDE (free)

How to use
ArgumentName
in
com.palantir.conjure.spec

Best Java code snippets using com.palantir.conjure.spec.ArgumentName (Showing top 13 results out of 315)

origin: palantir/conjure

private static List<ArgumentDefinition> parseArgs(
    Map<ParameterName, com.palantir.conjure.parser.services.ArgumentDefinition> args,
    HttpPath httpPath,
    ReferenceTypeResolver typeResolver) {
  ImmutableList.Builder<ArgumentDefinition> resultBuilder = ImmutableList.builder();
  for (Map.Entry<com.palantir.conjure.parser.services.ParameterName,
      com.palantir.conjure.parser.services.ArgumentDefinition> entry : args.entrySet()) {
    com.palantir.conjure.parser.services.ArgumentDefinition original = entry.getValue();
    ArgumentName argName = ArgumentName.of(entry.getKey().name());
    ParameterType paramType = parseParameterType(original, argName, httpPath);
    ArgumentDefinition.Builder builder = ArgumentDefinition.builder()
        .argName(argName)
        .type(original.type().visit(new ConjureTypeParserVisitor(typeResolver)))
        .paramType(paramType)
        .docs(original.docs().map(Documentation::of))
        .markers(parseMarkers(original.markers(), typeResolver));
    resultBuilder.add(builder.build());
  }
  return resultBuilder.build();
}
origin: palantir/conjure

  @Override
  public void validate(EndpointDefinition definition) {
    definition.getArgs().forEach(arg -> {
      Matcher matcher = ANCHORED_PATTERN.matcher(arg.getArgName().get());
      Preconditions.checkState(matcher.matches(),
          "Parameter names in endpoint paths and service definitions must match pattern %s: %s",
          ANCHORED_PATTERN,
          arg.getArgName().get());
    });
  }
}
origin: palantir/conjure

@Test
public void testSingleBodyParamValidator() {
  EndpointDefinition.Builder definition = EndpointDefinition.builder()
      .args(BODY_ARG_BUILDER.argName(ArgumentName.of("bodyArg1")).build())
      .args(BODY_ARG_BUILDER.argName(ArgumentName.of("bodyArg2")).build())
      .endpointName(ENDPOINT_NAME)
      .httpMethod(HttpMethod.GET)
      .httpPath(HttpPath.of("/a/path"));
  assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), emptyDealiasingVisitor))
      .isInstanceOf(IllegalStateException.class)
      .hasMessage("Endpoint cannot have multiple body parameters: [bodyArg1, bodyArg2]");
}
origin: palantir/conjure

  @Override
  public void validate(EndpointDefinition definition) {
    Set<ArgumentName> pathParamIds = new HashSet<>();
    definition.getArgs().stream()
        .filter(entry -> entry.getParamType().accept(ParameterTypeVisitor.IS_PATH))
        .forEach(entry -> {
          boolean added = pathParamIds.add(entry.getArgName());
          Preconditions.checkState(added,
              "Path parameter with identifier \"%s\" is defined multiple times for endpoint",
              entry.getArgName().get());
        });
    Set<ArgumentName> pathArgs = HttpPathValidator.pathArgs(definition.getHttpPath().get());
    Set<ArgumentName> extraParams = Sets.difference(pathParamIds, pathArgs);
    Preconditions.checkState(extraParams.isEmpty(),
        "Path parameters defined in endpoint but not present in path template: %s. "
            + "Note that the `param-id` is no longer supported and the path template name is always "
            + "used instead. So make sure the path template name matches the path parameter defined "
            + "in endpoint.", extraParams);
    Set<ArgumentName> missingParams = Sets.difference(pathArgs, pathParamIds);
    Preconditions.checkState(missingParams.isEmpty(),
        "Path parameters defined path template but not present in endpoint: %s", missingParams);
  }
}
origin: palantir/conjure

@Test
public void testNoGetBodyValidator() {
  EndpointDefinition.Builder definition = EndpointDefinition.builder()
      .args(BODY_ARG_BUILDER.argName(ArgumentName.of("bodyArg")).build())
      .endpointName(ENDPOINT_NAME)
      .httpMethod(HttpMethod.GET)
      .httpPath(HttpPath.of("/a/path"));
  assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), emptyDealiasingVisitor))
      .isInstanceOf(IllegalStateException.class)
      .hasMessage(String.format(
          "Endpoint cannot be a GET and contain a body: method: %s, path: %s",
          HttpMethod.GET,
          "/a/path"));
}
origin: palantir/conjure

private static ParameterType parseParameterType(
    com.palantir.conjure.parser.services.ArgumentDefinition argumentDef,
    ArgumentName argName,
    HttpPath httpPath) {
  Set<ArgumentName> args = HttpPathValidator.pathArgs(httpPath.get());
  switch (argumentDef.paramType()) {
    case AUTO:
      // AUTO type
      if (args.contains(argName)) {
        // argument exists in request line -- it is a path arg
        return ParameterType.path(PathParameterType.of());
      } else {
        // argument does not exist in request line -- it is a body arg
        return ParameterType.body(BodyParameterType.of());
      }
    case HEADER:
      String headerParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get());
      return ParameterType.header(HeaderParameterType.of(ParameterId.of(headerParamId)));
    case PATH:
      return ParameterType.path(PathParameterType.of());
    case BODY:
      return ParameterType.body(BodyParameterType.of());
    case QUERY:
      String queryParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get());
      return ParameterType.query(QueryParameterType.of(ParameterId.of(queryParamId)));
    default:
      throw new IllegalArgumentException("Unknown parameter type: " + argumentDef.paramType());
  }
}
origin: palantir/conjure

@Test
public void testArgumentTypeValidator() {
  EndpointDefinition.Builder definition = EndpointDefinition.builder()
      .args(ImmutableList.of(ArgumentDefinition.builder()
          .argName(ArgumentName.of("testArg"))
          .type(Type.primitive(PrimitiveType.BINARY))
          .paramType(ParameterType.header(HeaderParameterType.of(ParameterId.of("testArg"))))
          .build()))
      .endpointName(ENDPOINT_NAME)
      .httpMethod(HttpMethod.GET)
      .httpPath(HttpPath.of("/a/path"));
  assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), emptyDealiasingVisitor))
      .isInstanceOf(IllegalArgumentException.class)
      .hasMessage("Non body parameters cannot be of the 'binary' type: 'testArg' is not allowed");
}
origin: palantir/conjure

@Test
public void testPathParamValidatorUniquePathParams() {
  ArgumentDefinition paramDefinition1 = ArgumentDefinition.builder()
      .argName(ArgumentName.of("paramName"))
      .type(Type.primitive(PrimitiveType.STRING))
      .paramType(ParameterType.path(PathParameterType.of()))
      .build();
  ArgumentDefinition paramDefinition2 = ArgumentDefinition.builder()
      .argName(ArgumentName.of("paramName"))
      .type(Type.primitive(PrimitiveType.STRING))
      .paramType(ParameterType.path(PathParameterType.of()))
      .build();
  EndpointDefinition.Builder definition = EndpointDefinition.builder()
      .args(ImmutableList.of(paramDefinition1, paramDefinition2))
      .endpointName(ENDPOINT_NAME)
      .httpMethod(HttpMethod.GET)
      .httpPath(HttpPath.of("/a/path"));
  assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), emptyDealiasingVisitor))
      .isInstanceOf(IllegalStateException.class)
      .hasMessage("Path parameter with identifier \"paramName\" is defined multiple times for endpoint");
}
origin: palantir/conjure

  @Test
  public void testComplexHeaderObject() {
    TypeName typeName = TypeName.of("SomeObject", "com.palantir.foo");
    EndpointDefinition.Builder definition = EndpointDefinition.builder()
        .args(ArgumentDefinition.builder()
            .argName(ArgumentName.of("someName"))
            .type(Type.reference(typeName))
            .paramType(ParameterType.header(HeaderParameterType.of(ParameterId.of("SomeId"))))
            .build())
        .endpointName(ENDPOINT_NAME)
        .httpMethod(HttpMethod.GET)
        .httpPath(HttpPath.of("/a/path"));

    DealiasingTypeVisitor dealiasingVisitor = new DealiasingTypeVisitor(ImmutableMap.of(
        typeName, TypeDefinition.object(ObjectDefinition.of(typeName, ImmutableList.of(), Documentation.of("")))
    ));

    assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), dealiasingVisitor))
        .isInstanceOf(IllegalStateException.class)
        .hasMessage("Header parameters must be enums, primitives, aliases or optional primitive:"
            + " \"someName\" is not allowed");
  }
}
origin: palantir/conjure

  private EndpointDefinition.Builder createEndpoint(String paramName) {
    ArgumentDefinition arg = ArgumentDefinition.builder()
        .paramType(ParameterType.body(BodyParameterType.of()))
        .type(Type.primitive(PrimitiveType.STRING))
        .argName(ArgumentName.of(paramName))
        .build();
    return EndpointDefinition.builder()
        .httpMethod(HttpMethod.POST)
        .httpPath(HttpPath.of("/a/path"))
        .args(ImmutableList.of(arg))
        .endpointName(EndpointName.of("test"));
  }
}
origin: palantir/conjure

@Test
public void testComplexHeader() {
  EndpointDefinition.Builder definition = EndpointDefinition.builder()
      .args(ArgumentDefinition.builder()
          .argName(ArgumentName.of("someName"))
          .type(Type.list(ListType.builder().itemType(Type.primitive(PrimitiveType.STRING)).build()))
          .paramType(ParameterType.header(HeaderParameterType.of(ParameterId.of("someId"))))
          .build())
      .endpointName(ENDPOINT_NAME)
      .httpMethod(HttpMethod.GET)
      .httpPath(HttpPath.of("/a/path"));
  assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), emptyDealiasingVisitor))
      .isInstanceOf(IllegalStateException.class)
      .hasMessage("Header parameters must be enums, primitives, aliases or optional primitive:"
          + " \"someName\" is not allowed");
}
origin: palantir/conjure

@Test
public void testPathParamValidatorExtraParams() {
  ArgumentDefinition paramDefinition = ArgumentDefinition.builder()
      .type(Type.primitive(PrimitiveType.STRING))
      .argName(ArgumentName.of("paramName"))
      .paramType(ParameterType.path(PathParameterType.of()))
      .build();
  EndpointDefinition.Builder definition = EndpointDefinition.builder()
      .args(paramDefinition)
      .endpointName(ENDPOINT_NAME)
      .httpMethod(HttpMethod.GET)
      .httpPath(HttpPath.of("/a/path"));
  assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), emptyDealiasingVisitor))
      .isInstanceOf(IllegalStateException.class)
      .hasMessageContaining(
          "Path parameters defined in endpoint but not present in path template: [paramName]");
}
origin: palantir/conjure

@Test
@SuppressWarnings("CheckReturnValue")
public void testArgumentBodyTypeValidator() {
  EndpointDefinition.Builder definition = EndpointDefinition.builder()
      .args(ImmutableList.of(ArgumentDefinition.builder()
          .argName(ArgumentName.of("testArg"))
          .type(Type.primitive(PrimitiveType.BINARY))
          .paramType(ParameterType.body(BodyParameterType.of()))
          .build()))
      .endpointName(ENDPOINT_NAME)
      .httpMethod(HttpMethod.POST)
      .httpPath(HttpPath.of("/a/path"));
  // Should not throw exception
  EndpointDefinitionValidator.validateAll(definition.build(), emptyDealiasingVisitor);
}
com.palantir.conjure.specArgumentName

Most used methods

  • of
  • get

Popular in Java

  • Reading from database using SQL prepared statement
  • onCreateOptionsMenu (Activity)
  • getOriginalFilename (MultipartFile)
    Return the original filename in the client's filesystem.This may contain path information depending
  • getSharedPreferences (Context)
  • FileOutputStream (java.io)
    An output stream that writes bytes to a file. If the output file exists, it can be replaced or appen
  • PrintWriter (java.io)
    Wraps either an existing OutputStream or an existing Writerand provides convenience methods for prin
  • MessageDigest (java.security)
    Uses a one-way hash function to turn an arbitrary number of bytes into a fixed-length byte sequence.
  • ResourceBundle (java.util)
    ResourceBundle is an abstract class which is the superclass of classes which provide Locale-specifi
  • HttpServletRequest (javax.servlet.http)
    Extends the javax.servlet.ServletRequest interface to provide request information for HTTP servlets.
  • LoggerFactory (org.slf4j)
    The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for lo
  • Top 17 Plugins for Android Studio
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyStudentsTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now