add codeless test methods

Author: jochen-testingbot

README.md

@@ -24,6 +24,12 @@ TestingBot provides a cloud-based test infrastructure for automated cross-browse
   - [Storage Management](#storage-management)
   - [Screenshots](#screenshots)
   - [Team Management](#team-management)
+  - [Codeless Tests](#codeless-tests)
+- [CLI Usage](#cli-usage)
+  - [Installation](#installation-1)
+  - [Authentication](#authentication)
+  - [Available Commands](#available-commands)
+  - [CLI Examples](#cli-examples)
 - [Complete Examples](#complete-examples)
 - [Testing](#testing)
 - [Contributing](#contributing)
@@ -519,6 +525,148 @@ tb.resetCredentials(userId, function(error, result) {});
 const result = await tb.resetCredentials(userId);
 ```
 
+### Codeless Tests
+
+Codeless tests allow you to create automated tests without writing code. These tests can be configured to run on a schedule and include AI-powered test generation.
+
+#### getCodelessTests
+Retrieves a list of codeless tests
+
+```javascript
+// Callback style
+tb.getCodelessTests(offset, limit, function(error, tests) {});
+
+// Async/await style
+const tests = await tb.getCodelessTests(0, 10); // offset: 0, limit: 10
+```
+
+#### createCodelessTest
+Creates a new codeless test
+
+```javascript
+const testData = {
+  name: 'My Codeless Test',           // Required: Test name
+  url: 'https://example.com',         // Required: URL to test
+  cron: '0 0 * * *',                  // Optional: Cron schedule
+  screenshot: true,                    // Optional: Take screenshots
+  video: false,                        // Optional: Record video
+  idletimeout: 60,                    // Optional: Idle timeout in seconds
+  screenresolution: '1920x1080',      // Optional: Screen resolution
+  ai_prompt: 'Test the login flow'    // Optional: AI test agent prompt
+};
+
+// Callback style
+tb.createCodelessTest(testData, function(error, result) {});
+
+// Async/await style
+const result = await tb.createCodelessTest(testData);
+```
+
+#### updateCodelessTest
+Updates an existing codeless test
+
+```javascript
+const updateData = {
+  test: {
+    name: 'Updated Test Name',
+    cron: '0 12 * * *'
+  }
+};
+
+// Callback style
+tb.updateCodelessTest(updateData, testId, function(error, result) {});
+
+// Async/await style
+const result = await tb.updateCodelessTest(updateData, testId);
+```
+
+#### deleteCodelessTest
+Deletes a codeless test
+
+```javascript
+// Callback style
+tb.deleteCodelessTest(testId, function(error, result) {});
+
+// Async/await style
+const result = await tb.deleteCodelessTest(testId);
+```
+
+## CLI Usage
+
+The TestingBot API package includes a command-line interface for quick access to API functionality.
+
+### Installation
+
+```bash
+# Install globally for CLI access
+npm install -g testingbot-api
+
+# Or use npx with local installation
+npx testingbot <command>
+```
+
+### Authentication
+
+The CLI uses the same authentication methods as the API client:
+- Environment variables: `TB_KEY` and `TB_SECRET` or `TESTINGBOT_KEY` and `TESTINGBOT_SECRET`
+- Configuration file: `~/.testingbot` with `api_key` and `api_secret`
+
+### Available Commands
+
+```bash
+# User management
+testingbot user info                    # Get user information
+testingbot user update <json>           # Update user information
+
+# Test management
+testingbot tests list [offset] [limit]  # List tests
+testingbot tests get <id>               # Get test details
+testingbot tests delete <id>            # Delete a test
+testingbot tests stop <id>              # Stop a running test
+
+# Codeless tests (Lab)
+testingbot lab list [offset] [limit]    # List codeless tests
+testingbot lab create <json>            # Create a codeless test
+testingbot lab update <id> <json>       # Update a codeless test
+testingbot lab delete <id>              # Delete a codeless test
+
+# Browsers and devices
+testingbot browsers list [type]         # List browsers (type: all|web|mobile|real)
+testingbot devices list                 # List all devices
+testingbot devices available            # List available devices
+
+# Storage
+testingbot storage upload <file>        # Upload a file
+testingbot storage list [offset] [limit] # List stored files
+testingbot storage delete <id>          # Delete a stored file
+
+# Help
+testingbot --help                       # Show help
+testingbot --version                    # Show version
+```
+
+### CLI Examples
+
+```bash
+# Create a codeless test
+testingbot lab create '{
+  "name": "Homepage Test",
+  "url": "https://example.com",
+  "cron": "0 0 * * *",
+  "screenshot": true,
+  "ai_prompt": "Test the homepage loads correctly"
+}'
+
+# List recent tests
+testingbot tests list 0 20
+
+# Get browser list
+testingbot browsers list web
+
+# Upload a file to storage
+testingbot storage upload ./test-app.zip
+```
+
 ## Complete Examples
 
 ### Basic Usage

bin/testingbot

@@ -106,6 +106,7 @@ Commands:
 
   lab                     Codeless test management
     list [offset] [limit] List codeless tests
+    create <data>         Create codeless test (data as JSON)
     update <id> <data>    Update codeless test
     delete <id>           Delete codeless test
 
@@ -381,6 +382,24 @@ const commands = {
       checkCredentials();
       api.getCodelessTests(parseInt(offset), parseInt(limit), outputResult);
     },
+    create: (data) => {
+      checkCredentials();
+      if (!data) {
+        console.error('Error: Test data required (as JSON string)');
+        process.exit(1);
+      }
+      try {
+        const parsedData = JSON.parse(data);
+        if (!parsedData.name || !parsedData.url) {
+          console.error('Error: Test name and URL are required');
+          process.exit(1);
+        }
+        api.createCodelessTest(parsedData, outputResult);
+      } catch (e) {
+        console.error('Error: Invalid JSON data');
+        process.exit(1);
+      }
+    },
     update: (id, data) => {
       checkCredentials();
       if (!id || !data) {

lib/api.js

@@ -246,6 +246,30 @@ class TestingBot {
     }, callback);
   }
 
+  createCodelessTest (testData, callback) {
+    if (!testData || !testData.name || !testData.url) {
+      throw new Error('Test name and URL are required');
+    }
+
+    const data = {};
+
+    // Map test properties to the expected format
+    if (testData.name) data['test[name]'] = testData.name;
+    if (testData.url) data['test[url]'] = testData.url;
+    if (testData.cron) data['test[cron]'] = testData.cron;
+    if (testData.screenshot !== undefined) data['test[screenshot]'] = testData.screenshot;
+    if (testData.video !== undefined) data['test[video]'] = testData.video;
+    if (testData.idletimeout) data['test[idletimeout]'] = testData.idletimeout;
+    if (testData.screenresolution) data['test[screenresolution]'] = testData.screenresolution;
+    if (testData.ai_prompt) data['test[ai_prompt]'] = testData.ai_prompt;
+
+    return this.request({
+      method: 'POST',
+      url: '/lab',
+      data
+    }, callback);
+  }
+
   updateCodelessTest (data, testID, callback) {
     if (!testID) {
       throw new Error('Test ID is required');

test/api_test.js

@@ -419,6 +419,46 @@ describe('TestingBot API Tests', function() {
       });
     });
 
+    it('should create a codeless test', function(done) {
+      const testData = {
+        name: 'Test Codeless Test',
+        url: 'https://example.com',
+        cron: '31 * * * *',
+        screenshot: true,
+        video: false,
+        ai_prompt: 'Test the login functionality'
+      };
+
+      this.api.createCodelessTest(testData, (err, response) => {
+        if (err) {
+          // If we hit rate limits or don't have permission, skip this test
+          if (err.message && err.message.includes('rate limit')) {
+            return done();
+          }
+        }
+        assert.strictEqual(err, null, 'Should not have an error creating codeless test');
+        assert.ok(response, 'Should have a response');
+        // Clean up if test was created
+        if (response && response.id) {
+          this.api.deleteCodelessTest(response.id, () => {
+            done();
+          });
+        } else {
+          done();
+        }
+      });
+    });
+
+    it('should throw error when creating codeless test without required fields', function(done) {
+      try {
+        this.api.createCodelessTest({ name: 'Test' }, function() {});
+        done(new Error('Should have thrown an error'));
+      } catch (err) {
+        assert.ok(err.message.includes('Test name and URL are required'), 'Should throw required fields error');
+        done();
+      }
+    });
+
     it('should throw error when updating codeless test without test ID', function(done) {
       try {
         this.api.updateCodelessTest({ test: { name: 'Test' } }, null, function() {});

test/cli_test.js

@@ -664,6 +664,42 @@ describe('TestingBot CLI Tests', function () {
       }
     });
 
+    it('should error when test data is missing for create', async function () {
+      try {
+        await execWithEnv(`${binaryPath} lab create`, {
+          TB_KEY: process.env.TB_KEY,
+          TB_SECRET: process.env.TB_SECRET
+        });
+        assert.fail('Should have thrown an error');
+      } catch (error) {
+        assert(error.stderr.includes('Test data required'));
+      }
+    });
+
+    it('should error on invalid JSON for create', async function () {
+      try {
+        await execWithEnv(`${binaryPath} lab create "invalid json"`, {
+          TB_KEY: process.env.TB_KEY,
+          TB_SECRET: process.env.TB_SECRET
+        });
+        assert.fail('Should have thrown an error');
+      } catch (error) {
+        assert(error.stderr.includes('Invalid JSON'));
+      }
+    });
+
+    it('should error when required fields are missing for create', async function () {
+      try {
+        await execWithEnv(`${binaryPath} lab create '{"name": "test"}'`, {
+          TB_KEY: process.env.TB_KEY,
+          TB_SECRET: process.env.TB_SECRET
+        });
+        assert.fail('Should have thrown an error');
+      } catch (error) {
+        assert(error.stderr.includes('Test name and URL are required'));
+      }
+    });
+
     it('should error when test ID is missing for delete', async function () {
       try {
         await execWithEnv(`${binaryPath} lab delete`, {