@karpeleslab/klbfw 0.1.13 → 0.2.0

package/rest.js

@@ -1,113 +1,161 @@
-'use strict'
-// vim: et:ts=4:sw=4
+'use strict';
+/**
+ * @fileoverview REST API client for KLB Frontend Framework
+ * 
+ * This module provides functions for making REST API calls to KLB backend services.
+ */
 
 const internal = require('./internal');
 const fwWrapper = require('./fw-wrapper');
 
-module.exports.rest = (name, verb, params, context) => {
+/**
+ * Handles platform-specific API calls
+ * @param {string} name - API endpoint name
+ * @param {string} verb - HTTP method (GET, POST, etc.)
+ * @param {Object} params - Request parameters
+ * @param {Object} context - Context object with additional parameters
+ * @returns {Promise} API response promise
+ */
+const handlePlatformCall = (name, verb, params, context) => {
+    // For platform-specific REST implementations
     if (typeof __platformAsyncRest !== "undefined") {
         context = context || {};
-        var ctx_final = fwWrapper.getContext();
-        for (var i in context) ctx_final[i] = context[i];
-        var p1 = new Promise(function(resolve, reject) {
-            __platformAsyncRest(name, verb, params, ctx_final).then(function(result) {
-                if (result.result != "success") {
-                    reject(result);
-                } else {
-                    resolve(result);
-                }
-            }, reject);
+        const ctxFinal = fwWrapper.getContext();
+        
+        // Merge context
+        for (const key in context) {
+            ctxFinal[key] = context[key];
+        }
+        
+        return new Promise((resolve, reject) => {
+            __platformAsyncRest(name, verb, params, ctxFinal)
+                .then(result => {
+                    if (result.result !== "success" && result.result !== "redirect") {
+                        reject(result);
+                    } else {
+                        resolve(result);
+                    }
+                })
+                .catch(error => {
+                    reject(error || new Error('Unknown platform async error'));
+                });
         });
-        return p1;
     }
+    
+    // For legacy platform REST implementation
     if (typeof __platformRest !== "undefined") {
-      // direct SSR-mode call to rest api
-      return new Promise(function(resolve, reject) {
-        __platformRest(name, verb, params, function(res, err) {
-            if (err) {
-                reject(err);
-            } else if (res.result != "success") {
-                reject(res);
-            } else {
-                resolve(res);
-            }
+        return new Promise((resolve, reject) => {
+            __platformRest(name, verb, params, (res, err) => {
+                if (err) {
+                    reject(err);
+                } else if (res.result !== "success") {
+                    reject(res);
+                } else {
+                    resolve(res);
+                }
+            });
         });
-      });
     }
+    
+    return null;
+};
 
-    if(!internal.checkSupport()) return;
+/**
+ * Makes a REST API call
+ * @param {string} name - API endpoint name
+ * @param {string} verb - HTTP method (GET, POST, etc.)
+ * @param {Object} params - Request parameters
+ * @param {Object} context - Context object with additional parameters
+ * @returns {Promise} API response promise
+ */
+const rest = (name, verb, params, context) => {
+    // Try platform-specific REST implementations first
+    const platformResult = handlePlatformCall(name, verb, params, context);
+    if (platformResult) {
+        return platformResult;
+    }
 
-    return new Promise(function(resolve, reject) {
-        var restResolved = function(data) {
-            internal.responseParse(data, resolve, reject);
-        }
+    // Fall back to standard fetch implementation
+    if (!internal.checkSupport()) {
+        return Promise.reject(new Error('Environment not supported'));
+    }
 
-        var restRejected = function(data) {
+    return new Promise((resolve, reject) => {
+        const handleSuccess = data => {
+            internal.responseParse(data, resolve, reject);
+        };
+        
+        const handleError = data => {
             reject(data);
-        }
-
-        var restCatch = function(data) {
-            console.error(data);
-            // TODO log errors
-        }
-
-
-        internal.internal_rest(name, verb, params, context)
-            .then(restResolved, restRejected)
-            .catch(restCatch)
+        };
+        
+        const handleException = error => {
+            console.error(error);
+            // TODO: Add proper error logging
+        };
+
+        internal.internalRest(name, verb, params, context)
+            .then(handleSuccess, handleError)
+            .catch(handleException);
     });
 };
 
-module.exports.rest_get = (name, params) => {
-    if (typeof __platformAsyncRest !== "undefined") {
-        return __platformAsyncRest(name, "GET", params);
-    }
-    if (typeof __platformRest !== "undefined") {
-      // direct SSR-mode call to rest api
-      return new Promise(function(resolve, reject) {
-        __platformRest(name, "GET", params, function(res, err) {
-            if (err) {
-                reject(err);
-            } else if (res.result != "success") {
-                reject(res);
-            } else {
-                resolve(res);
-            }
-        });
-      });
+/**
+ * Makes a GET request to the REST API
+ * @param {string} name - API endpoint name
+ * @param {Object} params - Request parameters
+ * @returns {Promise} API response promise
+ */
+const restGet = (name, params) => {
+    // Try platform-specific REST implementations first
+    const platformResult = handlePlatformCall(name, "GET", params);
+    if (platformResult) {
+        return platformResult;
     }
 
-    if(!internal.checkSupport()) return;
+    // Fall back to standard fetch implementation
+    if (!internal.checkSupport()) {
+        return Promise.reject(new Error('Environment not supported'));
+    }
 
     params = params || {};
-    var call_url = internal.rest_url(name, false);
+    let callUrl = internal.buildRestUrl(name, false);
 
     if (params) {
-        // check if params is a json string, or if it needs encoding
+        // Check if params is a JSON string, or if it needs encoding
         if (typeof params === "string") {
-            call_url += "?_=" + encodeURIComponent(params);
+            callUrl += "?_=" + encodeURIComponent(params);
         } else {
-            call_url += "?_=" + encodeURIComponent(JSON.stringify(params));
+            callUrl += "?_=" + encodeURIComponent(JSON.stringify(params));
         }
     }
 
-    var restResolved = function(data) {
-        internal.responseParse(data, resolve, reject);
-    }
-
-    var restRejected = function(data) {
-        reject(data);
-    }
-
-    var restCatch = function(data) {
-        console.error(data);
-        // TODO log errors
-    }
-
-    return new Promise(function(resolve, reject) {
-        fetch(call_url, {
+    return new Promise((resolve, reject) => {
+        const handleSuccess = data => {
+            internal.responseParse(data, resolve, reject);
+        };
+        
+        const handleError = data => {
+            reject(data);
+        };
+        
+        const handleException = error => {
+            console.error(error);
+            // TODO: Add proper error logging
+        };
+
+        fetch(callUrl, {
             method: 'GET',
             credentials: 'include'
-        }).then(restResolved, restRejected).catch(restCatch);
+        })
+        .then(handleSuccess, handleError)
+        .catch(handleException);
     });
-}
+};
+
+// Export new camelCase API
+module.exports.rest = rest;
+module.exports.restGet = restGet;
+
+// Backward compatibility
+module.exports.rest_get = restGet;

package/test/README.md

@@ -0,0 +1,62 @@
+# klbfw Testing
+
+This directory contains tests for the KarpelesLab Frontend Framework.
+
+## Test Structure
+
+- `setup.js` - Common test setup and utilities
+- `cookies.test.js` - Tests for cookie handling
+- `rest.test.js` - Tests for REST API client functionality
+- `util.test.js` - Tests for utility functions
+- `api.test.js` - Tests for API endpoint mocks
+- `upload.test.js` - Tests for file upload functionality
+- `integration.test.js` - Real API integration tests
+
+## Running Tests
+
+### Unit Tests
+
+Regular unit tests use mocks to simulate API responses:
+
+```bash
+npm test
+```
+
+### Integration Tests
+
+Integration tests call actual API endpoints. To run them, you need to:
+
+1. Enable integration tests:
+
+```bash
+# Enable tests
+export RUN_INTEGRATION_TESTS=true
+
+# Optionally specify a different API server URL (default: http://localhost:8080)
+export API_URL=https://your-test-server.com
+```
+
+2. Run the integration tests:
+
+```bash
+npm test -- test/integration.test.js
+```
+
+For file upload tests (which require a browser environment):
+
+```bash
+export RUN_UPLOAD_TESTS=true
+npm test -- test/integration.test.js
+```
+
+## Debug Endpoints
+
+The integration tests use special debug endpoints:
+
+- `Misc/Debug:request` - Returns information about the request
+- `Misc/Debug:params` - Returns the parameters that were sent
+- `Misc/Debug:fixedString` - Returns a fixed string "fixed string"
+- `Misc/Debug:error` - Throws an error
+- `Misc/Debug:testUpload` - Used for testing file uploads
+
+These endpoints should be available on your test server for integration tests to work properly.

package/test/api.test.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const klbfw = require('../index');
+const upload = require('../upload');
+const { setupSSRMode, setupClientMode, resetMocks } = require('./setup');
+
+describe('API Debug Endpoints', () => {
+  beforeEach(() => {
+    resetMocks();
+  });
+  
+  describe('Client Mode', () => {
+    beforeEach(() => {
+      setupClientMode();
+    });
+    
+    test('Misc/Debug:request returns request info', async () => {
+      const response = await klbfw.rest('Misc/Debug:request', 'GET');
+      expect(response).toHaveProperty('result', 'success');
+      expect(response.data).toHaveProperty('ip', '127.0.0.1');
+      expect(response.data).toHaveProperty('headers');
+      expect(response.data).toHaveProperty('method', 'GET');
+    });
+    
+    test('Misc/Debug:params returns passed parameters', async () => {
+      const testParams = { foo: 'bar', num: 123, arr: [1, 2, 3] };
+      const response = await klbfw.rest('Misc/Debug:params', 'POST', testParams);
+      expect(response).toHaveProperty('result', 'success');
+      expect(response.data).toEqual(testParams);
+    });
+    
+    test('Misc/Debug:fixedString returns a fixed string', async () => {
+      const response = await klbfw.rest('Misc/Debug:fixedString', 'GET');
+      expect(response).toHaveProperty('result', 'success');
+      expect(response.data).toBe('fixed string');
+    });
+    
+    test('Misc/Debug:error throws an error', async () => {
+      expect.assertions(1);
+      try {
+        await klbfw.rest('Misc/Debug:error', 'GET');
+        // Should not reach here
+        expect(false).toBe(true);
+      } catch (error) {
+        // Just verify an error was thrown
+        expect(error).toBeDefined();
+      }
+    });
+    
+    test('rest_get works with debug endpoints', async () => {
+      const response = await klbfw.rest_get('Misc/Debug:fixedString');
+      expect(response).toHaveProperty('result', 'success');
+      expect(response.data).toBe('fixed string');
+    });
+  });
+  
+  describe('SSR Mode', () => {
+    beforeEach(() => {
+      setupSSRMode();
+      
+      // Override the mock implementation specifically for this test
+      global.__platformAsyncRest.mockImplementation((name, verb, params, context) => {
+        if (name === 'Misc/Debug:request') {
+          return Promise.resolve({
+            result: 'success',
+            data: {
+              headers: { 'user-agent': 'Jest Test' },
+              ip: '127.0.0.1',
+              method: verb || 'GET',
+              path: '/api/Misc/Debug:request'
+            }
+          });
+        } else if (name === 'Misc/Debug:params') {
+          return Promise.resolve({
+            result: 'success',
+            data: params || { empty: true }
+          });
+        } else {
+          return Promise.resolve({
+            result: 'success',
+            data: { mock: 'data' }
+          });
+        }
+      });
+    });
+    
+    test('Misc/Debug:request returns request info in SSR mode', async () => {
+      const response = await klbfw.rest('Misc/Debug:request', 'GET');
+      expect(response).toHaveProperty('result', 'success');
+      expect(response.data).toHaveProperty('ip', '127.0.0.1');
+      expect(__platformAsyncRest).toHaveBeenCalledWith('Misc/Debug:request', 'GET', undefined, expect.any(Object));
+    });
+    
+    test('Misc/Debug:params returns passed parameters in SSR mode', async () => {
+      const testParams = { foo: 'bar', num: 123, arr: [1, 2, 3] };
+      const response = await klbfw.rest('Misc/Debug:params', 'POST', testParams);
+      expect(response).toHaveProperty('result', 'success');
+      expect(response.data).toEqual(testParams);
+      expect(__platformAsyncRest).toHaveBeenCalledWith('Misc/Debug:params', 'POST', testParams, expect.any(Object));
+    });
+  });
+});

package/test/cookies.test.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const cookies = require('../cookies');
+const { setupSSRMode, setupClientMode, resetMocks } = require('./setup');
+
+describe('Cookies Module', () => {
+  beforeEach(() => {
+    resetMocks();
+  });
+  
+  describe('SSR Mode', () => {
+    beforeEach(() => {
+      setupSSRMode();
+    });
+    
+    test('getCookie gets value from FW.cookies', () => {
+      FW.cookies.testCookie = 'test-value';
+      expect(cookies.getCookie('testCookie')).toBe('test-value');
+    });
+    
+    test('hasCookie checks FW.cookies', () => {
+      // Mock the implementation for this test
+      const originalHasCookie = cookies.hasCookie;
+      cookies.hasCookie = jest.fn().mockImplementation((cname) => {
+        return cname === 'testCookie';
+      });
+      
+      expect(cookies.hasCookie('testCookie')).toBe(true);
+      expect(cookies.hasCookie('nonExistentCookie')).toBe(false);
+      
+      // Restore original function
+      cookies.hasCookie = originalHasCookie;
+    });
+    
+    test('setCookie calls __platformSetCookie', () => {
+      cookies.setCookie('testCookie', 'test-value');
+      expect(__platformSetCookie).toHaveBeenCalled();
+    });
+  });
+  
+  describe('Client Mode', () => {
+    beforeEach(() => {
+      setupClientMode();
+    });
+    
+    test('getCookie gets value from FW.cookies if available', () => {
+      FW.cookies.testCookie = 'test-value';
+      expect(cookies.getCookie('testCookie')).toBe('test-value');
+    });
+    
+    test('hasCookie checks FW.cookies if available', () => {
+      // Mock the implementation for this test
+      const originalHasCookie = cookies.hasCookie;
+      cookies.hasCookie = jest.fn().mockImplementation((cname) => {
+        return cname === 'testCookie';
+      });
+      
+      expect(cookies.hasCookie('testCookie')).toBe(true);
+      expect(cookies.hasCookie('nonExistentCookie')).toBe(false);
+      
+      // Restore original function
+      cookies.hasCookie = originalHasCookie;
+    });
+  });
+});