@dainprotocol/cli 1.2.26 → 1.2.30

package/dist/__tests__/dev.test.js

@@ -0,0 +1,321 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+/**
+ * Dev command tests - security, port handling, process management, file watching
+ */
+describe('dev.ts port handling', function () {
+    describe('port resolution priority', function () {
+        function resolvePort(envPort, cliPort, defaultPort) {
+            if (defaultPort === void 0) { defaultPort = '2022'; }
+            if (envPort)
+                return { port: envPort, source: '.env file' };
+            if (cliPort)
+                return { port: cliPort, source: 'command line argument' };
+            return { port: defaultPort, source: 'default value' };
+        }
+        test('env port takes highest priority', function () {
+            var result = resolvePort('3000', '4000');
+            expect(result.port).toBe('3000');
+            expect(result.source).toBe('.env file');
+        });
+        test('CLI port used when no env port', function () {
+            var result = resolvePort(undefined, '4000');
+            expect(result.port).toBe('4000');
+            expect(result.source).toBe('command line argument');
+        });
+        test('default port used when no env or CLI port', function () {
+            var result = resolvePort(undefined, undefined);
+            expect(result.port).toBe('2022');
+            expect(result.source).toBe('default value');
+        });
+    });
+    describe('port validation', function () {
+        function validatePortNumber(port) {
+            var portNumber = parseInt(port, 10);
+            var valid = !isNaN(portNumber) && portNumber >= 1 && portNumber <= 65535;
+            return { valid: valid, parsed: portNumber };
+        }
+        test('accepts port 1', function () {
+            expect(validatePortNumber('1').valid).toBe(true);
+        });
+        test('accepts port 65535', function () {
+            expect(validatePortNumber('65535').valid).toBe(true);
+        });
+        test('accepts common ports', function () {
+            expect(validatePortNumber('80').valid).toBe(true);
+            expect(validatePortNumber('443').valid).toBe(true);
+            expect(validatePortNumber('3000').valid).toBe(true);
+            expect(validatePortNumber('8080').valid).toBe(true);
+        });
+        test('rejects port 0', function () {
+            expect(validatePortNumber('0').valid).toBe(false);
+        });
+        test('rejects negative ports', function () {
+            expect(validatePortNumber('-1').valid).toBe(false);
+            expect(validatePortNumber('-80').valid).toBe(false);
+        });
+        test('rejects ports above 65535', function () {
+            expect(validatePortNumber('65536').valid).toBe(false);
+            expect(validatePortNumber('70000').valid).toBe(false);
+        });
+        test('rejects non-numeric strings', function () {
+            expect(validatePortNumber('abc').valid).toBe(false);
+            expect(validatePortNumber('').valid).toBe(false);
+            expect(validatePortNumber('3.14').parsed).toBe(3); // parseInt truncates
+        });
+    });
+});
+describe('dev.ts environment variables', function () {
+    test('builds correct env vars object', function () {
+        var port = '3000';
+        var config = {
+            'api-key': 'sk_test_123',
+            'project-id': 'proj_abc',
+            environment: 'development',
+            'out-dir': 'dist',
+        };
+        var envVars = {
+            PORT: port,
+            DAIN_API_KEY: config['api-key'],
+            DAIN_PROJECT_ID: config['project-id'],
+            DAIN_ENVIRONMENT: config.environment,
+            DAIN_OUT_DIR: config['out-dir'],
+        };
+        expect(envVars.PORT).toBe('3000');
+        expect(envVars.DAIN_API_KEY).toBe('sk_test_123');
+        expect(envVars.DAIN_PROJECT_ID).toBe('proj_abc');
+        expect(envVars.DAIN_ENVIRONMENT).toBe('development');
+        expect(envVars.DAIN_OUT_DIR).toBe('dist');
+    });
+});
+describe('dev.ts file watching', function () {
+    describe('watch paths calculation', function () {
+        test('includes main file directory', function () {
+            var mainFile = 'src/index.ts';
+            var watchPath = path_1.default.dirname(mainFile);
+            expect(watchPath).toBe('src');
+        });
+        test('includes static directory from config', function () {
+            var cwd = '/project';
+            var config = { 'static-dir': 'public' };
+            var staticPath = path_1.default.join(cwd, config['static-dir']);
+            expect(staticPath).toBe('/project/public');
+        });
+    });
+    describe('chokidar ignore pattern', function () {
+        test('ignores dotfiles and dotdirs', function () {
+            var pattern = /(^|[\/\\])\../;
+            expect(pattern.test('.git')).toBe(true);
+            expect(pattern.test('.env')).toBe(true);
+            expect(pattern.test('src/.hidden')).toBe(true);
+            expect(pattern.test('/path/to/.config')).toBe(true);
+            expect(pattern.test('src/index.ts')).toBe(false);
+        });
+    });
+    describe('debounce timer', function () {
+        beforeEach(function () {
+            jest.useFakeTimers();
+        });
+        afterEach(function () {
+            jest.useRealTimers();
+        });
+        test('debounces rapid file changes', function () {
+            var callCount = 0;
+            var debounceTimer = null;
+            var handleChange = function () {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(function () {
+                    callCount++;
+                }, 300);
+            };
+            // Rapid file changes
+            handleChange();
+            handleChange();
+            handleChange();
+            expect(callCount).toBe(0);
+            jest.advanceTimersByTime(300);
+            expect(callCount).toBe(1);
+        });
+        test('each new change resets debounce', function () {
+            var callCount = 0;
+            var debounceTimer = null;
+            var handleChange = function () {
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(function () {
+                    callCount++;
+                }, 300);
+            };
+            handleChange();
+            jest.advanceTimersByTime(200);
+            handleChange(); // Reset timer
+            jest.advanceTimersByTime(200);
+            handleChange(); // Reset timer again
+            jest.advanceTimersByTime(300);
+            expect(callCount).toBe(1);
+        });
+    });
+});
+describe('dev.ts workers runtime', function () {
+    test('constructs correct output file path', function () {
+        var cwd = '/project';
+        var mainFile = 'src/index.ts';
+        var dainDir = path_1.default.join(cwd, '.dain');
+        var outFile = path_1.default.join(dainDir, path_1.default.basename(mainFile, '.ts') + '.mjs');
+        expect(outFile).toBe('/project/.dain/index.mjs');
+    });
+    test('handles different main file names', function () {
+        var getOutFile = function (mainFile) {
+            return path_1.default.basename(mainFile, '.ts') + '.mjs';
+        };
+        expect(getOutFile('src/index.ts')).toBe('index.mjs');
+        expect(getOutFile('src/server.ts')).toBe('server.mjs');
+        expect(getOutFile('app/main.ts')).toBe('main.mjs');
+    });
+});
+describe('dev.ts proxy requirements', function () {
+    test('requires api-key when proxy enabled', function () {
+        var noproxy = false;
+        var apiKey = '';
+        var proxyEnabled = !noproxy;
+        var apiKeyMissing = !apiKey;
+        expect(proxyEnabled && apiKeyMissing).toBe(true);
+    });
+    test('skips api-key check when proxy disabled', function () {
+        var noproxy = true;
+        var apiKey = '';
+        var shouldCheckApiKey = !noproxy;
+        expect(shouldCheckApiKey).toBe(false);
+    });
+});
+describe('dev.ts security', function () {
+    describe('path traversal protection', function () {
+        // Extract the validation logic for testing
+        function validateMainFilePath(mainFile, cwd) {
+            var resolvedMain = path_1.default.resolve(cwd, mainFile);
+            return resolvedMain.startsWith(cwd);
+        }
+        test('allows valid relative paths', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('src/index.ts', cwd)).toBe(true);
+            expect(validateMainFilePath('./src/index.ts', cwd)).toBe(true);
+            expect(validateMainFilePath('index.ts', cwd)).toBe(true);
+        });
+        test('blocks path traversal attempts', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('../other/index.ts', cwd)).toBe(false);
+            expect(validateMainFilePath('../../etc/passwd', cwd)).toBe(false);
+            expect(validateMainFilePath('src/../../other/file.ts', cwd)).toBe(false);
+        });
+        test('blocks absolute paths outside project', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('/etc/passwd', cwd)).toBe(false);
+            expect(validateMainFilePath('/other/project/index.ts', cwd)).toBe(false);
+        });
+        test('allows absolute paths inside project', function () {
+            var cwd = '/project';
+            expect(validateMainFilePath('/project/src/index.ts', cwd)).toBe(true);
+        });
+    });
+    describe('port validation', function () {
+        function validatePort(port) {
+            var portNumber = parseInt(port, 10);
+            var valid = !isNaN(portNumber) && portNumber >= 1 && portNumber <= 65535;
+            return { valid: valid, port: valid ? portNumber : 2022 };
+        }
+        test('accepts valid ports', function () {
+            expect(validatePort('3000')).toEqual({ valid: true, port: 3000 });
+            expect(validatePort('8080')).toEqual({ valid: true, port: 8080 });
+            expect(validatePort('1')).toEqual({ valid: true, port: 1 });
+            expect(validatePort('65535')).toEqual({ valid: true, port: 65535 });
+        });
+        test('rejects invalid ports', function () {
+            expect(validatePort('0').valid).toBe(false);
+            expect(validatePort('-1').valid).toBe(false);
+            expect(validatePort('65536').valid).toBe(false);
+            expect(validatePort('abc').valid).toBe(false);
+            expect(validatePort('').valid).toBe(false);
+        });
+        test('returns default port for invalid input', function () {
+            expect(validatePort('invalid').port).toBe(2022);
+            expect(validatePort('99999').port).toBe(2022);
+        });
+    });
+    describe('process spawn vs exec', function () {
+        test('spawn uses array for arguments (no shell injection)', function () {
+            // This tests the concept - spawn with an array is safe
+            // The key point: with spawn + array args, shell metacharacters
+            // are treated as literal characters, not commands
+            // If someone tried to inject: "src/index.ts; rm -rf /"
+            // With exec(), this would execute the rm command
+            // With spawn(['src/index.ts; rm -rf /']), it's treated as a filename
+            var maliciousInput = 'src/index.ts; rm -rf /';
+            // The resolved path will contain the malicious string as-is
+            var resolved = path_1.default.resolve('/project', maliciousInput);
+            // The malicious part is embedded in the path, proving it's not parsed
+            expect(resolved).toMatch(/index\.ts;/);
+            // But crucially, the semicolon stays in the path - it's never executed
+            expect(resolved.includes(';')).toBe(true);
+        });
+    });
+});
+describe('graceful shutdown', function () {
+    test('cleanup function sets isCleaningUp flag', function () {
+        // Simulate the cleanup behavior
+        var isCleaningUp = false;
+        var cleanupCalled = 0;
+        function cleanup() {
+            if (isCleaningUp)
+                return;
+            isCleaningUp = true;
+            cleanupCalled++;
+        }
+        cleanup();
+        expect(cleanupCalled).toBe(1);
+        // Second call should be no-op
+        cleanup();
+        expect(cleanupCalled).toBe(1);
+    });
+    test('cleanup handles null resources safely', function () {
+        var childProcess = null;
+        var watcher = null;
+        function cleanup() {
+            if (childProcess) {
+                childProcess.kill();
+                childProcess = null;
+            }
+            if (watcher) {
+                watcher.close();
+                watcher = null;
+            }
+        }
+        // Should not throw
+        expect(function () { return cleanup(); }).not.toThrow();
+    });
+});
+describe('error detection in stderr', function () {
+    function shouldMarkAsFailed(output) {
+        return output.includes('Error:') || output.includes('error:');
+    }
+    test('detects Error: pattern', function () {
+        expect(shouldMarkAsFailed('Error: Something went wrong')).toBe(true);
+        expect(shouldMarkAsFailed('TypeError: undefined is not a function')).toBe(true);
+    });
+    test('detects error: pattern', function () {
+        expect(shouldMarkAsFailed('error: cannot find module')).toBe(true);
+    });
+    test('ignores warnings', function () {
+        expect(shouldMarkAsFailed('Warning: deprecated API')).toBe(false);
+        expect(shouldMarkAsFailed('WARN: something')).toBe(false);
+        expect(shouldMarkAsFailed('DeprecationWarning: this is deprecated')).toBe(false);
+    });
+    test('ignores normal output', function () {
+        expect(shouldMarkAsFailed('Server started on port 3000')).toBe(false);
+        expect(shouldMarkAsFailed('Compiling...')).toBe(false);
+    });
+});

package/dist/__tests__/init.test.js

@@ -0,0 +1,290 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+/**
+ * Init command tests - project initialization, template handling, validation
+ */
+describe('init.ts', function () {
+    describe('Node.js version validation', function () {
+        function validateNodeVersion(version) {
+            var versionNum = Number(version.slice(1).split('.')[0]);
+            return { valid: versionNum >= 20, major: versionNum };
+        }
+        test('accepts Node.js 20+', function () {
+            expect(validateNodeVersion('v20.0.0').valid).toBe(true);
+            expect(validateNodeVersion('v20.7.0').valid).toBe(true);
+            expect(validateNodeVersion('v21.0.0').valid).toBe(true);
+            expect(validateNodeVersion('v22.3.0').valid).toBe(true);
+        });
+        test('rejects Node.js < 20', function () {
+            expect(validateNodeVersion('v18.0.0').valid).toBe(false);
+            expect(validateNodeVersion('v19.9.0').valid).toBe(false);
+            expect(validateNodeVersion('v16.20.0').valid).toBe(false);
+        });
+        test('parses version correctly', function () {
+            expect(validateNodeVersion('v20.7.0').major).toBe(20);
+            expect(validateNodeVersion('v18.15.0').major).toBe(18);
+            expect(validateNodeVersion('v22.0.0').major).toBe(22);
+        });
+        test('handles pre-release versions', function () {
+            // Pre-release versions have format like v21.0.0-nightly
+            expect(validateNodeVersion('v21.0.0-nightly').major).toBe(21);
+        });
+    });
+    describe('project directory handling', function () {
+        test('creates project path from cwd and name', function () {
+            var cwd = '/home/user/projects';
+            var projectName = 'my-service';
+            var projectDir = path_1.default.join(cwd, projectName);
+            expect(projectDir).toBe('/home/user/projects/my-service');
+        });
+        test('handles project names with special characters', function () {
+            var cwd = '/project';
+            expect(path_1.default.join(cwd, 'my-service')).toBe('/project/my-service');
+            expect(path_1.default.join(cwd, 'my_service')).toBe('/project/my_service');
+            expect(path_1.default.join(cwd, '@scope/pkg')).toBe('/project/@scope/pkg');
+        });
+        test('handles spaces in project name', function () {
+            var cwd = '/project';
+            var projectDir = path_1.default.join(cwd, 'my service');
+            expect(projectDir).toBe('/project/my service');
+        });
+    });
+    describe('template directory resolution', function () {
+        test('resolves template path from __dirname', function () {
+            // The actual path is: __dirname/../templates/default
+            var dirname = '/path/to/dain-dev-cli/dist/commands';
+            var templateDir = path_1.default.join(dirname, '..', '..', 'templates', 'default');
+            expect(templateDir).toBe('/path/to/dain-dev-cli/templates/default');
+        });
+        test('uses "default" template', function () {
+            var templateName = 'default';
+            expect(templateName).toBe('default');
+        });
+    });
+    describe('package.json modification', function () {
+        test('updates package name', function () {
+            var packageJson = { name: 'template-name', version: '1.0.0' };
+            var projectName = 'my-new-project';
+            packageJson.name = projectName;
+            expect(packageJson.name).toBe('my-new-project');
+        });
+        test('preserves other package.json fields', function () {
+            var packageJson = {
+                name: 'template',
+                version: '1.0.0',
+                dependencies: { 'some-dep': '^1.0.0' },
+                scripts: { dev: 'node index.js' },
+            };
+            var projectName = 'updated-name';
+            packageJson.name = projectName;
+            expect(packageJson.name).toBe('updated-name');
+            expect(packageJson.version).toBe('1.0.0');
+            expect(packageJson.dependencies).toEqual({ 'some-dep': '^1.0.0' });
+            expect(packageJson.scripts).toEqual({ dev: 'node index.js' });
+        });
+    });
+    describe('project name validation', function () {
+        // Valid npm package name patterns
+        function isValidProjectName(name) {
+            // Simple validation: non-empty, no path separators at start
+            if (!name || name.startsWith('/') || name.startsWith('..')) {
+                return false;
+            }
+            return true;
+        }
+        test('accepts valid project names', function () {
+            expect(isValidProjectName('my-project')).toBe(true);
+            expect(isValidProjectName('my_project')).toBe(true);
+            expect(isValidProjectName('myproject123')).toBe(true);
+            expect(isValidProjectName('@scope/package')).toBe(true);
+        });
+        test('rejects empty names', function () {
+            expect(isValidProjectName('')).toBe(false);
+        });
+        test('rejects absolute paths', function () {
+            expect(isValidProjectName('/etc/passwd')).toBe(false);
+        });
+        test('rejects path traversal', function () {
+            expect(isValidProjectName('../other')).toBe(false);
+        });
+    });
+    describe('success messages', function () {
+        test('includes project name in success message', function () {
+            var projectName = 'my-service';
+            var message = "Initialized Dain project: ".concat(projectName);
+            expect(message).toContain('my-service');
+        });
+        test('includes project directory in message', function () {
+            var projectDir = '/home/user/projects/my-service';
+            var message = "Project created at ".concat(projectDir);
+            expect(message).toContain('/home/user/projects/my-service');
+        });
+        test('includes getting started instructions', function () {
+            var projectName = 'my-project';
+            var commands = ["cd ".concat(projectName), 'npm install', 'npm run dev'];
+            expect(commands[0]).toBe('cd my-project');
+            expect(commands[1]).toBe('npm install');
+            expect(commands[2]).toBe('npm run dev');
+        });
+    });
+});
+describe('status.ts', function () {
+    describe('URL construction', function () {
+        test('builds correct status URL', function () {
+            var baseUrl = 'https://api.example.com';
+            var orgId = 'org123';
+            var serviceId = 'svc456';
+            var deploymentId = 'dep789';
+            var environment = 'production';
+            var statusUrl = "".concat(baseUrl, "/codegen-deploy/status/").concat(orgId, "/").concat(serviceId, "/").concat(deploymentId, "/").concat(environment);
+            expect(statusUrl).toBe('https://api.example.com/codegen-deploy/status/org123/svc456/dep789/production');
+        });
+        test('handles different environments', function () {
+            var buildUrl = function (env) {
+                return "https://api.example.com/codegen-deploy/status/org/svc/dep/".concat(env);
+            };
+            expect(buildUrl('production')).toContain('/production');
+            expect(buildUrl('staging')).toContain('/staging');
+            expect(buildUrl('development')).toContain('/development');
+        });
+    });
+    describe('predefined parameters override', function () {
+        test('uses predefined values over config', function () {
+            var config = {
+                'deployment-id': 'config-dep',
+                'service-id': 'config-svc',
+                environment: 'config-env',
+            };
+            var predefined = {
+                deploymentId: 'pre-dep',
+                serviceId: 'pre-svc',
+                environment: 'pre-env',
+            };
+            var deploymentId = predefined.deploymentId || config['deployment-id'];
+            var serviceId = predefined.serviceId || config['service-id'];
+            var environment = predefined.environment || config.environment;
+            expect(deploymentId).toBe('pre-dep');
+            expect(serviceId).toBe('pre-svc');
+            expect(environment).toBe('pre-env');
+        });
+        test('falls back to config when predefined is undefined', function () {
+            var config = {
+                'deployment-id': 'config-dep',
+                'service-id': 'config-svc',
+            };
+            var predefinedDeploymentId = undefined;
+            var predefinedServiceId = undefined;
+            var deploymentId = predefinedDeploymentId || config['deployment-id'];
+            var serviceId = predefinedServiceId || config['service-id'];
+            expect(deploymentId).toBe('config-dep');
+            expect(serviceId).toBe('config-svc');
+        });
+    });
+    describe('response handling', function () {
+        test('returns result when predefined params are provided', function () {
+            var preDefinedDeploymentId = 'dep123';
+            var shouldReturn = !!preDefinedDeploymentId;
+            expect(shouldReturn).toBe(true);
+        });
+        test('exits when no predefined params', function () {
+            var preDefinedDeploymentId = undefined;
+            var shouldExit = !preDefinedDeploymentId;
+            expect(shouldExit).toBe(true);
+        });
+    });
+});
+describe('undeploy.ts', function () {
+    describe('URL construction', function () {
+        test('builds correct undeploy URL', function () {
+            var baseUrl = 'https://api.example.com';
+            var orgId = 'org123';
+            var serviceId = 'svc456';
+            var deploymentId = 'dep789';
+            var environment = 'production';
+            var undeployUrl = "".concat(baseUrl, "/codegen-deploy/undeploy/").concat(orgId, "/").concat(serviceId, "/").concat(deploymentId, "/").concat(environment);
+            expect(undeployUrl).toBe('https://api.example.com/codegen-deploy/undeploy/org123/svc456/dep789/production');
+        });
+    });
+    describe('HTTP method', function () {
+        test('uses DELETE method for undeploy', function () {
+            var method = 'DELETE';
+            expect(method).toBe('DELETE');
+        });
+    });
+    describe('validation requirements', function () {
+        test('requires org ID', function () {
+            var orgId = '';
+            var hasError = !orgId;
+            expect(hasError).toBe(true);
+        });
+        test('requires deployment ID', function () {
+            var deploymentId = '';
+            var hasError = !deploymentId;
+            expect(hasError).toBe(true);
+        });
+        test('requires service ID', function () {
+            var serviceId = '';
+            var hasError = !serviceId;
+            expect(hasError).toBe(true);
+        });
+        test('passes validation with all required fields', function () {
+            var orgId = 'org123';
+            var deploymentId = 'dep456';
+            var serviceId = 'svc789';
+            var allValid = orgId && deploymentId && serviceId;
+            expect(allValid).toBeTruthy();
+        });
+    });
+});
+describe('shared patterns across commands', function () {
+    describe('fetchWithTimeout pattern', function () {
+        var FETCH_TIMEOUT_MS = 30000;
+        test('default timeout is 30 seconds', function () {
+            expect(FETCH_TIMEOUT_MS).toBe(30000);
+        });
+        test('uses AbortController for cancellation', function () {
+            var controller = new AbortController();
+            expect(controller.signal.aborted).toBe(false);
+            controller.abort();
+            expect(controller.signal.aborted).toBe(true);
+        });
+    });
+    describe('Authorization header', function () {
+        test('formats Bearer token correctly', function () {
+            var apiKey = 'sk_agent_test_key';
+            var header = "Bearer ".concat(apiKey);
+            expect(header).toBe('Bearer sk_agent_test_key');
+        });
+    });
+    describe('error response handling', function () {
+        test('creates error message from response', function () {
+            var status = 404;
+            var statusText = 'Not Found';
+            var errorMessage = "failed: ".concat(status, " ").concat(statusText);
+            expect(errorMessage).toBe('failed: 404 Not Found');
+        });
+        test('handles various HTTP status codes', function () {
+            var createError = function (status, text) { return "".concat(status, " ").concat(text); };
+            expect(createError(400, 'Bad Request')).toBe('400 Bad Request');
+            expect(createError(401, 'Unauthorized')).toBe('401 Unauthorized');
+            expect(createError(403, 'Forbidden')).toBe('403 Forbidden');
+            expect(createError(404, 'Not Found')).toBe('404 Not Found');
+            expect(createError(500, 'Internal Server Error')).toBe('500 Internal Server Error');
+        });
+    });
+    describe('config resolution pattern', function () {
+        test('uses platform-base-url from config or default', function () {
+            var DEFAULT_PLATFORM_BASE_URL = 'https://default.example.com';
+            var config1 = { 'platform-base-url': 'https://custom.example.com' };
+            var config2 = {};
+            var url1 = config1['platform-base-url'] || DEFAULT_PLATFORM_BASE_URL;
+            var url2 = config2['platform-base-url'] || DEFAULT_PLATFORM_BASE_URL;
+            expect(url1).toBe('https://custom.example.com');
+            expect(url2).toBe('https://default.example.com');
+        });
+    });
+});