Merge pull request #53 from scr-oath/assertion-helpers

Add assert and require features like testify has.

Author: scr-oath

base64/test/test_api.lua

@@ -1,110 +1,111 @@
-local base64 = require("base64")
-local strings = require("strings")
+local base64 = require 'base64'
+local strings = require 'strings'
+local assert = require 'assert'
 
 function TestEncodeToString(t)
     local tests = {
         {
-            name="input with \1 chars and RawStdEncoding",
-            input="foo\01bar",
-            encoder=base64.RawStdEncoding,
-            expected="Zm9vAWJhcg",
+            name = "input with \1 chars and RawStdEncoding",
+            input = "foo\01bar",
+            encoder = base64.RawStdEncoding,
+            expected = "Zm9vAWJhcg",
         },
         {
-            name="input with \1 chars and StdEncoding",
-            input="foo\01bar",
-            encoder=base64.StdEncoding,
-            expected="Zm9vAWJhcg==",
+            name = "input with \1 chars and StdEncoding",
+            input = "foo\01bar",
+            encoder = base64.StdEncoding,
+            expected = "Zm9vAWJhcg==",
         },
         {
-            name="input with <> chars and RawURLEncoding",
-            input="this is a <tag> and should be encoded",
-            encoder=base64.RawURLEncoding,
-            expected="dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA",
+            name = "input with <> chars and RawURLEncoding",
+            input = "this is a <tag> and should be encoded",
+            encoder = base64.RawURLEncoding,
+            expected = "dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA",
         },
         {
-            name="input with <> chars and URLEncoding",
-            input="this is a <tag> and should be encoded",
-            encoder=base64.URLEncoding,
-            expected="dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==",
+            name = "input with <> chars and URLEncoding",
+            input = "this is a <tag> and should be encoded",
+            encoder = base64.URLEncoding,
+            expected = "dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==",
         },
     }
     for _, tt in ipairs(tests) do
         t:Run(tt.name, function(t)
             local got = tt.encoder:encode_to_string(tt.input)
-            assert(tt.expected == got, string.format("'%s' ~= '%s'", tt.expected, got))
+            assert:Equal(t, tt.expected, got)
         end)
     end
 end
 
 function TestDecodeString(t)
     local tests = {
         {
-            name="input with \1 chars and RawStdEncoding",
-            input="Zm9vAWJhcg",
-            encoder=base64.RawStdEncoding,
-            expected="foo\01bar",
+            name = "input with \1 chars and RawStdEncoding",
+            input = "Zm9vAWJhcg",
+            encoder = base64.RawStdEncoding,
+            expected = "foo\01bar",
         },
         {
-            name="input with \1 chars and StdEncoding",
-            input="Zm9vAWJhcg==",
-            encoder=base64.StdEncoding,
-            expected="foo\01bar",
+            name = "input with \1 chars and StdEncoding",
+            input = "Zm9vAWJhcg==",
+            encoder = base64.StdEncoding,
+            expected = "foo\01bar",
         },
         {
-            name="input with <> chars and RawURLEncoding",
-            input="dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA",
-            encoder=base64.RawURLEncoding,
-            expected="this is a <tag> and should be encoded",
+            name = "input with <> chars and RawURLEncoding",
+            input = "dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA",
+            encoder = base64.RawURLEncoding,
+            expected = "this is a <tag> and should be encoded",
         },
         {
-            name="input with <> chars and URLEncoding",
-            input="dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==",
-            encoder=base64.URLEncoding,
-            expected="this is a <tag> and should be encoded",
+            name = "input with <> chars and URLEncoding",
+            input = "dGhpcyBpcyBhIDx0YWc-IGFuZCBzaG91bGQgYmUgZW5jb2RlZA==",
+            encoder = base64.URLEncoding,
+            expected = "this is a <tag> and should be encoded",
         },
     }
     for _, tt in ipairs(tests) do
         t:Run(tt.name, function(t)
             local got, err = tt.encoder:decode_string(tt.input)
             if tt.want_err then
-                assert(err, "expected err")
+                assert:Error(t, err)
                 return
             end
-            assert(not err, err)
-            assert(tt.expected == got, string.format("'%s' ~= '%s'", tt.expected, got))
+            assert:NoError(t, err)
+            assert:Equal(t, tt.expected, got)
         end)
     end
 end
 
 function TestEncodeDecode(t)
     local tests = {
         {
-            name="input with \1 chars and RawStdEncoding",
-            input="foo\01bar",
-            encoder=base64.RawStdEncoding,
+            name = "input with \1 chars and RawStdEncoding",
+            input = "foo\01bar",
+            encoder = base64.RawStdEncoding,
         },
         {
-            name="input with \1 chars and StdEncoding",
-            input="foo\01bar",
-            encoder=base64.StdEncoding,
+            name = "input with \1 chars and StdEncoding",
+            input = "foo\01bar",
+            encoder = base64.StdEncoding,
         },
         {
-            name="input with <> chars and RawURLEncoding",
-            input="this is a <tag> and should be encoded",
-            encoder=base64.RawURLEncoding,
+            name = "input with <> chars and RawURLEncoding",
+            input = "this is a <tag> and should be encoded",
+            encoder = base64.RawURLEncoding,
         },
         {
-            name="input with <> chars and URLEncoding",
-            input="this is a <tag> and should be encoded",
-            encoder=base64.URLEncoding,
+            name = "input with <> chars and URLEncoding",
+            input = "this is a <tag> and should be encoded",
+            encoder = base64.URLEncoding,
         },
     }
     for _, tt in ipairs(tests) do
         t:Run(tt.name, function(t)
             local encoded = tt.encoder:encode_to_string(tt.input)
             local decoded, err = tt.encoder:decode_string(encoded)
-            assert(not err, err)
-            assert(tt.input == decoded, string.format("'%s' ~= '%s'", tt.input, decoded))
+            assert:NoError(t, err)
+            assert:Equal(t, tt.input, decoded)
         end)
     end
 end
@@ -115,42 +116,42 @@ function TestEncoder(t)
     encoder:write("foo", "bar", "baz")
     encoder:close()
     local s = writer:string()
-    assert(s == "Zm9vYmFyYmF6", string.format("'%s' ~= '%s'", s, "Zm9vYmFyYmF6"))
+    assert:Equal(t, "Zm9vYmFyYmF6", s)
 end
 
 function TestDecoder(t)
     local reader = strings.new_reader("Zm9vYmFyYmF6")
     local decoder = base64.new_decoder(base64.StdEncoding, reader)
     local s = decoder:read("*a")
-    assert(s == "foobarbaz", string.format("'%s' ~= '%s'", s, "foobarbaz"))
+    assert:Equal(t, "foobarbaz", s)
 end
 
 function TestDecoderReadNum(t)
     local encoded = base64.StdEncoding:encode_to_string("123 456 789")
     local reader = strings.new_reader(encoded)
     local decoder = base64.new_decoder(base64.StdEncoding, reader)
     local n = decoder:read("*n")
-    assert(n == 123, string.format("%d ~= %d", n, 123))
+    assert:Equal(t, 123, n)
     n = decoder:read("*n")
-    assert(n == 456, string.format("%d ~= %d", n, 456))
+    assert:Equal(t, 456, n)
     n = decoder:read("*n")
-    assert(n == 789, string.format("%d ~= %d", n, 789))
+    assert:Equal(t, 789, n)
 end
 
 function TestDecoderReadCount(t)
     local encoded = base64.StdEncoding:encode_to_string("123 456 789")
     local reader = strings.new_reader(encoded)
     local decoder = base64.new_decoder(base64.StdEncoding, reader)
     local s = decoder:read(3)
-    assert(s == "123", string.format("'%s' ~= '%s'", s, "123"))
+    assert:Equal(t, "123", s)
 end
 
 function TestDecoderReadline(t)
     local encoded = base64.StdEncoding:encode_to_string("foo\nbar")
     local reader = strings.new_reader(encoded)
     local decoder = base64.new_decoder(base64.StdEncoding, reader)
     local s = decoder:read("*l")
-    assert(s == "foo", string.format("'%s' ~= '%s'", s, "foo"))
+    assert:Equal(t, "foo", s)
     s = decoder:read("*l")
-    assert(s == "bar", string.format("'%s' ~= '%s'", s, "bar"))
+    assert:Equal(t, "bar", s)
 end

tests/README.md

@@ -93,3 +93,42 @@ function TestSuite(t)
     assert(MySuite.tearDownSuiteCount == 1, tostring(MySuite.tearDownSuiteCount))
 end
 ```
+
+## Example use of assert and require
+
+Similar to testify [assert](https://pkg.go.dev/github.com/stretchr/testify/assert) and 
+[require](https://pkg.go.dev/github.com/stretchr/testify/require), Lua's `assert` and `require` can be enhanced to
+add structured assertions.
+
+```lua
+local require = require 'require'
+local assert = require 'assert'
+local inspect = require 'inspect'
+
+function TestAssertions(t)
+    local s1 = "foo"
+    local s2 = "foo"
+    assert:Equal(t, s1, s2)
+    assert:Equalf(t, s1, s2, "I really didn't expect them to be equal %d", 123)
+    
+    local o1 = {
+        foo = "bar",
+    }
+    local o2 = {
+        foo = "bar",
+    }
+    assert:Equal(t, inspect(o1), inspect(o2))
+    assert:NotEqual(t, 123, 456, [[wow - they're equal?]])
+    
+    local err = nil
+    assert:NoError(t, err, "I got an error?!?")
+
+    assert:False(t, false, "expected false")
+    assert:Falsef(t, false, "expected false for %s", "foobar")
+    
+    assert:True(t, true, "I wanted the truth")
+    
+    err = 'foo bar'
+    assert:Error(t, err)
+end
+```

tests/assert.lua

@@ -0,0 +1,5 @@
+local assertions = require 'assertions'
+local orig_assert = assert
+return assertions:new {
+    call = orig_assert,
+}

tests/assert_const.go

@@ -0,0 +1,13 @@
+// GENERATED BY textFileToGoConst
+// GitHub:     github.com/logrusorgru/textFileToGoConst
+// input file: assert.lua
+// generated:  Fri Nov 11 18:29:58 PST 2022
+
+package tests
+
+const lua_assert = `local assertions = require 'assertions'
+local orig_assert = assert
+return assertions:new {
+    call = orig_assert,
+}
+`