@Test
  public void testApiClient() {
    // the default api client is used
    assertEquals(Configuration.getDefaultApiClient(), api.getApiClient());
    assertNotNull(api.getApiClient());
    assertEquals("http://petstore.swagger.io/v2", api.getApiClient().getBasePath());
    assertFalse(api.getApiClient().isDebugging());

    ApiClient oldClient = api.getApiClient();

    ApiClient newClient = new ApiClient();
    newClient.setBasePath("http://example.com");
    newClient.setDebugging(true);

    // set api client via constructor
    api = new PetApi(newClient);
    assertNotNull(api.getApiClient());
    assertEquals("http://example.com", api.getApiClient().getBasePath());
    assertTrue(api.getApiClient().isDebugging());

    // set api client via setter method
    api.setApiClient(oldClient);
    assertNotNull(api.getApiClient());
    assertEquals("http://petstore.swagger.io/v2", api.getApiClient().getBasePath());
    assertFalse(api.getApiClient().isDebugging());
  }
  @Test
  public void testParameterToPairsWhenValueIsCollection() throws Exception {
    Map<String, String> collectionFormatMap = new HashMap<String, String>();
    collectionFormatMap.put("csv", ",");
    collectionFormatMap.put("tsv", "\t");
    collectionFormatMap.put("ssv", " ");
    collectionFormatMap.put("pipes", "\\|");
    collectionFormatMap.put("", ","); // no format, must default to csv
    collectionFormatMap.put("unknown", ","); // all other formats, must default to csv

    String name = "param-a";

    List<Object> values = new ArrayList<Object>();
    values.add("value-a");
    values.add(123);
    values.add(new Date());

    // check for multi separately
    List<Pair> multiPairs = apiClient.parameterToPairs("multi", name, values);
    assertEquals(values.size(), multiPairs.size());

    // all other formats
    for (String collectionFormat : collectionFormatMap.keySet()) {
      List<Pair> pairs = apiClient.parameterToPairs(collectionFormat, name, values);

      assertEquals(1, pairs.size());

      String delimiter = collectionFormatMap.get(collectionFormat);
      String[] pairValueSplit = pairs.get(0).getValue().split(delimiter);

      // must equal input values
      assertEquals(values.size(), pairValueSplit.length);
    }
  }
  @Test
  public void testParameterToPairsWhenNameIsInvalid() throws Exception {
    List<Pair> pairs_a = apiClient.parameterToPairs("csv", null, new Integer(1));
    List<Pair> pairs_b = apiClient.parameterToPairs("csv", "", new Integer(1));

    assertTrue(pairs_a.isEmpty());
    assertTrue(pairs_b.isEmpty());
  }
  @Test
  public void testSetApiKeyAndPrefix() {
    ApiKeyAuth auth = (ApiKeyAuth) apiClient.getAuthentications().get("api_key");
    auth.setApiKey(null);
    auth.setApiKeyPrefix(null);

    apiClient.setApiKey("my-api-key");
    apiClient.setApiKeyPrefix("Token");
    assertEquals("my-api-key", auth.getApiKey());
    assertEquals("Token", auth.getApiKeyPrefix());

    // reset values
    auth.setApiKey(null);
    auth.setApiKeyPrefix(null);
  }
 private <T> T deserializeJson(String json, Class<T> klass, ApiClient apiClient) {
   ObjectMapper mapper = apiClient.getJSON().getContext(null);
   try {
     return mapper.readValue(json, klass);
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
 private String serializeJson(Object o, ApiClient apiClient) {
   ObjectMapper mapper = apiClient.getJSON().getContext(null);
   try {
     return mapper.writeValueAsString(o);
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
  @Test
  public void testSelectHeaderAccept() {
    String[] accepts = {"APPLICATION/JSON", "APPLICATION/XML"};
    assertEquals("application/json", apiClient.selectHeaderAccept(accepts));

    accepts = new String[] {"application/json", "application/xml"};
    assertEquals("application/json", apiClient.selectHeaderAccept(accepts));

    accepts = new String[] {"application/xml", "application/json"};
    assertEquals("application/json", apiClient.selectHeaderAccept(accepts));

    accepts = new String[] {"text/plain", "application/xml"};
    assertEquals("text/plain,application/xml", apiClient.selectHeaderAccept(accepts));

    accepts = new String[] {};
    assertNull(apiClient.selectHeaderAccept(accepts));
  }
  @Test
  public void testSelectHeaderContentType() {
    String[] contentTypes = {"APPLICATION/JSON", "APPLICATION/XML"};
    assertEquals("application/json", apiClient.selectHeaderContentType(contentTypes));

    contentTypes = new String[] {"application/json", "application/xml"};
    assertEquals("application/json", apiClient.selectHeaderContentType(contentTypes));

    contentTypes = new String[] {"application/xml", "application/json"};
    assertEquals("application/json", apiClient.selectHeaderContentType(contentTypes));

    contentTypes = new String[] {"text/plain", "application/xml"};
    assertEquals("text/plain", apiClient.selectHeaderContentType(contentTypes));

    contentTypes = new String[] {};
    assertEquals("application/json", apiClient.selectHeaderContentType(contentTypes));
  }
 @Test
 public void testSetUsername() {
   try {
     apiClient.setUsername("my-username");
     fail("there should be no HTTP basic authentications");
   } catch (RuntimeException e) {
   }
 }
 @Test
 public void testSetPassword() {
   try {
     apiClient.setPassword("my-password");
     fail("there should be no HTTP basic authentications");
   } catch (RuntimeException e) {
   }
 }
  @Test
  public void testRemoveCallsAPIEndpoint() {
    ServerBridge bridge = mock(ServerBridge.class);
    when(bridge.delete("datasources/a")).thenReturn("");

    ApiClient api = new ApiClient("abc");
    api.setServerBridge(bridge);

    Map<String, Object> raw = new HashMap<String, Object>();
    raw.put("id", "a");
    raw.put("name", "MyDS");

    DataSource dataSource = new DataSource(raw, api);
    dataSource.remove();

    verify(bridge).delete("datasources/a");
  }
  @Test
  public void testParameterToPairsWhenValueIsEmptyStrings() throws Exception {

    // single empty string
    List<Pair> pairs = apiClient.parameterToPairs("csv", "param-a", " ");
    assertEquals(1, pairs.size());

    // list of empty strings
    List<String> strs = new ArrayList<String>();
    strs.add(" ");
    strs.add(" ");
    strs.add(" ");

    List<Pair> concatStrings = apiClient.parameterToPairs("csv", "param-a", strs);

    assertEquals(1, concatStrings.size());
    assertFalse(concatStrings.get(0).getValue().isEmpty()); // should contain some delimiters
  }
  @Test
  public void testGetVariablesEmptyList() {
    ServerBridge bridge = mock(ServerBridge.class);
    when(bridge.get("datasources/a/variables")).thenReturn("[]");

    ApiClient api = new ApiClient("abc");
    api.setServerBridge(bridge);

    Map<String, Object> raw = new HashMap<String, Object>();
    raw.put("id", "a");
    raw.put("name", "MyDS");

    DataSource dataSource = new DataSource(raw, api);
    Variable[] variables = dataSource.getVariables();

    verify(bridge).get("datasources/a/variables");
    assertEquals(0, variables.length);
  }
  @Test
  public void testGetVariablesThreeVariables() {
    ServerBridge bridge = mock(ServerBridge.class);
    when(bridge.get("datasources/a/variables"))
        .thenReturn(
            "["
                + "{'id': 'a', 'name': 'A', 'unit': 'unitA', 'icon': 'iconA'},"
                + "{'id': 'b', 'name': 'B', 'unit': 'unitB', 'icon': 'iconB'},"
                + "{'id': 'c', 'name': 'C', 'unit': 'unitC', 'icon': 'iconC'}"
                + "]");

    ApiClient api = new ApiClient("abc");
    api.setServerBridge(bridge);

    Map<String, Object> raw = new HashMap<String, Object>();
    raw.put("id", "a");
    raw.put("name", "MyDS");

    DataSource dataSource = new DataSource(raw, api);
    Variable[] variables = dataSource.getVariables();

    verify(bridge).get("datasources/a/variables");
    assertEquals(3, variables.length);

    // Check IDs
    assertEquals("a", variables[0].getId());
    assertEquals("b", variables[1].getId());
    assertEquals("c", variables[2].getId());

    // Check names
    assertEquals("A", variables[0].getName());
    assertEquals("B", variables[1].getName());
    assertEquals("C", variables[2].getName());

    // Check units
    assertEquals("unitA", variables[0].getUnit());
    assertEquals("unitB", variables[1].getUnit());
    assertEquals("unitC", variables[2].getUnit());

    // Check icons
    assertEquals("iconA", variables[0].getIcon());
    assertEquals("iconB", variables[1].getIcon());
    assertEquals("iconC", variables[2].getIcon());
  }
  @Test
  public void testIsJsonMime() {
    assertFalse(apiClient.isJsonMime(null));
    assertFalse(apiClient.isJsonMime(""));
    assertFalse(apiClient.isJsonMime("text/plain"));
    assertFalse(apiClient.isJsonMime("application/xml"));
    assertFalse(apiClient.isJsonMime("application/jsonp"));

    assertTrue(apiClient.isJsonMime("application/json"));
    assertTrue(apiClient.isJsonMime("application/json; charset=UTF8"));
    assertTrue(apiClient.isJsonMime("APPLICATION/JSON"));
  }
  @Test
  public void testParameterToPairsWhenValueIsNotCollection() throws Exception {
    String name = "param-a";
    Integer value = 1;

    List<Pair> pairs = apiClient.parameterToPairs("csv", name, value);

    assertEquals(1, pairs.size());
    assertEquals(value, Integer.valueOf(pairs.get(0).getValue()));
  }
  @Test
  public void testGetAuthentications() {
    Map<String, Authentication> auths = apiClient.getAuthentications();

    Authentication auth = auths.get("api_key");
    assertNotNull(auth);
    assertTrue(auth instanceof ApiKeyAuth);
    ApiKeyAuth apiKeyAuth = (ApiKeyAuth) auth;
    assertEquals("header", apiKeyAuth.getLocation());
    assertEquals("api_key", apiKeyAuth.getParamName());

    auth = auths.get("petstore_auth");
    assertTrue(auth instanceof OAuth);
    assertSame(auth, apiClient.getAuthentication("petstore_auth"));

    assertNull(auths.get("unknown"));

    try {
      auths.put("my_auth", new HttpBasicAuth());
      fail("the authentications returned should not be modifiable");
    } catch (UnsupportedOperationException e) {
    }
  }
  @Test
  public void testParameterToPairsWhenValueIsNull() throws Exception {
    List<Pair> pairs = apiClient.parameterToPairs("csv", "param-a", null);

    assertTrue(pairs.isEmpty());
  }
  @Test
  public void testParseAndFormatDate() {
    // default date format
    String dateStr = "2015-11-07T03:49:09.356Z";
    assertEquals(
        dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T03:49:09.356+00:00")));
    assertEquals(dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T03:49:09.356Z")));
    assertEquals(
        dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T05:49:09.356+02:00")));
    assertEquals(
        dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T02:49:09.356-01:00")));

    // custom date format: without milli-seconds, custom time zone
    DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
    format.setTimeZone(TimeZone.getTimeZone("GMT+10"));
    apiClient.setDateFormat(format);
    dateStr = "2015-11-07T13:49:09+10:00";
    assertEquals(dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T03:49:09+00:00")));
    assertEquals(dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T03:49:09Z")));
    assertEquals(dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T00:49:09-03:00")));
    assertEquals(dateStr, apiClient.formatDate(apiClient.parseDate("2015-11-07T13:49:09+10:00")));
  }