com.damnhandy.uri.template.conformance.AbstractUriTemplateConformanceTest.java Source code

Introduction

Here is the source code for com.damnhandy.uri.template.conformance.AbstractUriTemplateConformanceTest.java

Source

/*
 * Copyright 2012, Ryan J. McDonough
 *
 * 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.damnhandy.uri.template.conformance;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import com.damnhandy.uri.template.UriTemplate;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * @author <a href="mailto:ryan@damnhandy.com">Ryan J. McDonough</a>
 *
 */
@RunWith(Parameterized.class)
public abstract class AbstractUriTemplateConformanceTest {

    /**
     * <p>
     * Loads the test data from the JSON file and generated the parameter list.
     * </p>
     *
     * @param file
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    protected static Collection<Object[]> loadTestData(File file) throws Exception {
        InputStream in = new FileInputStream(file);
        try {
            ObjectMapper mapper = new ObjectMapper();
            Map<String, Object> testsuites = mapper.readValue(in, new TypeReference<Map<String, Object>>() {
            });

            List<Object[]> params = new ArrayList<Object[]>();
            for (Map.Entry<String, Object> entry : testsuites.entrySet()) {
                String name = entry.getKey();
                Map<String, Object> testsuite = (Map<String, Object>) entry.getValue();
                Map<String, Object> variables = (Map<String, Object>) testsuite.get("variables");
                List<List<Object>> testcases = (List<List<Object>>) testsuite.get("testcases");

                for (List<Object> test : testcases) {
                    Object[] p = new Object[4];
                    p[0] = variables;
                    p[1] = test.get(0); // expression
                    p[2] = test.get(1); // expected result
                    p[3] = name; // test suite label
                    params.add(p);
                }
            }
            return params;
        } finally {
            in.close();
        }

    }

    /**
     * The name of the testsuite
     */
    protected String testsuite;

    /**
     * The expression patter string
     */
    protected String template;

    /**
     * The expected result
     */
    protected Object expected;

    /**
     * The collection of variables to be used on each test
     */
    protected Map<String, Object> variables;

    /**
     * @param expression
     * @param expected
     */
    public AbstractUriTemplateConformanceTest(Map<String, Object> vars, String template, Object expected,
            String testsuite) {
        this.template = template;
        this.expected = expected;
        this.variables = vars;
        this.testsuite = testsuite;
    }

    /**
     *
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    @Test
    public void test() throws Exception {
        UriTemplate t = UriTemplate.fromTemplate(template);
        String actual;
        try {
            actual = t.expand(variables);
            if (expected instanceof String) {
                Assert.assertEquals(testsuite + "->  Template: " + template, expected, actual);
            } else if (expected instanceof Collection) {
                List<String> combinations = (List<String>) expected;
                boolean match = false;
                for (String combo : combinations) {
                    if (combo.equalsIgnoreCase(actual)) {
                        match = true;
                        break;
                    }
                }
                Assert.assertTrue(testsuite + "->  Template: " + template + " returned " + actual
                        + " and did not match any combination", match);
            }
        } catch (Exception e) {
            Assert.fail(testsuite + "->  Template: " + template + " returned " + e.getMessage()
                    + " and did not match any combination");
        }

    }
}