src/test/java/org/apache/sling/hc/it/core/HealthCheckFilterTest.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 SF 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.sling.hc.it.core;

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Dictionary;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;

import javax.inject.Inject;

import org.apache.sling.hc.api.HealthCheck;
import org.apache.sling.hc.api.Result;
import org.apache.sling.hc.util.HealthCheckFilter;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.ops4j.pax.exam.Configuration;
import org.ops4j.pax.exam.Option;
import org.ops4j.pax.exam.junit.PaxExam;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@RunWith(PaxExam.class)
public class HealthCheckFilterTest {

    private final Logger log = LoggerFactory.getLogger(getClass());

    private HealthCheckFilter filter;

    @Inject
    private BundleContext bundleContext;

    private List<TestHealthCheck> testServices = new ArrayList<TestHealthCheck>();
    private static int instanceCounter = 0;

    class TestHealthCheck implements HealthCheck {

        private final int id;
        private final ServiceRegistration<?> reg;
        final String[] tags;

        TestHealthCheck(String... tags) {
            id = instanceCounter++;
            this.tags = tags;
            final Dictionary<String, Object> props = new Hashtable<String, Object>();
            if (tags != null) {
                props.put(HealthCheck.TAGS, tags);
            }
            props.put(HealthCheck.TAGS, tags);
            reg = bundleContext.registerService(HealthCheck.class.getName(),
                    this, props);
            log.info("Registered {} with {}={}", new Object[] { this,
                    HealthCheck.TAGS, props.get(HealthCheck.TAGS) });
        }

        @Override
        public String toString() {
            return Arrays.asList(tags).toString();
        }

        @Override
        public boolean equals(Object other) {
            return other instanceof TestHealthCheck
                    && ((TestHealthCheck) other).id == id;
        }

        @Override
        public int hashCode() {
            return id;
        }

        @Override
        public Result execute() {
            return null;
        }

        void unregister() {
            reg.unregister();
        }
    }

    @Configuration
    public Option[] config() {
        return U.config();
    }

    @Before
    public void setup() {
        testServices.add(new TestHealthCheck("foo"));
        testServices.add(new TestHealthCheck("bar"));
        testServices.add(new TestHealthCheck("foo", "bar"));
        testServices.add(new TestHealthCheck("other", "thing"));
        testServices.add(new TestHealthCheck());
        filter = new HealthCheckFilter(bundleContext);
    }

    @After
    public void cleanup() {
        for (TestHealthCheck tc : testServices) {
            tc.unregister();
        }
    }

    /**
     * @param included
     *            true or false, in the same order as testServices
     */
    private void assertServices(List<HealthCheck> s, boolean... included) {
        final Iterator<TestHealthCheck> it = testServices.iterator();
        for (boolean inc : included) {
            final TestHealthCheck thc = it.next();
            if (inc) {
                assertTrue("Expecting list of services to include " + thc,
                        s.contains(thc));
            } else {
                assertFalse("Not expecting list of services to include " + thc,
                        s.contains(thc));
            }
        }
    }

    @Test
    public void testSelectorService() {
        assertNotNull("Expecting HealthCheckSelector service to be provided",
                filter);
    }

    @Test
    public void testAllServices() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks();
        assertServices(s, true, true, true, true, true);
    }

    @Test
    public void testEmptyTags() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("", "", "");
        assertServices(s, true, true, true, true, true);
    }

    @Test
    public void testFooTag() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("foo");
        assertServices(s, true, false, true, false, false);
    }

    @Test
    public void testBarTag() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("bar");
        assertServices(s, false, true, true, false, false);
    }

    @Test
    public void testFooAndBar() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("foo", "bar");
        assertServices(s, false, false, true, false, false);
    }

    @Test
    public void testFooMinusBar() {
        final List<HealthCheck> s = filter
                .getTaggedHealthChecks("foo", "-bar");
        assertServices(s, true, false, false, false, false);
    }

    @Test
    public void testWhitespace() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks(
                "\t \n\r foo  \t", "", " \t-bar\n", "");
        assertServices(s, true, false, false, false, false);
    }

    @Test
    public void testOther() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("other");
        assertServices(s, false, false, false, true, false);
    }

    @Test
    public void testMinusOther() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("-other");
        assertServices(s, true, true, true, false, true);
    }

    @Test
    public void testMinusOtherFoo() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("-other",
                "-foo");
        assertServices(s, false, true, false, false, true);
    }

    @Test
    public void testNoResults() {
        final List<HealthCheck> s = filter.getTaggedHealthChecks("NOT A TAG");
        assertTrue("Expecting no services", s.isEmpty());
    }
}