event-log.cpp

Go to the documentation of this file.

/*
  EventLog  -  test facility to verify the occurrence of expected events
 
   Copyright (C)
     2018,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
#include "lib/error.hpp"
#include "lib/test/event-log.hpp"
 
 
 
namespace lib {
namespace test{
  namespace error = lumiera::error;
  
  using util::stringify;
  using util::contains;
  using util::isnil;
  using lib::Symbol;
  using std::string;
  
  
  namespace { /* == elementary matchers == */
    
    using Filter = decltype( buildSearchFilter (std::declval<Log const&>()) );
    
    using ArgSeq = lib::diff::RecordSetup<string>::Storage;
    using RExSeq = std::vector<std::regex>;
    
    
    inline auto
    find (string match)
    {
      return [=](Entry const& entry)
                {
                  return contains (string(entry), match);
                };
    }
    
    inline auto
    findRegExp (string regExpDef)
    {
      std::regex regExp(regExpDef);
      return [=](Entry const& entry)
                {
                  return std::regex_search(string(entry), regExp);
                };
    }
    
    inline auto
    findEvent (string match)
    {
      return [=](Entry const& entry)
                {
                  return (  entry.getType() == "event"
                         or entry.getType() == "error"
                         or entry.getType() == "create"
                         or entry.getType() == "destroy"
                         or entry.getType() == "logJoin"
                         )
                     and not isnil(entry.scope())
                     and contains (*entry.scope(), match);
                };
    }
    
    inline auto
    findEvent (string classifier, string match)
    {
      return [=](Entry const& entry)
                {
                  return (  entry.getType() == classifier
                         or (entry.hasAttribute("ID") and contains (entry.get("ID"), classifier))
                         )
                     and not isnil(entry.scope())
                     and contains (*entry.scope(), match);
                };
    }
    
    inline auto
    findCall (string match)
    {
      return [=](Entry const& entry)
                {
                  return entry.getType() == "call"
                     and contains (entry.get("fun"), match);
                };
    }
    
    
    inline auto
    matchArguments (ArgSeq&& argSeq)
    {
      return [=](Entry const& entry)
                {
                  auto scope = entry.scope();
                  for (auto const& match : argSeq)
                    if (isnil (scope) or not contains(*scope, match))
                      return false;
                    else
                      ++scope;
                  
                  return isnil(scope);  // must be exhausted by now
                };                     //  otherwise the sizes do not match...
    }
    
    inline auto
    matchArgument (size_t idx, string match)
    {
      return [=](Entry const& entry)
                {
                  return idx < entry.childSize()
                     and contains (entry.child(idx), match);
                };
    }
    
    
    inline auto
    matchArgsRegExp (RExSeq&& regExpSeq)
    {
      return [=](Entry const& entry)
                {
                  auto scope = entry.scope();
                  for (auto const& rex : regExpSeq)
                    {
                      if (isnil (scope)) return false;
                      while (scope and std::regex_search(*scope, rex))
                        ++scope;
                    }
                  
                  return isnil(scope);  // must be exhausted by now
                };                     //  otherwise we didn't get full coverage...
    }
    
    
    inline auto
    matchType (string typeID)
    {
      return [=](Entry const& entry)
                {
                  return contains (entry.getType(), typeID);
                };
    }
    
    
    inline auto
    ensureAttribute (string key)
    {
      return [=](Entry const& entry)
                {
                  return entry.hasAttribute(key);
                };
    }
    
    
    inline auto
    matchAttribute (string key, string valueMatch)
    {
      return [=](Entry const& entry)
                {
                  return entry.hasAttribute(key)
                     and contains (entry.get(key), valueMatch);
                };
    }
    
    
    
    /* === configure the underlying search engine === */
    
    enum Direction {
      FORWARD, BACKWARD, CURRENT
    };
    
    template<typename COND>
    inline void
    attachNextSerchStep (Filter& solution, COND&& searchCond, Direction direction)
    {
      if (CURRENT == direction)
        solution.search (forward<COND> (searchCond));
      else
        solution.addStep ([predicate{forward<COND> (searchCond)}, direction]
                          (auto& filter)
                            {
                              filter.reverse (BACKWARD == direction);
                              filter.disableFilter();  // deactivate any filtering temporarily
                              ++filter;               //  move one step in the required direction
                              filter.setNewFilter (predicate);
                            });
    }
    
    template<typename COND>
    inline void
    refineSerach (Filter& solution, COND&& additionalCond)
    {
      solution.addStep ([predicate{forward<COND> (additionalCond)}]
                        (auto& filter)
                          {
                            filter.andFilter (predicate);
                          });
    }
    
  }//(End) Elementary Matchers and handling of the search engine
  
  
  
  
  
  EventMatch::EventMatch (Log const& srcSeq)
    : solution_{buildSearchFilter (srcSeq)}
    , lastMatch_{"HEAD "+ solution_->get("this")}
    , look_for_match_{true}
    , violation_{}
    { }
  
  
  
  bool
  EventMatch::foundSolution()
  {
    return not isnil (solution_);
  }
  
  
  void
  EventMatch::evaluateQuery (string matchSpec, Literal rel)
  {
    if (look_for_match_ and not isnil (violation_)) return;
       // already failed, no further check necessary
    
    if (foundSolution()) // NOTE this pulls the filter
      {
        lastMatch_ = matchSpec+" @ "+string(*solution_)
                   + (isnil(lastMatch_)? ""
                                       : "\n.."+rel+" "+lastMatch_);
        if (not look_for_match_)
          violation_ = "FOUND at least "+lastMatch_;
      }
    else
      {
        if (look_for_match_)
          violation_ = "FAILED to "+matchSpec
                     + "\n.."+rel
                     + " "+lastMatch_;
        else
          violation_ = "";
      }
  }
 
    
    
  EventMatch&
  EventMatch::locate (string match)
  {
    attachNextSerchStep (solution_, find(match), CURRENT);
    evaluateQuery ("match(\""+match+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::locateMatch (string regExp)
  {
    attachNextSerchStep (solution_, findRegExp(regExp), CURRENT);
    evaluateQuery ("find-RegExp(\""+regExp+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::locateEvent (string match)
  {
    attachNextSerchStep (solution_, findEvent(match), CURRENT);
    evaluateQuery ("match-event(\""+match+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::locateEvent (string classifier, string match)
  {
    attachNextSerchStep (solution_, findEvent(classifier,match), CURRENT);
    evaluateQuery ("match-event(ID=\""+classifier+"\", \""+match+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::locateCall (string match)
  {
    attachNextSerchStep (solution_, findCall(match), CURRENT);
    evaluateQuery ("match-call(\""+match+"\")");
    return *this;
  }
  
  
  
  
  EventMatch&
  EventMatch::before (string match)
  {
    attachNextSerchStep (solution_, find(match), FORWARD);
    evaluateQuery ("match(\""+match+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::beforeMatch (string regExp)
  {
    attachNextSerchStep (solution_, findRegExp(regExp), FORWARD);
    evaluateQuery ("find-RegExp(\""+regExp+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::beforeEvent (string match)
  {
    attachNextSerchStep (solution_, findEvent(match), FORWARD);
    evaluateQuery ("match-event(\""+match+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::beforeEvent (string classifier, string match)
  {
    attachNextSerchStep (solution_, findEvent(classifier,match), FORWARD);
    evaluateQuery ("match-event(ID=\""+classifier+"\", \""+match+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::beforeCall (string match)
  {
    attachNextSerchStep (solution_, findCall(match), FORWARD);
    evaluateQuery ("match-call(\""+match+"\")");
    return *this;
  }
  
  
  
  
  EventMatch&
  EventMatch::after (string match)
  {
    attachNextSerchStep (solution_, find(match), BACKWARD);
    evaluateQuery ("match(\""+match+"\")", "before");
    return *this;
  }
  
  EventMatch&
  EventMatch::afterMatch (string regExp)
  {
    attachNextSerchStep (solution_, findRegExp(regExp), BACKWARD);
    evaluateQuery ("find-RegExp(\""+regExp+"\")", "before");
    return *this;
  }
  
  EventMatch&
  EventMatch::afterEvent (string match)
  {
    attachNextSerchStep (solution_, findEvent(match), BACKWARD);
    evaluateQuery ("match-event(\""+match+"\")", "before");
    return *this;
  }
  
  EventMatch&
  EventMatch::afterEvent (string classifier, string match)
  {
    attachNextSerchStep (solution_, findEvent(classifier,match), BACKWARD);
    evaluateQuery ("match-event(ID=\""+classifier+"\", \""+match+"\")", "before");
    return *this;
  }
  
  EventMatch&
  EventMatch::afterCall (string match)
  {
    attachNextSerchStep (solution_, findCall(match), BACKWARD);
    evaluateQuery ("match-call(\""+match+"\")", "before");
    return *this;
  }
  
  
  
  void
  EventMatch::refineSerach_matchArgument (size_t idx, string match)
  {
    refineSerach (solution_, matchArgument(idx, match));
    evaluateQuery ("match-argument(["+util::toString(idx)+"]="+match+")");
  }
  
  void
  EventMatch::refineSerach_matchArguments (ArgSeq&& argSeq)
  {
    string argList(util::join(argSeq));
    refineSerach (solution_, matchArguments(move(argSeq)));
    evaluateQuery ("match-arguments("+argList+")");
  }
  
  void
  EventMatch::refineSerach_matchArgsRegExp (RExSeq&& regExpSeq, string rendered_regExps)
  {
    refineSerach (solution_, matchArgsRegExp (move (regExpSeq)));
    evaluateQuery ("match-args-RegExp("+rendered_regExps+")");
  }
  
  
  
  EventMatch&
  EventMatch::type (string typeID)
  {
    refineSerach (solution_, matchType(typeID));
    evaluateQuery ("match-type("+typeID+")");
    return *this;
  }
  
  EventMatch&
  EventMatch::key (string key)
  {
    refineSerach (solution_, ensureAttribute(key));
    evaluateQuery ("ensure-attribute("+key+")");
    return *this;
  }
  
  EventMatch&
  EventMatch::attrib (string key, string valueMatch)
  {
    refineSerach (solution_, matchAttribute(key,valueMatch));
    evaluateQuery ("match-attribute("+key+"=\""+valueMatch+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::id (string classifier)
  {
    refineSerach (solution_, matchAttribute("ID",classifier));
    evaluateQuery ("match-ID(\""+classifier+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::on (string targetID)
  {
    refineSerach (solution_, matchAttribute("this",targetID));
    evaluateQuery ("match-this(\""+targetID+"\")");
    return *this;
  }
  
  EventMatch&
  EventMatch::on (CStr targetID)
  {
    refineSerach (solution_, matchAttribute("this",targetID));
    evaluateQuery ("match-this(\""+string(targetID)+"\")");
    return *this;
  }
 
  
  
  
  
  /* ==== EventLog implementation ==== */
 
  EventLog::EventLog (string logID)
    : log_(new Log)
    {
      log({"type=EventLogHeader", "this="+logID});
    }
  
  
  EventLog&
  EventLog::joinInto (EventLog& otherLog)
  {
    Log& target = *otherLog.log_;
    target.reserve (target.size() + log_->size() + 1);
    target.emplace_back (log_->front());
    auto p = log_->begin();
    while (++p != log_->end()) // move our log's content into the other log
      target.emplace_back (std::move(*p));
    this->log_->resize(1);
    this->log({"type=joined", otherLog.getID()});   // leave a tag to indicate
    otherLog.log({"type=logJoin", this->getID()}); //  where the `joinInto` took place,
    this->log_ = otherLog.log_;                   //   connect this to the other storage
    return *this;
  }
  
  
  
  EventLog&
  EventLog::clear()
  {
    string originalLogID = this->getID();
    return this->clear (originalLogID);
  }
  
  EventLog&
  EventLog::clear (string alteredLogID)
  {
    log_.reset (new Log);
    log({"type=EventLogHeader", "this="+alteredLogID});
    return *this;
  }
  
  EventLog&
  EventLog::clear (CStr alteredLogID)
  {
    return clear (string{alteredLogID});
  }
  
  
  
  /* ==== Logging API ==== */
  
  EventLog&
  EventLog::event (string text)
  {
    log ("event", ArgSeq{}, ArgSeq{text});  // we use this ctor variant to ensure
    return *this;                          //  that text is not misinterpreted as attribute,
  }                                       //   which might happen when text contains a '='
  
  EventLog&
  EventLog::event (string classifier, string text)
  {
    log ("event", ArgSeq{"ID="+classifier}, ArgSeq{text});
    return *this;
  }
  
  EventLog&
  EventLog::call (string target, string function)
  {
    return call(target, function, ArgSeq());
  }
  
  EventLog&
  EventLog::call (string target, string function, ArgSeq&& args)
  {
    log ("call", ArgSeq{"fun="+function, "this="+target}, std::forward<ArgSeq>(args));
    return *this;
  }
  
  EventLog&
  EventLog::call (CStr target, CStr function, ArgSeq&& args)
  {
    return call (string(target), string(function), std::forward<ArgSeq>(args));
  }
  
  
  EventLog&
  EventLog::warn (string text)
  {
    log({"type=warn", text});
    return *this;
  }
  
  EventLog&
  EventLog::error (string text)
  {
    log({"type=error", text});
    return *this;
  }
 
  EventLog&
  EventLog::fatal (string text)
  {
    log({"type=fatal", text});
    return *this;
  }
 
  
  
  EventLog&
  EventLog::create (string text)
  {
    log({"type=create", text});
    return *this;
  }
  
  EventLog&
  EventLog::destroy (string text)
  {
    log({"type=destroy", text});
    return *this;
  }
  
  
  
  
  /* ==== Query/Verification API ==== */
  
  EventMatch
  EventLog::verify (string match)  const
  {
    EventMatch matcher(*log_);
    matcher.locate (match);   // new matcher starts linear search from first log element
    return matcher;
  }
  
  
  EventMatch
  EventLog::verifyMatch (string regExp)  const
  {
    EventMatch matcher(*log_);
    matcher.locateMatch (regExp);
    return matcher;
  }
  
  
  EventMatch
  EventLog::verifyEvent (string match)  const
  {
    EventMatch matcher(*log_);
    matcher.locateEvent (match);
    return matcher;
  }
  
  
  EventMatch
  EventLog::verifyEvent (string classifier, string match)  const
  {
    EventMatch matcher(*log_);
    matcher.locateEvent (classifier, match);
    return matcher;
  }
  
  
  EventMatch
  EventLog::verifyCall (string match)  const
  {
    EventMatch matcher(*log_);
    matcher.locateCall (match);
    return matcher;
  }
  
  
  EventMatch
  EventLog::ensureNot (string match)  const
  {
    EventMatch matcher(*log_);
    matcher.look_for_match_ = false; // flip logic; fail if match succeeds
    matcher.locate (match);
    return matcher;
  }
  
  
  
}} // namespace lib::test