2.1/user/test/com/google/gwt/user/server/rpc/SerializationPolicyLoaderTest.java

/*
 * Copyright 2008 Google Inc.
 * 
 * Licensed 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 com.google.gwt.user.server.rpc;

import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.server.rpc.impl.TypeNameObfuscator;

import junit.framework.TestCase;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

/**
 * Test the {@link SerializationPolicyLoader} class.
 */
public class SerializationPolicyLoaderTest extends TestCase {
  // allowed by the policy
  static class A {
  }

  // not allowed by the policy
  static class B {
  }

  static class I {
  }

  private static final String OLD_VALID_POLICY_FILE_CONTENTS = A.class.getName()
      + ", true";

  // missing the instantiable attribute
  private static final String POLICY_FILE_MISSING_FIELD = A.class.getName();

  private static final String POLICY_FILE_TRIGGERS_CLASSNOTFOUND = "C,false";

  private static final String VALID_POLICY_FILE_CONTENTS = A.class.getName()
      + ", true, true, false, false, a, 1234\n" + B.class.getName()
      + ", false, false, true, false, b, 5678\n" + I.class.getName()
      + ", false, false, false, false, "
      + TypeNameObfuscator.SERVICE_INTERFACE_ID + ", 999\n";

  public static InputStream getInputStreamFromString(String content)
      throws UnsupportedEncodingException {
    return new ByteArrayInputStream(
        content.getBytes(SerializationPolicyLoader.SERIALIZATION_POLICY_FILE_ENCODING));
  }

  /**
   * Test that a valid policy file will allow the types in the policy to be used
   * and reject those that are not.
   * 
   * @throws ClassNotFoundException
   * @throws ParseException
   */
  public void testLoading() throws IOException, SerializationException,
      ParseException, ClassNotFoundException {

    InputStream is = getInputStreamFromString(VALID_POLICY_FILE_CONTENTS);
    List<ClassNotFoundException> notFounds = new ArrayList<ClassNotFoundException>();
    SerializationPolicy sp = SerializationPolicyLoader.loadFromStream(is,
        notFounds);
    assertTrue(notFounds.isEmpty());

    assertTrue(sp.shouldSerializeFields(A.class));
    sp.validateSerialize(A.class);
    assertFalse(sp.shouldDeserializeFields(A.class));
    assertCannotDeserialize(sp, A.class);

    assertFalse(sp.shouldSerializeFields(B.class));
    assertCannotDeserialize(sp, B.class);
    assertTrue(sp.shouldDeserializeFields(B.class));
    assertCannotDeserialize(sp, B.class);

    assertTrue(sp instanceof TypeNameObfuscator);
    TypeNameObfuscator ob = (TypeNameObfuscator) sp;
    assertEquals("a", ob.getTypeIdForClass(A.class));
    assertEquals(A.class.getName(), ob.getClassNameForTypeId("a"));
    assertEquals("b", ob.getTypeIdForClass(B.class));
    assertEquals(B.class.getName(), ob.getClassNameForTypeId("b"));
    assertEquals(TypeNameObfuscator.SERVICE_INTERFACE_ID,
        ob.getTypeIdForClass(I.class));
    assertEquals(I.class.getName(),
        ob.getClassNameForTypeId(TypeNameObfuscator.SERVICE_INTERFACE_ID));
  }

  /**
   * Test that a valid policy file will allow the types in the policy to be used
   * and reject those that are not. Uses the old policy file format, which is no
   * longer generated as of November 2008.
   * 
   * @throws ClassNotFoundException
   * @throws ParseException
   */
  public void testLoadingOldFileFormat() throws IOException,
      SerializationException, ParseException, ClassNotFoundException {

    InputStream is = getInputStreamFromString(OLD_VALID_POLICY_FILE_CONTENTS);
    SerializationPolicy sp = SerializationPolicyLoader.loadFromStream(is);

    assertTrue(sp.shouldDeserializeFields(A.class));
    assertTrue(sp.shouldSerializeFields(A.class));

    assertFalse(sp.shouldDeserializeFields(B.class));
    assertFalse(sp.shouldSerializeFields(B.class));

    sp.validateDeserialize(A.class);
    sp.validateSerialize(A.class);

    assertCannotDeserialize(sp, B.class);
    assertCannotSerialize(sp, B.class);
  }

  public void testPolicyFileMissingField() throws IOException,
      ClassNotFoundException {
    InputStream is = getInputStreamFromString(POLICY_FILE_MISSING_FIELD);
    try {
      SerializationPolicyLoader.loadFromStream(is);
      fail("Expected ParseException");
    } catch (ParseException e) {
      // expected to get here
    }
  }

  public void testPolicyFileTriggersClassNotFound() throws IOException,
      ParseException {
    InputStream is = getInputStreamFromString(POLICY_FILE_TRIGGERS_CLASSNOTFOUND);
    try {
      SerializationPolicyLoader.loadFromStream(is);
      fail("Expected ClassNotFoundException");
    } catch (ClassNotFoundException e) {
      // expected to get here
    }

    // Test loading without collecting ClassNotFoundExceptions.
    is.reset();
    SerializationPolicyLoader.loadFromStream(is, null);

    // Test loading and collecting ClassNotFoundExceptions.
    List<ClassNotFoundException> classNotFoundExceptions = new ArrayList<ClassNotFoundException>();
    is.reset();
    SerializationPolicyLoader.loadFromStream(is, classNotFoundExceptions);
    assertEquals(1, classNotFoundExceptions.size());
    assertNotNull(classNotFoundExceptions.get(0));
  }

  private void assertCannotDeserialize(SerializationPolicy sp, Class<?> cls) {
    try {
      sp.validateDeserialize(cls);
      fail("Expected SerializationException");
    } catch (SerializationException ex) {
      // should get here
    }
  }

  private void assertCannotSerialize(SerializationPolicy sp, Class<?> cls) {
    try {
      sp.validateSerialize(cls);
      fail("Expected SerializationException");
    } catch (SerializationException ex) {
      // should get here
    }
  }
}