com.google.api.server.spi.config.AnnotationBoolean Java Examples

@Test
public void testValidateMethods_ignoredMethod() throws Exception {
  final class Bean {

  }
  @Api
  final class Endpoint {
    @ApiMethod(ignored = AnnotationBoolean.TRUE)
    public void thisShouldBeIgnored(Bean resource1, Bean resource2) {
    }
  }
  ApiConfig config = configLoader.loadConfiguration(ServiceContext.create(), Endpoint.class);
  // If this passes validation, then no error will be thrown. Otherwise, the validator will
  // complain that the method has two resources.
  validator.validate(config);
}
 

private void readApiClass(ApiClassAnnotationConfig config, Annotation apiClass)
    throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
  config.setResourceIfNotEmpty((String) getAnnotationProperty(apiClass, "resource"));
  config.setAuthLevelIfSpecified((AuthLevel) getAnnotationProperty(apiClass, "authLevel"));
  config.setScopesIfSpecified((String[]) getAnnotationProperty(apiClass, "scopes"));
  config.setAudiencesIfSpecified((String[]) getAnnotationProperty(apiClass, "audiences"));
  config.setIssuerAudiencesIfSpecified(getIssuerAudiences(apiClass));
  config.setClientIdsIfSpecified((String[]) getAnnotationProperty(apiClass, "clientIds"));
  config.setAuthenticatorsIfSpecified(
      this.<Class<? extends Authenticator>[]>getAnnotationProperty(apiClass, "authenticators"));
  config.setPeerAuthenticatorsIfSpecified(this.<
      Class<? extends PeerAuthenticator>[]>getAnnotationProperty(apiClass, "peerAuthenticators"));
  config.setUseDatastoreIfSpecified(
      (AnnotationBoolean) getAnnotationProperty(apiClass, "useDatastoreForAdditionalConfig"));
  config.setApiKeyRequiredIfSpecified(
      (AnnotationBoolean) this.getAnnotationProperty(apiClass, "apiKeyRequired"));
}
 

private void readApiMethodInstance(ApiMethodAnnotationConfig config, Annotation apiMethod)
    throws IllegalArgumentException, SecurityException, IllegalAccessException,
        InvocationTargetException, NoSuchMethodException {
  config.setNameIfNotEmpty((String) getAnnotationProperty(apiMethod, "name"));
  config.setDescriptionIfNotEmpty((String) getAnnotationProperty(apiMethod, "description"));
  config.setPathIfNotEmpty((String) getAnnotationProperty(apiMethod, "path"));
  config.setHttpMethodIfNotEmpty((String) getAnnotationProperty(apiMethod, "httpMethod"));
  config.setAuthLevelIfSpecified((AuthLevel) getAnnotationProperty(apiMethod, "authLevel"));
  config.setScopesIfSpecified((String[]) getAnnotationProperty(apiMethod, "scopes"));
  config.setAudiencesIfSpecified((String[]) getAnnotationProperty(apiMethod, "audiences"));
  config.setIssuerAudiencesIfSpecified(getIssuerAudiences(apiMethod));
  config.setClientIdsIfSpecified((String[]) getAnnotationProperty(apiMethod, "clientIds"));
  config.setAuthenticatorsIfSpecified(
      this.<Class<? extends Authenticator>[]>getAnnotationProperty(apiMethod, "authenticators"));
  config.setPeerAuthenticatorsIfSpecified(this.<
      Class<? extends PeerAuthenticator>[]>getAnnotationProperty(apiMethod,
      "peerAuthenticators"));
  config.setIgnoredIfSpecified((AnnotationBoolean) getAnnotationProperty(apiMethod, "ignored"));
  config.setApiKeyRequiredIfSpecified(
      (AnnotationBoolean) this.getAnnotationProperty(apiMethod, "apiKeyRequired"));
  config.setMetricCosts(
      (ApiMetricCost[]) getAnnotationProperty(apiMethod, "metricCosts"));
}
 

@Test
public void testLevelOverridingWithDefaultOverrides() throws Exception {
  @Api(
      scopes = {"s0c", "s1c"},
      audiences = {"a0c", "a1c"},
      clientIds = {"c0c", "c1c"},
      resource = "resource2",
      useDatastoreForAdditionalConfig = AnnotationBoolean.TRUE
  )
  final class Test extends SimpleLevelOverridingInheritedApi {
  }

  ApiConfig config = createConfig(Test.class);
  annotationReader.loadEndpointClass(serviceContext, Test.class, config);
  annotationReader.loadEndpointMethods(serviceContext, Test.class,
      config.getApiClassConfig().getMethods());

  // All values overridden at a lower level, so nothing should change.
  verifySimpleLevelOverriding(config);
}
 

@Test
public void testSetIsDiscoverableIfSpecified_unspecified() {
  annotationConfig.setIsDiscoverableIfSpecified(AnnotationBoolean.UNSPECIFIED);
  testDefaults();

  annotationConfig.setIsDiscoverableIfSpecified(AnnotationBoolean.FALSE);
  annotationConfig.setIsDiscoverableIfSpecified(AnnotationBoolean.UNSPECIFIED);
  assertEquals(false, config.getIsDiscoverable());
}
 

@Test
public void testSetAllowCookieAuthIfSpecified_unspecified() {
  annotationConfig.setAllowCookieAuthIfSpecified(AnnotationBoolean.UNSPECIFIED);
  testDefaultConfig();

  annotationConfig.setAllowCookieAuthIfSpecified(AnnotationBoolean.TRUE);
  annotationConfig.setAllowCookieAuthIfSpecified(AnnotationBoolean.UNSPECIFIED);
  assertEquals(true, config.getAllowCookieAuth());
}
 

@Test
public void testAbstract() throws Exception {
  @Api(isAbstract = AnnotationBoolean.TRUE)
  class Test {}

  ApiConfig config = createConfig(Test.class);
  annotationReader.loadEndpointClass(serviceContext, Test.class, config);
  assertTrue(config.getIsAbstract());
}
 

@Test
public void testLevelOverridingWithClassOverrides() throws Exception {
  @ApiClass(
      scopes = {"s0c", "s1c"},
      audiences = {"a0c", "a1c"},
      clientIds = {"c0c", "c1c"},
      resource = "resource2",
      useDatastoreForAdditionalConfig = AnnotationBoolean.TRUE
  )
  final class Test extends SimpleLevelOverridingInheritedApi {
  }

  ApiConfig config = createConfig(Test.class);
  annotationReader.loadEndpointClass(serviceContext, Test.class, config);
  assertEquals("resource2", config.getApiClassConfig().getResource());
  assertTrue(config.getApiClassConfig().getUseDatastore());

  annotationReader.loadEndpointMethods(serviceContext, Test.class,
      config.getApiClassConfig().getMethods());

  ApiMethodConfig noOverrides =
      config.getApiClassConfig().getMethods().get(methodToEndpointMethod(
          SimpleLevelOverridingApi.class.getMethod("noOverrides")));
  assertEquals(toScopeExpression("s0c", "s1c"), noOverrides.getScopeExpression());
  assertEquals(Lists.newArrayList("a0c", "a1c"), noOverrides.getAudiences());
  assertEquals(Lists.newArrayList("c0c", "c1c"), noOverrides.getClientIds());

  ApiMethodConfig overrides =
      config.getApiClassConfig().getMethods().get(methodToEndpointMethod(
          SimpleLevelOverridingApi.class.getMethod("overrides")));
  assertEquals(toScopeExpression("s0b", "s1b"), overrides.getScopeExpression());
  assertEquals(Lists.newArrayList("a0b", "a1b"), overrides.getAudiences());
  assertEquals(Lists.newArrayList("c0b", "c1b"), overrides.getClientIds());
}
 

@Test
public void testSetUseDatastoreIfSpecified() throws Exception {
  annotationConfig.setUseDatastoreIfSpecified(AnnotationBoolean.TRUE);
  Mockito.verify(config).setUseDatastore(true);

  annotationConfig.setUseDatastoreIfSpecified(AnnotationBoolean.FALSE);
  Mockito.verify(config).setUseDatastore(false);

  Mockito.verifyNoMoreInteractions(config);
}
 

@Test
public void testSetIsAbstractIfSpecified_unspecified() {
  annotationConfig.setIsAbstractIfSpecified(AnnotationBoolean.UNSPECIFIED);
  testDefaults();

  annotationConfig.setIsAbstractIfSpecified(AnnotationBoolean.TRUE);
  annotationConfig.setIsAbstractIfSpecified(AnnotationBoolean.UNSPECIFIED);
  assertEquals(true, config.getIsAbstract());
}
 

@Test
public void testSetIsDefaultVersionIfSpecified_unspecified() {
  annotationConfig.setIsDefaultVersionIfSpecified(AnnotationBoolean.UNSPECIFIED);
  testDefaults();

  annotationConfig.setIsDefaultVersionIfSpecified(AnnotationBoolean.TRUE);
  annotationConfig.setIsDefaultVersionIfSpecified(AnnotationBoolean.UNSPECIFIED);
  assertEquals(true, config.getIsDefaultVersion());
}
 

private void readApi(ApiAnnotationConfig config, Annotation api)
    throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  config.setIsAbstractIfSpecified((AnnotationBoolean) getAnnotationProperty(api, "isAbstract"));
  config.setRootIfNotEmpty((String) getAnnotationProperty(api, "root"));

  config.setNameIfNotEmpty((String) getAnnotationProperty(api, "name"));
  config.setCanonicalNameIfNotEmpty((String) getAnnotationProperty(api, "canonicalName"));

  config.setVersionIfNotEmpty((String) getAnnotationProperty(api, "version"));
  config.setTitleIfNotEmpty((String) getAnnotationProperty(api, "title"));
  config.setDescriptionIfNotEmpty((String) getAnnotationProperty(api, "description"));
  config.setDocumentationLinkIfNotEmpty((String) getAnnotationProperty(api, "documentationLink"));
  config.setIsDefaultVersionIfSpecified(
      (AnnotationBoolean) getAnnotationProperty(api, "defaultVersion"));
  config.setIsDiscoverableIfSpecified(
      (AnnotationBoolean) getAnnotationProperty(api, "discoverable"));
  config.setUseDatastoreIfSpecified(
      (AnnotationBoolean) getAnnotationProperty(api, "useDatastoreForAdditionalConfig"));

  config.setBackendRootIfNotEmpty((String) getAnnotationProperty(api, "backendRoot"));

  config.setResourceIfNotEmpty((String) getAnnotationProperty(api, "resource"));
  config.setAuthLevelIfSpecified((AuthLevel) getAnnotationProperty(api, "authLevel"));
  config.setScopesIfSpecified((String[]) getAnnotationProperty(api, "scopes"));
  config.setAudiencesIfSpecified((String[]) getAnnotationProperty(api, "audiences"));
  config.setIssuersIfSpecified(getIssuerConfigs(api));
  config.setIssuerAudiencesIfSpecified(getIssuerAudiences(api));
  config.setClientIdsIfSpecified((String[]) getAnnotationProperty(api, "clientIds"));
  config.setAuthenticatorsIfSpecified(
      this.<Class<? extends Authenticator>[]>getAnnotationProperty(api, "authenticators"));
  config.setPeerAuthenticatorsIfSpecified(this
      .<Class<? extends PeerAuthenticator>[]>getAnnotationProperty(api, "peerAuthenticators"));
  config.setApiKeyRequiredIfSpecified(
      (AnnotationBoolean) this.getAnnotationProperty(api, "apiKeyRequired"));
  config.setApiLimitMetrics(
      (ApiLimitMetric[]) this.getAnnotationProperty(api, "limitDefinitions"));
}
 

/**
 * Tests that ignored methods aren't written to config.
 */
@Test
public void ignoredMethod() throws Exception {
  final class Endpoint {
    @ApiMethod(ignored = AnnotationBoolean.TRUE)
    public void thisShouldBeIgnored() {
    }
  }

  new ApiConfigAnnotationReader().loadEndpointMethods(
      serviceContext, Endpoint.class, apiConfig.getApiClassConfig().getMethods());
  for (String config : writer.writeConfig(Collections.singleton(apiConfig)).values()) {
    assertThat(config).doesNotContain("thisShouldBeIgnored");
  }
}
 

@Test
public void testAbstract() throws Exception {
  @Api(isAbstract = AnnotationBoolean.TRUE)
  class Test {}

  String apiConfigSource = g.generateConfig(Test.class).get("myapi-v1.api");
  ObjectNode root = objectMapper.readValue(apiConfigSource, ObjectNode.class);
  assertTrue(root.get("abstract").asBoolean());
}
 

/**
 * Returns an Objectify Query object for the specified filters.
 *
 * @return an Objectify Query.
 */
@ApiResourceProperty(ignored = AnnotationBoolean.TRUE)
public Query<Conference> getQuery() {
    // First check the feasibility of inequality filters.
    checkFilters();
    Query<Conference> query = ofy().load().type(Conference.class);
    if (inequalityFilter == null) {
        // Order by name.
        query = query.order("name");
    } else {
        // If we have any inequality filters, order by the field first.
        query = query.order(inequalityFilter.field.getFieldName());
        query = query.order("name");
    }
    for (Filter filter : this.filters) {
        // Applies filters in order.
        if (filter.field.fieldType == FieldType.STRING) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), filter.value);
        } else if (filter.field.fieldType == FieldType.INTEGER) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), Integer.parseInt(filter.value));
        }
    }
    LOG.info(query.toString());
    return query;
}
 

/**
 * Returns an Objectify Query object for the specified filters.
 *
 * @return an Objectify Query.
 */
@ApiResourceProperty(ignored = AnnotationBoolean.TRUE)
public Query<Conference> getQuery() {
    // First check the feasibility of inequality filters.
    checkFilters();
    Query<Conference> query = ofy().load().type(Conference.class);
    if (inequalityFilter == null) {
        // Order by name.
        query = query.order("name");
    } else {
        // If we have any inequality filters, order by the field first.
        query = query.order(inequalityFilter.field.getFieldName());
        query = query.order("name");
    }
    for (Filter filter : this.filters) {
        // Applies filters in order.
        if (filter.field.fieldType == FieldType.STRING) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), filter.value);
        } else if (filter.field.fieldType == FieldType.INTEGER) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), Integer.parseInt(filter.value));
        }
    }
    LOG.info(query.toString());
    return query;
}
 

/**
 * Returns an Objectify Query object for the specified filters.
 *
 * @return an Objectify Query.
 */
@ApiResourceProperty(ignored = AnnotationBoolean.TRUE)
public Query<Conference> getQuery() {
    // First check the feasibility of inequality filters.
    checkFilters();
    Query<Conference> query = ofy().load().type(Conference.class);
    if (inequalityFilter == null) {
        // Order by name.
        query = query.order("name");
    } else {
        // If we have any inequality filters, order by the field first.
        query = query.order(inequalityFilter.field.getFieldName());
        query = query.order("name");
    }
    for (Filter filter : this.filters) {
        // Applies filters in order.
        if (filter.field.fieldType == FieldType.STRING) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), filter.value);
        } else if (filter.field.fieldType == FieldType.INTEGER) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), Integer.parseInt(filter.value));
        }
    }
    LOG.info(query.toString());
    return query;
}
 

/**
 * Returns an Objectify Query object for the specified filters.
 *
 * @return an Objectify Query.
 */
@ApiResourceProperty(ignored = AnnotationBoolean.TRUE)
public Query<Conference> getQuery() {
    // First check the feasibility of inequality filters.
    checkFilters();
    Query<Conference> query = ofy().load().type(Conference.class);
    if (inequalityFilter == null) {
        // Order by name.
        query = query.order("name");
    } else {
        // If we have any inequality filters, order by the field first.
        query = query.order(inequalityFilter.field.getFieldName());
        query = query.order("name");
    }
    for (Filter filter : this.filters) {
        // Applies filters in order.
        if (filter.field.fieldType == FieldType.STRING) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), filter.value);
        } else if (filter.field.fieldType == FieldType.INTEGER) {
            query = query.filter(String.format("%s %s", filter.field.getFieldName(),
                    filter.operator.getQueryOperator()), Integer.parseInt(filter.value));
        }
    }
    LOG.info(query.toString());
    return query;
}
 

@ApiMethod(ignored = AnnotationBoolean.TRUE)
public synchronized void initialize(DiscoveryProvider discoveryProvider) {
  if (!initialized) {
    this.discoveryProvider = discoveryProvider;
    initialized = true;
  }
}
 

@Override
public PropertyName findNameForSerialization(Annotated a) {
  ApiResourceProperty apiName = a.getAnnotation(ApiResourceProperty.class);
  if (apiName != null && apiName.ignored() != AnnotationBoolean.TRUE) {
    return PropertyName.construct(apiName.name());
  }
  return null;
}
 

/**
 * Converts the auth config from the auth annotation. Subclasses may override
 * to add additional information to the auth config.
 */
protected void readApiAuth(ApiAuthAnnotationConfig config, Annotation auth)
    throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
  config.setAllowCookieAuthIfSpecified(
      (AnnotationBoolean) getAnnotationProperty(auth, "allowCookieAuth"));
  config.setBlockedRegionsIfNotEmpty((String[]) getAnnotationProperty(auth, "blockedRegions"));
}
 

public void setIsAbstractIfSpecified(AnnotationBoolean isAbstract) {
  if (isAbstract == AnnotationBoolean.TRUE) {
    config.setIsAbstract(true);
  } else if (isAbstract == AnnotationBoolean.FALSE) {
    config.setIsAbstract(false);
  }
}
 

public void setIsDefaultVersionIfSpecified(AnnotationBoolean defaultVersion) {
  if (defaultVersion == AnnotationBoolean.TRUE) {
    config.setIsDefaultVersion(true);
  } else if (defaultVersion == AnnotationBoolean.FALSE) {
    config.setIsDefaultVersion(false);
  }
}
 

public void setIsDiscoverableIfSpecified(AnnotationBoolean discoverable) {
  if (discoverable == AnnotationBoolean.TRUE) {
    config.setIsDiscoverable(true);
  } else if (discoverable == AnnotationBoolean.FALSE) {
    config.setIsDiscoverable(false);
  }
}
 

public void setUseDatastoreIfSpecified(AnnotationBoolean useDatastore) {
  if (useDatastore == AnnotationBoolean.TRUE) {
    config.setUseDatastore(true);
  } else if (useDatastore == AnnotationBoolean.FALSE) {
    config.setUseDatastore(false);
  }
}
 

public void setApiKeyRequiredIfSpecified(AnnotationBoolean apiKeyRequired) {
  if (apiKeyRequired == AnnotationBoolean.TRUE) {
    config.setApiKeyRequired(true);
  } else if (apiKeyRequired == AnnotationBoolean.FALSE) {
    config.setApiKeyRequired(false);
  }
}
 

public void setAllowCookieAuthIfSpecified(AnnotationBoolean allowCookieAuth) {
  if (allowCookieAuth == AnnotationBoolean.TRUE) {
    config.setAllowCookieAuth(true);
  } else if (allowCookieAuth == AnnotationBoolean.FALSE) {
    config.setAllowCookieAuth(false);
  }
}
 

public void setUseDatastoreIfSpecified(AnnotationBoolean useDatastore) {
  if (useDatastore == AnnotationBoolean.TRUE) {
    config.setUseDatastore(true);
  } else if (useDatastore == AnnotationBoolean.FALSE) {
    config.setUseDatastore(false);
  }
}
 

public void setApiKeyRequiredIfSpecified(AnnotationBoolean apiKeyRequired) {
  if (apiKeyRequired == AnnotationBoolean.TRUE) {
    config.setApiKeyRequired(true);
  } else if (apiKeyRequired == AnnotationBoolean.FALSE) {
    config.setApiKeyRequired(false);
  }
}
 

public void setIgnoredIfSpecified(AnnotationBoolean ignored) {
  if (ignored == AnnotationBoolean.TRUE) {
    config.setIgnored(true);
  } else if (ignored == AnnotationBoolean.FALSE) {
    config.setIgnored(false);
  }
}