TimeClause.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 ASF 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.camel.component.mock;

import java.util.Date;
import java.util.Locale;
import java.util.concurrent.TimeUnit;

import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.builder.BinaryPredicateSupport;
import org.apache.camel.util.Time;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Represents time based clauses for setting expectations on the mocks.
 * Such as time constrains for the received messages.
 *
 * @version 
 */
public class TimeClause extends BinaryPredicateSupport {

    private static final Logger LOG = LoggerFactory.getLogger(TimeClause.class);

    private Time timeFrom;
    private Time timeTo;
    private boolean beforeNext;
    private String was;

    public TimeClause(Expression left, Expression right) {
        // previous, next
        super(left, right);
    }

    // TimeUnit DSL
    // -------------------------------------------------------------------------

    public class TimeClassUnit {

        private final TimeClause clause;
        private int from;
        private int to;

        public TimeClassUnit(TimeClause clause, int to) {
            this(clause, -1, to);
        }

        public TimeClassUnit(TimeClause clause, int from, int to) {
            this.clause = clause;
            this.from = from;
            this.to = to;
        }

        public TimeClause millis() {
            period(TimeUnit.MILLISECONDS);
            return clause;
        }

        public TimeClause seconds() {
            period(TimeUnit.SECONDS);
            return clause;
        }

        public TimeClause minutes() {
            period(TimeUnit.MINUTES);
            return clause;
        }

        private void period(TimeUnit unit) {
            if (from > 0) {
                timeFrom = new Time(from, unit);
            }
            timeTo = new Time(to, unit);
        }
    }

    // DSL
    // -------------------------------------------------------------------------

    public TimeClassUnit noLaterThan(int period) {
        TimeClassUnit unit = new TimeClassUnit(this, period);
        return unit;
    }

    public TimeClassUnit between(int from, int to) {
        TimeClassUnit unit = new TimeClassUnit(this, from, to);
        return unit;
    }

    public void beforeNext() {
        this.beforeNext = true;
    }

    public void afterPrevious() {
        this.beforeNext = false;
    }

    // Implementation
    // -------------------------------------------------------------------------

    protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
        was = null;
        boolean answer = true;

        if (timeTo == null) {
            throw new IllegalArgumentException("The time period has not been set. Ensure to include the time unit as well.");
        }

        Date currentDate = exchange.getProperty(Exchange.RECEIVED_TIMESTAMP, Date.class);

        // the other date is either the previous or the next
        Date otherDate;
        if (beforeNext) {
            // grab the previous value (left)
            if (leftValue != null) {
                otherDate = (Date) leftValue;
            } else {
                // we hit a boundary so grab the other
                otherDate = (Date) rightValue;
            }
        } else {
            // grab the next value (right)
            if (rightValue != null) {
                otherDate = (Date) rightValue;
            } else {
                // we hit a boundary so grab the other
                otherDate = (Date) leftValue;
            }
        }

        // if we could not grab the value, we hit a boundary (ie. either 0 message or last message)
        if (otherDate == null) {
            return true;
        }

        // compute if we were within the allowed time range
        Time current = new Time(currentDate.getTime(), TimeUnit.MILLISECONDS);
        Time other = new Time(otherDate.getTime(), TimeUnit.MILLISECONDS);
        // must absolute delta as when we hit the boundaries the delta would negative
        long delta = Math.abs(other.toMillis() - current.toMillis());
        was = "delta: " + delta + " millis";

        if (timeFrom != null) {
            long from = timeFrom.toMillis();
            answer = delta >= from;
        }
        if (answer) {
            long to = timeTo.toMillis();
            answer = delta <= to;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Evaluated time clause [{}] with current: {}, other: {} -> {}", new Object[]{toString(), currentDate, otherDate, answer});
        }

        return answer;
    }

    @Override
    protected String getOperationText() {
        return beforeNext ? "before next" : "after previous";
    }

    @Override
    public String toString() {
        if (timeFrom == null) {
            return "no later than " + timeTo + " " + getOperationText() + " (" + was + ")";
        } else {
            return "between " + timeFrom.getNumber() + "-" + timeTo.getNumber() + " " + timeTo.getTimeUnit().toString().toLowerCase(Locale.ENGLISH)
                    + " " + getOperationText() + " (" + was + ")";
        }
    }
}