diff --git a/index.js b/index.js
index 79fa538..3b0ae24 100644
--- a/index.js
+++ b/index.js
@@ -224,7 +224,10 @@ sql.offset = offset =>
 sql.defaultPageSize = 10
 
 sql.pagination = (page, { pageSize: pageSize = sql.defaultPageSize } = {}) =>
-  sql`${sql.limit(pageSize)} ${sql.offset(page * pageSize)}`
+  () => ({
+    text: `${sql.limit(pageSize)().text} ${sql.offset(page * pageSize)().text}`,
+    parameters: []
+  })
 
 sql.if = (condition, truly, falsy = () => ({ text: '', parameters: [] })) => condition ? truly : falsy
 
diff --git a/test/manipulation-methods/sql.delete.js b/test/manipulation-methods/sql.delete.js
index 20245c7..fc9054c 100644
--- a/test/manipulation-methods/sql.delete.js
+++ b/test/manipulation-methods/sql.delete.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../../')
+const { testSql } = require('../test')
 
 describe('sql.delete', () => {
   beforeEach(() => {
@@ -24,23 +25,16 @@ describe('sql.delete', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'DELETE FROM "table" WHERE "column1" = $1 AND "column2" = $2 AND "column3" = $3',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg0 = actualArg(0)
-    const expectedArg0 = expectedArg
-    assert.deepEqual({ text: actualArg0.text, parameters: actualArg0.parameters }, expectedArg0)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'DELETE FROM "table" WHERE "column1" = $6 AND "column2" = $7 AND "column3" = $8',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'DELETE FROM "table" WHERE "column1" = $1 AND "column2" = $2 AND "column3" = $3',
+          5: 'DELETE FROM "table" WHERE "column1" = $6 AND "column2" = $7 AND "column3" = $8'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('delete rows with SQL Tag', async () => {
@@ -50,30 +44,18 @@ describe('sql.delete', () => {
     }
 
     sql.client = client
-    const actualRowCount = await sql.delete(
-      sql`DELETE FROM "table"`
-    )
+    const actualRowCount = await sql.delete(sql`DELETE FROM "table"`)
 
     assert.equal(actualRowCount, expectedRowCount)
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'DELETE FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg0 = actualArg(0)
-    const expectedArg0 = expectedArg
-    assert.deepEqual({ text: actualArg0.text, parameters: actualArg0.parameters }, expectedArg0)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'DELETE FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'DELETE FROM "table"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/manipulation-methods/sql.insert.js b/test/manipulation-methods/sql.insert.js
index 4f25655..2deeb22 100644
--- a/test/manipulation-methods/sql.insert.js
+++ b/test/manipulation-methods/sql.insert.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../../')
+const { testSql } = require('../test')
 
 describe('sql.update', () => {
   beforeEach(() => {
@@ -25,19 +26,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "id"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "id"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "id"',
+          5: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "id"'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('insert multiple rows', async () => {
@@ -60,19 +58,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3), ($4, $5, $6), ($7, $8, $9) RETURNING "id"',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8), ($9, $10, $11), ($12, $13, $14) RETURNING "id"',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3), ($4, $5, $6), ($7, $8, $9) RETURNING "id"',
+          5: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8), ($9, $10, $11), ($12, $13, $14) RETURNING "id"'
+        },
+        parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
+      }
+    )
   })
 
   it('return array of IDs if inserting single row as array', async () => {
@@ -93,19 +88,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "id"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "id"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "id"',
+          5: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "id"'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('return overwritten default serial column', async () => {
@@ -125,19 +117,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "column4"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "column4"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "column4"',
+          5: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "column4"'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('return given serial column', async () => {
@@ -157,23 +146,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "column4"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg0 = actualArg(0)
-    const expectedArg0 = expectedArg
-    assert.deepEqual({ text: actualArg0.text, parameters: actualArg0.parameters }, expectedArg0)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "column4"',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($1, $2, $3) RETURNING "column4"',
+          5: 'INSERT INTO "table" ("column1", "column2", "column3") VALUES ($6, $7, $8) RETURNING "column4"'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('insert given keys of row', async () => {
@@ -193,19 +175,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" ("column1", "column2") VALUES ($1, $2) RETURNING "id"',
-      parameters: ['value1', 'value2']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" ("column1", "column2") VALUES ($6, $7) RETURNING "id"',
-      parameters: ['value1', 'value2']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'INSERT INTO "table" ("column1", "column2") VALUES ($1, $2) RETURNING "id"',
+          5: 'INSERT INTO "table" ("column1", "column2") VALUES ($6, $7) RETURNING "id"'
+        },
+        parameters: ['value1', 'value2']
+      }
+    )
   })
 
   it('insert given keys of multiple rows', async () => {
@@ -229,19 +208,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" ("column1", "column2") VALUES ($1, $2), ($3, $4), ($5, $6) RETURNING "id"',
-      parameters: ['value11', 'value12', 'value21', 'value22', 'value31', 'value32']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" ("column1", "column2") VALUES ($6, $7), ($8, $9), ($10, $11) RETURNING "id"',
-      parameters: ['value11', 'value12', 'value21', 'value22', 'value31', 'value32']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'INSERT INTO "table" ("column1", "column2") VALUES ($1, $2), ($3, $4), ($5, $6) RETURNING "id"',
+          5: 'INSERT INTO "table" ("column1", "column2") VALUES ($6, $7), ($8, $9), ($10, $11) RETURNING "id"'
+        },
+        parameters: ['value11', 'value12', 'value21', 'value22', 'value31', 'value32']
+      }
+    )
   })
 
   it('insert with SQL Tag and the standard default serial column', async () => {
@@ -259,19 +235,13 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" SELECT * FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" SELECT * FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'INSERT INTO "table" SELECT * FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('insert with SQL Tag and the overwritten default serial column', async () => {
@@ -290,19 +260,13 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" SELECT * FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" SELECT * FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'INSERT INTO "table" SELECT * FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('insert with SQL Tag and the given serial column', async () => {
@@ -321,18 +285,12 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'INSERT INTO "table" SELECT * FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'INSERT INTO "table" SELECT * FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'INSERT INTO "table" SELECT * FROM "table"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/manipulation-methods/sql.update.js b/test/manipulation-methods/sql.update.js
index 168134e..ef5b492 100644
--- a/test/manipulation-methods/sql.update.js
+++ b/test/manipulation-methods/sql.update.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../../')
+const { testSql } = require('../test')
 
 describe('sql.update', () => {
   beforeEach(() => {
@@ -25,23 +26,16 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'UPDATE "table" SET "column1" = $1, "column2" = $2 WHERE "column3" = $3 AND "column4" = $4',
-      parameters: ['value1', 'value2', 'value3', 'value4']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg0 = actualArg(0)
-    const expectedArg0 = expectedArg
-    assert.deepEqual({ text: actualArg0.text, parameters: actualArg0.parameters }, expectedArg0)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'UPDATE "table" SET "column1" = $6, "column2" = $7 WHERE "column3" = $8 AND "column4" = $9',
-      parameters: ['value1', 'value2', 'value3', 'value4']
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'UPDATE "table" SET "column1" = $1, "column2" = $2 WHERE "column3" = $3 AND "column4" = $4',
+          5: 'UPDATE "table" SET "column1" = $6, "column2" = $7 WHERE "column3" = $8 AND "column4" = $9'
+        },
+        parameters: ['value1', 'value2', 'value3', 'value4']
+      }
+    )
   })
 
   it('update rows with SQL Tag', async () => {
@@ -59,22 +53,12 @@ describe('sql.update', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'UPDATE "table" SET "column" = \'value\'',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
-
-    const actualArg0 = actualArg(0)
-    const expectedArg0 = expectedArg
-    assert.deepEqual({ text: actualArg0.text, parameters: actualArg0.parameters }, expectedArg0)
-
-    const actualArg5 = actualArg(5)
-    const expectedArg5 = {
-      text: 'UPDATE "table" SET "column" = \'value\'',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg5.text, parameters: actualArg5.parameters }, expectedArg5)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'UPDATE "table" SET "column" = \'value\'',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/selection-methods/sql.any.js b/test/selection-methods/sql.any.js
index 8f42a22..d1d7c06 100644
--- a/test/selection-methods/sql.any.js
+++ b/test/selection-methods/sql.any.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../../')
+const { testSql } = require('../test')
 
 describe('sql.any', () => {
   beforeEach(() => {
@@ -21,12 +22,16 @@ describe('sql.any', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table" WHERE "column" = $1',
-      parameters: ['value']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'SELECT "*" FROM "table" WHERE "column" = $1',
+          5: 'SELECT "*" FROM "table" WHERE "column" = $6'
+        },
+        parameters: ['value']
+      }
+    )
   })
 
   it('supports shorthands to select specific columns', async () => {
@@ -42,12 +47,16 @@ describe('sql.any', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "column1", "column2" FROM "table" WHERE "column3" = $1',
-      parameters: ['value']
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: {
+          0: 'SELECT "column1", "column2" FROM "table" WHERE "column3" = $1',
+          5: 'SELECT "column1", "column2" FROM "table" WHERE "column3" = $6'
+        },
+        parameters: ['value']
+      }
+    )
   })
 
   it('select rows which are given back as return', async () => {
@@ -56,21 +65,20 @@ describe('sql.any', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: expectedRows }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
-    const actualRows = await sql.any(query)
+    const actualRows = await sql.any(sql`SELECT "*" FROM "table"`)
 
     assert.deepEqual(actualRows, expectedRows)
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('select rows which are given back as return also if there are no rows', async () => {
@@ -79,20 +87,19 @@ describe('sql.any', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: expectedRows }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
-    const actualRows = await sql.any(query)
+    const actualRows = await sql.any(sql`SELECT "*" FROM "table"`)
 
     assert.deepEqual(actualRows, expectedRows)
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/selection-methods/sql.many.js b/test/selection-methods/sql.many.js
index 1b6136f..d38bec0 100644
--- a/test/selection-methods/sql.many.js
+++ b/test/selection-methods/sql.many.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../../')
+const { testSql } = require('../test')
 
 describe('sql.many', () => {
   beforeEach(() => {
@@ -14,21 +15,20 @@ describe('sql.many', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: expectedRows }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
-    const actualRows = await sql.many(query)
+    const actualRows = await sql.many(sql`SELECT "*" FROM "table"`)
 
     assert.deepEqual(actualRows, expectedRows)
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('throw an exception if a there are none rows in the result', async () => {
@@ -37,11 +37,9 @@ describe('sql.many', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: expectedRows }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
     try {
-      await sql.many(query)
+      await sql.many(sql`SELECT "*" FROM "table"`)
       assert(false)
     } catch (e) {
       assert.equal(e.message, 'Expects to have at least one row in the query result')
@@ -49,11 +47,12 @@ describe('sql.many', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/selection-methods/sql.one.js b/test/selection-methods/sql.one.js
index c78f93b..093dbaa 100644
--- a/test/selection-methods/sql.one.js
+++ b/test/selection-methods/sql.one.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../../')
+const { testSql } = require('../test')
 
 describe('sql.one', () => {
   beforeEach(() => {
@@ -14,21 +15,20 @@ describe('sql.one', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: [expectedRow] }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
-    const actualRow = await sql.one(query)
+    const actualRow = await sql.one(sql`SELECT "*" FROM "table"`)
 
     assert.deepEqual(actualRow, expectedRow)
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('throw an exception if a there is none row in the result', async () => {
@@ -37,11 +37,9 @@ describe('sql.one', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: [expectedRow] }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
     try {
-      await sql.one(query)
+      await sql.one(sql`SELECT "*" FROM "table"`)
       assert(false)
     } catch (e) {
       assert.equal(e.message, 'Expects to have one row in the query result')
@@ -49,12 +47,13 @@ describe('sql.one', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('throw an exception if a there is more than one row in the result', async () => {
@@ -63,11 +62,9 @@ describe('sql.one', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: expectedRows }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
     try {
-      await sql.one(query)
+      await sql.one(sql`SELECT "*" FROM "table"`)
       assert(false)
     } catch (e) {
       assert.equal(e.message, 'Expects to have not more than one row in the query result')
@@ -75,11 +72,12 @@ describe('sql.one', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/selection-methods/sql.oneOrNone.js b/test/selection-methods/sql.oneOrNone.js
index 987a8ca..eb5e933 100644
--- a/test/selection-methods/sql.oneOrNone.js
+++ b/test/selection-methods/sql.oneOrNone.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../../')
+const { testSql } = require('../test')
 
 describe('sql.oneOrNone', () => {
   beforeEach(() => {
@@ -14,21 +15,20 @@ describe('sql.oneOrNone', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: [expectedRow] }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
-    const actualRow = await sql.oneOrNone(query)
+    const actualRow = await sql.oneOrNone(sql`SELECT "*" FROM "table"`)
 
     assert.deepEqual(actualRow, expectedRow)
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('select one row which is given back as return also if there is no row in the results', async () => {
@@ -37,21 +37,20 @@ describe('sql.oneOrNone', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: [expectedRow] }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
-    const actualRow = await sql.oneOrNone(query)
+    const actualRow = await sql.oneOrNone(sql`SELECT "*" FROM "table"`)
 
     assert.equal(actualRow, expectedRow)
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('throw an exception if a there is more than one row in the result', async () => {
@@ -60,11 +59,9 @@ describe('sql.oneOrNone', () => {
       query: sinon.fake.returns(Promise.resolve({ rows: expectedRows }))
     }
 
-    const query = sql`SELECT "*" FROM "table"`
-
     sql.client = client
     try {
-      await sql.oneOrNone(query)
+      await sql.oneOrNone(sql`SELECT "*" FROM "table"`)
       assert(false)
     } catch (e) {
       assert.equal(e.message, 'Expects to have not more than one row in the query result')
@@ -72,11 +69,12 @@ describe('sql.oneOrNone', () => {
 
     assert(client.query.calledOnce)
 
-    const actualArg = client.query.getCall(0).args[0]
-    const expectedArg = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg.text, parameters: actualArg.parameters }, expectedArg)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/sql.js b/test/sql.js
index 52d78ee..e79e09a 100644
--- a/test/sql.js
+++ b/test/sql.js
@@ -1,69 +1,46 @@
-const assert = require('power-assert')
-
 const sql = require('../')
+const { testSql } = require('./test')
 
 describe('sql', () => {
   it('return build function with text and parameter attribute assigned', () => {
-    const actual = sql`SELECT "*" FROM "table"`
-
-    const expected = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actual.text, parameters: actual.parameters }, expected)
-
-    const actual0 = actual(0)
-    const expected0 = expected
-    assert.deepEqual({ text: actual0.text, parameters: actual0.parameters }, expected0)
+    testSql(
+      sql`SELECT "*" FROM "table"`,
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
   })
 
   it('exchange primitive parameter', () => {
     const value1 = 'value1'
     const value2 = 'value2'
     const value3 = 'value3'
-
-    const actual = sql`SELECT "*" FROM "table" WHERE "column1" = ${value1} AND "column2" = ${value2} AND "column3" = ${value3}`
-
-    const expected = {
-      text: 'SELECT "*" FROM "table" WHERE "column1" = $1 AND "column2" = $2 AND "column3" = $3',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actual.text, parameters: actual.parameters }, expected)
-
-    const actual0 = actual(0)
-    const expected0 = expected
-    assert.deepEqual({ text: actual0.text, parameters: actual0.parameters }, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: 'SELECT "*" FROM "table" WHERE "column1" = $6 AND "column2" = $7 AND "column3" = $8',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actual5.text, parameters: actual5.parameters }, expected5)
+    testSql(
+      sql`SELECT "*" FROM "table" WHERE "column1" = ${value1} AND "column2" = ${value2} AND "column3" = ${value3}`,
+      {
+        text: {
+          0: 'SELECT "*" FROM "table" WHERE "column1" = $1 AND "column2" = $2 AND "column3" = $3',
+          5: 'SELECT "*" FROM "table" WHERE "column1" = $6 AND "column2" = $7 AND "column3" = $8'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('use functions with text and parameters to use "parameterPosition"', () => {
     const condition1 = parameterPosition => ({ text: `"column1" = $${parameterPosition + 1}`, parameters: ['value1'] })
     const condition2 = parameterPosition => ({ text: `"column2" = $${parameterPosition + 1}`, parameters: ['value2'] })
     const condition3 = parameterPosition => ({ text: `"column3" = $${parameterPosition + 1}`, parameters: ['value3'] })
-
-    const actual = sql`SELECT "*" FROM "table" WHERE ${condition1} AND ${condition2} AND ${condition3}`
-
-    const expected = {
-      text: 'SELECT "*" FROM "table" WHERE "column1" = $1 AND "column2" = $2 AND "column3" = $3',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actual.text, parameters: actual.parameters }, expected)
-
-    const actual0 = actual(0)
-    const expected0 = expected
-    assert.deepEqual({ text: actual0.text, parameters: actual0.parameters }, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: 'SELECT "*" FROM "table" WHERE "column1" = $6 AND "column2" = $7 AND "column3" = $8',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual({ text: actual5.text, parameters: actual5.parameters }, expected5)
+    testSql(
+      sql`SELECT "*" FROM "table" WHERE ${condition1} AND ${condition2} AND ${condition3}`,
+      {
+        text: {
+          0: 'SELECT "*" FROM "table" WHERE "column1" = $1 AND "column2" = $2 AND "column3" = $3',
+          5: 'SELECT "*" FROM "table" WHERE "column1" = $6 AND "column2" = $7 AND "column3" = $8'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 })
diff --git a/test/sql.query.js b/test/sql.query.js
index 3fb9add..b6e876b 100644
--- a/test/sql.query.js
+++ b/test/sql.query.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../')
+const { testSql } = require('./test')
 
 describe('sql.query', () => {
   beforeEach(() => {
@@ -18,12 +19,13 @@ describe('sql.query', () => {
 
     assert.equal(client.query.callCount, 1)
 
-    const actualArg0 = client.query.getCall(0).args[0]
-    const expectedArg0 = {
-      text: 'SELECT "*" FROM "table"',
-      parameters: []
-    }
-    assert.deepEqual({ text: actualArg0.text, parameters: actualArg0.parameters }, expectedArg0)
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
+    )
 
     const actualArg1 = client.query.getCall(0).args[1]
     const expectedArg1 = 'param2'
diff --git a/test/sql.transaction.js b/test/sql.transaction.js
index 106cb89..acc0700 100644
--- a/test/sql.transaction.js
+++ b/test/sql.transaction.js
@@ -2,6 +2,7 @@ const assert = require('power-assert')
 const sinon = require('sinon')
 
 const sql = require('../')
+const { testSql } = require('./test')
 
 describe('sql.transaction', () => {
   beforeEach(() => {
@@ -20,22 +21,28 @@ describe('sql.transaction', () => {
 
     assert.equal(client.query.callCount, 3)
 
-    const actualArg0 = client.query.getCall(0).args[0]
-    assert.deepEqual(
-      { text: actualArg0.text, parameters: actualArg0.parameters },
-      { text: 'BEGIN', parameters: [] }
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'BEGIN',
+        parameters: []
+      }
     )
 
-    const actualArg1 = client.query.getCall(1).args[0]
-    assert.deepEqual(
-      { text: actualArg1.text, parameters: actualArg1.parameters },
-      { text: 'SELECT "*" FROM "table"', parameters: [] }
+    testSql(
+      client.query.getCall(1).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
     )
 
-    const actualArg2 = client.query.getCall(2).args[0]
-    assert.deepEqual(
-      { text: actualArg2.text, parameters: actualArg2.parameters },
-      { text: 'COMMIT', parameters: [] }
+    testSql(
+      client.query.getCall(2).args[0],
+      {
+        text: 'COMMIT',
+        parameters: []
+      }
     )
   })
 
@@ -57,22 +64,28 @@ describe('sql.transaction', () => {
 
     assert.equal(client.query.callCount, 3)
 
-    const actualArg0 = client.query.getCall(0).args[0]
-    assert.deepEqual(
-      { text: actualArg0.text, parameters: actualArg0.parameters },
-      { text: 'BEGIN', parameters: [] }
+    testSql(
+      client.query.getCall(0).args[0],
+      {
+        text: 'BEGIN',
+        parameters: []
+      }
     )
 
-    const actualArg1 = client.query.getCall(1).args[0]
-    assert.deepEqual(
-      { text: actualArg1.text, parameters: actualArg1.parameters },
-      { text: 'SELECT "*" FROM "table"', parameters: [] }
+    testSql(
+      client.query.getCall(1).args[0],
+      {
+        text: 'SELECT "*" FROM "table"',
+        parameters: []
+      }
     )
 
-    const actualArg2 = client.query.getCall(2).args[0]
-    assert.deepEqual(
-      { text: actualArg2.text, parameters: actualArg2.parameters },
-      { text: 'ROLLBACK', parameters: [] }
+    testSql(
+      client.query.getCall(2).args[0],
+      {
+        text: 'ROLLBACK',
+        parameters: []
+      }
     )
   })
 })
diff --git a/test/tag-helpers/sql.assignments.js b/test/tag-helpers/sql.assignments.js
index d64786a..85900de 100644
--- a/test/tag-helpers/sql.assignments.js
+++ b/test/tag-helpers/sql.assignments.js
@@ -1,31 +1,17 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.assignments', () => {
   it('use the given object to build assignments', () => {
-    const actual = sql.assignments({
-      column1: 'value1',
-      column2: 'value2',
-      column3: 'value3'
-    })
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '"column1" = $1, "column2" = $2, "column3" = $3',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '"column1" = $6, "column2" = $7, "column3" = $8',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.assignments({ column1: 'value1', column2: 'value2', column3: 'value3' }),
+      {
+        text: {
+          0: '"column1" = $1, "column2" = $2, "column3" = $3',
+          5: '"column1" = $6, "column2" = $7, "column3" = $8'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.conditions.js b/test/tag-helpers/sql.conditions.js
index 0292263..597b1a0 100644
--- a/test/tag-helpers/sql.conditions.js
+++ b/test/tag-helpers/sql.conditions.js
@@ -1,31 +1,17 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.conditions', () => {
   it('use the given object to build conditions', () => {
-    const actual = sql.conditions({
-      column1: 'value1',
-      column2: 'value2',
-      column3: 'value3'
-    })
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '"column1" = $1 AND "column2" = $2 AND "column3" = $3',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '"column1" = $6 AND "column2" = $7 AND "column3" = $8',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.conditions({ column1: 'value1', column2: 'value2', column3: 'value3' }),
+      {
+        text: {
+          0: '"column1" = $1 AND "column2" = $2 AND "column3" = $3',
+          5: '"column1" = $6 AND "column2" = $7 AND "column3" = $8'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.if.js b/test/tag-helpers/sql.if.js
index 0f9d6ae..a73caa5 100644
--- a/test/tag-helpers/sql.if.js
+++ b/test/tag-helpers/sql.if.js
@@ -1,23 +1,38 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.if', () => {
   it('use the then given value in a truly case', () => {
-    const actual = sql.if(true, () => ({ text: 'true', parameters: [] }))()
-    const expected = { text: 'true', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.if(true, () => ({ text: 'true', parameters: [] })),
+      {
+        text: 'true',
+        parameters: []
+      }
+    )
   })
 
   it('use the else default value in a falsy case', () => {
-    const actual = sql.if(false, () => ({ text: 'true', parameters: [] }))()
-    const expected = { text: '', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.if(false, () => ({ text: 'true', parameters: [] })),
+      {
+        text: '',
+        parameters: []
+      }
+    )
   })
 
   it('use the else given value in a falsy case', () => {
-    const actual = sql.if(false, () => ({ text: 'true', parameters: [] }), () => ({ text: 'false', parameters: [] }))()
-    const expected = { text: 'false', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.if(
+        false,
+        () => ({ text: 'true', parameters: [] }),
+        () => ({ text: 'false', parameters: [] })
+      ),
+      {
+        text: 'false',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.key.js b/test/tag-helpers/sql.key.js
index 1fcf356..000bca2 100644
--- a/test/tag-helpers/sql.key.js
+++ b/test/tag-helpers/sql.key.js
@@ -1,23 +1,24 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.key', () => {
   it('escapes the given key', () => {
-    const actual = sql.key('column')()
-    const expected = {
-      text: '"column"',
-      parameters: []
-    }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.key('column'),
+      {
+        text: '"column"',
+        parameters: []
+      }
+    )
   })
 
   it('escapes the given unsecure key', () => {
-    const actual = sql.key('column"column')()
-    const expected = {
-      text: '"column""column"',
-      parameters: []
-    }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.key('column"column'),
+      {
+        text: '"column""column"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.keys.js b/test/tag-helpers/sql.keys.js
index 41b43c2..a9a49cf 100644
--- a/test/tag-helpers/sql.keys.js
+++ b/test/tag-helpers/sql.keys.js
@@ -1,44 +1,34 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.keys', () => {
   it('escape the given keys', () => {
-    const actual = sql.keys([
-      'column1',
-      'column2',
-      'column3'
-    ])()
-    const expected = {
-      text: '"column1", "column2", "column3"',
-      parameters: []
-    }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.keys(['column1', 'column2', 'column3']),
+      {
+        text: '"column1", "column2", "column3"',
+        parameters: []
+      }
+    )
   })
 
   it('escape the given unsecure keys', () => {
-    const actual = sql.keys([
-      'column1"column1',
-      'column2"column2',
-      'column3"column3'
-    ])()
-    const expected = {
-      text: '"column1""column1", "column2""column2", "column3""column3"',
-      parameters: []
-    }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.keys(['column1"column1', 'column2"column2', 'column3"column3']),
+      {
+        text: '"column1""column1", "column2""column2", "column3""column3"',
+        parameters: []
+      }
+    )
   })
 
   it('exchange the keys of the given object', () => {
-    const actual = sql.keys({
-      column1: 'value1',
-      column2: 'value2',
-      column3: 'value3'
-    })()
-    const expected = {
-      text: '"column1", "column2", "column3"',
-      parameters: []
-    }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.keys({ column1: 'value1', column2: 'value2', column3: 'value3' }),
+      {
+        text: '"column1", "column2", "column3"',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.limit.js b/test/tag-helpers/sql.limit.js
index ded2cd1..aeba976 100644
--- a/test/tag-helpers/sql.limit.js
+++ b/test/tag-helpers/sql.limit.js
@@ -1,6 +1,5 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.limit', () => {
   beforeEach(() => {
@@ -9,46 +8,74 @@ describe('sql.limit', () => {
   })
 
   it('use the given positive number', () => {
-    const actual = sql.limit(5)()
-    const expected = { text: 'LIMIT 5', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.limit(5),
+      {
+        text: 'LIMIT 5',
+        parameters: []
+      }
+    )
   })
 
   it('use a large positive number with the normal default limit', () => {
-    const actual = sql.limit(150)()
-    const expected = { text: 'LIMIT 100', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.limit(150),
+      {
+        text: 'LIMIT 100',
+        parameters: []
+      }
+    )
   })
 
   it('use the overwritten default limit if there is a to large positive number given', () => {
     sql.defaultMaxLimit = 500
-    const actual = sql.limit(150)()
-    const expected = { text: 'LIMIT 150', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.limit(150),
+      {
+        text: 'LIMIT 150',
+        parameters: []
+      }
+    )
   })
 
   it('use the given limit if there is a to large number given', () => {
-    const actual = sql.limit(150, { maxLimit: 500 })()
-    const expected = { text: 'LIMIT 150', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.limit(150, { maxLimit: 500 }),
+      {
+        text: 'LIMIT 150',
+        parameters: []
+      }
+    )
   })
 
   it('use the normal default fallback if there is not a positive number given', () => {
-    const actual = sql.limit(NaN)()
-    const expected = { text: 'LIMIT 10', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.limit(NaN),
+      {
+        text: 'LIMIT 10',
+        parameters: []
+      }
+    )
   })
 
   it('use the overwritten default fallback if there is not a positive number given', () => {
     sql.defaultFallbackLimit = 15
-    const actual = sql.limit(NaN)()
-    const expected = { text: 'LIMIT 15', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.limit(NaN),
+      {
+        text: 'LIMIT 15',
+        parameters: []
+      }
+    )
   })
 
   it('use the given fallback if there is not a positive number given', () => {
-    const actual = sql.limit(NaN, { fallbackLimit: 15 })()
-    const expected = { text: 'LIMIT 15', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.limit(NaN, { fallbackLimit: 15 }),
+      {
+        text: 'LIMIT 15',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.offset.js b/test/tag-helpers/sql.offset.js
index 3528c55..bd64a22 100644
--- a/test/tag-helpers/sql.offset.js
+++ b/test/tag-helpers/sql.offset.js
@@ -1,17 +1,24 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.offset', () => {
   it('use the given positive number', () => {
-    const actual = sql.offset(5)()
-    const expected = { text: 'OFFSET 5', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.offset(5),
+      {
+        text: 'OFFSET 5',
+        parameters: []
+      }
+    )
   })
 
   it('use the fallback if there is not a positive number given', () => {
-    const actual = sql.offset(NaN)()
-    const expected = { text: 'OFFSET 0', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.offset(NaN),
+      {
+        text: 'OFFSET 0',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.pagination.js b/test/tag-helpers/sql.pagination.js
index 13e6dd3..907ccab 100644
--- a/test/tag-helpers/sql.pagination.js
+++ b/test/tag-helpers/sql.pagination.js
@@ -1,6 +1,5 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.pagination', () => {
   beforeEach(() => {
@@ -8,27 +7,43 @@ describe('sql.pagination', () => {
   })
 
   it('use the given page and normal default pageSize to set limit and offset', () => {
-    const actual = sql.pagination(5)()
-    const expected = { text: 'LIMIT 10 OFFSET 50', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.pagination(5),
+      {
+        text: 'LIMIT 10 OFFSET 50',
+        parameters: []
+      }
+    )
   })
 
   it('use the first page if there is not a positive page given', () => {
-    const actual = sql.pagination(NaN)()
-    const expected = { text: 'LIMIT 10 OFFSET 0', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.pagination(NaN),
+      {
+        text: 'LIMIT 10 OFFSET 0',
+        parameters: []
+      }
+    )
   })
 
   it('use the given page and overwritten default pageSize to set limit and offset', () => {
     sql.defaultPageSize = 15
-    const actual = sql.pagination(5)()
-    const expected = { text: 'LIMIT 15 OFFSET 75', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.pagination(5),
+      {
+        text: 'LIMIT 15 OFFSET 75',
+        parameters: []
+      }
+    )
   })
 
   it('use the given page and given pageSize to set limit and offset', () => {
-    const actual = sql.pagination(5, { pageSize: 15 })()
-    const expected = { text: 'LIMIT 15 OFFSET 75', parameters: [] }
-    assert.deepEqual(actual, expected)
+    testTagHelper(
+      sql.pagination(5, { pageSize: 15 }),
+      {
+        text: 'LIMIT 15 OFFSET 75',
+        parameters: []
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.value.js b/test/tag-helpers/sql.value.js
index b20433c..ccca9e9 100644
--- a/test/tag-helpers/sql.value.js
+++ b/test/tag-helpers/sql.value.js
@@ -1,27 +1,17 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.value', () => {
   it('should exchange the given value', () => {
-    const actual = sql.value('value')
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '$1',
-      parameters: ['value']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '$6',
-      parameters: ['value']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.value('value'),
+      {
+        text: {
+          0: '$1',
+          5: '$6'
+        },
+        parameters: ['value']
+      }
+    )
   })
 })
diff --git a/test/tag-helpers/sql.values.js b/test/tag-helpers/sql.values.js
index 0b44d78..a1ec808 100644
--- a/test/tag-helpers/sql.values.js
+++ b/test/tag-helpers/sql.values.js
@@ -1,74 +1,46 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.values', () => {
   it('exchange the given values', () => {
-    const actual = sql.values(['value1', 'value2', 'value3'])
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '$1, $2, $3',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '$6, $7, $8',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.values(['value1', 'value2', 'value3']),
+      {
+        text: {
+          0: '$1, $2, $3',
+          5: '$6, $7, $8'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('exchange the values of the given object', () => {
-    const actual = sql.values({ column1: 'value1', column2: 'value2', column3: 'value3' })
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '$1, $2, $3',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '$6, $7, $8',
-      parameters: ['value1', 'value2', 'value3']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.values({ column1: 'value1', column2: 'value2', column3: 'value3' }),
+      {
+        text: {
+          0: '$1, $2, $3',
+          5: '$6, $7, $8'
+        },
+        parameters: ['value1', 'value2', 'value3']
+      }
+    )
   })
 
   it('exchange only the values of the given keys of the given object', () => {
-    const actual = sql.values(
-      { column1: 'value1', column2: 'value2', column3: 'value3', column4: 'value4' },
-      { keys: ['column1', 'column2'] }
+    testTagHelper(
+      sql.values(
+        { column1: 'value1', column2: 'value2', column3: 'value3', column4: 'value4' },
+        { keys: ['column1', 'column2'] }
+      ),
+      {
+        text: {
+          0: '$1, $2',
+          5: '$6, $7'
+        },
+        parameters: ['value1', 'value2']
+      }
     )
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '$1, $2',
-      parameters: ['value1', 'value2']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '$6, $7',
-      parameters: ['value1', 'value2']
-    }
-    assert.deepEqual(actual5, expected5)
   })
 })
diff --git a/test/tag-helpers/sql.valuesList.js b/test/tag-helpers/sql.valuesList.js
index 711bf8c..071be0d 100644
--- a/test/tag-helpers/sql.valuesList.js
+++ b/test/tag-helpers/sql.valuesList.js
@@ -1,112 +1,75 @@
-const assert = require('power-assert')
-
 const sql = require('../../')
+const { testTagHelper } = require('../test')
 
 describe('sql.valuesList', () => {
   it('exchange the given values of the list', () => {
-    const actual = sql.valuesList([
-      ['value11', 'value12', 'value13'],
-      ['value21', 'value22', 'value23'],
-      ['value31', 'value32', 'value33']
-    ])
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '($1, $2, $3), ($4, $5, $6), ($7, $8, $9)',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '($6, $7, $8), ($9, $10, $11), ($12, $13, $14)',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.valuesList([
+        ['value11', 'value12', 'value13'],
+        ['value21', 'value22', 'value23'],
+        ['value31', 'value32', 'value33']
+      ]),
+      {
+        text: {
+          0: '($1, $2, $3), ($4, $5, $6), ($7, $8, $9)',
+          5: '($6, $7, $8), ($9, $10, $11), ($12, $13, $14)'
+        },
+        parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
+      }
+    )
   })
 
   it('exchange the values of the given objects of the list', () => {
-    const actual = sql.valuesList([
-      { column1: 'value11', column2: 'value12', column3: 'value13' },
-      { column1: 'value21', column2: 'value22', column3: 'value23' },
-      { column1: 'value31', column2: 'value32', column3: 'value33' }
-    ])
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '($1, $2, $3), ($4, $5, $6), ($7, $8, $9)',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '($6, $7, $8), ($9, $10, $11), ($12, $13, $14)',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.valuesList([
+        { column1: 'value11', column2: 'value12', column3: 'value13' },
+        { column1: 'value21', column2: 'value22', column3: 'value23' },
+        { column1: 'value31', column2: 'value32', column3: 'value33' }
+      ]),
+      {
+        text: {
+          0: '($1, $2, $3), ($4, $5, $6), ($7, $8, $9)',
+          5: '($6, $7, $8), ($9, $10, $11), ($12, $13, $14)'
+        },
+        parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
+      }
+    )
   })
 
   it('if objects are used, the order of the attributes must not be relevant', () => {
-    const actual = sql.valuesList([
-      { column1: 'value11', column2: 'value12', column3: 'value13' },
-      { column2: 'value22', column3: 'value23', column1: 'value21' },
-      { column3: 'value33', column1: 'value31', column2: 'value32' }
-    ])
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '($1, $2, $3), ($4, $5, $6), ($7, $8, $9)',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '($6, $7, $8), ($9, $10, $11), ($12, $13, $14)',
-      parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
-    }
-    assert.deepEqual(actual5, expected5)
+    testTagHelper(
+      sql.valuesList([
+        { column1: 'value11', column2: 'value12', column3: 'value13' },
+        { column2: 'value22', column3: 'value23', column1: 'value21' },
+        { column3: 'value33', column1: 'value31', column2: 'value32' }
+      ]),
+      {
+        text: {
+          0: '($1, $2, $3), ($4, $5, $6), ($7, $8, $9)',
+          5: '($6, $7, $8), ($9, $10, $11), ($12, $13, $14)'
+        },
+        parameters: ['value11', 'value12', 'value13', 'value21', 'value22', 'value23', 'value31', 'value32', 'value33']
+      }
+    )
   })
 
   it('exchange only the values of the given keys of the given objects of the list', () => {
-    const actual = sql.valuesList(
-      [
-        { column1: 'value11', column2: 'value12', column3: 'value13', column4: 'value14' },
-        { column1: 'value21', column2: 'value22', column3: 'value23', column4: 'value24' },
-        { column1: 'value31', column2: 'value32', column3: 'value33', column4: 'value34' }
-      ],
-      { keys: ['column1', 'column2'] }
+    testTagHelper(
+      sql.valuesList(
+        [
+          { column1: 'value11', column2: 'value12', column3: 'value13', column4: 'value14' },
+          { column1: 'value21', column2: 'value22', column3: 'value23', column4: 'value24' },
+          { column1: 'value31', column2: 'value32', column3: 'value33', column4: 'value34' }
+        ],
+        { keys: ['column1', 'column2'] }
+      ),
+      {
+        text: {
+          0: '($1, $2), ($3, $4), ($5, $6)',
+          5: '($6, $7), ($8, $9), ($10, $11)'
+        },
+        parameters: ['value11', 'value12', 'value21', 'value22', 'value31', 'value32']
+      }
     )
-
-    assert.equal(actual.text, undefined)
-    assert.equal(actual.parameters, undefined)
-    assert.equal(actual.symbol, undefined)
-
-    const actual0 = actual(0)
-    const expected0 = {
-      text: '($1, $2), ($3, $4), ($5, $6)',
-      parameters: ['value11', 'value12', 'value21', 'value22', 'value31', 'value32']
-    }
-    assert.deepEqual(actual0, expected0)
-
-    const actual5 = actual(5)
-    const expected5 = {
-      text: '($6, $7), ($8, $9), ($10, $11)',
-      parameters: ['value11', 'value12', 'value21', 'value22', 'value31', 'value32']
-    }
-    assert.deepEqual(actual5, expected5)
   })
 })
diff --git a/test/test.js b/test/test.js
new file mode 100644
index 0000000..6770c14
--- /dev/null
+++ b/test/test.js
@@ -0,0 +1,44 @@
+const assert = require('power-assert')
+
+function testSql (actual, expected) {
+  if (typeof expected.text === 'object') {
+    assert.deepEqual(
+      { text: actual.text, parameters: actual.parameters },
+      { text: expected.text['0'], parameters: expected.parameters }
+    )
+  } else {
+    assert.deepEqual(
+      { text: actual.text, parameters: actual.parameters },
+      { text: expected.text, parameters: expected.parameters }
+    )
+  }
+  assert.equal(typeof actual.symbol, 'symbol')
+  assert.equal(actual.symbol.toString(), 'Symbol(sql-pg)')
+  testBuild(actual, expected)
+}
+
+function testTagHelper (actual, expected) {
+  assert.equal(actual.text, undefined)
+  assert.equal(actual.parameters, undefined)
+  assert.equal(actual.symbol, undefined)
+  testBuild(actual, expected)
+}
+
+function testBuild (actual, expected) {
+  if (typeof expected.text !== 'object') {
+    expected.text = {
+      0: expected.text,
+      5: expected.text
+    }
+  }
+  for (let parameterPosition of Object.keys(expected.text)) {
+    parameterPosition = parseInt(parameterPosition, 10)
+    const parameterPositionActual = actual(parameterPosition)
+    assert.deepEqual(
+      { text: parameterPositionActual.text, parameters: parameterPositionActual.parameters },
+      { text: expected.text[parameterPosition], parameters: expected.parameters }
+    )
+  }
+}
+
+module.exports = { testSql, testTagHelper }