RegExJobFilterTest.java

package hudson.views;

import hudson.model.AbstractProject;
import hudson.model.Cause;
import hudson.model.Hudson;
import hudson.model.Job;
import hudson.model.Label;
import hudson.model.Node;
import hudson.model.ResourceList;
import hudson.model.Run;
import hudson.model.SCMedItem;
import hudson.model.TaskListener;
import hudson.model.TopLevelItem;
import hudson.model.TopLevelItemDescriptor;
import hudson.model.Queue.Executable;
import hudson.model.queue.CauseOfBlockage;
import hudson.scm.CVSSCM;
import hudson.scm.PollingResult;
import hudson.scm.SCM;
import hudson.views.AbstractIncludeExcludeJobFilter.IncludeExcludeType;

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

import junit.framework.TestCase;

public class RegExJobFilterTest extends TestCase {

	/**
	 * Tests that the example given in the help page works as described.
	 */
	public void testHelpExample() {
		List<TopLevelItem> all = toList("Work_Job", "Work_Nightly", "A-utility-job", "My_Job", "Job2_Nightly", "Util_Nightly", "My_Util");
		List<TopLevelItem> filtered = new ArrayList<TopLevelItem>();
		
		RegExJobFilter includeNonNightly = new RegExJobFilter(".*_Nightly", 
				AbstractIncludeExcludeJobFilter.IncludeExcludeType.includeUnmatched.toString(), // true, false, 
				RegExJobFilter.ValueType.NAME.toString());
		filtered = includeNonNightly.filter(filtered, all, null);
		List<TopLevelItem> expected = toList("Work_Job", "A-utility-job", "My_Job", "My_Util");
		assertListEquals(expected, filtered);

		RegExJobFilter excludeUtil = new RegExJobFilter(".*[Uu]til.*", 
				AbstractIncludeExcludeJobFilter.IncludeExcludeType.excludeMatched.toString(), // false, true, 
				RegExJobFilter.ValueType.NAME.toString());
		filtered = excludeUtil.filter(filtered, all, null);
		expected = toList("Work_Job", "My_Job");
		assertListEquals(expected, filtered);
	}
	private void assertListEquals(List<TopLevelItem> l1, List<TopLevelItem> l2) {
		assertEquals(l1.size(), l2.size());
		for (int i = 0; i < l1.size(); i++) {
			TopLevelItem i1 = l1.get(i);
			TopLevelItem i2 = l2.get(i);
			assertEquals(i1.getName(), i2.getName());
		}
	}
	private List<TopLevelItem> toList(String... names) {
		List<TopLevelItem> items = new ArrayList<TopLevelItem>();
		for (String name: names) {
			TopLevelItem item = new TestItem(name);
			items.add(item);
		}
		return items;
	}
	
	public void testIncludeExclude() {
		doTestIncludeExclude("junit", ".*u.*", IncludeExcludeType.includeMatched, true, false);
		doTestIncludeExclude("junit", ".*u.*", IncludeExcludeType.includeUnmatched, false, false);
		doTestIncludeExclude("junit", ".*u.*", IncludeExcludeType.excludeMatched, false, true);
		doTestIncludeExclude("junit", ".*u.*", IncludeExcludeType.excludeUnmatched, false, false);
		
		doTestIncludeExclude("test", ".*u.*", IncludeExcludeType.includeMatched, false, false);
		doTestIncludeExclude("test", ".*u.*", IncludeExcludeType.includeUnmatched, true, false);
		doTestIncludeExclude("test", ".*u.*", IncludeExcludeType.excludeMatched, false, false);
		doTestIncludeExclude("test", ".*u.*", IncludeExcludeType.excludeUnmatched, false, true);
	}
	
	public void doTestIncludeExclude(String jobName, 
			String regex, IncludeExcludeType includeExcludeType, // boolean negate, boolean exclude, 
			boolean expectInclude, boolean expectExclude) {
		TopLevelItem item = new TestItem(jobName);
		RegExJobFilter filter = new RegExJobFilter(regex, includeExcludeType.toString(), RegExJobFilter.ValueType.NAME.toString());
		boolean matched = filter.matches(item);
		assertEquals(expectExclude, filter.exclude(matched));
		assertEquals(expectInclude, filter.include(matched));
	}
	
	public void testScmRegEx() throws IOException {
		doTestScmRegEx("root", "modules", "branch", false);
		doTestScmRegEx(null, "modules", "branch", false);
		doTestScmRegEx("root", "modules", null, false);
		doTestScmRegEx("root/my-office", "modules", "branch", true);
		doTestScmRegEx("root", "modules/my-office", "branch", true);
		doTestScmRegEx("root", "modules", "branch/my-office", true);
	}
	private void doTestScmRegEx(String root, String modules, String branch, boolean expectMatch) throws IOException {
		RegExJobFilter filter = new RegExJobFilter(".*my-office.*", IncludeExcludeType.includeMatched.toString(), RegExJobFilter.ValueType.SCM.toString());
		CVSSCM scm = new CVSSCM(root, modules, branch, null, false, false, false, null);
		TestItem item = new TestItem("name", scm);
		boolean matched = filter.matches(item);
		assertEquals(expectMatch, matched);
	}
	@SuppressWarnings("unchecked")
	private class TestItem extends Job implements SCMedItem, TopLevelItem {

		private SCM scm;
		
		public TestItem(String name) {
			this(name, null);
		}

		public TestItem(String name, SCM scm) {
			super(null, name);
			this.scm = scm;
		}

		public AbstractProject<?, ?> asProject() {
			return null;
		}

		public SCM getScm() {
			return scm;
		}
		
		public TopLevelItemDescriptor getDescriptor() {
			return null;
		}
		@Override
		public Hudson getParent() {
			return null;
		}
		@Override
		protected SortedMap _getRuns() {
			return null;
		}

		@Override
		public boolean isBuildable() {
			return false;
		}

		@Override
		protected void removeRun(Run arg0) {
		}

		public PollingResult poll(TaskListener tasklistener) {
			return null;
		}

		public boolean pollSCMChanges(TaskListener tasklistener) {
			return false;
		}

		public ResourceList getResourceList() {
			return null;
		}

		public boolean scheduleBuild() {
			return false;
		}

		public boolean scheduleBuild(Cause cause) {
			return false;
		}

		public boolean scheduleBuild(int i, Cause cause) {
			return false;
		}

		public boolean scheduleBuild(int i) {
			return false;
		}

		public void checkAbortPermission() {
		}

		public Executable createExecutable() throws IOException {
			return null;
		}

		public Label getAssignedLabel() {
			return null;
		}

		public CauseOfBlockage getCauseOfBlockage() {
			return null;
		}

		public long getEstimatedDuration() {
			return 0;
		}

		public Node getLastBuiltOn() {
			return null;
		}

		public String getWhyBlocked() {
			return null;
		}

		public boolean hasAbortPermission() {
			return false;
		}

		public boolean isBuildBlocked() {
			return false;
		}

		public boolean isConcurrentBuild() {
			return false;
		}
		
	}
}