add back test cases for java jersey1 client

.gitignore

@@ -57,6 +57,7 @@ samples/client/petstore/qt5cpp/PetStore/Makefile
 **/.gradle
 samples/client/petstore/java/hello.txt
 samples/client/petstore/java/okhttp-gson/hello.txt
+samples/client/petstore/java/jersey1/hello.txt
 samples/client/petstore/java/jersey2-java8/hello.txt
 samples/client/petstore/android/default/hello.txt
 samples/client/petstore/android/volley/.gradle/

samples/client/petstore/java/jersey1/src/test/java/io/swagger/PetstoreProfiling.java

@@ -0,0 +1,106 @@
+package io.swagger;
+
+import java.io.*;
+import java.util.*;
+
+import io.swagger.client.*;
+import io.swagger.client.api.*;
+import io.swagger.client.model.*;
+
+public class PetstoreProfiling {
+    public int total = 5;
+    public Long newPetId = 50003L;
+    public String outputFile = "./petstore_profiling.output";
+
+    public void callApis(int index, List<Map<String, String>> results) {
+        long start;
+
+        try {
+            PetApi petApi = new PetApi();
+
+            /* ADD PET */
+            Pet pet = new Pet();
+            pet.setId(newPetId);
+            pet.setName("profiler");
+            pet.setStatus(Pet.StatusEnum.AVAILABLE);
+            pet.setPhotoUrls(Arrays.asList("http://profiler.com"));
+            // new tag
+            Tag tag = new Tag();
+            tag.setId(newPetId); // use the same id as pet
+            tag.setName("profile tag 1");
+            // new category
+            Category category = new Category();
+            category.setId(newPetId); // use the same id as pet
+            category.setName("profile category 1");
+
+            pet.setTags(Arrays.asList(tag));
+            pet.setCategory(category);
+
+            /* ADD PET */
+            start = System.nanoTime();
+            petApi.addPet(pet);
+            results.add(buildResult(index, "ADD PET", System.nanoTime() - start));
+
+            /* GET PET */
+            start = System.nanoTime();
+            pet = petApi.getPetById(newPetId);
+            results.add(buildResult(index, "GET PET", System.nanoTime() - start));
+
+            /* UPDATE PET WITH FORM */
+            start = System.nanoTime();
+            petApi.updatePetWithForm(newPetId, "new profiler", "sold");
+            results.add(buildResult(index, "UPDATE PET", System.nanoTime() - start));
+
+            /* DELETE PET */
+            start = System.nanoTime();
+            petApi.deletePet(newPetId, "special-key");
+            results.add(buildResult(index, "DELETE PET", System.nanoTime() - start));
+        } catch (ApiException e) {
+            System.out.println("Caught error: " + e.getMessage());
+            System.out.println("HTTP response headers: " + e.getResponseHeaders());
+            System.out.println("HTTP response body: " + e.getResponseBody());
+            System.out.println("HTTP status code: " + e.getCode());
+        }
+    }
+
+    public void run() {
+        System.out.printf("Running profiling... (total: %s)\n", total);
+
+        List<Map<String, String>> results = new ArrayList<Map<String, String>>();
+        for (int i = 0; i < total; i++) {
+            callApis(i, results);
+        }
+        writeResultsToFile(results);
+
+        System.out.printf("Profiling results written to %s\n", outputFile);
+    }
+
+    private Map<String, String> buildResult(int index, String name, long time) {
+        Map<String, String> result = new HashMap<String, String>();
+        result.put("index", String.valueOf(index));
+        result.put("name", name);
+        result.put("time", String.valueOf(time / 1000000000.0));
+        return result;
+    }
+
+    private void writeResultsToFile(List<Map<String, String>> results) {
+        try {
+            java.io.File file = new java.io.File(outputFile);
+            PrintWriter writer = new PrintWriter(file);
+            String command = "mvn compile test-compile exec:java -Dexec.classpathScope=test -Dexec.mainClass=\"io.swagger.PetstoreProfiling\"";
+            writer.println("# To run the profiling:");
+            writer.printf("#   %s\n\n", command);
+            for (Map<String, String> result : results) {
+                writer.printf("%s: %s => %s\n", result.get("index"), result.get("name"), result.get("time"));
+            }
+            writer.close();
+        } catch (FileNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void main(String[] args) {
+        final PetstoreProfiling profiling = new PetstoreProfiling();
+        profiling.run();
+    }
+}

samples/client/petstore/java/jersey1/src/test/java/io/swagger/TestUtils.java

@@ -0,0 +1,17 @@
+package io.swagger;
+
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class TestUtils {
+    private static final AtomicLong atomicId = createAtomicId();
+
+    public static long nextId() {
+      return atomicId.getAndIncrement();
+    }
+
+    private static AtomicLong createAtomicId() {
+        int baseId = new Random(System.currentTimeMillis()).nextInt(1000000) + 20000;
+        return new AtomicLong((long) baseId);
+    }
+}

samples/client/petstore/java/jersey1/src/test/java/io/swagger/client/ApiClientTest.java

@@ -0,0 +1,239 @@
+package io.swagger.client;
+
+import io.swagger.client.auth.*;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+import org.junit.*;
+import static org.junit.Assert.*;
+
+
+public class ApiClientTest {
+    ApiClient apiClient = null;
+
+    @Before
+    public void setup() {
+        apiClient = new ApiClient();
+    }
+
+    @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")));
+    }
+
+    @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 testSelectHeaderAccept() {
+        String[] accepts = {"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[]{"application/xml", "application/json; charset=UTF8"};
+        assertEquals("application/json; charset=UTF8", 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; charset=UTF8"};
+        assertEquals("application/json; charset=UTF8", 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 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) {
+        }
+    }
+
+    @Ignore("There is no more basic auth in petstore security definitions")
+    @Test
+    public void testSetUsernameAndPassword() {
+        HttpBasicAuth auth = null;
+        for (Authentication _auth : apiClient.getAuthentications().values()) {
+            if (_auth instanceof HttpBasicAuth) {
+                auth = (HttpBasicAuth) _auth;
+                break;
+            }
+        }
+        auth.setUsername(null);
+        auth.setPassword(null);
+
+        apiClient.setUsername("my-username");
+        apiClient.setPassword("my-password");
+        assertEquals("my-username", auth.getUsername());
+        assertEquals("my-password", auth.getPassword());
+
+        // reset values
+        auth.setUsername(null);
+        auth.setPassword(null);
+    }
+
+    @Test
+    public void testSetApiKeyAndPrefix() {
+        ApiKeyAuth auth = null;
+        for (Authentication _auth : apiClient.getAuthentications().values()) {
+            if (_auth instanceof ApiKeyAuth) {
+                auth = (ApiKeyAuth) _auth;
+                break;
+            }
+        }
+        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);
+    }
+
+    @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 testParameterToPairsWhenValueIsNull() throws Exception {
+        List<Pair> pairs = apiClient.parameterToPairs("csv", "param-a", null);
+
+        assertTrue(pairs.isEmpty());
+    }
+
+    @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 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 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);
+        }
+    }
+}

samples/client/petstore/java/jersey1/src/test/java/io/swagger/client/ConfigurationTest.java

@@ -0,0 +1,15 @@
+package io.swagger.client;
+
+import org.junit.*;
+import static org.junit.Assert.*;
+
+
+public class ConfigurationTest {
+    @Test
+    public void testDefaultApiClient() {
+        ApiClient apiClient = Configuration.getDefaultApiClient();
+        assertNotNull(apiClient);
+        assertEquals("http://petstore.swagger.io/v2", apiClient.getBasePath());
+        assertFalse(apiClient.isDebugging());
+    }
+}