matchers.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <unordered_map>
#include <memory>
#include <optional>
#include <boost/throw_exception.hpp>
#include <sstream>
#include <vector>
 
namespace pact_consumer::matchers {
 
  class IMatcher {
    public:
      using Ptr = std::shared_ptr<IMatcher>;
      virtual std::string getJson() const = 0;
      virtual std::string as_example() const { return ""; };
      virtual std::string as_regex() const { return as_example(); };
  };
 
  class ObjectMatcher : public IMatcher {
    public:
      ObjectMatcher(const std::unordered_map<std::string, IMatcher::Ptr>& i_fields) : fields { i_fields } {};
 
      virtual std::string getJson() const;
 
    private:
      std::unordered_map<std::string, IMatcher::Ptr> fields;
  };
 
  class IntegerMatcher : public IMatcher {
    public:
      IntegerMatcher() {};
      IntegerMatcher(long v) : value { v } {};
      IntegerMatcher(int v) : value { v } {};
 
      virtual std::string getJson() const;
 
    private:
      std::optional<long> value;
  };
 
  class DecimalMatcher : public IMatcher {
    public:
      DecimalMatcher() {};
      DecimalMatcher(float v) : value { v } {};
      DecimalMatcher(double v) : value { v } {};
 
      virtual std::string getJson() const;
 
    private:
      std::optional<double> value;
  };
 
  template<typename T>
  class TypeMatcher : public IMatcher {
    public:
      TypeMatcher(T v) : value { v } {};
 
      virtual std::string getJson() const;
 
    private:
      T value;
  };
 
  template<typename T>
  class NumberMatcher : public IMatcher {
    public:
      NumberMatcher() {};
      NumberMatcher(T v) : value { v } {};
 
      virtual std::string getJson() const;
 
    private:
      std::optional<T> value;
  };
 
  template<typename T>
  class EqualsMatcher : public IMatcher {
    public:
      EqualsMatcher(T v) : value { v } {};
 
      virtual std::string getJson() const;
      
      virtual std::string as_example() const { 
        std::ostringstream stringStream;
        stringStream << value;
        return stringStream.str(); 
      };
 
    private:
      T value;
  };
 
  class DateTimeMatcher : public IMatcher {
    public:
      DateTimeMatcher(const std::string& f) : format { f } {};
      DateTimeMatcher(const std::string& f, const std::string& e) : format { f }, example { e } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string format, example;
  };
 
  class DateMatcher : public IMatcher {
    public:
      DateMatcher(const std::string& f) : format { f } {};
      DateMatcher(const std::string& f, const std::string& e) : format { f }, example { e } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string format, example;
  };
 
  class TimeMatcher : public IMatcher {
    public:
      TimeMatcher(const std::string& f) : format { f } {};
      TimeMatcher(const std::string& f, const std::string& e) : format { f }, example { e } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string format, example;
  };
 
  class RegexMatcher : public IMatcher {
    public:
      RegexMatcher(const std::string& r) : regex { r } {};
      RegexMatcher(const std::string& r, const std::string& e) : regex { r }, example { e } {};
 
      virtual std::string getJson() const;
 
      virtual std::string as_example() const { return example; };
      virtual std::string as_regex() const { return regex; };
 
    private:
      std::string regex, example;
  };
 
  class EachlikeMatcher : public IMatcher {
    public:
      EachlikeMatcher(IMatcher::Ptr t) : obj { t } {};
      EachlikeMatcher(int e, IMatcher::Ptr t) : obj { t }, examples { e } {};
      EachlikeMatcher(int e, int m, IMatcher::Ptr t) : obj { t }, examples { e }, min { m } {};
      EachlikeMatcher(int e, int m, int mx, IMatcher::Ptr t) : obj { t }, examples { e }, min { m }, max { mx } {};
 
      virtual std::string getJson() const;
 
    private:
      int examples = 1;
      std::optional<int> min;
      std::optional<int> max;
      IMatcher::Ptr obj;
  };
 
  class ArrayContainsMatcher : public IMatcher {
    public:
      ArrayContainsMatcher(const std::vector<IMatcher::Ptr>& i_variants) : variants { i_variants } {};
 
      virtual std::string getJson() const;
 
    private:
      std::vector<IMatcher::Ptr> variants;
  };
 
  class HexadecimalMatcher : public IMatcher {
    public:
      HexadecimalMatcher() {};
      HexadecimalMatcher(const std::string& hex) : example { hex } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string example;
  };
 
  class IPAddressMatcher : public IMatcher {
    public:
      IPAddressMatcher() {};
      IPAddressMatcher(const std::string& address) : example { address } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string example;
  };
 
  class UuidMatcher : public IMatcher {
    public:
      UuidMatcher() {};
      UuidMatcher(const std::string& uuid) : example { uuid } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string example;
  };
 
  class IncludesMatcher : public IMatcher {
    public:
      IncludesMatcher(const std::string& v) : value { v } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string value;
  };
 
  class NullMatcher : public IMatcher {
    public:
      virtual std::string getJson() const;
  };
 
  class UrlMatcher : public IMatcher {
    public:
      UrlMatcher(const std::string& b, const std::vector<IMatcher::Ptr>& f) : basePath { b }, pathFragments { f } {};
 
      virtual std::string getJson() const;
 
    private:
      std::string basePath;
      std::vector<IMatcher::Ptr> pathFragments;
  };
 
  IMatcher::Ptr Object(const std::unordered_map<std::string, IMatcher::Ptr>& fields);
 
  IMatcher::Ptr Integer(long value);
 
  IMatcher::Ptr Integer(int value);
 
  IMatcher::Ptr Integer();
 
  IMatcher::Ptr Like(long value);
  IMatcher::Ptr Like(int value);
  IMatcher::Ptr Like(double value);
  IMatcher::Ptr Like(const std::string& value);
  IMatcher::Ptr Like(const char *value);
  IMatcher::Ptr Like(bool value);
 
  IMatcher::Ptr DateTime(const std::string& format, const std::string& example);
 
  IMatcher::Ptr DateTime(const std::string& format);
 
  IMatcher::Ptr Date(const std::string& format, const std::string& example);
 
  IMatcher::Ptr Date(const std::string& format);
 
  IMatcher::Ptr Time(const std::string& format, const std::string& example);
 
  IMatcher::Ptr Time(const std::string& format);
 
  IMatcher::Ptr Matching(const std::string& regex, const std::string& example);
 
  IMatcher::Ptr Matching(const std::string& regex);
 
  IMatcher::Ptr EachLike(const IMatcher::Ptr obj);
 
  IMatcher::Ptr EachLike(int examples, const IMatcher::Ptr obj);
 
  IMatcher::Ptr AtLeastOneLike(const IMatcher::Ptr obj);
 
  IMatcher::Ptr AtLeastOneLike(int examples, const IMatcher::Ptr obj);
 
  IMatcher::Ptr HexValue(const std::string& example);
 
  IMatcher::Ptr HexValue();
 
  IMatcher::Ptr IPAddress(const std::string& example);
 
  IMatcher::Ptr IPAddress();
 
  IMatcher::Ptr Numeric(int example);
 
  IMatcher::Ptr Numeric(long example);
 
  IMatcher::Ptr Numeric(float example);
 
  IMatcher::Ptr Numeric(double example);
 
  IMatcher::Ptr Numeric();
 
  IMatcher::Ptr Decimal(float example);
 
  IMatcher::Ptr Decimal(double example);
 
  IMatcher::Ptr Decimal();
 
  IMatcher::Ptr Uuid(const std::string& example);
 
  IMatcher::Ptr Uuid();
 
  IMatcher::Ptr AtMostLike(int max, const IMatcher::Ptr obj);
 
  IMatcher::Ptr AtMostLike(int max, int examples, const IMatcher::Ptr obj);
 
  IMatcher::Ptr MinArrayLike(int min, const IMatcher::Ptr obj);
 
  IMatcher::Ptr MinArrayLike(int min, int examples, const IMatcher::Ptr obj);
 
  IMatcher::Ptr ConstrainedArrayLike(int min, int max, const IMatcher::Ptr obj);
 
  IMatcher::Ptr ConstrainedArrayLike(int min, int max, int examples, const IMatcher::Ptr obj);
 
  IMatcher::Ptr EqualTo(int value);
 
  IMatcher::Ptr EqualTo(long value);
 
  IMatcher::Ptr EqualTo(float value);
 
  IMatcher::Ptr EqualTo(double value);
 
  IMatcher::Ptr EqualTo(const std::string& value);
 
  IMatcher::Ptr EqualTo(const char *value);
 
  IMatcher::Ptr EqualTo(bool value);
 
  IMatcher::Ptr IncludesStr(const std::string& value);
 
  IMatcher::Ptr NullValue();
 
  IMatcher::Ptr Url(const std::string& basePath, const std::vector<IMatcher::Ptr>& pathFragments);
 
  IMatcher::Ptr Url(const std::vector<IMatcher::Ptr>& pathFragments);
 
  IMatcher::Ptr ArrayContaining(const std::vector<IMatcher::Ptr>& variants);
}