healthcheck/core/src/test/java/org/apache/felix/hc/core/impl/CompositeHealthCheckTest.java - felix-dev - Git at Google

 /*
  * 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.felix.hc.core.impl;

 import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.argThat;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;

 import org.apache.felix.hc.api.HealthCheck;
 import org.apache.felix.hc.api.Result;
 import org.apache.felix.hc.api.execution.HealthCheckExecutionOptions;
 import org.apache.felix.hc.api.execution.HealthCheckExecutionResult;
 import org.apache.felix.hc.api.execution.HealthCheckExecutor;
 import org.apache.felix.hc.api.execution.HealthCheckMetadata;
 import org.apache.felix.hc.api.execution.HealthCheckSelector;
 import org.apache.felix.hc.core.impl.executor.ExecutionResult;
 import org.apache.felix.hc.core.impl.util.HealthCheckFilter;
 import org.hamcrest.Description;
 import org.hamcrest.Matcher;
 import org.hamcrest.TypeSafeMatcher;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentMatcher;
 import org.mockito.Matchers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.Constants;
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.ComponentContext;

 public class CompositeHealthCheckTest {

     @Spy
     private CompositeHealthCheck compositeHealthCheck = new CompositeHealthCheck();

     @Mock
     private HealthCheckExecutor healthCheckExecutor;

     @Mock
     private ComponentContext componentContext;

     @Before
     public void setup() {
         MockitoAnnotations.initMocks(this);
         compositeHealthCheck.setHealthCheckExecutor(healthCheckExecutor);
         compositeHealthCheck.setFilterTags(new String[] {});
         compositeHealthCheck.setComponentContext(componentContext);
     }

     @Test
     public void testExecution() {

         doReturn((Result) null).when(compositeHealthCheck).checkForRecursion(Matchers.<ServiceReference> any(),
                 Matchers.<Set<String>> any());
         String[] testTags = new String[] { "tag1" };
         compositeHealthCheck.setFilterTags(testTags);

         List<HealthCheckExecutionResult> executionResults = new LinkedList<HealthCheckExecutionResult>();
         executionResults.add(createExecutionResult("Check 1", testTags, new Result(Result.Status.OK, "Good")));
         executionResults.add(createExecutionResult("Check 2", testTags, new Result(Result.Status.CRITICAL, "Bad")));

         when(healthCheckExecutor.execute(any(HealthCheckSelector.class), any(HealthCheckExecutionOptions.class)))
                 .thenReturn(executionResults);

         Result result = compositeHealthCheck.execute();

         verify(healthCheckExecutor, times(1)).execute(argThat(selectorWithTags(testTags)), argThat(andOptions));

         assertEquals(Result.Status.CRITICAL, result.getStatus());

     }

     private ArgumentMatcher<HealthCheckSelector> selectorWithTags(final String[] tags) {
         return new ArgumentMatcher<HealthCheckSelector>() {
             @Override
             public boolean matches(HealthCheckSelector healthCheckSelector) {
                 return Arrays.equals(healthCheckSelector.tags(), tags) && healthCheckSelector.names() == null;
             }

             @Override
             public String toString() {
                 return "a select with tags (" + Arrays.toString(tags) + ") and no names.";
             }
         };
     }

     private HealthCheckExecutionResult createExecutionResult(String name, String[] testTags, Result result) {
         HealthCheckExecutionResult healthCheckExecutionResult = new ExecutionResult(
                 new HealthCheckMetadata(new DummyHcServiceReference(name, testTags,
                         new String[0])),
                 result, 0L);
         return healthCheckExecutionResult;
     }

     @Test
     public void testSimpleRecursion() {

         // composite check referencing itself
         final String[] filterTags = new String[] { "check1" };
         final DummyHcServiceReference hcRef = new DummyHcServiceReference("Check 1", new String[] { "check1" }, filterTags);

         // test check is hcRef
         doReturn(hcRef).when(componentContext).getServiceReference();
         compositeHealthCheck.setFilterTags(filterTags);

         compositeHealthCheck.setHealthCheckFilter(new HealthCheckFilter(null) {

             @Override
             public ServiceReference[] getHealthCheckServiceReferences(HealthCheckSelector selector) {
                 String[] tags = selector.tags();
                 ServiceReference[] result = new ServiceReference[] {};
                 if (tags.length > 0) {
                     if (tags[0].equals(filterTags[0])) {
                         result = new ServiceReference[] { hcRef };
                     }
                 }
                 return result;
             }

         });

         Result result = compositeHealthCheck.execute();

         verify(healthCheckExecutor, never()).execute(any(HealthCheckSelector.class));
         assertEquals(Result.Status.HEALTH_CHECK_ERROR, result.getStatus());
     }

     @Test
     public void testCyclicRecursion() {

         // three checks, cyclic
         final String[] filterTags = new String[] { "check2" };
         final DummyHcServiceReference hcRef1 = new DummyHcServiceReference("Check 1", new String[] { "check1" }, filterTags);
         final DummyHcServiceReference hcRef2 = new DummyHcServiceReference("Check 2", new String[] { "check2" }, new String[] { "check3" });
         final DummyHcServiceReference hcRef3 = new DummyHcServiceReference("Check 3", new String[] { "check3" }, new String[] { "check1" });

         // test check is hcRef1
         doReturn(hcRef1).when(componentContext).getServiceReference();
         compositeHealthCheck.setFilterTags(filterTags);

         compositeHealthCheck.setHealthCheckFilter(new HealthCheckFilter(null) {

             @Override
             public ServiceReference[] getHealthCheckServiceReferences(HealthCheckSelector selector, boolean combineTagsWithOr) {
                 String[] tags = selector.tags();
                 ServiceReference[] result = new ServiceReference[] {};
                 if (tags.length > 0) {
                     if (tags[0].equals(filterTags[0])) {
                         result = new ServiceReference[] { hcRef2 };
                     } else if (tags[0].equals("check3")) {
                         result = new ServiceReference[] { hcRef3 };
                     } else if (tags[0].equals("check1")) {
                         result = new ServiceReference[] { hcRef1 };
                     }
                 }

                 return result;
             }

         });

         Result result = compositeHealthCheck.execute();

         verify(healthCheckExecutor, never()).execute(any(HealthCheckSelector.class));
         assertEquals(Result.Status.HEALTH_CHECK_ERROR, result.getStatus());
     }

     @Test
     public void testCombineWithOr() {

         // composite check referencing itself
         final String[] filterTags = new String[] { "check1" };
         compositeHealthCheck.setFilterTags(filterTags);
         compositeHealthCheck.setCombineTagsWithOr(true);

         compositeHealthCheck.execute();

         verify(healthCheckExecutor, times(1)).execute(argThat(selectorWithTags(filterTags)), argThat(orOptions));
     }

     private ArgumentMatcher<HealthCheckExecutionOptions> orOptions = new ArgumentMatcher<HealthCheckExecutionOptions>() {
         @Override
         public boolean matches(HealthCheckExecutionOptions options) {
             return options.isCombineTagsWithOr();
         }

         @Override
         public String toString() {
             return "options combining tags with or.";
         }
     };

     private ArgumentMatcher<HealthCheckExecutionOptions> andOptions = new ArgumentMatcher<HealthCheckExecutionOptions>() {
         @Override
         public boolean matches(HealthCheckExecutionOptions options) {
             return !options.isCombineTagsWithOr();
         }

         @Override
         public String toString() {
             return "options combining tags with and.";
         }
     };

     private static class DummyHcServiceReference implements ServiceReference {

         private long id;
         private String name;
         private String[] tags;
         private String[] filterTags;

         public DummyHcServiceReference(String name, String[] tags, String[] filterTags) {
             super();
             this.id = (long) (Math.random() * Long.MAX_VALUE);
             this.name = name;
             this.tags = tags;
             this.filterTags = filterTags;
         }

         @Override
         public Object getProperty(String key) {

             if (Constants.SERVICE_ID.equals(key)) {
                 return id;
             } else if (HealthCheck.NAME.equals(key)) {
                 return name;
             } else if (HealthCheck.MBEAN_NAME.equals(key)) {
                 return name;
             } else if (HealthCheck.TAGS.equals(key)) {
                 return tags;
             } else if (CompositeHealthCheck.PROP_FILTER_TAGS.equals(key)) {
                 return filterTags;
             } else if (ComponentConstants.COMPONENT_NAME.equals(key)) {
                 return filterTags != null ? CompositeHealthCheck.class.getName() : "some.other.HealthCheck";
             } else {
                 return null;
             }
         }

         @Override
         public String[] getPropertyKeys() {
             throw new UnsupportedOperationException();
         }

         @Override
         public Bundle getBundle() {
             throw new UnsupportedOperationException();
         }

         @Override
         public Bundle[] getUsingBundles() {
             throw new UnsupportedOperationException();
         }

         @Override
         public boolean isAssignableTo(Bundle bundle, String className) {
             throw new UnsupportedOperationException();
         }

         @Override
         public int compareTo(Object reference) {
             throw new UnsupportedOperationException();
         }

     }
 }
	/*
	* 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.felix.hc.core.impl;

	import static org.junit.Assert.assertEquals;
	import static org.mockito.ArgumentMatchers.any;
	import static org.mockito.ArgumentMatchers.argThat;
	import static org.mockito.Mockito.doReturn;
	import static org.mockito.Mockito.never;
	import static org.mockito.Mockito.times;
	import static org.mockito.Mockito.verify;
	import static org.mockito.Mockito.when;

	import java.util.Arrays;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Set;

	import org.apache.felix.hc.api.HealthCheck;
	import org.apache.felix.hc.api.Result;
	import org.apache.felix.hc.api.execution.HealthCheckExecutionOptions;
	import org.apache.felix.hc.api.execution.HealthCheckExecutionResult;
	import org.apache.felix.hc.api.execution.HealthCheckExecutor;
	import org.apache.felix.hc.api.execution.HealthCheckMetadata;
	import org.apache.felix.hc.api.execution.HealthCheckSelector;
	import org.apache.felix.hc.core.impl.executor.ExecutionResult;
	import org.apache.felix.hc.core.impl.util.HealthCheckFilter;
	import org.hamcrest.Description;
	import org.hamcrest.Matcher;
	import org.hamcrest.TypeSafeMatcher;
	import org.junit.Before;
	import org.junit.Test;
	import org.mockito.ArgumentMatcher;
	import org.mockito.Matchers;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;
	import org.mockito.Spy;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.Constants;
	import org.osgi.framework.ServiceReference;
	import org.osgi.service.component.ComponentConstants;
	import org.osgi.service.component.ComponentContext;

	public class CompositeHealthCheckTest {

	@Spy
	private CompositeHealthCheck compositeHealthCheck = new CompositeHealthCheck();

	@Mock
	private HealthCheckExecutor healthCheckExecutor;

	@Mock
	private ComponentContext componentContext;

	@Before
	public void setup() {
	MockitoAnnotations.initMocks(this);
	compositeHealthCheck.setHealthCheckExecutor(healthCheckExecutor);
	compositeHealthCheck.setFilterTags(new String[] {});
	compositeHealthCheck.setComponentContext(componentContext);
	}

	@Test
	public void testExecution() {

	doReturn((Result) null).when(compositeHealthCheck).checkForRecursion(Matchers.<ServiceReference> any(),
	Matchers.<Set<String>> any());
	String[] testTags = new String[] { "tag1" };
	compositeHealthCheck.setFilterTags(testTags);

	List<HealthCheckExecutionResult> executionResults = new LinkedList<HealthCheckExecutionResult>();
	executionResults.add(createExecutionResult("Check 1", testTags, new Result(Result.Status.OK, "Good")));
	executionResults.add(createExecutionResult("Check 2", testTags, new Result(Result.Status.CRITICAL, "Bad")));

	when(healthCheckExecutor.execute(any(HealthCheckSelector.class), any(HealthCheckExecutionOptions.class)))
	.thenReturn(executionResults);

	Result result = compositeHealthCheck.execute();

	verify(healthCheckExecutor, times(1)).execute(argThat(selectorWithTags(testTags)), argThat(andOptions));

	assertEquals(Result.Status.CRITICAL, result.getStatus());

	}

	private ArgumentMatcher<HealthCheckSelector> selectorWithTags(final String[] tags) {
	return new ArgumentMatcher<HealthCheckSelector>() {
	@Override
	public boolean matches(HealthCheckSelector healthCheckSelector) {
	return Arrays.equals(healthCheckSelector.tags(), tags) && healthCheckSelector.names() == null;
	}

	@Override
	public String toString() {
	return "a select with tags (" + Arrays.toString(tags) + ") and no names.";
	}
	};
	}

	private HealthCheckExecutionResult createExecutionResult(String name, String[] testTags, Result result) {
	HealthCheckExecutionResult healthCheckExecutionResult = new ExecutionResult(
	new HealthCheckMetadata(new DummyHcServiceReference(name, testTags,
	new String[0])),
	result, 0L);
	return healthCheckExecutionResult;
	}

	@Test
	public void testSimpleRecursion() {

	// composite check referencing itself
	final String[] filterTags = new String[] { "check1" };
	final DummyHcServiceReference hcRef = new DummyHcServiceReference("Check 1", new String[] { "check1" }, filterTags);

	// test check is hcRef
	doReturn(hcRef).when(componentContext).getServiceReference();
	compositeHealthCheck.setFilterTags(filterTags);

	compositeHealthCheck.setHealthCheckFilter(new HealthCheckFilter(null) {

	@Override
	public ServiceReference[] getHealthCheckServiceReferences(HealthCheckSelector selector) {
	String[] tags = selector.tags();
	ServiceReference[] result = new ServiceReference[] {};
	if (tags.length > 0) {
	if (tags[0].equals(filterTags[0])) {
	result = new ServiceReference[] { hcRef };
	}
	}
	return result;
	}

	});

	Result result = compositeHealthCheck.execute();

	verify(healthCheckExecutor, never()).execute(any(HealthCheckSelector.class));
	assertEquals(Result.Status.HEALTH_CHECK_ERROR, result.getStatus());
	}

	@Test
	public void testCyclicRecursion() {

	// three checks, cyclic
	final String[] filterTags = new String[] { "check2" };
	final DummyHcServiceReference hcRef1 = new DummyHcServiceReference("Check 1", new String[] { "check1" }, filterTags);
	final DummyHcServiceReference hcRef2 = new DummyHcServiceReference("Check 2", new String[] { "check2" }, new String[] { "check3" });
	final DummyHcServiceReference hcRef3 = new DummyHcServiceReference("Check 3", new String[] { "check3" }, new String[] { "check1" });

	// test check is hcRef1
	doReturn(hcRef1).when(componentContext).getServiceReference();
	compositeHealthCheck.setFilterTags(filterTags);

	compositeHealthCheck.setHealthCheckFilter(new HealthCheckFilter(null) {

	@Override
	public ServiceReference[] getHealthCheckServiceReferences(HealthCheckSelector selector, boolean combineTagsWithOr) {
	String[] tags = selector.tags();
	ServiceReference[] result = new ServiceReference[] {};
	if (tags.length > 0) {
	if (tags[0].equals(filterTags[0])) {
	result = new ServiceReference[] { hcRef2 };
	} else if (tags[0].equals("check3")) {
	result = new ServiceReference[] { hcRef3 };
	} else if (tags[0].equals("check1")) {
	result = new ServiceReference[] { hcRef1 };
	}
	}

	return result;
	}

	});

	Result result = compositeHealthCheck.execute();

	verify(healthCheckExecutor, never()).execute(any(HealthCheckSelector.class));
	assertEquals(Result.Status.HEALTH_CHECK_ERROR, result.getStatus());
	}

	@Test
	public void testCombineWithOr() {

	// composite check referencing itself
	final String[] filterTags = new String[] { "check1" };
	compositeHealthCheck.setFilterTags(filterTags);
	compositeHealthCheck.setCombineTagsWithOr(true);

	compositeHealthCheck.execute();

	verify(healthCheckExecutor, times(1)).execute(argThat(selectorWithTags(filterTags)), argThat(orOptions));
	}

	private ArgumentMatcher<HealthCheckExecutionOptions> orOptions = new ArgumentMatcher<HealthCheckExecutionOptions>() {
	@Override
	public boolean matches(HealthCheckExecutionOptions options) {
	return options.isCombineTagsWithOr();
	}

	@Override
	public String toString() {
	return "options combining tags with or.";
	}
	};

	private ArgumentMatcher<HealthCheckExecutionOptions> andOptions = new ArgumentMatcher<HealthCheckExecutionOptions>() {
	@Override
	public boolean matches(HealthCheckExecutionOptions options) {
	return !options.isCombineTagsWithOr();
	}

	@Override
	public String toString() {
	return "options combining tags with and.";
	}
	};

	private static class DummyHcServiceReference implements ServiceReference {

	private long id;
	private String name;
	private String[] tags;
	private String[] filterTags;

	public DummyHcServiceReference(String name, String[] tags, String[] filterTags) {
	super();
	this.id = (long) (Math.random() * Long.MAX_VALUE);
	this.name = name;
	this.tags = tags;
	this.filterTags = filterTags;
	}

	@Override
	public Object getProperty(String key) {

	if (Constants.SERVICE_ID.equals(key)) {
	return id;
	} else if (HealthCheck.NAME.equals(key)) {
	return name;
	} else if (HealthCheck.MBEAN_NAME.equals(key)) {
	return name;
	} else if (HealthCheck.TAGS.equals(key)) {
	return tags;
	} else if (CompositeHealthCheck.PROP_FILTER_TAGS.equals(key)) {
	return filterTags;
	} else if (ComponentConstants.COMPONENT_NAME.equals(key)) {
	return filterTags != null ? CompositeHealthCheck.class.getName() : "some.other.HealthCheck";
	} else {
	return null;
	}
	}

	@Override
	public String[] getPropertyKeys() {
	throw new UnsupportedOperationException();
	}

	@Override
	public Bundle getBundle() {
	throw new UnsupportedOperationException();
	}

	@Override
	public Bundle[] getUsingBundles() {
	throw new UnsupportedOperationException();
	}

	@Override
	public boolean isAssignableTo(Bundle bundle, String className) {
	throw new UnsupportedOperationException();
	}

	@Override
	public int compareTo(Object reference) {
	throw new UnsupportedOperationException();
	}

	}
	}