path: root/security/src/test/api/java/org/apache/harmony/security/tests/java/security/cert/CertStore1Test.java

/*
 *  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.
 */

/**
 * @author Vera Y. Petrashkova
 */

package org.apache.harmony.security.tests.java.security.cert;

import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Provider;
import java.security.Security;
import java.security.cert.CertStore;
import java.security.cert.CertStoreException;
import java.security.cert.CertStoreParameters;
import java.security.cert.CertStoreSpi;
import java.security.cert.CollectionCertStoreParameters;
import java.security.cert.LDAPCertStoreParameters;
import java.util.Collection;

import org.apache.harmony.security.tests.support.SpiEngUtils;
import org.apache.harmony.security.tests.support.cert.MyCertStoreParameters;
import org.apache.harmony.security.tests.support.cert.MyCertStoreSpi;

import junit.framework.TestCase;

/**
 * Tests for <code>CertStore</code> class constructors and
 * methods.
 */

public class CertStore1Test extends TestCase {

    /**
     * Constructor for CertStoreTests.
     *
     * @param arg0
     */
    public CertStore1Test(String arg0) {
        super(arg0);
    }

    public static final String srvCertStore = "CertStore";

    private static final String defaultType = "LDAP";
    public static final String[] validValues = {
            "LDAP", "ldap", "Ldap", "lDAP", "lDaP" };
    public static String[] validValuesC = null;

    private static String[] invalidValues = SpiEngUtils.invalidValues;

    private static boolean LDAPSupport = false;
    private static final String CollectionType = "Collection";
    private static boolean CollectionSupport = false;

    private static Provider defaultProvider;
    private static String defaultProviderName;
    private static Provider defaultProviderCol;
    private static String defaultProviderColName;

    private static String NotSupportMsg = "";

    static {
        defaultProvider = SpiEngUtils.isSupport(defaultType,
                srvCertStore);
        LDAPSupport = (defaultProvider != null);
        defaultProviderName = (LDAPSupport ? defaultProvider.getName() : null);
        NotSupportMsg = "LDAP and Collection algorithm are not supported";

        defaultProviderCol = SpiEngUtils.isSupport(CollectionType,
                srvCertStore);
        CollectionSupport = (defaultProviderCol != null);
        defaultProviderColName = (CollectionSupport ? defaultProviderCol.getName() : null);
        if (CollectionSupport) {
            validValuesC = new String[3];
            validValuesC[0] = CollectionType;
            validValuesC[1] = CollectionType.toUpperCase();
            validValuesC[2] = CollectionType.toLowerCase();
        }
    }

    private Provider dProv = null;
    private String dName = null;
    private String dType = null;
    private CertStoreParameters dParams = null;
    private String[] dValid;

    private boolean initParams() {
        if (!LDAPSupport && !CollectionSupport) {
            fail(NotSupportMsg);
            return false;
        }
        dParams = (CollectionSupport ? (CertStoreParameters) new CollectionCertStoreParameters() :
                (CertStoreParameters) new LDAPCertStoreParameters());
        dType = (CollectionSupport ? CollectionType : defaultType);
        dProv = (CollectionSupport ? defaultProviderCol : defaultProvider);
        dName = (CollectionSupport ? defaultProviderColName : defaultProviderName);
        dValid = (CollectionSupport ? validValuesC : validValues);
        return true;
    }

    private CertStore[] createCS() {
        if (!LDAPSupport && !CollectionSupport) {
            fail(NotSupportMsg);
            return null;
        }
        try {
            CertStore[] ss = new CertStore[3];
            ss[0] = CertStore.getInstance(dType, dParams);
            ss[1] = CertStore.getInstance(dType, dParams, dProv);
            ss[2] = CertStore.getInstance(dType, dParams, dName);
            return ss;
        } catch (Exception e) {
            return null;
        }
    }


    /**
     * Test for <code>getDefaultType()</code> method
     * Assertion: returns security property "certstore.type" or "LDAP"
     */
    public void testCertStore01() {
        if (!LDAPSupport) {
            return;
        }
        String dt = CertStore.getDefaultType();
        String sn = Security.getProperty("certstore.type");
        String def = "Proba.cert.store.type";
        if (sn == null) {
            sn = defaultType;
        }
        assertNotNull("Default type have not be null", dt);
        assertEquals("Incorrect default type", dt, sn);

        Security.setProperty("certstore.type", def);
        dt = CertStore.getDefaultType();
        assertEquals("Incorrect default type", dt, def);
        Security.setProperty("certstore.type", sn);
        assertEquals("Incorrect default type", Security.getProperty("certstore.type"), sn);
    }

    /**
     * Test for
     * <code>CertStore</code> constructor
     * Assertion: returns CertStore object
     */

    public void testCertStore02() throws NoSuchAlgorithmException,
            InvalidAlgorithmParameterException, CertStoreException {
        if (!initParams()) {
            return;
        }
        MyCertStoreParameters pp = new MyCertStoreParameters();
        CertStoreSpi spi = new MyCertStoreSpi(pp);
        CertStore certS = new myCertStore(spi, dProv, dType, pp);
        assertEquals("Incorrect algorithm", certS.getType(), dType);
        assertEquals("Incorrect provider", certS.getProvider(), dProv);
        assertTrue("Incorrect parameters", certS.getCertStoreParameters()
                instanceof MyCertStoreParameters);
        try {
            certS.getCertificates(null);
            fail("CertStoreException must be thrown");
        } catch (CertStoreException e) {
        }
        certS = new myCertStore(null, null, null, null);
        assertNull("Incorrect algorithm", certS.getType());
        assertNull("Incorrect provider", certS.getProvider());
        assertNull("Incorrect parameters", certS.getCertStoreParameters());
        try {
            certS.getCertificates(null);
            fail("NullPointerException must be thrown");
        } catch (NullPointerException e) {
        }
    }

    /**
     * Test for <code>getInstance(String type, CertStoreParameters params)</code> method
     * Assertion:
     * throws NullPointerException when type is null
     * throws NoSuchAlgorithmException when type is incorrect;
     */
    public void testCertStore03() throws InvalidAlgorithmParameterException {
        if (!initParams()) {
            return;
        }
        try {
            CertStore.getInstance(null, dParams);
            fail("NullPointerException or NoSuchAlgorithmException must be thrown when type is null");
        } catch (NullPointerException e) {
        } catch (NoSuchAlgorithmException e) {
        }
        for (int i = 0; i < invalidValues.length; i++) {
            try {
                CertStore.getInstance(invalidValues[i], dParams);
                fail("NoSuchAlgorithmException must be thrown");
            } catch (NoSuchAlgorithmException e) {
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, CertStoreParameters params)</code> method
     * Assertion: return CertStore object
     */
    public void testCertStore05()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams);
            assertEquals("Incorrect type", certS.getType(), dValid[i]);
            certS.getCertStoreParameters();
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion: throws IllegalArgumentException when provider is null or empty
     * <p/>
     * FIXME: verify IllegalArgumentException when provider is empty
     */
    public void testCertStore06()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException,
            NoSuchProviderException {
        if (!initParams()) {
            return;
        }
        String provider = null;
        for (int i = 0; i < dValid.length; i++) {
            try {
                CertStore.getInstance(dValid[i], dParams, provider);
                fail("IllegalArgumentException must be thrown");
            } catch (IllegalArgumentException e) {
            }
            try {
                CertStore.getInstance(dValid[i], dParams, "");
                fail("IllegalArgumentException must be thrown");
            } catch (IllegalArgumentException e) {
            }
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion: throws NoSuchProviderException when provider has invalid value
     */
    public void testCertStore07()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        for (int i = 0; i < dValid.length; i++) {
            for (int j = 1; j < invalidValues.length; j++) {
                try {
                    CertStore.getInstance(dValid[i], dParams, invalidValues[j]);
                    fail("NoSuchProviderException must be thrown");
                } catch (NoSuchProviderException e) {
                }
            }
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion:
     * throws NullPointerException when type is null
     * throws NoSuchAlgorithmException when type is incorrect;
     */
    public void testCertStore08()
            throws InvalidAlgorithmParameterException, NoSuchProviderException,
            NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        for (int i = 0; i < invalidValues.length; i++) {
            try {
                CertStore.getInstance(invalidValues[i], dParams, dName);
                fail("NoSuchAlgorithmException must be thrown");
            } catch (NoSuchAlgorithmException e) {
            }
        }
        try {
            CertStore.getInstance(null, dParams, dName);
            fail("NullPointerException or NoSuchAlgorithmException must be thrown when type is null");
        } catch (NullPointerException e) {
        } catch (NoSuchAlgorithmException e) {
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, String provider)</code>
     * Assertion: return CertStore object
     */
    public void testCertStore10()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException, NoSuchProviderException {
        if (!initParams()) {
            return;
        }
        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams, dName);
            assertEquals("Incorrect type", certS.getType(), dValid[i]);
            certS.getCertStoreParameters();
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, Provider provider)</code>
     * Assertion: throws IllegalArgumentException when provider is null
     */
    public void testCertStore11()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException,
            NoSuchProviderException {
        if (!initParams()) {
            return;
        }
        Provider provider = null;
        for (int i = 0; i < dValid.length; i++) {
            try {
                CertStore.getInstance(dValid[i], dParams, provider);
                fail("IllegalArgumentException must be thrown");
            } catch (IllegalArgumentException e) {
            }
        }
    }

    /**
     * Test for <code>getInstance(String type, CertStoreParameters params, Provider provider)</code> method
     * Assertion:
     * throws NullPointerException when type is null
     * throws NoSuchAlgorithmException when type is incorrect;
     */
    public void testCertStore12()
            throws InvalidAlgorithmParameterException,
            NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        try {
            CertStore.getInstance(null, dParams, dProv);
            fail("NullPointerException or NoSuchAlgorithmException must be thrown when type is null");
        } catch (NullPointerException e) {
        } catch (NoSuchAlgorithmException e) {
        }
        for (int i = 0; i < invalidValues.length; i++) {
            try {
                CertStore.getInstance(invalidValues[i], dParams, dProv);
                fail("NoSuchAlgorithmException must be thrown");
            } catch (NoSuchAlgorithmException e) {
            }
        }
    }

    /**
     * Test for method
     * <code>getInstance(String type, CertStoreParameters params, Provider provider)</code>
     * Assertion: return CertStore object
     */
    public void testCertStore14()
            throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
        if (!initParams()) {
            return;
        }
        CertStore certS;
        for (int i = 0; i < dValid.length; i++) {
            certS = CertStore.getInstance(dValid[i], dParams, dProv);
            assertEquals("Incorrect type", certS.getType(), dValid[i]);
            certS.getCertStoreParameters();
        }
    }

    /**
     * Test for methods
     * <code>getCertificates(CertSelector selector)</code>
     * <code>getCRLs(CRLSelector selector)</code>
     * Assertion: returns empty Collection when selector is null
     */
    public void testCertStore15()
            throws NoSuchAlgorithmException, InvalidAlgorithmParameterException,
            CertStoreException {
        if (!initParams()) {
            return;
        }
        CertStore[] certS = createCS();
        assertNotNull("CertStore object were not created", certS);
        Collection coll;
        for (int i = 0; i < certS.length; i++) {
            coll = certS[i].getCertificates(null);
            assertTrue("Result collection not empty", coll.isEmpty());
            coll = certS[i].getCRLs(null);
            assertTrue("Result collection not empty", coll.isEmpty());
        }
    }
}

/**
 * Additional class to verify CertStore constructor
 */
class myCertStore extends CertStore {
    public myCertStore(CertStoreSpi spi, Provider prov, String type, CertStoreParameters params) {
        super(spi, prov, type, params);
    }
}