public String componentParameterJsonSchema(String componentName) throws Exception {
   // favor using pre generated schema if component has that
   String json = context.getComponentParameterJsonSchema(componentName);
   if (json == null) {
     // okay this requires having the component on the classpath and being instantiated
     Component component = context.getComponent(componentName);
     if (component != null) {
       ComponentConfiguration configuration = component.createComponentConfiguration();
       json = configuration.createParameterJsonSchema();
     }
   }
   return json;
 }
  @Test
  public void testComponentConfiguration() throws Exception {
    TimerComponent comp = context.getComponent("timer", TimerComponent.class);
    EndpointConfiguration conf = comp.createConfiguration("timer:foo?period=2000");

    assertEquals("2000", conf.getParameter("period"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);

    assertTrue(json.contains("\"timerName\": { \"type\": \"java.lang.String\" }"));
    assertTrue(json.contains("\"delay\": { \"type\": \"long\" }"));
  }
  @Test
  public void testComponentConfiguration() throws Exception {
    TestComponent comp = context.getComponent("test", TestComponent.class);
    EndpointConfiguration conf = comp.createConfiguration("test:my:foo?timeout=1000");

    assertEquals("1000", conf.getParameter("timeout"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);

    assertTrue(json.contains("\"retainFirst\": { \"type\": \"int\" }"));
    assertTrue(json.contains("\"timeout\": { \"type\": \"long\" }"));
  }
  @Test
  public void testComponentConfiguration() throws Exception {
    DirectComponent comp = context.getComponent("direct", DirectComponent.class);
    EndpointConfiguration conf = comp.createConfiguration("direct:foo?block=true");

    assertEquals("true", conf.getParameter("block"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);

    assertTrue(json.contains("\"timeout\": { \"type\": \"long\" }"));
    assertTrue(json.contains("\"block\": { \"type\": \"boolean\" }"));
  }
  @Test
  public void testComponentConfiguration() throws Exception {
    SqlComponent comp = context.getComponent("sql", SqlComponent.class);
    EndpointConfiguration conf =
        comp.createConfiguration(
            "sql:select?dataSourceRef=jdbc/myDataSource&allowNamedParameters=true&consumer.delay=5000");

    assertEquals("jdbc/myDataSource", conf.getParameter("dataSourceRef"));
    assertEquals("true", conf.getParameter("allowNamedParameters"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);
  }
 public List<String> completeEndpointPath(
     String componentName, Map<String, Object> endpointParameters, String completionText)
     throws Exception {
   if (completionText == null) {
     completionText = "";
   }
   Component component = context.getComponent(componentName, false);
   if (component != null) {
     ComponentConfiguration configuration = component.createComponentConfiguration();
     configuration.setParameters(endpointParameters);
     return configuration.completeEndpointPath(completionText);
   } else {
     return new ArrayList<String>();
   }
 }
  @Test
  public void testComponentConfiguration() throws Exception {
    NettyHttpComponent comp = context.getComponent("netty4-http", NettyHttpComponent.class);
    EndpointConfiguration conf =
        comp.createConfiguration(
            "netty4-http:tcp://localhost:5150?sync=true"
                + "&httpMethodRestrict=POST&traceEnabled=true");

    assertEquals("true", conf.getParameter("traceEnabled"));
    assertEquals("POST", conf.getParameter("httpMethodRestrict"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);
  }
  @Test
  public void testComponentConfiguration() throws Exception {
    NettyComponent comp = context.getComponent("netty4", NettyComponent.class);
    EndpointConfiguration conf =
        comp.createConfiguration(
            "netty4:tcp://localhost:5150?sync=true"
                + "&maximumPoolSize=32&ssl=true&passphrase=#password");

    assertEquals("true", conf.getParameter("sync"));
    assertEquals("32", conf.getParameter("maximumPoolSize"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);

    assertTrue(json.contains("\"producerPoolMinEvictableIdle\": { \"type\": \"integer\" }"));
    assertTrue(json.contains("\"allowDefaultCodec\": { \"type\": \"boolean\" }"));
  }
  @Test
  public void testComponentConfiguration() throws Exception {
    DataSetComponent comp = context.getComponent("dataset", DataSetComponent.class);
    EndpointConfiguration conf =
        comp.createConfiguration(
            "dataset:foo?minRate=3&produceDelay=33&consumeDelay=333&preloadSize=3333&initialDelay=33333&disableDataSetIndex=true");

    assertEquals(
        "Unexpected endpoint configuration value for minRate", "3", conf.getParameter("minRate"));
    assertEquals(
        "Unexpected endpoint configuration value for produceDelay",
        "33",
        conf.getParameter("produceDelay"));
    assertEquals(
        "Unexpected endpoint configuration value for consumeDelay",
        "333",
        conf.getParameter("consumeDelay"));
    assertEquals(
        "Unexpected endpoint configuration value for preloadSize",
        "3333",
        conf.getParameter("preloadSize"));
    assertEquals(
        "Unexpected endpoint configuration value for initialDelay",
        "33333",
        conf.getParameter("initialDelay"));
    assertEquals(
        "Unexpected endpoint configuration value for disableDataSetIndex",
        "true",
        conf.getParameter("disableDataSetIndex"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);

    assertTrue(
        json.contains(
            "\"name\": { \"kind\": \"path\", \"group\": \"common\", \"required\": \"true\", \"type\""));
    assertTrue(
        json.contains(
            "\"kind\": \"parameter\", \"group\": \"consumer\", \"label\": \"consumer\", \"type\": \"integer\""));
    assertTrue(
        json.contains(
            "\"retainFirst\": { \"kind\": \"parameter\", \"group\": \"producer\", \"label\": \"producer\", \"type\": \"integer"));
  }
 public static void assertParameterConfig(
     ComponentConfiguration configuration, String name, Class<?> parameterType) {
   ParameterConfiguration config = configuration.getParameterConfiguration(name);
   assertNotNull("ParameterConfiguration should exist for parameter name " + name, config);
   assertEquals("ParameterConfiguration." + name + ".getName()", name, config.getName());
   assertEquals(
       "ParameterConfiguration." + name + ".getParameterType()",
       parameterType,
       config.getParameterType());
 }
  @Test
  public void testComponentConfiguration() throws Exception {
    DataSetComponent comp = context.getComponent("dataset", DataSetComponent.class);
    EndpointConfiguration conf = comp.createConfiguration("dataset:foo?minRate=3");

    assertEquals("3", conf.getParameter("minRate"));

    ComponentConfiguration compConf = comp.createComponentConfiguration();
    String json = compConf.createParameterJsonSchema();
    assertNotNull(json);

    assertTrue(json.contains("\"preloadSize\": { \"kind\": \"parameter\", \"type\": \"integer\""));
    assertTrue(json.contains("\"minRate\": { \"kind\": \"parameter\", \"type\": \"integer\""));
    assertTrue(
        json.contains(
            "\"exchangePattern\": { \"kind\": \"parameter\", \"label\": \"advanced\", \"type\": \"string\", \"javaType\": \"org.apache.camel.ExchangePattern\""
                + ", \"enum\": [ \"InOnly\", \"RobustInOnly\", \"InOut\", \"InOptionalOut\", \"OutOnly\", \"RobustOutOnly\", \"OutIn\", \"OutOptionalIn\" ]"));
    assertTrue(json.contains("\"InOut\""));
  }
  @Test
  public void testConfiguration() throws Exception {
    Component component = context().getComponent(componentName);
    ComponentConfiguration configuration = component.createComponentConfiguration();
    SortedMap<String, ParameterConfiguration> parameterConfigurationMap =
        configuration.getParameterConfigurationMap();
    if (verbose) {
      Set<Map.Entry<String, ParameterConfiguration>> entries = parameterConfigurationMap.entrySet();
      for (Map.Entry<String, ParameterConfiguration> entry : entries) {
        String name = entry.getKey();
        ParameterConfiguration config = entry.getValue();
        LOG.info("Has name: {} with type {}", name, config.getParameterType().getName());
      }
    }

    assertParameterConfig(configuration, "format", PayloadFormat.class);
    assertParameterConfig(configuration, "sObjectName", String.class);
    assertParameterConfig(configuration, "sObjectFields", String.class);
    assertParameterConfig(configuration, "updateTopic", boolean.class);

    configuration.setParameter("format", PayloadFormat.XML);
    configuration.setParameter("sObjectName", "Merchandise__c");
    configuration.setParameter("sObjectFields", "Description__c,Total_Inventory__c");
    configuration.setParameter("updateTopic", false);

    // operation name is base uri
    configuration.setBaseUri("getSObject");

    SalesforceEndpoint endpoint =
        assertIsInstanceOf(SalesforceEndpoint.class, configuration.createEndpoint());
    final SalesforceEndpointConfig endpointConfig = endpoint.getConfiguration();
    assertEquals("endpoint.format", PayloadFormat.XML, endpointConfig.getFormat());
    assertEquals("endpoint.sObjectName", "Merchandise__c", endpointConfig.getSObjectName());
    assertEquals(
        "endpoint.sObjectFields",
        "Description__c,Total_Inventory__c",
        endpointConfig.getSObjectFields());
    assertEquals("endpoint.updateTopic", false, endpointConfig.isUpdateTopic());
  }
  @Test
  public void testEndpointCompletion() throws Exception {
    Component component = context().getComponent(componentName);
    ComponentConfiguration configuration = component.createComponentConfiguration();

    // get operation names
    assertCompletionOptions(
        configuration.completeEndpointPath(""),
        "getVersions",
        "getResources",
        "getGlobalObjects",
        "getBasicInfo",
        "getDescription",
        "getSObject",
        "createSObject",
        "updateSObject",
        "deleteSObject",
        "getSObjectWithId",
        "upsertSObject",
        "deleteSObjectWithId",
        "getBlobField",
        "query",
        "queryMore",
        "queryAll",
        "search",
        "apexCall",
        "recent",
        "createJob",
        "getJob",
        "closeJob",
        "abortJob",
        "createBatch",
        "getBatch",
        "getAllBatches",
        "getRequest",
        "getResults",
        "createBatchQuery",
        "getQueryResultIds",
        "getQueryResult",
        "getRecentReports",
        "getReportDescription",
        "executeSyncReport",
        "executeAsyncReport",
        "getReportInstances",
        "getReportResults",
        "limits",
        "approval",
        "approvals",
        "[PushTopicName]");

    // get filtered operation names
    assertCompletionOptions(
        configuration.completeEndpointPath("get"),
        "getVersions",
        "getResources",
        "getGlobalObjects",
        "getBasicInfo",
        "getDescription",
        "getSObject",
        "getSObjectWithId",
        "getBlobField",
        "getJob",
        "getBatch",
        "getAllBatches",
        "getRequest",
        "getResults",
        "getQueryResultIds",
        "getQueryResult",
        "getRecentReports",
        "getReportDescription",
        "getReportInstances",
        "getReportResults");

    /* TODO support parameter completion
            // get ALL REST operation parameters
            // TODO support operation specific parameter completion
            assertCompletionOptions(configuration.completeEndpointPath("getSObject?"),
                "apiVersion", "httpClient", "format", "sObjectName", "sObjectId", "sObjectFields",
                "sObjectIdName", "sObjectIdValue", "sObjectBlobFieldName", "sObjectClass", "sObjectQuery", "sObjectSearch");

            // get filtered REST parameters
            assertCompletionOptions(configuration.completeEndpointPath("getSObject?format=XML&"),
                "apiVersion", "httpClient", "sObjectName", "sObjectId", "sObjectFields",
                "sObjectIdName", "sObjectIdValue", "sObjectBlobFieldName", "sObjectClass", "sObjectQuery", "sObjectSearch");

            // get ALL Bulk operation parameters
            // TODO support operation specific parameter completion
            assertCompletionOptions(configuration.completeEndpointPath("createJob?"),
                "apiVersion", "httpClient", "sObjectQuery", "contentType", "jobId", "batchId", "resultId");

            // get filtered Bulk operation parameters
            assertCompletionOptions(configuration.completeEndpointPath("createJob?contentType=XML&"),
                "apiVersion", "httpClient", "sObjectQuery", "jobId", "batchId", "resultId");

            // get ALL topic parameters for consumers
            assertCompletionOptions(configuration.completeEndpointPath("myTopic?"),
                "apiVersion", "httpClient", "updateTopic", "notifyForFields", "notifyForOperations");

            // get filtered topic parameters for consumers
            assertCompletionOptions(configuration.completeEndpointPath("myTopic?updateTopic=true&"),
                "apiVersion", "httpClient", "notifyForFields", "notifyForOperations");

            // get parameters from partial name
            assertCompletionOptions(configuration.completeEndpointPath("getSObject?sObject"),
                "sObjectName", "sObjectId", "sObjectFields",
                "sObjectIdName", "sObjectIdValue", "sObjectBlobFieldName", "sObjectClass", "sObjectQuery", "sObjectSearch");
    */

    // get sObjectName values, from scanned DTO packages
    assertCompletionOptions(
        configuration.completeEndpointPath("getSObject?sObjectName="),
        "Account",
        "Tasks__c",
        "Line_Item__c",
        "Merchandise__c",
        "Document",
        "MSPTest");

    // get sObjectFields values, from scanned DTO
    assertCompletionOptions(
        configuration.completeEndpointPath("getSObject?sObjectName=Merchandise__c&sObjectFields="),
        "Description__c",
        "Price__c",
        "Total_Inventory__c",
        "attributes",
        "Id",
        "OwnerId",
        "IsDeleted",
        "Name",
        "CreatedDate",
        "CreatedById",
        "LastModifiedDate",
        "LastModifiedById",
        "SystemModstamp",
        "LastActivityDate",
        "LastViewedDate",
        "LastReferencedDate");

    // get sObjectClass values, from scanned DTO packages
    assertCompletionOptions(
        configuration.completeEndpointPath("getSObject?sObjectClass="),
        Account.class.getName(),
        Tasks__c.class.getName(),
        Line_Item__c.class.getName(),
        Merchandise__c.class.getName(),
        Document.class.getName(),
        MSPTest.class.getName(),
        QueryRecordsLine_Item__c.class.getName());
  }
  @Override
  public List<String> completeEndpointPath(
      ComponentConfiguration configuration, String completionText) {
    final List<String> result = new ArrayList<String>();

    final Set<String> apiNames = collection.getApiNames();
    boolean useDefaultName = apiNames.size() == 1 && apiNames.contains("");

    // check if there is an API name present
    completionText = ObjectHelper.isEmpty(completionText) ? "" : completionText;
    final int prefixEnd = completionText.indexOf('/');
    final int pathEnd = completionText.lastIndexOf('?');

    // empty or incomplete API prefix, and no options, add API names or method names if
    // useDefaultName
    final Map<E, ? extends ApiMethodHelper<? extends ApiMethod>> apiHelpers =
        collection.getApiHelpers();
    if (prefixEnd == -1 && pathEnd == -1) {

      if (useDefaultName) {

        // complete method names for default API
        final Set<Class<? extends ApiMethod>> apiMethods = collection.getApiMethods().keySet();
        final Class<? extends ApiMethod> apiMethod = apiMethods.iterator().next();
        final ApiMethodHelper<? extends ApiMethod> helper = apiHelpers.values().iterator().next();
        getCompletedMethods(result, completionText, apiMethod, helper);
      } else {

        // complete API names
        for (String name : apiNames) {
          if (!name.isEmpty() || name.startsWith(completionText)) {
            result.add(name);
          }
        }
      }

      // path with complete API name prefix, but no options
    } else if (prefixEnd != -1 && pathEnd == -1) {

      // complete method names for specified API
      final E apiName = getApiNameOrNull(completionText.substring(0, prefixEnd));
      if (apiName != null) {
        final ApiMethodHelper<? extends ApiMethod> helper = apiHelpers.get(apiName);
        completionText = completionText.substring(prefixEnd + 1);
        for (Map.Entry<Class<? extends ApiMethod>, E> entry :
            collection.getApiMethods().entrySet()) {
          if (entry.getValue().equals(apiName)) {
            getCompletedMethods(result, completionText, entry.getKey(), helper);
            break;
          }
        }
      }

      // complete options
    } else {

      // get last option text
      final int lastParam = completionText.lastIndexOf('&');
      String optionText;
      if (lastParam != -1) {
        optionText = completionText.substring(lastParam + 1);
      } else {
        optionText = completionText.substring(pathEnd);
      }

      String methodName = null;
      ApiMethodHelper<? extends ApiMethod> helper = null;
      if (useDefaultName) {

        // get default endpoint configuration and helper
        methodName = completionText.substring(0, pathEnd);
        helper = apiHelpers.values().iterator().next();
      } else {

        // get API name and method name, if they exist
        final String[] pathElements = completionText.substring(0, pathEnd).split("/");
        if (pathElements.length == 2) {
          final E apiName = getApiNameOrNull(pathElements[0]);
          methodName = pathElements[1];
          helper = collection.getHelper(apiName);
        }
      }
      if (helper != null && !ObjectHelper.isEmpty(methodName)) {
        // get other options from configuration
        Set<String> existingOptions = configuration.getParameters().keySet();
        // get all method options
        try {
          final List<Object> arguments = helper.getArguments(methodName);
          final int nArgs = arguments.size();
          final Set<String> options = new HashSet<String>();
          for (int i = 1; i < nArgs; i += 2) {
            options.add((String) arguments.get(i));
          }
          options.removeAll(existingOptions);

          // return matching options
          for (String option : options) {
            if (option.startsWith(optionText)) {
              result.add(option);
            }
          }
        } catch (IllegalArgumentException ignore) {
          // thrown from getArguments() when no matching methods,
          // return an empty result
        }
      }
    }

    return result;
  }