wink-server/src/test/java/org/apache/wink/server/categories/CollectionCategoriesTest.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.
 *  
 *******************************************************************************/
package org.apache.wink.server.categories;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MultivaluedMap;

import org.apache.wink.common.annotations.Workspace;
import org.apache.wink.common.categories.Categories;
import org.apache.wink.common.categories.CollectionCategories;
import org.apache.wink.common.internal.MultivaluedMapImpl;
import org.apache.wink.common.internal.utils.MediaTypeUtils;
import org.apache.wink.common.model.atom.AtomCategory;
import org.apache.wink.server.internal.servlet.MockServletInvocationTest;
import org.apache.wink.test.diff.DiffIgnoreUpdateWithAttributeQualifier;
import org.apache.wink.test.mock.MockRequestConstructor;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;

public class CollectionCategoriesTest extends MockServletInvocationTest {

    private String ATOM_CATEGORIES_DUCUMENT = "collection_categories_document.xml";

    @Override
    protected Class<?>[] getClasses() {
        return new Class[] {CategoriesDocResource.class, CategoriesResource.class};
    }

    @Path("/cat")
    @Workspace(workspaceTitle = "Workspace", collectionTitle = "Title")
    public static class CategoriesDocResource implements CollectionCategories {

        public List<Categories> getCategories() {

            List<Categories> catsList = new ArrayList<Categories>();
            CategoriesResource categoriesResource = new CategoriesResource();

            // Defect severity categories are defined in stand-alone Categories
            // Document
            // created by CategoriesResource
            Categories severityCategories = new Categories();
            MultivaluedMap<String, String> variables = new MultivaluedMapImpl<String, String>();
            variables.add(CategoriesResource.CategoryParamCN, CategoriesResource.SeverityCN);
            severityCategories.setHref(categoriesResource, variables);
            catsList.add(severityCategories);

            Categories severityCategoriesClass = new Categories();
            MultivaluedMap<String, String> variables4Class =
                new MultivaluedMapImpl<String, String>();
            variables4Class.add(CategoriesResource.CategoryParamCN, CategoriesResource.SeverityCN);
            severityCategoriesClass.setHref(CategoriesResource.class, variables4Class);
            catsList.add(severityCategoriesClass);

            // Build defect status categories object for ServiceDocument
            Categories statusCategories = CategoriesResource.buildStatusCategoriesDocument();
            statusCategories.setFixed(true);

            if (!statusCategories.contains("Deffered", "urn:com:hp:qadefects:categories:status")) {
                statusCategories.addCategory("urn:com:hp:qadefects:categories:status",
                                             "Deffered",
                                             "Deffered");
            }
            if (!statusCategories.contains("Approved")) {
                statusCategories.addCategory("Approved");
            }

            catsList.add(statusCategories);

            return catsList;

        }
    }

    public void testAtomCategoriesSerialization() throws Exception {

        MockHttpServletRequest mockRequest =
            MockRequestConstructor.constructMockRequest("GET",
                                                        "/",
                                                        MediaTypeUtils.ATOM_SERVICE_DOCUMENT);

        MockHttpServletResponse response = invoke(mockRequest);
        String content = response.getContentAsString();

        String expectedSerialization = null;
        try {
            expectedSerialization = readCategoriesDocumentFromFile();
        } catch (IOException e) {
            fail("Failed to read " + ATOM_CATEGORIES_DUCUMENT);
        }

        DiffIgnoreUpdateWithAttributeQualifier diff;
        try {
            diff = new DiffIgnoreUpdateWithAttributeQualifier(expectedSerialization, content);
        } catch (Exception e) {
            fail("Failed to perform diff");
            throw e;
        }

        assertTrue("Expected atom feed documents to be similar" + " "
            + diff.toString()
            + "\nexpected:\n"
            + expectedSerialization
            + "\nresult:\n"
            + content, diff.similar());
    }

    private String readCategoriesDocumentFromFile() throws IOException {
        // Read expected Entry from file
        InputStream is =
            CollectionCategoriesTest.class.getResourceAsStream(ATOM_CATEGORIES_DUCUMENT);
        byte[] b = new byte[4096];
        int read = is.read(b);
        String expectedSerialization = new String(b, 0, read);
        return expectedSerialization;
    }

    @Path("/categories/{category_name}")
    public static class CategoriesResource {

        public static final String StatusCN        = "status";
        public static final String SeverityCN      = "severity";
        public static final String AllCatgoriesCN  = "all";
        public static final String CategoryParamCN = "category_name";
        public static final String CategoriesURL   = "categories";

        /**
         * This method will be invoked to get Categories Document
         * 
         * @param categoryName
         * @return CategoriesDocumentResource
         */
        @GET
        @Produces(MediaTypeUtils.ATOM_CATEGORIES_DOCUMENT)
        public Categories getCategoriesDocument(@PathParam(CategoryParamCN) String categoryName) {

            Categories cats = null;
            if (categoryName.equals(SeverityCN)) {
                cats = buildSeverityCategoryDocument();
            } else if (categoryName.equals(StatusCN)) {
                cats = buildStatusCategoriesDocument();
            } else if (categoryName.equals(AllCatgoriesCN)) {
                cats = buildCompleteCategoriesDocument();
            }
            return cats;
        }

        private Categories buildCompleteCategoriesDocument() {
            Categories severityCategoryDocument = buildSeverityCategoryDocument();
            Categories statusCategoriesDocument = buildStatusCategoriesDocument();

            List<AtomCategory> categories = severityCategoryDocument.getCategories();
            List<AtomCategory> categories2 = statusCategoriesDocument.getCategories();
            List<AtomCategory> categoriesAll = new ArrayList<AtomCategory>();
            categoriesAll.addAll(categories);
            categoriesAll.addAll(categories2);
            Categories allCategories = new Categories(categoriesAll);
            allCategories.setScheme("urn:com:hp:qadefects:categories");
            return allCategories;
        }

        public static Categories buildSeverityCategoryDocument() {
            Categories cats = new Categories();
            cats.setScheme("urn:com:hp:qadefects:categories:severity");
            cats.setFixed(true);

            AtomCategory severityCritical = new AtomCategory();
            severityCritical.setLabel("critical");
            severityCritical.setScheme("urn:com:hp:qadefects:categories:severity");
            severityCritical.setTerm("1-critical");
            cats.addCategory(severityCritical);

            AtomCategory severityHigh = new AtomCategory();
            severityHigh.setLabel("high");
            severityHigh.setScheme("urn:com:hp:qadefects:categories:severity");
            severityHigh.setTerm("2-high");
            cats.addCategory(severityHigh);

            AtomCategory severityMidium = new AtomCategory();
            severityMidium.setLabel("medium");
            severityMidium.setScheme("urn:com:hp:qadefects:categories:severity");
            severityMidium.setTerm("3-medium");
            cats.addCategory(severityMidium);

            AtomCategory severityMinor = new AtomCategory();
            severityMinor.setLabel("minor");
            severityMinor.setScheme("urn:com:hp:qadefects:categories:severity");
            severityMinor.setTerm("4-minor");
            cats.addCategory(severityMinor);

            return cats;
        }

        public static Categories buildStatusCategoriesDocument() {
            Categories statusCategories = new Categories();
            statusCategories.setScheme("urn:com:hp:qadefects:categories:status");

            AtomCategory assigned = new AtomCategory();
            assigned.setLabel("Assigned");
            assigned.setScheme("urn:com:hp:qadefects:categories:status");
            assigned.setTerm("Assigned");
            statusCategories.addCategory(assigned);

            AtomCategory statusFixed = new AtomCategory();
            statusFixed.setLabel("Fixed");
            statusFixed.setScheme("urn:com:hp:qadefects:categories:status");
            statusFixed.setTerm("Fixed");
            statusCategories.addCategory(statusFixed);

            AtomCategory statusNew = new AtomCategory();
            statusNew.setLabel("New");
            statusNew.setScheme("urn:com:hp:qadefects:categories:status");
            statusNew.setTerm("New");
            statusCategories.addCategory(statusNew);

            AtomCategory statusRejected = new AtomCategory();
            statusRejected.setLabel("Rejected");
            statusRejected.setScheme("urn:com:hp:qadefects:categories:status");
            statusRejected.setTerm("Rejected");
            statusCategories.addCategory(statusRejected);

            return statusCategories;
        }
    }

}