wink-common/src/test/java/org/apache/wink/common/internal/registry/ProvidersRegistryTest.java - wink - Git at Google

 /*******************************************************************************
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing,
  *  software distributed under the License is distributed on an
  *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  *  KIND, either express or implied.  See the License for the
  *  specific language governing permissions and limitations
  *  under the License.
  *
  *******************************************************************************/
 package org.apache.wink.common.internal.registry;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.Type;
 import java.util.HashMap;
 import java.util.Set;

 import javax.ws.rs.Consumes;
 import javax.ws.rs.Produces;
 import javax.ws.rs.WebApplicationException;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.MultivaluedMap;
 import javax.ws.rs.ext.MessageBodyReader;
 import javax.ws.rs.ext.MessageBodyWriter;
 import javax.ws.rs.ext.Provider;

 import junit.framework.TestCase;

 import org.apache.wink.common.internal.application.ApplicationValidator;
 import org.apache.wink.common.internal.lifecycle.LifecycleManagersRegistry;
 import org.apache.wink.common.internal.utils.SoftConcurrentMap;

 public class ProvidersRegistryTest extends TestCase {

     /**
      * Tests that the providersCache object is and remains instanceof ConcurrentHashMap.
      *
      * ProvidersRegistry.MediaTypeMap uses type ConcurrentHashMap on the providersCache object to provide some lock protection on
      * the map when providers are dynamically added.  However, lock protection is already built into the ProvidersRegistry methods:
      * getContextResolver(), getMessageBodyReader(), and getMessageBodyWriter().
      *
      * However, the second protection (in the ProvidersRegistry methods) is for the cache itself which could be written to by two
      * different threads even if they both were getting a single MessageBodyReader (i.e. a cache value may be dropped and then two
      * threads come back later and try to write a new cache value).  Due to some weird HashMap properties, this can blow up in
      * weird ways.
      *
      * Thus, we need to ensure the providersCache continues to be instantiated with ConcurrentHashMap.
      */
     public void testProtectionModel() throws Exception {

         // I need the instantiated object providersCache in the abstract private nested class MediaTypeMap, so here we go!
         ProvidersRegistry providersRegistry = new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
         Field field = providersRegistry.getClass().getDeclaredField("messageBodyReaders");
         field.setAccessible(true);
         Object messageBodyReaders = field.get(providersRegistry);
         Field field2 = messageBodyReaders.getClass().getSuperclass().getDeclaredField("providersCache");
         field2.setAccessible(true);
         Object providersCache = field2.get(messageBodyReaders);

         assertTrue(providersCache instanceof SoftConcurrentMap);
     }

     /**
      * Application subclass methods .getClasses and .getSingletons may list provider class or instance that is the same
      * as a default Wink provider to override it to establish a new priority order.
      *
      * The order that the Wink runtime loads providers is:
      * Application.getSingletons
      * Application.getClasses
      * system (through wink-providers file)
      * extra jars (through each wink-application file)
      */
     @SuppressWarnings("unchecked")
     public void testOverrideSystemProvider() throws Exception {
         ProvidersRegistry providersRegistry = createProvidersRegistryImpl();
         assertTrue(providersRegistry.addProvider(StringReader.class, 0.5, false));  // registered as a user provider
         MessageBodyReader<String> reader1 = providersRegistry.getMessageBodyReader(String.class, null, null, MediaType.TEXT_PLAIN_TYPE, null);

         // registered twice as a custom user provider with higher priority
         // See javadoc for Application.getSingletons to see why we ignore the attempt to add a second StringReader
         assertFalse(providersRegistry.addProvider(StringReader.class, 0.6, false));
         MessageBodyReader<String> reader2 = providersRegistry.getMessageBodyReader(String.class, null, null, MediaType.TEXT_PLAIN_TYPE, null);
         assertTrue(reader1 == reader2);  // object compare to make sure reader2 has been silently ignored

         // registered as a system provider
         assertFalse(providersRegistry.addProvider(StringReader.class, 0.1, false));
         MessageBodyReader<String> reader3 = providersRegistry.getMessageBodyReader(String.class, null, null, MediaType.TEXT_PLAIN_TYPE, null);
         assertTrue(reader1 == reader3);  // object compare to make sure reader3 has been silently ignored
         assertTrue(reader2 == reader3);  // object compare to make sure reader3 has been silently ignored

         // to confirm that the ignores are indeed happening, I need to get the private field
         // "messageBodyReaders" object, then it's superclass "data" object and inspect it:
         Field field = providersRegistry.getClass().getDeclaredField("messageBodyReaders");
         field.setAccessible(true);
         Object messageBodyReaders = field.get(providersRegistry);
         Field field2 = messageBodyReaders.getClass().getSuperclass().getDeclaredField("data");
         field2.setAccessible(true);
         HashMap data = (HashMap)field2.get(messageBodyReaders);
         Set readers = (Set)data.get(MediaType.WILDCARD_TYPE);

         // make there is only one provider in the list to conform to JAX-RS 4.1 first sentence
         assertEquals(1, readers.size());
     }

     /**
      * Tests that a structured syntax suffix is handled correctly for determining a writer.
      *
      * @throws Exception
      */
     public void testProvidesStructuredSyntaxSuffixHandledOk() throws Exception {
       ProvidersRegistry providersRegistry =
           new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
       providersRegistry.addProvider(GenericProvider.class);
       providersRegistry.addProvider(SpecificProvider.class);

       MediaType mediaType;
       MessageBodyWriter<String> writer;

       mediaType = MediaType.valueOf("application/json"); // use generic provider

       writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
       assertTrue(writer instanceof GenericProvider);

       mediaType = MediaType.valueOf("application/vnd.other+json"); // use generic provider

       writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
       assertTrue(writer instanceof GenericProvider);

       mediaType = MediaType.valueOf("application/subschema+json"); // use specific provider

       writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
       assertTrue(writer instanceof SpecificProvider);

       mediaType = MediaType.valueOf("application/subschema"); // cannot use specific provider, nor generic

       writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
       assertNull(writer);

       mediaType = MediaType.valueOf("text/json"); // cannot use specific provider, nor generic

       writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
       assertNull(writer);
     }

     /**
      * Tests that a structured syntax suffix is handled correctly for determining a reader.
      *
      * @throws Exception
      */
     public void testConsumesStructuredSyntaxSuffixHandledOk() throws Exception {
       ProvidersRegistry providersRegistry =
           new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
       providersRegistry.addProvider(GenericProvider.class);
       providersRegistry.addProvider(SpecificProvider.class);

       MediaType mediaType;
       MessageBodyReader<String> reader;

       mediaType = MediaType.valueOf("application/json"); // use generic provider

       reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
       assertTrue(reader instanceof GenericProvider);

       mediaType = MediaType.valueOf("application/vnd.other+json"); // use generic provider

       reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
       assertTrue(reader instanceof GenericProvider);

       mediaType = MediaType.valueOf("application/subschema+json"); // use specific provider

       reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
       assertTrue(reader instanceof SpecificProvider);

       mediaType = MediaType.valueOf("application/subschema"); // cannot use specific provider, nor generic

       reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
       assertNull(reader);

       mediaType = MediaType.valueOf("text/json"); // cannot use specific provider, nor generic

       reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
       assertNull(reader);
     }

     // TODO:  perhaps future tests should be added to actually exercise the providersCache code, but it would be an involved,
     // multi-threaded test that dynamically adds providers at just the right time to ensure no problems with
     // concurrent writes.

     // Utility:
     private ProvidersRegistry createProvidersRegistryImpl() {
         ProvidersRegistry providers =
             new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
         ;
         return providers;
     }

     @Provider
     @Produces( {MediaType.WILDCARD})
     public static class StringReader implements MessageBodyReader<String> {

         public boolean isReadable(Class<?> type, Type genericType,
                 Annotation[] annotations, MediaType mediaType) {
             return true;
         }

         public String readFrom(Class<String> type, Type genericType,
                 Annotation[] annotations, MediaType mediaType,
                 MultivaluedMap<String, String> httpHeaders,
                 InputStream entityStream) throws IOException {
             return "STRING";
         }
     }

     @Provider
     @Produces({"application/subschema+json"})
     @Consumes({"application/subschema+json"})
     public static class SpecificProvider implements MessageBodyReader<String>, MessageBodyWriter<String> {
       public boolean isWriteable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
       {
         return String.class.isAssignableFrom(type);
       }

       public long getSize( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
       {
         return -1L;
       }

       public void writeTo( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
           MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream ) throws IOException,
           WebApplicationException
       {
       }

       public boolean isReadable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
       {
         return String.class.isAssignableFrom(type);
       }

       public String readFrom( Class<String> type, Type genericType, Annotation[] annotations, MediaType mediaType,
           MultivaluedMap<String, String> httpHeaders, InputStream entityStream ) throws IOException,
           WebApplicationException
       {
         return null;
       }
     }

     @Provider
     @Produces({"application/json"})
     @Consumes({"application/json"})
     public static class GenericProvider implements MessageBodyReader<String>, MessageBodyWriter<String> {
       public boolean isWriteable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
       {
         return String.class.isAssignableFrom(type);
       }

       public long getSize( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
       {
         return -1L;
       }

       public void writeTo( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
           MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream ) throws IOException,
           WebApplicationException
       {
       }

       public boolean isReadable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
       {
         return String.class.isAssignableFrom(type);
       }

       public String readFrom( Class<String> type, Type genericType, Annotation[] annotations, MediaType mediaType,
           MultivaluedMap<String, String> httpHeaders, InputStream entityStream ) throws IOException,
           WebApplicationException
       {
         return null;
       }
     }
 }
	/*******************************************************************************
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*******************************************************************************/
	package org.apache.wink.common.internal.registry;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.lang.annotation.Annotation;
	import java.lang.reflect.Field;
	import java.lang.reflect.Type;
	import java.util.HashMap;
	import java.util.Set;

	import javax.ws.rs.Consumes;
	import javax.ws.rs.Produces;
	import javax.ws.rs.WebApplicationException;
	import javax.ws.rs.core.MediaType;
	import javax.ws.rs.core.MultivaluedMap;
	import javax.ws.rs.ext.MessageBodyReader;
	import javax.ws.rs.ext.MessageBodyWriter;
	import javax.ws.rs.ext.Provider;

	import junit.framework.TestCase;

	import org.apache.wink.common.internal.application.ApplicationValidator;
	import org.apache.wink.common.internal.lifecycle.LifecycleManagersRegistry;
	import org.apache.wink.common.internal.utils.SoftConcurrentMap;

	public class ProvidersRegistryTest extends TestCase {

	/**
	* Tests that the providersCache object is and remains instanceof ConcurrentHashMap.
	*
	* ProvidersRegistry.MediaTypeMap uses type ConcurrentHashMap on the providersCache object to provide some lock protection on
	* the map when providers are dynamically added. However, lock protection is already built into the ProvidersRegistry methods:
	* getContextResolver(), getMessageBodyReader(), and getMessageBodyWriter().
	*
	* However, the second protection (in the ProvidersRegistry methods) is for the cache itself which could be written to by two
	* different threads even if they both were getting a single MessageBodyReader (i.e. a cache value may be dropped and then two
	* threads come back later and try to write a new cache value). Due to some weird HashMap properties, this can blow up in
	* weird ways.
	*
	* Thus, we need to ensure the providersCache continues to be instantiated with ConcurrentHashMap.
	*/
	public void testProtectionModel() throws Exception {

	// I need the instantiated object providersCache in the abstract private nested class MediaTypeMap, so here we go!
	ProvidersRegistry providersRegistry = new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
	Field field = providersRegistry.getClass().getDeclaredField("messageBodyReaders");
	field.setAccessible(true);
	Object messageBodyReaders = field.get(providersRegistry);
	Field field2 = messageBodyReaders.getClass().getSuperclass().getDeclaredField("providersCache");
	field2.setAccessible(true);
	Object providersCache = field2.get(messageBodyReaders);

	assertTrue(providersCache instanceof SoftConcurrentMap);
	}

	/**
	* Application subclass methods .getClasses and .getSingletons may list provider class or instance that is the same
	* as a default Wink provider to override it to establish a new priority order.
	*
	* The order that the Wink runtime loads providers is:
	* Application.getSingletons
	* Application.getClasses
	* system (through wink-providers file)
	* extra jars (through each wink-application file)
	*/
	@SuppressWarnings("unchecked")
	public void testOverrideSystemProvider() throws Exception {
	ProvidersRegistry providersRegistry = createProvidersRegistryImpl();
	assertTrue(providersRegistry.addProvider(StringReader.class, 0.5, false)); // registered as a user provider
	MessageBodyReader<String> reader1 = providersRegistry.getMessageBodyReader(String.class, null, null, MediaType.TEXT_PLAIN_TYPE, null);

	// registered twice as a custom user provider with higher priority
	// See javadoc for Application.getSingletons to see why we ignore the attempt to add a second StringReader
	assertFalse(providersRegistry.addProvider(StringReader.class, 0.6, false));
	MessageBodyReader<String> reader2 = providersRegistry.getMessageBodyReader(String.class, null, null, MediaType.TEXT_PLAIN_TYPE, null);
	assertTrue(reader1 == reader2); // object compare to make sure reader2 has been silently ignored

	// registered as a system provider
	assertFalse(providersRegistry.addProvider(StringReader.class, 0.1, false));
	MessageBodyReader<String> reader3 = providersRegistry.getMessageBodyReader(String.class, null, null, MediaType.TEXT_PLAIN_TYPE, null);
	assertTrue(reader1 == reader3); // object compare to make sure reader3 has been silently ignored
	assertTrue(reader2 == reader3); // object compare to make sure reader3 has been silently ignored

	// to confirm that the ignores are indeed happening, I need to get the private field
	// "messageBodyReaders" object, then it's superclass "data" object and inspect it:
	Field field = providersRegistry.getClass().getDeclaredField("messageBodyReaders");
	field.setAccessible(true);
	Object messageBodyReaders = field.get(providersRegistry);
	Field field2 = messageBodyReaders.getClass().getSuperclass().getDeclaredField("data");
	field2.setAccessible(true);
	HashMap data = (HashMap)field2.get(messageBodyReaders);
	Set readers = (Set)data.get(MediaType.WILDCARD_TYPE);

	// make there is only one provider in the list to conform to JAX-RS 4.1 first sentence
	assertEquals(1, readers.size());
	}

	/**
	* Tests that a structured syntax suffix is handled correctly for determining a writer.
	*
	* @throws Exception
	*/
	public void testProvidesStructuredSyntaxSuffixHandledOk() throws Exception {
	ProvidersRegistry providersRegistry =
	new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
	providersRegistry.addProvider(GenericProvider.class);
	providersRegistry.addProvider(SpecificProvider.class);

	MediaType mediaType;
	MessageBodyWriter<String> writer;

	mediaType = MediaType.valueOf("application/json"); // use generic provider

	writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
	assertTrue(writer instanceof GenericProvider);

	mediaType = MediaType.valueOf("application/vnd.other+json"); // use generic provider

	writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
	assertTrue(writer instanceof GenericProvider);

	mediaType = MediaType.valueOf("application/subschema+json"); // use specific provider

	writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
	assertTrue(writer instanceof SpecificProvider);

	mediaType = MediaType.valueOf("application/subschema"); // cannot use specific provider, nor generic

	writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
	assertNull(writer);

	mediaType = MediaType.valueOf("text/json"); // cannot use specific provider, nor generic

	writer = providersRegistry.getMessageBodyWriter(String.class, null, null, mediaType, null);
	assertNull(writer);
	}

	/**
	* Tests that a structured syntax suffix is handled correctly for determining a reader.
	*
	* @throws Exception
	*/
	public void testConsumesStructuredSyntaxSuffixHandledOk() throws Exception {
	ProvidersRegistry providersRegistry =
	new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
	providersRegistry.addProvider(GenericProvider.class);
	providersRegistry.addProvider(SpecificProvider.class);

	MediaType mediaType;
	MessageBodyReader<String> reader;

	mediaType = MediaType.valueOf("application/json"); // use generic provider

	reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
	assertTrue(reader instanceof GenericProvider);

	mediaType = MediaType.valueOf("application/vnd.other+json"); // use generic provider

	reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
	assertTrue(reader instanceof GenericProvider);

	mediaType = MediaType.valueOf("application/subschema+json"); // use specific provider

	reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
	assertTrue(reader instanceof SpecificProvider);

	mediaType = MediaType.valueOf("application/subschema"); // cannot use specific provider, nor generic

	reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
	assertNull(reader);

	mediaType = MediaType.valueOf("text/json"); // cannot use specific provider, nor generic

	reader = providersRegistry.getMessageBodyReader(String.class, null, null, mediaType, null);
	assertNull(reader);
	}

	// TODO: perhaps future tests should be added to actually exercise the providersCache code, but it would be an involved,
	// multi-threaded test that dynamically adds providers at just the right time to ensure no problems with
	// concurrent writes.

	// Utility:
	private ProvidersRegistry createProvidersRegistryImpl() {
	ProvidersRegistry providers =
	new ProvidersRegistry(new LifecycleManagersRegistry(), new ApplicationValidator());
	;
	return providers;
	}

	@Provider
	@Produces( {MediaType.WILDCARD})
	public static class StringReader implements MessageBodyReader<String> {

	public boolean isReadable(Class<?> type, Type genericType,
	Annotation[] annotations, MediaType mediaType) {
	return true;
	}

	public String readFrom(Class<String> type, Type genericType,
	Annotation[] annotations, MediaType mediaType,
	MultivaluedMap<String, String> httpHeaders,
	InputStream entityStream) throws IOException {
	return "STRING";
	}
	}

	@Provider
	@Produces({"application/subschema+json"})
	@Consumes({"application/subschema+json"})
	public static class SpecificProvider implements MessageBodyReader<String>, MessageBodyWriter<String> {
	public boolean isWriteable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
	{
	return String.class.isAssignableFrom(type);
	}

	public long getSize( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
	{
	return -1L;
	}

	public void writeTo( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
	MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream ) throws IOException,
	WebApplicationException
	{
	}

	public boolean isReadable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
	{
	return String.class.isAssignableFrom(type);
	}

	public String readFrom( Class<String> type, Type genericType, Annotation[] annotations, MediaType mediaType,
	MultivaluedMap<String, String> httpHeaders, InputStream entityStream ) throws IOException,
	WebApplicationException
	{
	return null;
	}
	}

	@Provider
	@Produces({"application/json"})
	@Consumes({"application/json"})
	public static class GenericProvider implements MessageBodyReader<String>, MessageBodyWriter<String> {
	public boolean isWriteable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
	{
	return String.class.isAssignableFrom(type);
	}

	public long getSize( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
	{
	return -1L;
	}

	public void writeTo( String t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
	MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream ) throws IOException,
	WebApplicationException
	{
	}

	public boolean isReadable( Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType )
	{
	return String.class.isAssignableFrom(type);
	}

	public String readFrom( Class<String> type, Type genericType, Annotation[] annotations, MediaType mediaType,
	MultivaluedMap<String, String> httpHeaders, InputStream entityStream ) throws IOException,
	WebApplicationException
	{
	return null;
	}
	}
	}