DOPE-214: added backticks to tests

ergon · May 24, 2024 · 60f8ea5 · 60f8ea5
1 parent e2bc2fb
commit 60f8ea5
Show file tree

Hide file tree

Showing 5 changed files with 36 additions and 36 deletions.
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/QueryBuilderTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/QueryBuilderTest.kt
@@ -15,34 +15,34 @@ class QueryBuilderTest {
     fun `should support select with CM`() {
         val actual: String = QueryBuilder().select(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT someNumberField", actual)
+        assertEquals("SELECT `someNumberField`", actual)
     }
 
     @Test
     fun `should support select with multiple CM`() {
         val actual: String = QueryBuilder().select(someCMBooleanField(), someCMStringList()).toDopeQuery().queryString
 
-        assertEquals("SELECT someBooleanField, someStringList", actual)
+        assertEquals("SELECT `someBooleanField`, `someStringList`", actual)
     }
 
     @Test
     fun `should support select distinct with CM`() {
         val actual: String = QueryBuilder().selectDistinct(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT DISTINCT someNumberField", actual)
+        assertEquals("SELECT DISTINCT `someNumberField`", actual)
     }
 
     @Test
     fun `should support select distinct with multiple CM`() {
         val actual: String = QueryBuilder().selectDistinct(someCMBooleanField(), someCMStringList()).toDopeQuery().queryString
 
-        assertEquals("SELECT DISTINCT someBooleanField, someStringList", actual)
+        assertEquals("SELECT DISTINCT `someBooleanField`, `someStringList`", actual)
     }
 
     @Test
     fun `should support select raw with CM`() {
         val actual: String = QueryBuilder().selectRaw(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT RAW someNumberField", actual)
+        assertEquals("SELECT RAW `someNumberField`", actual)
     }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/CountTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/CountTest.kt
@@ -15,41 +15,41 @@ class CountTest {
     fun `should support count with CMField Number`() {
         val actual: String = count(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("COUNT(someNumberField)", actual)
+        assertEquals("COUNT(`someNumberField`)", actual)
     }
 
     @Test
     fun `should support count with CMField String`() {
         val actual: String = count(someCMStringField()).toDopeQuery().queryString
 
-        assertEquals("COUNT(someStringField)", actual)
+        assertEquals("COUNT(`someStringField`)", actual)
     }
 
     @Test
     fun `should support count with CMField Boolean`() {
         val actual: String = count(someCMBooleanField()).toDopeQuery().queryString
 
-        assertEquals("COUNT(someBooleanField)", actual)
+        assertEquals("COUNT(`someBooleanField`)", actual)
     }
 
     @Test
     fun `should support count with CMList Number`() {
         val actual: String = count(someCMNumberList()).toDopeQuery().queryString
 
-        assertEquals("COUNT(someNumberList)", actual)
+        assertEquals("COUNT(`someNumberList`)", actual)
     }
 
     @Test
     fun `should support count with CMList String`() {
         val actual: String = count(someCMStringList()).toDopeQuery().queryString
 
-        assertEquals("COUNT(someStringList)", actual)
+        assertEquals("COUNT(`someStringList`)", actual)
     }
 
     @Test
     fun `should support count with CMList Boolean`() {
         val actual: String = count(someCMBooleanList()).toDopeQuery().queryString
 
-        assertEquals("COUNT(someBooleanList)", actual)
+        assertEquals("COUNT(`someBooleanList`)", actual)
     }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MinTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/aggregator/MinTest.kt
@@ -15,41 +15,41 @@ class MinTest {
     fun `should support min with CMField Number`() {
         val actual: String = min(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("MIN(someNumberField)", actual)
+        assertEquals("MIN(`someNumberField`)", actual)
     }
 
     @Test
     fun `should support min with CMField String`() {
         val actual: String = min(someCMStringField()).toDopeQuery().queryString
 
-        assertEquals("MIN(someStringField)", actual)
+        assertEquals("MIN(`someStringField`)", actual)
     }
 
     @Test
     fun `should support min with CMField Boolean`() {
         val actual: String = min(someCMBooleanField()).toDopeQuery().queryString
 
-        assertEquals("MIN(someBooleanField)", actual)
+        assertEquals("MIN(`someBooleanField`)", actual)
     }
 
     @Test
     fun `should support min with CMList Number`() {
         val actual: String = min(someCMNumberList()).toDopeQuery().queryString
 
-        assertEquals("MIN(someNumberList)", actual)
+        assertEquals("MIN(`someNumberList`)", actual)
     }
 
     @Test
     fun `should support min with CMList String`() {
         val actual: String = min(someCMStringList()).toDopeQuery().queryString
 
-        assertEquals("MIN(someStringList)", actual)
+        assertEquals("MIN(`someStringList`)", actual)
     }
 
     @Test
     fun `should support min with CMList Boolean`() {
         val actual: String = min(someCMBooleanList()).toDopeQuery().queryString
 
-        assertEquals("MIN(someBooleanList)", actual)
+        assertEquals("MIN(`someBooleanList`)", actual)
     }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/DeleteClauseTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/DeleteClauseTest.kt
@@ -16,34 +16,34 @@ class DeleteClauseTest {
     fun `should support delete where with CM`() {
         val actual: String = someDelete().where(someCMBooleanField()).toDopeQuery().queryString
 
-        assertEquals("DELETE FROM someBucket WHERE someBooleanField", actual)
+        assertEquals("DELETE FROM `someBucket` WHERE `someBooleanField`", actual)
     }
 
     @Test
     fun `should support delete limit with CM`() {
         val actual: String = someDelete().limit(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("DELETE FROM someBucket LIMIT someNumberField", actual)
+        assertEquals("DELETE FROM `someBucket` LIMIT `someNumberField`", actual)
     }
 
     @Test
     fun `should support delete offset with CM`() {
         val actual: String = someDelete().offset(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("DELETE FROM someBucket OFFSET someNumberField", actual)
+        assertEquals("DELETE FROM `someBucket` OFFSET `someNumberField`", actual)
     }
 
     @Test
     fun `should support delete returning with CM`() {
         val actual: String = someDelete().returning(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("DELETE FROM someBucket RETURNING someNumberField", actual)
+        assertEquals("DELETE FROM `someBucket` RETURNING `someNumberField`", actual)
     }
 
     @Test
     fun `should support delete returning with multiple CM`() {
         val actual: String = someDelete().returning(someCMNumberField(), someCMStringList(), someCMBooleanField()).toDopeQuery().queryString
 
-        assertEquals("DELETE FROM someBucket RETURNING someNumberField, someStringList, someBooleanField", actual)
+        assertEquals("DELETE FROM `someBucket` RETURNING `someNumberField`, `someStringList`, `someBooleanField`", actual)
     }
 }
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/SelectClauseTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/extensions/clause/SelectClauseTest.kt
@@ -28,97 +28,97 @@ class SelectClauseTest {
     fun `should support select where with CM`() {
         val actual: String = someSelect().where(someCMBooleanField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * WHERE someBooleanField", actual)
+        assertEquals("SELECT * WHERE `someBooleanField`", actual)
     }
 
     @Test
     fun `should support select unnest with CM Number`() {
         val actual: String = someFrom().unnest(someCMNumberList()).toDopeQuery().queryString
 
-        assertEquals("SELECT * FROM someBucket UNNEST someNumberList", actual)
+        assertEquals("SELECT * FROM `someBucket` UNNEST `someNumberList`", actual)
     }
 
     @Test
     fun `should support select unnest with CM String`() {
         val actual: String = someFrom().unnest(someCMStringList()).toDopeQuery().queryString
 
-        assertEquals("SELECT * FROM someBucket UNNEST someStringList", actual)
+        assertEquals("SELECT * FROM `someBucket` UNNEST `someStringList`", actual)
     }
 
     @Test
     fun `should support select unnest with CM Boolean`() {
         val actual: String = someFrom().unnest(someCMBooleanList()).toDopeQuery().queryString
 
-        assertEquals("SELECT * FROM someBucket UNNEST someBooleanList", actual)
+        assertEquals("SELECT * FROM `someBucket` UNNEST `someBooleanList`", actual)
     }
 
     @Test
     fun `should support select join with CM`() {
         val actual: String = someFrom().join(someBucket("other"), onKeys = someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * FROM someBucket JOIN other ON KEYS someNumberField", actual)
+        assertEquals("SELECT * FROM `someBucket` JOIN `other` ON KEYS `someNumberField`", actual)
     }
 
     @Test
     fun `should support select inner join with CM`() {
         val actual: String = someFrom().innerJoin(someBucket("other"), onKeys = someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * FROM someBucket INNER JOIN other ON KEYS someNumberField", actual)
+        assertEquals("SELECT * FROM `someBucket` INNER JOIN `other` ON KEYS `someNumberField`", actual)
     }
 
     @Test
     fun `should support select left join with CM`() {
         val actual: String = someFrom().leftJoin(someBucket("other"), onKeys = someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * FROM someBucket LEFT JOIN other ON KEYS someNumberField", actual)
+        assertEquals("SELECT * FROM `someBucket` LEFT JOIN `other` ON KEYS `someNumberField`", actual)
     }
 
     @Test
     fun `should support select right join with CM`() {
         val actual: String = someFrom().rightJoin(someBucket("other"), onKeys = someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * FROM someBucket RIGHT JOIN other ON KEYS someNumberField", actual)
+        assertEquals("SELECT * FROM `someBucket` RIGHT JOIN `other` ON KEYS `someNumberField`", actual)
     }
 
     @Test
     fun `should support select group by with multiple CM`() {
         val actual: String = someSelect().groupBy(someCMStringField(), someCMNumberList()).toDopeQuery().queryString
 
-        assertEquals("SELECT * GROUP BY someStringField, someNumberList", actual)
+        assertEquals("SELECT * GROUP BY `someStringField`, `someNumberList`", actual)
     }
 
     @Test
     fun `should support select group by with CM`() {
         val actual: String = someSelect().groupBy(someCMStringField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * GROUP BY someStringField", actual)
+        assertEquals("SELECT * GROUP BY `someStringField`", actual)
     }
 
     @Test
     fun `should support select order by with CM and type`() {
         val actual: String = someSelect().orderBy(someCMStringField(), OrderByType.ASC).toDopeQuery().queryString
 
-        assertEquals("SELECT * ORDER BY someStringField ASC", actual)
+        assertEquals("SELECT * ORDER BY `someStringField` ASC", actual)
     }
 
     @Test
     fun `should support select order by with CM`() {
         val actual: String = someSelect().orderBy(someCMStringField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * ORDER BY someStringField", actual)
+        assertEquals("SELECT * ORDER BY `someStringField`", actual)
     }
 
     @Test
     fun `should support select limit with CM`() {
         val actual: String = someSelect().limit(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * LIMIT someNumberField", actual)
+        assertEquals("SELECT * LIMIT `someNumberField`", actual)
     }
 
     @Test
     fun `should support select offset with CM`() {
         val actual: String = someSelect().offset(someCMNumberField()).toDopeQuery().queryString
 
-        assertEquals("SELECT * OFFSET someNumberField", actual)
+        assertEquals("SELECT * OFFSET `someNumberField`", actual)
     }
 }