JSON Pathで指定した値が一致しないことを検証するテストの追加

playtest-gauge-rest/specs/http/response/json/booleans.spec

@@ -7,6 +7,13 @@
 * レスポンスのJSONの"$.key2[0]"が真偽値の"false"である
 * レスポンスのJSONの"$.key2[0]"が真偽値のfalseである
 
+## JSON Pathで指定したオブジェクトが一致しない
+* レスポンスボディとしてシナリオデータストアに"{ \"key1\": true, \"key2\": [ false ] }"を保存する
+* レスポンスのJSONの"$.key1"が真偽値の"false"でない
+* レスポンスのJSONの"$.key1"が真偽値のfalseでない
+* レスポンスのJSONの"$.key2[0]"が真偽値の"true"でない
+* レスポンスのJSONの"$.key2[0]"が真偽値のtrueでない
+
 ## 配列内において存在（無）
 * レスポンスボディとしてシナリオデータストアに"{\"key1\":[{\"id\":\"a\",\"key3\":false}, {\"id\":\"b\",\"key3\": true }, {\"id\":\"c\",\"key3\":true}]}"を保存する
 * レスポンスのJSONの"$.key1"の配列の、UniqueKey"id"の値が"b"である要素の"key3"が、真偽値の"true"である

playtest-gauge-rest/specs/http/response/json/doubles.spec

@@ -5,6 +5,11 @@
 * レスポンスのJSONの"$.key1"が小数の"10.00"である
 * レスポンスのJSONの"$.key2[0]"が小数の"0.01"である
 
+## JSON Pathで指定したオブジェクトが一致しない
+* レスポンスボディとしてシナリオデータストアに"{ \"key1\": 10.00, \"key2\": [ 0.01 ] }"を保存する
+* レスポンスのJSONの"$.key1"が小数の"0.01"でない
+* レスポンスのJSONの"$.key2[0]"が小数の"10.00"でない
+
 ## JSON Pathで指定した配列を条件で絞った1要素
 * レスポンスボディとしてシナリオデータストアに"{\"key1\":[{\"id\":\"a\",\"key3\":1.0}, {\"id\":\"b\",\"key3\": 2.0 }, {\"id\":\"c\",\"key3\":3.0}]}"を保存する
 * レスポンスのJSONの"$.key1"の配列の、UniqueKey"id"の値が"b"である要素の"key3"が、小数値の"2.0"である

playtest-gauge-rest/specs/http/response/json/integers.spec

@@ -5,6 +5,11 @@
 * レスポンスのJSONの"$.key1"が整数の"0"である
 * レスポンスのJSONの"$.key2[0]"が整数の"10"である
 
+## JSON Pathで指定したオブジェクトが一致しない
+* レスポンスボディとしてシナリオデータストアに"{ \"key1\": 0, \"key2\": [ 10 ] }"を保存する
+* レスポンスのJSONの"$.key1"が整数の"10"でない
+* レスポンスのJSONの"$.key2[0]"が整数の"0"でない
+
 ## JSON Pathで指定した配列を条件で絞った1要素
 * レスポンスボディとしてシナリオデータストアに"{\"key1\":[{\"id\":\"a\",\"key3\":1}, {\"id\":\"b\",\"key3\": 2 }, {\"id\":\"c\",\"key3\":3}]}"を保存する
 * レスポンスのJSONの"$.key1"の配列の、UniqueKey"id"の値が"b"である要素の"key3"が、整数値の"2"である

playtest-gauge-rest/specs/http/response/json/regex.spec

@@ -6,3 +6,7 @@
 * レスポンスのJSONの"$.key2.key3"が"^[0-9a-zA-Z_.+-]*@+[a-zA-Z0-9.]*"である
 * レスポンスのJSONの"$.key2.key3"が".+"である
 * レスポンスのJSONの"$.key4"が".*"である
+
+## JSON Pathで指定したオブジェクトが一致しない
+* レスポンスボディとしてシナリオデータストアに"{ \"key1\": \"09012345678\" }"を保存する
+* レスポンスのJSONの"$.key1"が"[0-9]{12}"でない

playtest-gauge-rest/specs/http/response/json/strings.spec

@@ -5,6 +5,11 @@
 * レスポンスのJSONの"$.key1"が文字列の"value1"である
 * レスポンスのJSONの"$.key2[0]"が文字列の"value2"である
 
+## JSON Pathで指定したオブジェクトが一致しない
+* レスポンスボディとしてシナリオデータストアに"{ \"key1\": \"value1\", \"key2\": [ \"value2\" ] }"を保存する
+* レスポンスのJSONの"$.key1"が文字列の"value2"でない
+* レスポンスのJSONの"$.key2[0]"が文字列の"value1"でない
+
 ## JSON Pathで指定した配列を条件で絞った1オブジェクト
 * レスポンスボディとしてシナリオデータストアに"{\"key1\":[{\"id\":\"a\",\"key3\":\"x\"}, {\"id\":\"b\",\"key3\": \"y\" }, {\"id\":\"c\",\"key3\":\"z\"}]}"を保存する
 * レスポンスのJSONの"$.key1"の配列の、UniqueKey"id"の値が"b"である要素の"key3"が、文字列の"y"である

playtest-gauge-rest/src/main/kotlin/com/uzabase/playtest/gauge/rest/json/JsonBooleanStep.kt

@@ -4,6 +4,7 @@ import com.thoughtworks.gauge.Step
 import com.uzabase.playtest.gauge.rest.DataStore
 import com.uzabase.playtest.json.JsonNode
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotEquals
 
 class JsonBooleanStep {
     @Step("レスポンスのJSONの<jsonPath>が真偽値の<expected>である")
@@ -13,20 +14,41 @@ class JsonBooleanStep {
         assertEquals(expected, actual)
     }
 
+    @Step("レスポンスのJSONの<jsonPath>が真偽値の<expected>でない")
+    fun assertNotEquals(jsonPath: String, expected: Boolean) {
+        val json = DataStore.loadResponseBodyFromScenario().string
+        val actual = JsonNode.of(json).get<Boolean>(jsonPath)
+        assertNotEquals(expected, actual)
+    }
+
     @Step("レスポンスのJSONの<jsonPath>が真偽値のtrueである")
     fun assertTrue(jsonPath: String) {
         val json = DataStore.loadResponseBodyFromScenario().string
         val actual = JsonNode.of(json).get<Boolean>(jsonPath)
         assertEquals(true, actual)
     }
 
+    @Step("レスポンスのJSONの<jsonPath>が真偽値のtrueでない")
+    fun assertNotTrue(jsonPath: String) {
+        val json = DataStore.loadResponseBodyFromScenario().string
+        val actual = JsonNode.of(json).get<Boolean>(jsonPath)
+        assertNotEquals(true, actual)
+    }
+
     @Step("レスポンスのJSONの<jsonPath>が真偽値のfalseである")
     fun assertFalse(jsonPath: String) {
         val json = DataStore.loadResponseBodyFromScenario().string
         val actual = JsonNode.of(json).get<Boolean>(jsonPath)
         assertEquals(false, actual)
     }
 
+    @Step("レスポンスのJSONの<jsonPath>が真偽値のfalseでない")
+    fun assertNotFalse(jsonPath: String) {
+        val json = DataStore.loadResponseBodyFromScenario().string
+        val actual = JsonNode.of(json).get<Boolean>(jsonPath)
+        assertNotEquals(false, actual)
+    }
+
     @Step("レスポンスのJSONの<jsonPath>の配列の、UniqueKey<uniqueKey>の値が<filterValue>である要素の<key>が、真偽値の<expected>である")
     fun assertEqualsInUniqueObject(
         jsonPath: String,

playtest-gauge-rest/src/main/kotlin/com/uzabase/playtest/gauge/rest/json/JsonDoubleStep.kt

@@ -13,6 +13,13 @@ class JsonDoubleStep {
         assertEquals(expected, actual)
     }
 
+    @Step("レスポンスのJSONの<jsonPath>が小数の<expected>でない")
+    fun assertNotEquals(jsonPath: String, expected: Double) {
+        val json = DataStore.loadResponseBodyFromScenario().string
+        val actual = JsonNode.of(json).get<Double>(jsonPath)
+        assertNotEquals(expected, actual)
+    }
+
     @Step("レスポンスのJSONの<jsonPath>の配列の、UniqueKey<uniqueKey>の値が<filterValue>である要素の<key>が、小数値の<expected>である")
     fun assertEqualsInUniqueObject(jsonPath: String, uniqueKey: String, filterValue: String, key: String, expected: Double) {
         val json = DataStore.loadResponseBodyFromScenario().string

playtest-gauge-rest/src/main/kotlin/com/uzabase/playtest/gauge/rest/json/JsonIntegerStep.kt

@@ -13,6 +13,13 @@ class JsonIntegerStep {
         assertEquals(expected, actual)
     }
 
+    @Step("レスポンスのJSONの<jsonPath>が整数の<expected>でない")
+    fun assertNotEquals(jsonPath: String, expected: Int) {
+        val json = DataStore.loadResponseBodyFromScenario().string
+        val actual = JsonNode.of(json).get<Int>(jsonPath)
+        assertNotEquals(expected, actual)
+    }
+
     @Step("レスポンスのJSONの<jsonPath>の配列の、UniqueKey<uniqueKey>の値が<filterValue>である要素の<key>が、整数値の<expected>である")
     fun assertEqualsInUniqueObject(jsonPath: String, uniqueKey: String, filterValue: String, key: String, expected: Int) {
         val json = DataStore.loadResponseBodyFromScenario().string

playtest-gauge-rest/src/main/kotlin/com/uzabase/playtest/gauge/rest/json/JsonRegexStep.kt

@@ -3,6 +3,7 @@ package com.uzabase.playtest.gauge.rest.json
 import com.thoughtworks.gauge.Step
 import com.uzabase.playtest.gauge.rest.DataStore
 import com.uzabase.playtest.json.JsonNode
+import org.junit.jupiter.api.Assertions.assertFalse
 import kotlin.test.assertTrue
 
 
@@ -16,4 +17,14 @@ class JsonRegexStep {
             assertTrue(regex.matches(this!!))
         }
     }
+
+    @Step("レスポンスのJSONの<jsonPath>が<pattern>でない")
+    fun assertRegexNotMatch(jsonPath: String, pattern: String) {
+        val regex = Regex(pattern)
+        DataStore.loadResponseBodyFromScenario().string.let {
+            JsonNode.of(it).getValue<String>(jsonPath)
+        }.run {
+            assertFalse(regex.matches(this!!))
+        }
+    }
 }

playtest-gauge-rest/src/main/kotlin/com/uzabase/playtest/gauge/rest/json/JsonStringStep.kt

@@ -13,6 +13,13 @@ class JsonStringStep {
         assertEquals(expected, actual)
     }
 
+    @Step("レスポンスのJSONの<jsonPath>が文字列の<expected>でない")
+    fun assertNotEquals(jsonPath: String, expected: String) {
+        val json = DataStore.loadResponseBodyFromScenario().string
+        val actual = JsonNode.of(json).get<String>(jsonPath)
+        assertNotEquals(expected, actual)
+    }
+
     @Step("レスポンスのJSONの<jsonPath>の配列の、UniqueKey<uniqueKey>の値が<filterValue>である要素の<key>が、文字列の<expected>である")
     fun assertEqualsInUniqueObject(jsonPath: String, uniqueKey: String, filterValue: String, key: String, expected: String) {
         val json = DataStore.loadResponseBodyFromScenario().string