src/test/kotlin/net/pterodactylus/sone/web/ajax/JsonReturnObjectTest.kt

   1 package net.pterodactylus.sone.web.ajax
   2
   3 import com.fasterxml.jackson.databind.JsonNode
   4 import com.fasterxml.jackson.databind.ObjectMapper
   5 import com.fasterxml.jackson.databind.node.BooleanNode
   6 import com.fasterxml.jackson.databind.node.IntNode
   7 import com.fasterxml.jackson.databind.node.JsonNodeFactory
   8 import com.fasterxml.jackson.databind.node.ObjectNode
   9 import com.fasterxml.jackson.databind.node.TextNode
  10 import org.hamcrest.MatcherAssert.assertThat
  11 import org.hamcrest.Matchers.equalTo
  12 import org.hamcrest.Matchers.not
  13 import org.junit.Test
  14
  15 /**
  16  * Unit test for [JsonReturnObject].
  17  */
  18 class JsonReturnObjectTest {
  19
  20         private val jsonReturnObject = JsonReturnObject(true)
  21         private val objectMapper = ObjectMapper()
  22
  23         @Test
  24         fun `json object retains success status if true`() {
  25                 assertThat(JsonReturnObject(true).isSuccess, equalTo(true))
  26         }
  27
  28         @Test
  29         fun `json object retains success status if false`() {
  30                 assertThat(JsonReturnObject(false).isSuccess, equalTo(false))
  31         }
  32
  33         @Test
  34         fun `json object returns text nodes for string properties`() {
  35                 jsonReturnObject.put("foo", "bar")
  36                 assertThat(jsonReturnObject["foo"], equalTo<Any>(TextNode("bar")))
  37         }
  38
  39         @Test
  40         fun `json object returns int nodes for int properties`() {
  41                 jsonReturnObject.put("foo", 123)
  42                 assertThat(jsonReturnObject["foo"], equalTo<Any>(IntNode(123)))
  43         }
  44
  45         @Test
  46         fun `json object returns boolean nodes for boolean properties`() {
  47                 jsonReturnObject.put("foo", true)
  48                 assertThat(jsonReturnObject["foo"], equalTo<Any>(BooleanNode.TRUE))
  49         }
  50
  51         @Test
  52         fun `json object returns json node for json properties`() {
  53                 val objectNode = ObjectNode(JsonNodeFactory.instance)
  54                 jsonReturnObject.put("foo", objectNode)
  55                 assertThat(jsonReturnObject["foo"], equalTo<Any>(objectNode))
  56         }
  57
  58         @Test
  59         fun `json object returns all properties`() {
  60                 val objectNode = ObjectNode(JsonNodeFactory.instance)
  61                 jsonReturnObject.put("text", "text")
  62                 jsonReturnObject.put("int", 123)
  63                 jsonReturnObject.put("boolean", true)
  64                 jsonReturnObject.put("object", objectNode)
  65                 assertThat(jsonReturnObject.content, equalTo<Any>(mapOf(
  66                                 "text" to TextNode("text"),
  67                                 "int" to IntNode(123),
  68                                 "boolean" to BooleanNode.TRUE,
  69                                 "object" to objectNode
  70                 )))
  71         }
  72
  73         @Test
  74         fun `json object is serialized correctly`() {
  75                 val objectNode = ObjectNode(JsonNodeFactory.instance)
  76                 jsonReturnObject.put("text", "text")
  77                 jsonReturnObject.put("int", 123)
  78                 jsonReturnObject.put("boolean", true)
  79                 jsonReturnObject.put("object", objectNode)
  80                 val json = objectMapper.writeValueAsString(jsonReturnObject)
  81                 val parsedJson = objectMapper.readTree(json)
  82                 assertThat(parsedJson, equalTo<JsonNode>(ObjectNode(JsonNodeFactory.instance).apply {
  83                         put("success", true)
  84                         put("text", "text")
  85                         put("int", 123)
  86                         put("boolean", true)
  87                         set("object", objectNode)
  88                 }))
  89         }
  90
  91         @Test
  92         fun `successful object is not equal to unsuccessful object`() {
  93                 assertThat(JsonReturnObject(true), not(equalTo(JsonReturnObject(false))))
  94         }
  95
  96         @Test
  97         fun `objects with different content are not equal`() {
  98                 val firstObject = JsonReturnObject(true).apply {
  99                         put("text", "text")
 100                 }
 101                 val secondObject = JsonReturnObject(true).apply {
 102                         put("number", 123)
 103                 }
 104                 assertThat(firstObject, not(equalTo(secondObject)))
 105         }
 106
 107         @Test
 108         fun `object is not equal to null`() {
 109             assertThat(JsonReturnObject(true), not(equalTo<Any?>(null)))
 110         }
 111
 112         @Test
 113         fun `object is not equal to object of different class`() {
 114             assertThat(JsonReturnObject(true), not(equalTo<Any>("string")))
 115         }
 116
 117         @Test
 118         fun `equals is correctly implemented`() {
 119                 val firstObject = JsonReturnObject(true).apply {
 120                         put("text", "text")
 121                         put("int", 123)
 122                         put("boolean", true)
 123                         put("object", ObjectNode(JsonNodeFactory.instance))
 124                 }
 125                 val secondObject = JsonReturnObject(true).apply {
 126                         put("text", "text")
 127                         put("int", 123)
 128                         put("boolean", true)
 129                         put("object", ObjectNode(JsonNodeFactory.instance))
 130                 }
 131                 assertThat(firstObject, equalTo(secondObject))
 132         }
 133
 134         @Test
 135         fun `hash code of equal objects is equal`() {
 136                 val firstObject = JsonReturnObject(true).apply {
 137                         put("text", "text")
 138                         put("int", 123)
 139                         put("boolean", true)
 140                         put("object", ObjectNode(JsonNodeFactory.instance))
 141                 }
 142                 val secondObject = JsonReturnObject(true).apply {
 143                         put("text", "text")
 144                         put("int", 123)
 145                         put("boolean", true)
 146                         put("object", ObjectNode(JsonNodeFactory.instance))
 147                 }
 148                 assertThat(firstObject.hashCode(), equalTo(secondObject.hashCode()))
 149         }
 150
 151 }