src/test/kotlin/net/pterodactylus/sone/test/Matchers.kt

   1 package net.pterodactylus.sone.test
   2
   3 import net.pterodactylus.sone.freenet.wot.*
   4 import net.pterodactylus.sone.utils.*
   5 import net.pterodactylus.util.web.*
   6 import org.hamcrest.*
   7 import org.hamcrest.Matchers.*
   8
   9 fun hasHeader(name: String, value: String) = object : TypeSafeDiagnosingMatcher<Header>() {
  10         override fun matchesSafely(item: Header, mismatchDescription: Description) =
  11                         compare(item.name, { it.equals(name, ignoreCase = true) }) { mismatchDescription.appendText("name is ").appendValue(it) }
  12                                         ?: compare(item.hasValue(value), { it }) { mismatchDescription.appendText("does not have value ").appendValue(value) }
  13                                         ?: true
  14
  15         override fun describeTo(description: Description) {
  16                 description.appendText("name is ").appendValue(name)
  17                                 .appendText(", value is ").appendValue(value)
  18         }
  19 }
  20
  21 fun <T : Any> compare(value: T, comparison: (T) -> Boolean, onError: (T) -> Unit) =
  22                 false.takeUnless { comparison(value) }
  23                                 ?.also { onError(value) }
  24
  25 fun <K, V> isEmptyMap() = object : TypeSafeDiagnosingMatcher<Map<K, V>>() {
  26         override fun describeTo(description: Description) {
  27                 description.appendText("empty map")
  28         }
  29
  30         override fun matchesSafely(item: Map<K, V>, mismatchDescription: Description) =
  31                         item.isEmpty().onFalse {
  32                                 mismatchDescription.appendText("was ").appendValue(item)
  33                         }
  34 }
  35
  36 fun isTrust(trust: Int?, score: Int?, rank: Int?) =
  37                 AttributeMatcher<Trust>("trust")
  38                                 .addAttribute("trust", trust, Trust::explicit)
  39                                 .addAttribute("score", score, Trust::implicit)
  40                                 .addAttribute("rank", rank, Trust::distance)
  41
  42 fun isTrusted(ownIdentity: OwnIdentity, trust: Matcher<Trust>) = object : TypeSafeDiagnosingMatcher<Identity>() {
  43         override fun matchesSafely(item: Identity, mismatchDescription: Description) =
  44                         item.getTrust(ownIdentity)?.let { foundTrust ->
  45                                 trust.matches(foundTrust).onFalse {
  46                                         trust.describeMismatch(foundTrust, mismatchDescription)
  47                                 }
  48                         } ?: {
  49                                 mismatchDescription.appendText("not trusted")
  50                                 false
  51                         }()
  52
  53         override fun describeTo(description: Description) {
  54                 description
  55                                 .appendText("trusted by ").appendValue(ownIdentity)
  56                                 .appendText(" with ").appendValue(trust)
  57         }
  58 }
  59
  60 fun isIdentity(id: String, nickname: String, requestUri: String, contexts: Matcher<out Iterable<String>>, properties: Matcher<out Map<out String, String>>) =
  61                 AttributeMatcher<Identity>("identity")
  62                                 .addAttribute("id", id, Identity::getId)
  63                                 .addAttribute("nickname", nickname, Identity::getNickname)
  64                                 .addAttribute("requestUri", requestUri, Identity::getRequestUri)
  65                                 .addAttribute("contexts", Identity::getContexts, contexts)
  66                                 .addAttribute("properties", Identity::getProperties, properties)
  67
  68 /**
  69  * [TypeSafeDiagnosingMatcher] implementation that aims to cut down boilerplate on verifying the attributes
  70  * of typical container objects.
  71  */
  72 class AttributeMatcher<T>(private val objectName: String) : TypeSafeDiagnosingMatcher<T>() {
  73
  74         private data class AttributeToMatch<T, V>(
  75                         val name: String,
  76                         val getter: (T) -> V,
  77                         val matcher: Matcher<out V>
  78         )
  79
  80         private val attributesToMatch = mutableListOf<AttributeToMatch<T, *>>()
  81
  82         /**
  83          * Adds an attribute to check for equality, returning `this`.
  84          */
  85         fun <V> addAttribute(name: String, expected: V, getter: (T) -> V): AttributeMatcher<T> = apply {
  86                 attributesToMatch.add(AttributeToMatch(name, getter, describedAs("$name %0", equalTo(expected), expected)))
  87         }
  88
  89         /**
  90          * Adds an attribute to check with the given [hamcrest matcher][Matcher].
  91          */
  92         fun <V> addAttribute(name: String, getter: (T) -> V, matcher: Matcher<out V>) = apply {
  93                 attributesToMatch.add(AttributeToMatch(name, getter, matcher))
  94         }
  95
  96         override fun describeTo(description: Description) {
  97                 attributesToMatch.forEachIndexed { index, attributeToMatch ->
  98                         if (index == 0) {
  99                                 description.appendText("$objectName with ")
 100                         } else {
 101                                 description.appendText(", ")
 102                         }
 103                         attributeToMatch.matcher.describeTo(description)
 104                 }
 105         }
 106
 107         override fun matchesSafely(item: T, mismatchDescription: Description): Boolean =
 108                         attributesToMatch.fold(true) { matches, attributeToMatch ->
 109                                 if (!matches) {
 110                                         false
 111                                 } else {
 112                                         if (!attributeToMatch.matcher.matches(attributeToMatch.getter(item))) {
 113                                                 mismatchDescription.appendText("but ${attributeToMatch.name} ")
 114                                                 attributeToMatch.matcher.describeMismatch(attributeToMatch.getter(item), mismatchDescription)
 115                                                 false
 116                                         } else {
 117                                                 true
 118                                         }
 119                                 }
 120                         }
 121
 122 }