com.indeed.proctor.common.ProctorLoadResult Maven / Gradle / Ivy

Go to download
package com.indeed.proctor.common;

import com.google.common.base.Function;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;

import javax.annotation.Nonnull;
import java.util.Collection;
import java.util.Map;
import java.util.Set;

/**
 * @author matts
 */
public class ProctorLoadResult {
    @Nonnull
    private final Map testErrorMap;
    @Nonnull
    private final Set missingTests;

    private final boolean verifiedRules;

    public ProctorLoadResult(
            @Nonnull final Set testsWithErrors,
            @Nonnull Set missingTests
    ) {
        this(testsWithErrors, missingTests, false);
    }

    public ProctorLoadResult(
            @Nonnull final Set testsWithErrors,
            @Nonnull Set missingTests,
            final boolean verifiedRules
    ) {
        this(makeTestErrorMap(testsWithErrors), missingTests, verifiedRules);
    }

    public ProctorLoadResult(
        @Nonnull final Map testErrorMap,
        @Nonnull Set missingTests,
        final boolean verifiedRules
    ) {
        this.testErrorMap = testErrorMap;
        this.missingTests = missingTests;
        this.verifiedRules = verifiedRules;
    }

    @Nonnull
    public Set getTestsWithErrors() {
        return testErrorMap.keySet();
    }

    @Nonnull
    public Map getTestErrorMap() {
        return testErrorMap;
    }

    @Nonnull
    public Set getMissingTests() {
        return missingTests;
    }

    public boolean getVerifiedRules() {
        return verifiedRules;
    }

    private static Map makeTestErrorMap(final Set testsWithErrors) {
        return Maps.asMap(testsWithErrors, new Function() {
            @Override
            public String apply(final String testName) {
                return testName + " has an invalid specification";
            }
        });
    }

    @SuppressWarnings("UnusedDeclaration")
    public boolean hasInvalidTests() {
        return !(testErrorMap.isEmpty() && missingTests.isEmpty());
    }

    private static final ProctorLoadResult EMPTY = newBuilder().build();
    @Nonnull
    public static ProctorLoadResult emptyResult() {
        return EMPTY;
    }

    @Nonnull
    public static Builder newBuilder() {
        return new Builder();
    }

    public static class Builder {
        private ImmutableMap.Builder testsWithErrors = ImmutableMap.builder();
        private ImmutableSet.Builder missingTests = ImmutableSet.builder();
        private boolean verifiedRules = false;
        private Builder() { }

        @Nonnull
        public Builder recordError(final String testName, final String message) {
            testsWithErrors.put(testName, message);
            return this;
        }

        @Nonnull
        public Builder recordError(final String testName) {
            testsWithErrors.put(testName, testName + " has an invalid specification");
            return this;
        }

        @Nonnull
        public Builder recordMissing(final String testName) {
            missingTests.add(testName);
            return this;
        }

        @Nonnull
        public Builder recordAllMissing(final Collection testNames) {
            missingTests.addAll(testNames);
            return this;
        }

        public Builder recordVerifiedRules(final boolean verifiedRulesInput){
            verifiedRules = verifiedRulesInput;
            return this;
        }

        @Nonnull
        public ProctorLoadResult build() {
            return new ProctorLoadResult(testsWithErrors.build(), missingTests.build(), verifiedRules);
        }
    }
}