io.swagger.models.parameters.HeaderParameter Java Examples

protected Parameter createParameter(HttpParameterType httpParameterType) {
  switch (httpParameterType) {
    case PATH:
      return new PathParameter();
    case QUERY:
      return new QueryParameter();
    case HEADER:
      return new HeaderParameter();
    case FORM:
      return new FormParameter();
    case COOKIE:
      return new CookieParameter();
    case BODY:
      return new BodyParameter();
    default:
      throw new IllegalStateException("not support httpParameterType " + httpParameterType);
  }
}
 

@Test
public void createCommonParameters() throws Exception {
    reader = new JaxrsReader(new Swagger(), Mockito.mock(Log.class));
    Swagger result = reader.read(CommonParametersApi.class);
    Parameter headerParam = result.getParameter("headerParam");
    assertTrue(headerParam instanceof HeaderParameter);
    Parameter queryParam = result.getParameter("queryParam");
    assertTrue(queryParam instanceof QueryParameter);

    result = reader.read(ReferenceCommonParametersApi.class);
    Operation get = result.getPath("/apath").getGet();
    List<Parameter> parameters = get.getParameters();
    for (Parameter parameter : parameters) {
        assertTrue(parameter instanceof RefParameter);
    }

    ObjectMapper mapper = Json.mapper();
    ObjectWriter jsonWriter = mapper.writer(new DefaultPrettyPrinter());
    String json = jsonWriter.writeValueAsString(result);
    JsonNode expectJson = mapper.readTree(this.getClass().getResourceAsStream("/expectedOutput/swagger-common-parameters.json"));
    JsonAssert.assertJsonEquals(expectJson, json);
}
 

private io.swagger.models.parameters.Parameter createOasHeader(com.github.jrcodeza.schema.v2.generator.model.Header header) {
	io.swagger.models.parameters.HeaderParameter parameter = new io.swagger.models.parameters.HeaderParameter();
	parameter.setType("string");
	parameter.setIn("header");
	parameter.setName(header.getName());
	parameter.setDescription(header.getDescription());
	parameter.setRequired(header.isRequired());
	return parameter;
}
 

@Override
public Condition processParameter(Parameter parameter) {
    if (parameter instanceof HeaderParameter) {
        ConditionPredicate predicate = new DefaultParameterConditionPredicate(true, parameter.getName(), parameter.getIn());
        return new SinglePredicateCondition(
                String.format("header «%s» is empty", parameter.getName()),
                "",
                predicate
        );
    }

    return null;
}
 

@BeforeClass
public static void beforeClass() {
  Parameter hp = new HeaderParameter();
  hp.setName("header");
  RestParam restParam = new RestParam(hp, int.class);

  restOperation = Mockito.mock(RestOperationMeta.class);
  //        clientRequest = Mockito.mock(RestClientRequest.class);
  paramList = new ArrayList<>();


  paramList.add(restParam);
  when(restOperation.getParamList()).thenReturn(paramList);
  when(restOperation.getParamByName("test")).thenReturn(restParam);
}
 

private HeaderProcessor createProcessor(String name, Type type, String defaultValue, boolean required) {
  JavaType javaType = TypeFactory.defaultInstance().constructType(type);

  HeaderParameter headerParameter = new HeaderParameter();
  headerParameter.name(name)
      .required(required)
      .setDefaultValue(defaultValue);

  if (javaType.isContainerType()) {
    headerParameter.type(ArrayProperty.TYPE);
  }
  return new HeaderProcessor(headerParameter, javaType);
}
 

@Test
public void testCreate() {
  ParamValueProcessorCreator creator =
      ParamValueProcessorCreatorManager.INSTANCE.findValue(HeaderProcessorCreator.PARAMTYPE);
  HeaderParameter hp = new HeaderParameter();
  hp.setName("h1");

  ParamValueProcessor processor = creator.create(hp, String.class);

  Assert.assertEquals(HeaderProcessor.class, processor.getClass());
}
 

@Override
public Object extract(String name, Parameter parameter, RoutingContext context) {
    HeaderParameter headerParam = (HeaderParameter) parameter;
    if ("array".equals(headerParam.getType())) {
        return context.request().headers().getAll(name);
    }
    return this.extract(name, parameter, context.request().headers());
}
 

private Parameter createParam(String paramType) {
    if ("path".equals(paramType))
        return new PathParameter();
    else if ("query".equals(paramType))
        return new QueryParameter();
    else if ("form".equals(paramType))
        return new FormParameter();
    else if ("formData".equals(paramType))
        return new FormParameter();
    else if ("header".equals(paramType))
        return new HeaderParameter();
    else if ("body".equals(paramType))
        return new BodyParameter();
    return null;
}
 

private io.swagger.models.parameters.Parameter createParam(ParameterType paramType) {
    if (paramType == ParameterType.Path)
        return new PathParameter();
    else if (paramType == ParameterType.Query)
        return new QueryParameter();
    else if (paramType == ParameterType.Form)
        return new FormParameter();
    else if (paramType == ParameterType.Header)
        return new HeaderParameter();
    else if (paramType == ParameterType.Body)
        return new BodyParameter();
    return null;
}
 

public HeaderProcessor(HeaderParameter headerParameter, JavaType targetType) {
  super(headerParameter.getName(), targetType, headerParameter.getDefaultValue(), headerParameter.getRequired());

  this.repeatedType = ArrayProperty.isType(headerParameter.getType());
}
 

@Override
public ParamValueProcessor create(Parameter parameter, Type genericParamType) {
  JavaType targetType =
      genericParamType == null ? null : TypeFactory.defaultInstance().constructType(genericParamType);
  return new HeaderProcessor((HeaderParameter) parameter, targetType);
}