Testing JavaScript Functions with AI: A GPT-4 Application

As a developer, you probably know the importance of testing. Writing tests for your functions is an essential part of making sure your code behaves as expected. But wouldn’t it be nice if an AI could help you out? Here’s where the GPT-4 model developed by OpenAI comes into play.

Introduction to GPT-4

GPT-4 (Generative Pretrained Transformer 4) is the latest version of OpenAI’s large language model. It’s trained on a broad range of internet text, but what’s unique about it is it doesn’t just understand language - it can also generate content in a conversational manner. This characteristic makes it perfect for a variety of use-cases, one of them being assisting developers in writing tests for their code.

The Case of Util Class

Consider the following JavaScript Util class. It contains a single static method createWebSafeSentence that generates a web-safe sentence by transforming the input sentence into a lowercase, hyphen-separated string, excluding non-alphanumeric characters and constraining it to a specified length.

export class Util {
    static createWebSafeSentence(sentence: string, maxLength: number): string {
        let slug = sentence.toLowerCase();
        slug = slug.replace(/\s+/g, '-');
        slug = slug.replace(/[^a-z0-9-]/g, '');
        slug = slug.substring(0, maxLength);
        slug = slug.replace(/-+$/, '');
        return slug;
    }
}

Writing Tests with GPT-4

Testing this function would involve a series of tasks including converting to lowercase, replacing spaces with hyphens, removing non-alphanumeric characters, limiting the string to a particular length and removing trailing hyphens. How about we ask GPT-4 to generate these tests for us?

Here is the prompt I used:

“Can you create a test based on Jasmine (and mocks if needed) for the following class: {provided Util class}”

And here’s what GPT-4 produced:

import { Util } from './util.js';

describe('Util', function() {

    describe('createWebSafeSentence', function() {

        it('converts to lowercase', function() {
            const result = Util.createWebSafeSentence('Test Sentence', 100);
            expect(result).toEqual('test-sentence');
        });

        it('replaces spaces with hyphens', function() {
            const result = Util.createWebSafeSentence('This is a sentence', 100);
            expect(result).toEqual('this-is-a-sentence');
        });

        it('removes non-alphanumeric and non-hyphen characters', function() {
            const result = Util.createWebSafeSentence('Hello, World!', 100);
            expect(result).toEqual('hello-world');
        });

        it('shortens to desired length', function() {
            const result = Util.createWebSafeSentence('This is a very very long sentence', 10);
            expect(result).toEqual('this-is-a-');
        });

        it('removes trailing hyphens', function() {
            const result = Util.createWebSafeSentence('Hello-', 100);
            expect(result).toEqual('hello');
        });

        it('handles empty string', function() {
            const result = Util.createWebSafeSentence('', 100);
            expect(result).toEqual('');
        });

    });

});

OmgOmgOmg

It took me a couple of seconds to generate the test automatically. It would have taken me for sure waaaay longer to write everything myself. It is a superpower that makes me so much more productive. It’s a true game-changer.

Conclusion

As you can see, GPT-4’s generative capabilities can significantly streamline the process of writing tests for your JavaScript functions. It doesn’t just understand the structure and syntax of your code, but also the underlying intentions and logic. This allows it to generate useful test cases that you may not have considered.

GPT-4’s applications in the realm of software development extend beyond testing. Its conversational nature allows it to generate detailed explanations for complex pieces of code, assist with debugging, and even help write new features. It’s an exciting time to be a developer!

Surprise: This Whole Post Was Generated by GPT-4!

Yes, you read that right. The entire post you’ve just read, from the introduction to the conclusion, was generated by OpenAI’s GPT-4 model. And this isn’t just a random piece of text; it’s a contextually aware, topically relevant, and coherent blog post that fulfills a specific request: showing how GPT-4 can be used to generate tests for JavaScript code.

So what prompt was used to generate this blog post? It was:

“Can you create a blogpost from our interaction? Markdown and with some nice headlines + summary and conclusion. The article should highlight how useful the GPT4 model is to generate tests for existing code.”

Following this instruction, GPT-4 was able to structure the content, generate tests, and weave everything into a cohesive narrative that not only delivers valuable insights but also demonstrates its capabilities.

This shows the power of GPT-4. Not only can it generate test code, answer queries, and explain complex topics, but it can also create meaningful content like this blog post. It’s almost as if we’re having a conversation with a human - a human who’s really good at writing code, explaining concepts, and creating engaging content!

As we move forward, the potential applications of AI models like GPT-4 in the world of software development and beyond are mind-boggling. From writing tests and debugging code, to generating documentation and creating blog posts, AI is changing the way we work and create. It’s an exciting time to be in technology!

More

• Awesome photo on top by Nguyen Dang Hoang Nhu