wifi/tests/src/android/net/wifi/hotspot2/pps/UpdateParameterTest.java

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * 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 android.net.wifi.hotspot2.pps;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import android.os.Parcel;
import android.test.suitebuilder.annotation.SmallTest;
import android.util.Base64;

import org.junit.Test;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
 * Unit tests for {@link android.net.wifi.hotspot2.pps.UpdateParameter}.
 */
@SmallTest
public class UpdateParameterTest {
    private static final int MAX_URI_BYTES = 1023;
    private static final int MAX_URL_BYTES = 1023;
    private static final int MAX_USERNAME_BYTES = 63;
    private static final int MAX_PASSWORD_BYTES = 255;
    private static final int CERTIFICATE_SHA256_BYTES = 32;

    /**
     * Helper function for creating a {@link UpdateParameter} for testing.
     *
     * @return {@link UpdateParameter}
     */
    private static UpdateParameter createUpdateParameter() {
        UpdateParameter updateParam = new UpdateParameter();
        updateParam.setUpdateIntervalInMinutes(1712);
        updateParam.setUpdateMethod(UpdateParameter.UPDATE_METHOD_OMADM);
        updateParam.setRestriction(UpdateParameter.UPDATE_RESTRICTION_HOMESP);
        updateParam.setServerUri("server.pdate.com");
        updateParam.setUsername("username");
        updateParam.setBase64EncodedPassword(
                Base64.encodeToString("password".getBytes(), Base64.DEFAULT));
        updateParam.setTrustRootCertUrl("trust.cert.com");
        updateParam.setTrustRootCertSha256Fingerprint(new byte[32]);
        return updateParam;
    }

    /**
     * Helper function for verifying UpdateParameter after parcel write then read.
     * @param paramToWrite The UpdateParamter to verify
     * @throws Exception
     */
    private static void verifyParcel(UpdateParameter paramToWrite) throws Exception {
        Parcel parcel = Parcel.obtain();
        paramToWrite.writeToParcel(parcel, 0);

        parcel.setDataPosition(0);    // Rewind data position back to the beginning for read.
        UpdateParameter paramFromRead = UpdateParameter.CREATOR.createFromParcel(parcel);
        assertTrue(paramFromRead.equals(paramToWrite));
    }

    /**
     * Verify parcel read/write for an empty UpdateParameter.
     *
     * @throws Exception
     */
    @Test
    public void verifyParcelWithEmptyUpdateParameter() throws Exception {
        verifyParcel(new UpdateParameter());
    }

    /**
     * Verify parcel read/write for a UpdateParameter with all fields set.
     *
     * @throws Exception
     */
    @Test
    public void verifyParcelWithFullUpdateParameter() throws Exception {
        verifyParcel(createUpdateParameter());
    }

    /**
     * Verify that UpdateParameter created using copy constructor with null source should be the
     * same as the UpdateParameter created using default constructor.
     *
     * @throws Exception
     */
    @Test
    public void verifyCopyConstructionWithNullSource() throws Exception {
        UpdateParameter copyParam = new UpdateParameter(null);
        UpdateParameter defaultParam = new UpdateParameter();
        assertTrue(defaultParam.equals(copyParam));
    }

    /**
     * Verify that UpdateParameter created using copy constructor with a valid source should be the
     * same as the source.
     *
     * @throws Exception
     */
    @Test
    public void verifyCopyConstructionWithFullUpdateParameter() throws Exception {
        UpdateParameter origParam = createUpdateParameter();
        UpdateParameter copyParam = new UpdateParameter(origParam);
        assertTrue(origParam.equals(copyParam));
    }

    /**
     * Verify that a default UpdateParameter is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithDefault() throws Exception {
        UpdateParameter updateParam = new UpdateParameter();
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter created using {@link #createUpdateParameter} is valid,
     * since all fields are filled in with valid values.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithFullPolicy() throws Exception {
        assertTrue(createUpdateParameter().validate());
    }

    /**
     * Verify that an UpdateParameter with an unknown update method is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithUnknowMethod() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setUpdateMethod("adsfasd");
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with an unknown restriction is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithUnknowRestriction() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setRestriction("adsfasd");
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with an username exceeding maximum size is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithUsernameExceedingMaxSize() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        byte[] rawUsernameBytes = new byte[MAX_USERNAME_BYTES + 1];
        Arrays.fill(rawUsernameBytes, (byte) 'a');
        updateParam.setUsername(new String(rawUsernameBytes, StandardCharsets.UTF_8));
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with an empty username is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithEmptyUsername() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setUsername(null);
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with a password exceeding maximum size is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithPasswordExceedingMaxSize() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        byte[] rawPasswordBytes = new byte[MAX_PASSWORD_BYTES + 1];
        Arrays.fill(rawPasswordBytes, (byte) 'a');
        updateParam.setBase64EncodedPassword(new String(rawPasswordBytes, StandardCharsets.UTF_8));
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with an empty password is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithEmptyPassword() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setBase64EncodedPassword(null);
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with a Base64 encoded password that contained invalid padding
     * is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithPasswordContainedInvalidPadding() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setBase64EncodedPassword(updateParam.getBase64EncodedPassword() + "=");
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter without trust root certificate URL is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithoutTrustRootCertUrl() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setTrustRootCertUrl(null);
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with invalid trust root certificate URL is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithInvalidTrustRootCertUrl() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        byte[] rawUrlBytes = new byte[MAX_URL_BYTES + 1];
        Arrays.fill(rawUrlBytes, (byte) 'a');
        updateParam.setTrustRootCertUrl(new String(rawUrlBytes, StandardCharsets.UTF_8));
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter without trust root certificate SHA-256 fingerprint is
     * invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithouttrustRootCertSha256Fingerprint() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setTrustRootCertSha256Fingerprint(null);
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with an incorrect size trust root certificate SHA-256
     * fingerprint is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithInvalidtrustRootCertSha256Fingerprint() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setTrustRootCertSha256Fingerprint(new byte[CERTIFICATE_SHA256_BYTES + 1]);
        assertFalse(updateParam.validate());

        updateParam.setTrustRootCertSha256Fingerprint(new byte[CERTIFICATE_SHA256_BYTES - 1]);
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter without server URI is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithoutServerUri() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setServerUri(null);
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with an invalid server URI is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validatePolicyWithInvalidServerUri() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        byte[] rawUriBytes = new byte[MAX_URI_BYTES + 1];
        Arrays.fill(rawUriBytes, (byte) 'a');
        updateParam.setServerUri(new String(rawUriBytes, StandardCharsets.UTF_8));
        assertFalse(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with update interval set to "never" will not perform
     * validation on other parameters, since update is not applicable in this case.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithNoServerCheck() throws Exception {
        UpdateParameter updateParam = new UpdateParameter();
        updateParam.setUpdateIntervalInMinutes(UpdateParameter.UPDATE_CHECK_INTERVAL_NEVER);
        updateParam.setUsername(null);
        updateParam.setBase64EncodedPassword(null);
        updateParam.setUpdateMethod(null);
        updateParam.setRestriction(null);
        updateParam.setServerUri(null);
        updateParam.setTrustRootCertUrl(null);
        updateParam.setTrustRootCertSha256Fingerprint(null);
        assertTrue(updateParam.validate());
    }

    /**
     * Verify that an UpdateParameter with unset update interval is invalid.
     *
     * @throws Exception
     */
    @Test
    public void validateUpdateParameterWithoutUpdateInterval() throws Exception {
        UpdateParameter updateParam = createUpdateParameter();
        updateParam.setUpdateIntervalInMinutes(Long.MIN_VALUE);
        assertFalse(updateParam.validate());
    }
}