path: root/client-compiler/tests/src/com/vaadin/tools/CvalCheckerTest.java

/*
 * Copyright 2000-2014 Vaadin Ltd.
 *
 * 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.vaadin.tools;

import static com.vaadin.tools.CvalAddonsChecker.VAADIN_ADDON_LICENSE;
import static com.vaadin.tools.CvalAddonsChecker.VAADIN_ADDON_NAME;
import static com.vaadin.tools.CvalAddonsChecker.VAADIN_ADDON_TITLE;
import static com.vaadin.tools.CvalAddonsChecker.VAADIN_ADDON_VERSION;
import static com.vaadin.tools.CvalChecker.GRACE_DAYS_MSECS;
import static com.vaadin.tools.CvalChecker.cacheLicenseInfo;
import static com.vaadin.tools.CvalChecker.deleteCache;
import static com.vaadin.tools.CvalChecker.parseJson;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.prefs.Preferences;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import com.vaadin.tools.CvalChecker.CvalInfo;
import com.vaadin.tools.CvalChecker.CvalServer;
import com.vaadin.tools.CvalChecker.InvalidCvalException;
import com.vaadin.tools.CvalChecker.UnreachableCvalServerException;

/**
 * The CvalChecker test.
 */
public class CvalCheckerTest {

    static final String productNameCval = "test.cval";
    static final String productTitleCval = "Vaadin Test";
    static final String productNameAgpl = "test.agpl";
    static final String productTitleAgpl = "Vaadin Test";
    static final String productNameApache = "test.apache";
    static final String VALID_KEY = "valid";
    static final String INVALID_KEY = "invalid";

    static final String responseJson = "{'licenseKey':'" + VALID_KEY + "',"
            + "'licensee':'Test User','type':'normal',"
            + "'expiredEpoch':'1893511225000'," + "'product':{'name':'"
            + productNameCval + "', 'version': 2}}";

    private static ByteArrayOutputStream outContent;

    // A provider returning a valid license if productKey is valid or null if
    // invalid
    static final CvalServer validLicenseProvider = new CvalServer() {
        @Override
        String askServer(String productName, String productKey, int timeout) {
            return VALID_KEY.equals(productKey) ? responseJson : null;
        }
    };
    // A provider returning a valid evaluation license
    static final CvalServer validEvaluationLicenseProvider = new CvalServer() {
        @Override
        String askServer(String productName, String productKey, int timeout) {
            return responseJson.replace("normal", "evaluation");
        }
    };
    // A provider returning an expired license with a server message
    static final CvalServer expiredLicenseProviderWithMessage = new CvalServer() {
        @Override
        String askServer(String productName, String productKey, int timeout) {
            return responseJson
                    .replace("'expired",
                            "'message':'Custom\\\\nServer\\\\nMessage','expired':true,'expired");
        }
    };
    // A provider returning an expired license with a server message
    static final CvalServer expiredLicenseProvider = new CvalServer() {
        @Override
        String askServer(String productName, String productKey, int timeout) {
            return responseJson.replace("'expired", "'expired':true,'expired");
        }
    };
    // A provider returning an expired epoch license
    static final CvalServer expiredEpochLicenseProvider = new CvalServer() {
        @Override
        String askServer(String productName, String productKey, int timeout) {
            long ts = System.currentTimeMillis() - GRACE_DAYS_MSECS - 1000;
            return responseJson.replace("1893511225000", "" + ts);
        }
    };
    // A provider returning an unlimited license
    static final CvalServer unlimitedLicenseProvider = new CvalServer() {
        @Override
        String askServer(String productName, String productKey, int timeout) {
            return responseJson.replaceFirst("1893511225000", "");
        }
    };
    // An unreachable provider
    static final CvalServer unreachableLicenseProvider = new CvalServer() {
        @Override
        String askServer(String productName, String productKey, int timeout)
                throws IOException {
            // Normally there is no route for this ip in public routers, so we
            // should get a timeout.
            licenseUrl = "http://localhost:9999/";
            return super.askServer(productName, productKey, 1000);
        }
    };

    private CvalChecker licenseChecker;
    private String licenseName;

    @Before
    public void setup() {
        licenseChecker = new CvalChecker()
                .setLicenseProvider(validLicenseProvider);
        licenseName = CvalChecker.computeLicenseName(productNameCval);
        System.getProperties().remove(licenseName);
        deleteCache(productNameCval);
    }

    @Test
    public void testValidateProduct() throws Exception {
        deleteCache(productNameCval);

        // If the license key in our environment is null, throw an exception
        try {
            licenseChecker.validateProduct(productNameCval, "2.1",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.assertEquals(productNameCval, expected.name);
        }
        Assert.assertFalse(cacheExists(productNameCval));

        // If the license key is empty, throw an exception
        System.setProperty(licenseName, "");
        try {
            licenseChecker.validateProduct(productNameCval, "2.1",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.assertEquals(productNameCval, expected.name);
        }
        Assert.assertFalse(cacheExists(productNameCval));

        // If license key is invalid, throw an exception
        System.setProperty(licenseName, "invalid");
        try {
            licenseChecker.validateProduct(productNameCval, "2.1",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.assertEquals(productNameCval, expected.name);
        }
        Assert.assertFalse(cacheExists(productNameCval));

        // Fail if version is bigger
        System.setProperty(licenseName, VALID_KEY);
        try {
            licenseChecker.validateProduct(productNameCval, "3.0",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.assertEquals(productNameCval, expected.name);
        }
        Assert.assertFalse(cacheExists(productNameCval));

        // Success if license key and version are valid
        System.setProperty(licenseName, VALID_KEY);
        licenseChecker
                .validateProduct(productNameCval, "2.1", productTitleCval);
        Assert.assertTrue(cacheExists(productNameCval));

        // Success if license and cache file are valid, although the license
        // server is offline
        licenseChecker.setLicenseProvider(unreachableLicenseProvider);
        licenseChecker
                .validateProduct(productNameCval, "2.1", productTitleCval);
        Assert.assertTrue(cacheExists(productNameCval));

        // Fail if license key changes although cache file were validated
        // previously and it is ok, we are offline
        try {
            System.setProperty(licenseName, INVALID_KEY);
            licenseChecker.validateProduct(productNameCval, "2.1",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.fail();
        } catch (UnreachableCvalServerException expected) {
            Assert.assertEquals(productNameCval, expected.name);
        }
        Assert.assertFalse(cacheExists(productNameCval));

        // Fail with unreachable exception if license has never verified and
        // server is offline
        try {
            System.setProperty(licenseName, VALID_KEY);
            licenseChecker.validateProduct(productNameCval, "2.1",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.fail();
        } catch (UnreachableCvalServerException expected) {
            Assert.assertEquals(productNameCval, expected.name);
        }
        Assert.assertFalse(cacheExists(productNameCval));

        // Fail when expired flag comes in the server response, although the
        // expired is valid.
        deleteCache(productNameCval);
        licenseChecker.setLicenseProvider(expiredLicenseProviderWithMessage);
        try {
            licenseChecker.validateProduct(productNameCval, "2.1",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.assertEquals(productNameCval, expected.name);
            // Check that we use server customized message if it comes
            Assert.assertTrue(expected.getMessage().contains("Custom"));
        }
        Assert.assertTrue(cacheExists(productNameCval));

        // Check an unlimited license
        licenseChecker.setLicenseProvider(unlimitedLicenseProvider);
        licenseChecker
                .validateProduct(productNameCval, "2.1", productTitleCval);
        Assert.assertTrue(cacheExists(productNameCval));

        // Fail if expired flag does not come, but expired epoch is in the past
        System.setProperty(licenseName, VALID_KEY);
        deleteCache(productNameCval);
        licenseChecker.setLicenseProvider(expiredEpochLicenseProvider);
        try {
            licenseChecker.validateProduct(productNameCval, "2.1",
                    productTitleCval);
            Assert.fail();
        } catch (InvalidCvalException expected) {
            Assert.assertEquals(productNameCval, expected.name);
        }
        Assert.assertTrue(cacheExists(productNameCval));
    }

    /*
     * Creates a new .jar file with a MANIFEST.MF with all vaadin license info
     * attributes set, and add the .jar to the classpath
     */
    static void addLicensedJarToClasspath(String productName, String licenseType)
            throws Exception {
        // Create a manifest with Vaadin CVAL license
        Manifest testManifest = new Manifest();
        testManifest.getMainAttributes().putValue("Manifest-Version", "1.0");
        testManifest.getMainAttributes().putValue(VAADIN_ADDON_LICENSE,
                licenseType);
        testManifest.getMainAttributes().putValue(VAADIN_ADDON_NAME,
                productName);
        testManifest.getMainAttributes().putValue(VAADIN_ADDON_TITLE,
                "Test " + productName);
        testManifest.getMainAttributes().putValue(VAADIN_ADDON_VERSION, "2");

        // Create a temporary Jar
        String tmpDir = System.getProperty("java.io.tmpdir");
        File testJarFile = new File(tmpDir + "vaadin." + productName + ".jar");
        testJarFile.deleteOnExit();
        JarOutputStream target = new JarOutputStream(new FileOutputStream(
                testJarFile), testManifest);
        target.close();

        // Add the new jar to our classpath (use reflection)
        URL url = new URL("file://" + testJarFile.getAbsolutePath());
        final Method addURL = URLClassLoader.class.getDeclaredMethod("addURL",
                new Class[] { URL.class });
        addURL.setAccessible(true);
        final URLClassLoader urlClassLoader = (URLClassLoader) Thread
                .currentThread().getContextClassLoader();
        addURL.invoke(urlClassLoader, new Object[] { url });
    }

    static boolean cacheExists(String productName) {
        return cachedPreferences(productName) != null;
    }

    static String cachedPreferences(String productName) {
        // ~/Library/Preferences/com.apple.java.util.prefs.plist
        // .java/.userPrefs/com/google/gwt/dev/shell/prefs.xml
        // HKEY_CURRENT_USER\SOFTWARE\JavaSoft\Prefs
        Preferences p = Preferences.userNodeForPackage(CvalInfo.class);
        return p.get(productName, null);
    }

    static void saveCache(String productName, String key, Boolean expired,
            Long expireTs, String type) {
        String json = responseJson.replace(productNameCval, productName);
        if (expired != null && expired) {
            expireTs = System.currentTimeMillis() - GRACE_DAYS_MSECS - 1000;
        }
        if (expireTs != null) {
            json = json.replace("1893511225000", "" + expireTs);
        }
        if (key != null) {
            json = json.replace(VALID_KEY, key);
        }
        if (type != null) {
            json = json.replace("normal", type);

        }
        cacheLicenseInfo(parseJson(json));
    }

    static void captureSystemOut() {
        outContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(outContent));
    }

    static String readSystemOut() {
        restoreSystemOut();
        return outContent.toString();
    }

    static void restoreSystemOut() {
        System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
    }
}