diff --git a/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/ItsHookModule.java b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/ItsHookModule.java
index de7709d..0fcf032 100644
--- a/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/ItsHookModule.java
+++ b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/ItsHookModule.java
@@ -21,12 +21,14 @@
 import com.googlesource.gerrit.plugins.hooks.its.ItsName;
 import com.googlesource.gerrit.plugins.hooks.validation.ItsValidateComment;
 import com.googlesource.gerrit.plugins.hooks.workflow.ActionRequest;
+import com.googlesource.gerrit.plugins.hooks.workflow.Condition;
 import com.googlesource.gerrit.plugins.hooks.workflow.GerritHookFilterAddComment;
 import com.googlesource.gerrit.plugins.hooks.workflow.GerritHookFilterAddRelatedLinkToChangeId;
 import com.googlesource.gerrit.plugins.hooks.workflow.GerritHookFilterAddRelatedLinkToGitWeb;
 import com.googlesource.gerrit.plugins.hooks.workflow.GerritHookFilterChangeState;
 import com.googlesource.gerrit.plugins.hooks.workflow.ActionController;
 import com.googlesource.gerrit.plugins.hooks.workflow.Property;
+import com.googlesource.gerrit.plugins.hooks.workflow.Rule;
 
 public class ItsHookModule extends FactoryModule {
 
@@ -53,5 +55,7 @@
         ActionController.class);
     factory(ActionRequest.Factory.class);
     factory(Property.Factory.class);
+    factory(Condition.Factory.class);
+    factory(Rule.Factory.class);
   }
 }
diff --git a/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/Condition.java b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/Condition.java
new file mode 100644
index 0000000..1bb1564
--- /dev/null
+++ b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/Condition.java
@@ -0,0 +1,94 @@
+// Copyright (C) 2013 The Android Open Source Project
+//
+// 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.googlesource.gerrit.plugins.hooks.workflow;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+import com.google.common.collect.Sets;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+
+/**
+ * A condition as used in {@link Rule}, as precondition to {@link Action}s.
+ *
+ * A condition consists of a key and an associated set of values. A condition
+ * is said to match a set of properties, is this set contains at least one
+ * property that matches the rules key and whose value matches at least one
+ * of the rule's value.
+ */
+public class Condition {
+  private final String key;
+  private final Set<String> values;
+
+  public interface Factory {
+    Condition create(@Assisted("key") String key,
+        @Assisted("values") String values);
+  }
+
+  /**
+   * Constructs a condition.
+   * @param key The key to use for values.
+   * @param values A comma separated list of values to associate to the key.
+   */
+  @Inject
+  public Condition(@Assisted("key") String key,
+      @Nullable @Assisted("values") String values) {
+    this.key = key;
+    Set<String> modifyableValues;
+    if (values == null) {
+      modifyableValues = Collections.emptySet();
+    } else {
+      modifyableValues = Sets.newHashSet(Arrays.asList(values.split(",")));
+    }
+    this.values = Collections.unmodifiableSet(modifyableValues);
+  }
+
+  public String getKey() {
+    return key;
+  }
+
+  public Set<String> getValues() {
+    return values;
+  }
+
+  /**
+   * Checks whether or not the Condition matches the given set of properties
+   *
+   * @param properties The set of properties to match against.
+   * @return True iff properties contains at least one property that matches
+   *    the rules key and whose value matches at least one of the rule's value.
+   */
+  public boolean isMetBy(Iterable<Property> properties) {
+    for (Property property : properties) {
+      String propertyKey = property.getKey();
+      if ((key == null && propertyKey == null)
+          || (key != null && key.equals(propertyKey))) {
+        if (values.contains(property.getValue())) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return "[" + key + " = " + values + "]";
+  }
+}
diff --git a/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/Rule.java b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/Rule.java
new file mode 100644
index 0000000..512af73
--- /dev/null
+++ b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/Rule.java
@@ -0,0 +1,91 @@
+// Copyright (C) 2013 The Android Open Source Project
+//
+// 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.googlesource.gerrit.plugins.hooks.workflow;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.inject.Inject;
+import com.google.inject.assistedinject.Assisted;
+
+/**
+ * A single rule that associates {@code Action}s to {@code Condition}s.
+ */
+public class Rule {
+  private final String name;
+  private List<ActionRequest> actionRequests;
+  private Set<Condition> conditions;
+
+  public interface Factory {
+    Rule create(String name);
+  }
+
+  @Inject
+  public Rule(@Assisted String name) {
+    this.name = name;
+    this.actionRequests = Lists.newLinkedList();
+    this.conditions = Sets.newHashSet();
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  /**
+   * Adds a condition to the rule.
+   *
+   * @param condition The condition to add.
+   */
+  public void addCondition(Condition condition) {
+    conditions.add(condition);
+  }
+
+  /**
+   * Adds an action to the rule.
+   *
+   * @param action The action to add.
+   */
+  public void addActionRequest(ActionRequest actionRequest) {
+    actionRequests.add(actionRequest);
+  }
+
+  /**
+   * Gets this rule's the action requests for a given set of properties.
+   *
+   * If the given set of properties meets all of the rule's conditions, the
+   * rule's actions are returned. Otherwise the empty collection is returned.
+   *
+   * @param properties The properties to check against the rule's conditions.
+   * @return The actions that should get fired.
+   */
+  public Collection<ActionRequest> actionRequestsFor(
+      Iterable<Property> properties) {
+    for (Condition condition : conditions) {
+      if (!condition.isMetBy(properties)) {
+        return Collections.emptyList();
+      }
+    }
+    return Collections.unmodifiableList(actionRequests);
+  }
+
+  @Override
+  public String toString() {
+    return "[" + name + ", " + conditions + " -> " + actionRequests + "]";
+  }
+}
diff --git a/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleBase.java b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleBase.java
index e7ef399..101dfa6 100644
--- a/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleBase.java
+++ b/hooks-its/src/main/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleBase.java
@@ -14,14 +14,116 @@
 
 package com.googlesource.gerrit.plugins.hooks.workflow;
 
+import java.io.File;
 import java.util.Collection;
+import java.util.Collections;
+
+import com.google.common.collect.Lists;
+import com.google.gerrit.server.config.SitePath;
+import com.google.inject.Inject;
+
+import org.eclipse.jgit.storage.file.FileBasedConfig;
+import org.eclipse.jgit.util.FS;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Collection and matcher agains {@link Rule}s.
  */
 public class RuleBase {
-  public RuleBase() {
-    // TODO construct rule base
+  private static final Logger log = LoggerFactory.getLogger(RuleBase.class);
+
+  /**
+   * File (relative to site) to load rules from
+   */
+  private static final String ITS_CONFIG_FILE = "etc" + File.separatorChar +
+      "its" + File.separator + "action.config";
+
+  /**
+   * The section for rules within {@link #ITS_CONFIG_FILE}
+   */
+  private static final String RULE_SECTION = "rule";
+
+  /**
+   * The key for actions within {@link #ITS_CONFIG_FILE}
+   */
+  private static final String ACTION_KEY = "action";
+
+  private final File sitePath;
+  private final Rule.Factory ruleFactory;
+  private final Condition.Factory conditionFactory;
+  private final ActionRequest.Factory actionRequestFactory;
+
+  private Collection<Rule> rules;
+
+  public interface Factory {
+    RuleBase create();
+  }
+
+  @Inject
+  public RuleBase(@SitePath File sitePath, Rule.Factory ruleFactory,
+      Condition.Factory conditionFactory,
+      ActionRequest.Factory actionRequestFactory) {
+    this.sitePath = sitePath;
+    this.ruleFactory = ruleFactory;
+    this.conditionFactory = conditionFactory;
+    this.actionRequestFactory = actionRequestFactory;
+    loadRules();
+  }
+
+  /**
+   * Loads the rules for the RuleBase.
+   *
+   * Consider using {@link #loadRules()@}, as that method only loads the rules,
+   * if they have not yet been loaded.
+   */
+  private void forceLoadRules() throws Exception {
+    File configFile = new File(sitePath, ITS_CONFIG_FILE);
+    if (configFile.exists()) {
+      FileBasedConfig cfg = new FileBasedConfig(configFile, FS.DETECTED);
+      cfg.load();
+
+      rules = Lists.newArrayList();
+      Collection<String> subsections = cfg.getSubsections(RULE_SECTION);
+      for (String subsection : subsections) {
+        Rule rule = ruleFactory.create(subsection);
+        Collection<String> keys = cfg.getNames(RULE_SECTION, subsection);
+        for (String key : keys) {
+          String values[] = cfg.getStringList(RULE_SECTION, subsection, key);
+          if (ACTION_KEY.equals(key)) {
+            for (String value : values) {
+              ActionRequest actionRequest = actionRequestFactory.create(value);
+              rule.addActionRequest(actionRequest);
+            }
+          } else {
+            for (String value : values) {
+              Condition condition = conditionFactory.create(key, value);
+              rule.addCondition(condition);
+            }
+          }
+        }
+        rules.add(rule);
+      }
+    } else {
+      // configFile does not exist.
+      log.warn("ITS actions configuration file (" + configFile + ") does not exist.");
+      rules = Collections.emptySet();
+    }
+  }
+
+  /**
+   * Loads the rules for the RuleBase, if they have not yet been loaded.
+   */
+  private void loadRules() {
+    if (rules == null) {
+      try {
+        forceLoadRules();
+      } catch (Exception e) {
+        log.error("Invalid ITS action configuration", e);
+        rules = Collections.emptySet();
+      }
+    }
   }
 
   /**
@@ -32,7 +134,10 @@
    */
   public Collection<ActionRequest> actionRequestsFor(
       Iterable<Property> properties) {
-    // TODO implement
-    throw new RuntimeException("unimplemented");
+    Collection<ActionRequest> ret = Lists.newLinkedList();
+    for (Rule rule : rules) {
+      ret.addAll(rule.actionRequestsFor(properties));
+    }
+    return ret;
   }
 }
diff --git a/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/ConditionTest.java b/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/ConditionTest.java
new file mode 100644
index 0000000..d672ab7
--- /dev/null
+++ b/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/ConditionTest.java
@@ -0,0 +1,229 @@
+// Copyright (C) 2013 The Android Open Source Project
+//
+// 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.googlesource.gerrit.plugins.hooks.workflow;
+
+import static org.easymock.EasyMock.expect;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import com.google.gerrit.server.config.FactoryModule;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.googlesource.gerrit.plugins.hooks.testutil.LoggingMockingTestCase;
+
+public class ConditionTest  extends LoggingMockingTestCase {
+  private Injector injector;
+
+  public void testSimpleValue() {
+    Condition condition = createCondition("testKey", "testValue");
+    assertEquals("key not matching 'testKey'", "testKey", condition.getKey());
+    Set<String> expectedValues = Sets.newHashSet();
+    expectedValues.add("testValue");
+    assertEquals("values do not match", expectedValues, condition.getValues());
+  }
+
+  public void testGetKeyNull() {
+    Condition condition = new Condition(null, "testValues");
+    assertNull("key is not null", condition.getKey());
+  }
+
+  public void testGetValuesNull() {
+    Condition condition = createCondition("testKey", null);
+    Set<String> values = condition.getValues();
+    assertNotNull("values is null", values);
+    assertTrue("values is not empty", values.isEmpty());
+  }
+
+  public void testOredValue() {
+    Condition condition = createCondition("testKey", "value1,value2,value3");
+    assertEquals("key not matching 'testKey'", "testKey", condition.getKey());
+    Set<String> expectedValues = Sets.newLinkedHashSet();
+    expectedValues.add("value1");
+    expectedValues.add("value2");
+    expectedValues.add("value3");
+    assertEquals("values do not match", expectedValues, condition.getValues());
+  }
+
+  public void testIsMetBySimple() {
+    Condition condition = createCondition("testKey", "testValue");
+
+    Property property1 = createMock(Property.class);
+    expect(property1.getKey()).andReturn("testKey").anyTimes();
+    expect(property1.getValue()).andReturn("testValue").anyTimes();
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(1);
+    properties.add(property1);
+
+    replayMocks();
+
+    assertTrue("isMetBy gave false", condition.isMetBy(properties));
+  }
+
+  public void testIsMetBySimpleEmpty() {
+    Condition condition = createCondition("testKey", "testValue");
+
+    Collection<Property> properties = Collections.emptySet();
+
+    replayMocks();
+
+    assertFalse("isMetBy gave true", condition.isMetBy(properties));
+  }
+
+  public void testIsMetByMismatchedKey() {
+    Condition condition = createCondition("testKey", "testValue");
+
+    Property property1 = createMock(Property.class);
+    expect(property1.getKey()).andReturn("otherKey").anyTimes();
+    expect(property1.getValue()).andReturn("testValue").anyTimes();
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(1);
+    properties.add(property1);
+
+    replayMocks();
+
+    assertFalse("isMetBy gave true", condition.isMetBy(properties));
+  }
+
+  public void testIsMetByMismatchedValue() {
+    Condition condition = createCondition("testKey", "testValue");
+
+    Property property1 = createMock(Property.class);
+    expect(property1.getKey()).andReturn("testKey").anyTimes();
+    expect(property1.getValue()).andReturn("otherValue").anyTimes();
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(1);
+    properties.add(property1);
+
+    replayMocks();
+
+    assertFalse("isMetBy gave true", condition.isMetBy(properties));
+  }
+
+  public void testIsMetByOredSingle() {
+    Condition condition = createCondition("testKey", "value1,value2,value3");
+
+    Property property1 = createMock(Property.class);
+    expect(property1.getKey()).andReturn("testKey").anyTimes();
+    expect(property1.getValue()).andReturn("value2").anyTimes();
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(1);
+    properties.add(property1);
+
+    replayMocks();
+
+    assertTrue("isMetBy gave false", condition.isMetBy(properties));
+  }
+
+  public void testIsMetByOredMultiple() {
+    Condition condition = createCondition("testKey", "value1,value2,value3");
+
+    Property property1 = createMock(Property.class);
+    expect(property1.getKey()).andReturn("testKey").anyTimes();
+    expect(property1.getValue()).andReturn("value1").anyTimes();
+
+    Property property2 = createMock(Property.class);
+    expect(property2.getKey()).andReturn("testKey").anyTimes();
+    expect(property2.getValue()).andReturn("value3").anyTimes();
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(2);
+    properties.add(property1);
+    properties.add(property2);
+
+    replayMocks();
+
+    assertTrue("isMetBy gave false", condition.isMetBy(properties));
+  }
+
+  public void testIsMetByOredAll() {
+    Condition condition = createCondition("testKey", "value1,value2,value3");
+
+    Property property1 = createMock(Property.class);
+    expect(property1.getKey()).andReturn("testKey").anyTimes();
+    expect(property1.getValue()).andReturn("value1").anyTimes();
+
+    Property property2 = createMock(Property.class);
+    expect(property2.getKey()).andReturn("testKey").anyTimes();
+    expect(property2.getValue()).andReturn("value2").anyTimes();
+
+    Property property3 = createMock(Property.class);
+    expect(property3.getKey()).andReturn("testKey").anyTimes();
+    expect(property3.getValue()).andReturn("value3").anyTimes();
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(1);
+    properties.add(property1);
+    properties.add(property2);
+    properties.add(property3);
+
+    replayMocks();
+
+    assertTrue("isMetBy gave false", condition.isMetBy(properties));
+  }
+
+  public void testIsMetByOredOvershoot() {
+    Condition condition = createCondition("testKey", "value1,value2,value3");
+
+    Property property1 = createMock(Property.class);
+    expect(property1.getKey()).andReturn("testKey").anyTimes();
+    expect(property1.getValue()).andReturn("otherValue1").anyTimes();
+
+    Property property2 = createMock(Property.class);
+    expect(property2.getKey()).andReturn("testKey").anyTimes();
+    expect(property2.getValue()).andReturn("value2").anyTimes();
+
+    Property property3 = createMock(Property.class);
+    expect(property3.getKey()).andReturn("testKey").anyTimes();
+    expect(property3.getValue()).andReturn("otherValue3").anyTimes();
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(3);
+    properties.add(property1);
+    properties.add(property2);
+    properties.add(property3);
+
+    replayMocks();
+
+    assertTrue("isMetBy gave false", condition.isMetBy(properties));
+  }
+
+  public void testUnmodifiableValue() {
+    Condition condition = createCondition("testKey", "testValue");
+    Set<String> values = condition.getValues();
+    try {
+      values.add("value2");
+      fail("value is not unmodifyable");
+    } catch (UnsupportedOperationException e) {
+    }
+  }
+
+  private Condition createCondition(String key, String value) {
+    Condition.Factory factory = injector.getInstance(Condition.Factory.class);
+    return factory.create(key, value);
+  }
+
+  public void setUp() throws Exception {
+    super.setUp();
+
+    injector = Guice.createInjector(new TestModule());
+  }
+
+  private class TestModule extends FactoryModule {
+    @Override
+    protected void configure() {
+      factory(Condition.Factory.class);
+    }
+  }
+}
\ No newline at end of file
diff --git a/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleBaseTest.java b/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleBaseTest.java
new file mode 100644
index 0000000..2c6b466
--- /dev/null
+++ b/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleBaseTest.java
@@ -0,0 +1,279 @@
+// Copyright (C) 2013 The Android Open Source Project
+//
+// 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.googlesource.gerrit.plugins.hooks.workflow;
+
+import static org.easymock.EasyMock.expect;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+import org.eclipse.jgit.util.FileUtils;
+
+import com.google.common.collect.Lists;
+import com.google.gerrit.server.config.FactoryModule;
+import com.google.gerrit.server.config.SitePath;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.googlesource.gerrit.plugins.hooks.testutil.LoggingMockingTestCase;
+
+public class RuleBaseTest extends LoggingMockingTestCase {
+  private Injector injector;
+
+  private File sitePath;
+  private Rule.Factory ruleFactory;
+  private Condition.Factory conditionFactory;
+  private ActionRequest.Factory actionRequestFactory;
+
+  private boolean cleanupSitePath;
+
+  public void testWarnNonExistingRuleBase() {
+    replayMocks();
+
+    createRuleBase();
+
+    assertLogMessageContains("does not exist");
+  }
+
+  public void testEmptyRuleBase() throws IOException {
+    injectRuleBase("");
+
+    replayMocks();
+
+    createRuleBase();
+  }
+
+  public void testSimpleRuleBase() throws IOException {
+    injectRuleBase("[rule \"rule1\"]\n" +
+        "\tconditionA = value1\n" +
+        "\taction = action1");
+
+    Rule rule1 = createMock(Rule.class);
+    expect(ruleFactory.create("rule1")).andReturn(rule1);
+
+    Condition condition1 = createMock(Condition.class);
+    expect(conditionFactory.create("conditionA", "value1")).andReturn(condition1);
+    rule1.addCondition(condition1);
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action1")).andReturn(actionRequest1);
+    rule1.addActionRequest(actionRequest1);
+
+    replayMocks();
+
+    createRuleBase();
+  }
+
+  public void testBasicRuleBase() throws IOException {
+    injectRuleBase("[rule \"rule1\"]\n" +
+        "\tconditionA = value1,value2\n" +
+        "\tconditionA = value3,value of 4\n" +
+        "\tconditionB = value5\n" +
+        "\taction = action1\n" +
+        "\taction = action2 param\n" +
+        "\n" +
+        "[ruleXZ \"nonrule\"]\n" +
+        "\tconditionA = value1\n" +
+        "\taction = action2\n" +
+        "[rule \"rule2\"]\n" +
+        "\tconditionC = value6\n" +
+        "\taction = action3");
+
+    Rule rule1 = createMock(Rule.class);
+    expect(ruleFactory.create("rule1")).andReturn(rule1);
+
+    Condition condition1 = createMock(Condition.class);
+    expect(conditionFactory.create("conditionA", "value1,value2")).
+        andReturn(condition1);
+    rule1.addCondition(condition1);
+
+    Condition condition2 = createMock(Condition.class);
+    expect(conditionFactory.create("conditionA", "value3,value of 4")).
+        andReturn(condition2);
+    rule1.addCondition(condition2);
+
+    Condition condition3 = createMock(Condition.class);
+    expect(conditionFactory.create("conditionB", "value5")).
+        andReturn(condition3);
+    rule1.addCondition(condition3);
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action1")).andReturn(actionRequest1);
+    rule1.addActionRequest(actionRequest1);
+
+    ActionRequest actionRequest2 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action2 param")).andReturn(actionRequest2);
+    rule1.addActionRequest(actionRequest2);
+
+    Rule rule2 = createMock(Rule.class);
+    expect(ruleFactory.create("rule2")).andReturn(rule2);
+
+    Condition condition4 = createMock(Condition.class);
+    expect(conditionFactory.create("conditionC", "value6")).
+        andReturn(condition4);
+    rule2.addCondition(condition4);
+
+    ActionRequest actionRequest3 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action3")).andReturn(actionRequest3);
+    rule2.addActionRequest(actionRequest3);
+
+    replayMocks();
+
+    createRuleBase();
+  }
+
+  public void testActionRequestsForSimple() throws IOException {
+    injectRuleBase("[rule \"rule1\"]\n" +
+        "\taction = action1");
+
+    Rule rule1 = createMock(Rule.class);
+    expect(ruleFactory.create("rule1")).andReturn(rule1);
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action1")).andReturn(actionRequest1);
+    rule1.addActionRequest(actionRequest1);
+
+    Collection<Property> properties = Collections.emptySet();
+
+    List<ActionRequest> rule1Match = Lists.newArrayListWithCapacity(1);
+    rule1Match.add(actionRequest1);
+    expect(rule1.actionRequestsFor(properties)).andReturn(rule1Match);
+
+    replayMocks();
+
+    RuleBase ruleBase = createRuleBase();
+    Collection<ActionRequest> actual = ruleBase.actionRequestsFor(properties);
+
+    List<ActionRequest> expected = Lists.newArrayListWithCapacity(3);
+    expected.add(actionRequest1);
+
+    assertEquals("Matched actionRequests do not match", expected, actual);
+  }
+
+  public void testActionRequestsForExtended() throws IOException {
+    injectRuleBase("[rule \"rule1\"]\n" +
+        "\taction = action1\n" +
+        "\taction = action2\n" +
+        "\n" +
+        "[rule \"rule2\"]\n" +
+        "\taction = action3");
+
+    Rule rule1 = createMock(Rule.class);
+    expect(ruleFactory.create("rule1")).andReturn(rule1);
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action1")).andReturn(actionRequest1);
+    rule1.addActionRequest(actionRequest1);
+
+    ActionRequest actionRequest2 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action2")).andReturn(actionRequest2);
+    rule1.addActionRequest(actionRequest2);
+
+    Rule rule2 = createMock(Rule.class);
+    expect(ruleFactory.create("rule2")).andReturn(rule2);
+
+    ActionRequest actionRequest3 = createMock(ActionRequest.class);
+    expect(actionRequestFactory.create("action3")).andReturn(actionRequest3);
+    rule2.addActionRequest(actionRequest3);
+
+    Collection<Property> properties = Lists.newArrayListWithCapacity(1);
+    Property property1 = createMock(Property.class);
+    properties.add(property1);
+
+    List<ActionRequest> rule1Match = Lists.newArrayListWithCapacity(2);
+    rule1Match.add(actionRequest1);
+    rule1Match.add(actionRequest2);
+    expect(rule1.actionRequestsFor(properties)).andReturn(rule1Match);
+
+    List<ActionRequest> rule2Match = Lists.newArrayListWithCapacity(1);
+    rule2Match.add(actionRequest3);
+    expect(rule2.actionRequestsFor(properties)).andReturn(rule2Match);
+
+    replayMocks();
+
+    RuleBase ruleBase = createRuleBase();
+    Collection<ActionRequest> actual = ruleBase.actionRequestsFor(properties);
+
+    List<ActionRequest> expected = Lists.newArrayListWithCapacity(3);
+    expected.add(actionRequest1);
+    expected.add(actionRequest2);
+    expected.add(actionRequest3);
+
+    assertEquals("Matched actionRequests do not match", expected, actual);
+  }
+
+  private RuleBase createRuleBase() {
+    return injector.getInstance(RuleBase.class);
+  }
+
+  private void injectRuleBase(String rules) throws IOException {
+    File ruleBaseFile = new File(sitePath, "etc" + File.separatorChar + "its" +
+        File.separator + "action.config");
+    File ruleBaseParentFile = ruleBaseFile.getParentFile();
+    assertTrue("Failed to create parent (" + ruleBaseParentFile + ") for " +
+        "rule base", ruleBaseParentFile.mkdirs());
+    FileWriter unbufferedWriter = new FileWriter(ruleBaseFile);
+    BufferedWriter writer = new BufferedWriter(unbufferedWriter);
+    writer.write(rules);
+    writer.close();
+    unbufferedWriter.close();
+  }
+
+  public void setUp() throws Exception {
+    super.setUp();
+    cleanupSitePath = false;
+    injector = Guice.createInjector(new TestModule());
+  }
+
+  public void tearDown() throws Exception {
+    if (cleanupSitePath) {
+      if (sitePath.exists()) {
+        FileUtils.delete(sitePath, FileUtils.RECURSIVE);
+      }
+    }
+    super.tearDown();
+  }
+
+  private File randomTargetFile() {
+    final File t = new File("target");
+    return new File(t, "random-name-" + UUID.randomUUID().toString());
+  }
+
+  private class TestModule extends FactoryModule {
+    @Override
+    protected void configure() {
+
+      sitePath = randomTargetFile();
+      assertFalse("sitePath already (" + sitePath + ") already exists",
+          sitePath.exists());
+      cleanupSitePath = true;
+
+      bind(File.class).annotatedWith(SitePath.class).toInstance(sitePath);
+
+      ruleFactory = createMock(Rule.Factory.class);
+      bind(Rule.Factory.class).toInstance(ruleFactory);
+
+      conditionFactory = createMock(Condition.Factory.class);
+      bind(Condition.Factory.class).toInstance(conditionFactory);
+
+      actionRequestFactory = createMock(ActionRequest.Factory.class);
+      bind(ActionRequest.Factory.class).toInstance(actionRequestFactory);
+    }
+  }
+}
\ No newline at end of file
diff --git a/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleTest.java b/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleTest.java
new file mode 100644
index 0000000..d09a790
--- /dev/null
+++ b/hooks-its/src/test/java/com/googlesource/gerrit/plugins/hooks/workflow/RuleTest.java
@@ -0,0 +1,134 @@
+// Copyright (C) 2013 The Android Open Source Project
+//
+// 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.googlesource.gerrit.plugins.hooks.workflow;
+
+import static org.easymock.EasyMock.expect;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import com.google.common.collect.Lists;
+import com.google.gerrit.server.config.FactoryModule;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.googlesource.gerrit.plugins.hooks.testutil.LoggingMockingTestCase;
+
+public class RuleTest extends LoggingMockingTestCase {
+  private Injector injector;
+
+  public void testGetName() {
+    Rule rule = createRule("testRule");
+    assertEquals("Rule name does not match", "testRule", rule.getName());
+  }
+
+  public void testActionsForUnconditionalRule() {
+    Collection<Property> properties = Collections.emptySet();
+
+    Rule rule = createRule("testRule");
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    rule.addActionRequest(actionRequest1);
+
+    replayMocks();
+
+    Collection<ActionRequest> actual = rule.actionRequestsFor(properties);
+
+    Collection<ActionRequest> expected = Lists.newArrayListWithCapacity(1);
+    expected.add(actionRequest1);
+    assertEquals("Matched actionRequests do not match", expected, actual);
+  }
+
+  public void testActionRequestsForConditionalRuleEmptyProperties() {
+    Collection<Property> properties = Collections.emptySet();
+
+    Rule rule = createRule("testRule");
+
+    Condition condition1 = createMock(Condition.class);
+    expect(condition1.isMetBy(properties)).andReturn(false).anyTimes();
+    rule.addCondition(condition1);
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    rule.addActionRequest(actionRequest1);
+
+    replayMocks();
+
+    Collection<ActionRequest> actual = rule.actionRequestsFor(properties);
+
+    List<ActionRequest> expected = Collections.emptyList();
+    assertEquals("Matched actionRequests do not match", expected, actual);
+  }
+
+  public void testActionRequestsForConditionalRules() {
+    Collection<Property> properties = Collections.emptySet();
+
+    Rule rule = createRule("testRule");
+
+    Condition condition1 = createMock(Condition.class);
+    expect(condition1.isMetBy(properties)).andReturn(true).anyTimes();
+    rule.addCondition(condition1);
+
+    Condition condition2 = createMock(Condition.class);
+    expect(condition2.isMetBy(properties)).andReturn(false).anyTimes();
+    rule.addCondition(condition2);
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    rule.addActionRequest(actionRequest1);
+
+    replayMocks();
+
+    Collection<ActionRequest> actual = rule.actionRequestsFor(properties);
+
+    List<ActionRequest> expected = Collections.emptyList();
+    assertEquals("Matched actionRequests do not match", expected, actual);
+  }
+
+  public void testActionRequestsForMultipleActionRequests() {
+    Collection<Property> properties = Collections.emptySet();
+
+    Rule rule = createRule("testRule");
+
+    ActionRequest actionRequest1 = createMock(ActionRequest.class);
+    rule.addActionRequest(actionRequest1);
+
+    ActionRequest actionRequest2 = createMock(ActionRequest.class);
+    rule.addActionRequest(actionRequest2);
+
+    replayMocks();
+
+    Collection<ActionRequest> actual = rule.actionRequestsFor(properties);
+
+    List<ActionRequest> expected = Lists.newArrayListWithCapacity(1);
+    expected.add(actionRequest1);
+    expected.add(actionRequest2);
+    assertEquals("Matched actionRequests do not match", expected, actual);
+  }
+
+  private Rule createRule(String name) {
+    Rule.Factory factory = injector.getInstance(Rule.Factory.class);
+    return factory.create(name);
+  }
+
+  public void setUp() throws Exception {
+    super.setUp();
+    injector = Guice.createInjector(new TestModule());
+  }
+
+  private class TestModule extends FactoryModule {
+    @Override
+    protected void configure() {
+      factory(Rule.Factory.class);
+    }
+  }
+}
\ No newline at end of file