DEV Community

loading...
Cover image for Test your entire project(Php, Js, Python, Ruby) with just comments.

Test your entire project(Php, Js, Python, Ruby) with just comments.

sanixdarker profile image darker ・4 min read

Hey there, today am presenting you something really special i made about tests, i hope you're going to like the way i build this solution !
Now, let's jump into it !

Introduction

Let's face it frankly, tests are certainly important but they are sometimes extremely boring to write, when you couple that with the fact that each language or each framework has its own way of handling unit tests, it does not help them. things !

Boring

So I asked myself a fairly simple question, is it possible to manage unit tests in a universal way whatever the programming language "script" or the framework !

solution

1-) First question: What do all code projects have in common?

The answer is quite simple, the comments; they are the only elements which are present in almost any project, whether it is with a scripting language or a compiled language.

Alt Text

2-) Second question: How can we transform simple comments to unit tests ?

Here we are trying to create a system that will do unit tests in a file or a project based on comments, so it was a question for us to define a kind of uniform syntax whatever the programming language in which we are, then create a pseudo test environment like a file in which we put all the elements of testa class and we test the corresponding assertion !

Behind all of this we would have a cli program that will browse and fetch all tests cases and test them to generate a final report.

For a simple assertion we end up with something like this :

# ::testa_start::
# ::case_start::
# >> testa.isEqual(2, 2)
# << true
# ::case_end::
# ::testa_end::
Enter fullscreen mode Exit fullscreen mode

In this example, we use ::testa_start:: and ::testa_end:: to surround our pseudo test environment, we can now define a test case with ::case_start:: and ::case_end::, then using >> and << to define the expected inputs and outputs, here testa.isEqual just checks if 2 is equal to 2, and we expect a true in output, we also have testa.isSup, etc ...

With this structure, we can therefore structure several test cases in a single test pseudo environment in the code :

# Inside a python code

# ::testa_start::
# ::case_start::
# >> testa.isEqual(2, 2)
# << true
# ::case_end::

# ::case_start::
# >> testa.isSup(3, 2)
# << true
# ::case_end:

# ::testa_end::
Enter fullscreen mode Exit fullscreen mode

What should be remembered here is that if I want to do the same tests on javascript for example, I just have to replace the comments because, on javascript, the comments per line are // and not #; so we are going to have :

// Inside a javascript code

// ::testa_start::

// ::case_start::
// >> testa.isEqual(2, 2)
// << true
// ::case_end::

// ::case_start::
// >> testa.isSup(3, 2)
// << true
// ::case_end:

// ::testa_end::
Enter fullscreen mode Exit fullscreen mode

3-) Third question: How to encapsulate a method and define the correct output relative to a precise input ?

Just like the assertion of a simple test case, we define a precise syntax to surround our method !

# ::testa_start::
# ::case_start::
# >> addition(2, 2)
# << 4
# ::case_end::
# ::code_start::
def addition(a, b):
    """ This method will return the sum
    of a and b """

    return a+b
# ::code_end::
# ::testa_end::
Enter fullscreen mode Exit fullscreen mode

Unlike the simple case tests, here we have ::code_start:: and ::code_end:: which define the pieces of code that must be taken into account in the pseudo test environment.

After the execution of the tests in a file/project, testa we generate a test report parraport to the tests which are in success and those which are in failed !

4-) Fourth question: How to manage imports from external libraries !

In some cases we often have functions that call external libs or other functions in other files, to solve this problem, I added to the syntax of testa ::import_start:: and ::import_end::, this part in a file includes all the imports which will be necessary for the tests in each pseudo environment (files with assertion).

# ::import_start::
Your imports here
# ::import_end::
Enter fullscreen mode Exit fullscreen mode

5-) Fifth question: How to standardize these tests with only one command line.

For this last problem I used the configuration file model, a bit like the package.json with npm or yarn, in this case tesla.json, but a fairly simple file which describes which directory (file or project) to test, from which language it is and what is the interpreter that must be used, so we have this semblance of structure:

  • An example on PHP:
{
    "module": "ta-php",
    "path": ["./square.php"],
    "extensions": [".php"],
    "launcher": "php"
}
Enter fullscreen mode Exit fullscreen mode
  • An example with python:
{
    "module": "ta-py",
    "path": ["./sha256.py", "./square.py"],
    "extensions": [".py"],
    "launcher": "python"
}
Enter fullscreen mode Exit fullscreen mode
  • An example on Ruby:
{
    "module": "ta-rb",
    "path": ["./my_ruby_app/", "./square.rb"],
    "extensions": [".rb"],
    "launcher": "ruby"
}
Enter fullscreen mode Exit fullscreen mode

Conclusion

In conclusion, we can say that we have made a kind of library which works on the CLI allowing to do unit tests whatever the scripting programming language is and to set it up, it's quite simple.

Installation

Testa is a free and open source project, this is some link !

Thank you for reading, make sure to like, suscribe or leave a comment !

Discussion (0)

pic
Editor guide