@onlineapps/conn-base-storage 1.0.0

package/test/unit/internal-url-adapter.test.js

@@ -0,0 +1,211 @@
+/**
+ * Tests for Internal URL Adapter
+ */
+
+const InternalUrlAdapter = require('../../src/internal-url-adapter');
+
+describe('InternalUrlAdapter', () => {
+  let adapter;
+
+  beforeEach(() => {
+    adapter = new InternalUrlAdapter();
+  });
+
+  describe('URL Resolution', () => {
+    test('should resolve internal://storage URL for Docker environment', () => {
+      adapter.dockerNetwork = true;
+      const internalUrl = 'internal://storage/bucket/path/to/file.json';
+      const resolved = adapter.resolve(internalUrl);
+
+      expect(resolved).toBe('http://api_services_storage:9000/bucket/path/to/file.json');
+    });
+
+    test('should resolve internal://storage URL for local environment', () => {
+      adapter.dockerNetwork = false;
+      const internalUrl = 'internal://storage/bucket/path/to/file.json';
+      const resolved = adapter.resolve(internalUrl);
+
+      expect(resolved).toBe('http://localhost:9000/bucket/path/to/file.json');
+    });
+
+    test('should resolve internal://registry URL', () => {
+      adapter.dockerNetwork = false;
+      const internalUrl = 'internal://registry/services/list';
+      const resolved = adapter.resolve(internalUrl);
+
+      expect(resolved).toBe('http://localhost:8080/services/list');
+    });
+
+    test('should resolve internal://monitoring URL', () => {
+      adapter.dockerNetwork = true;
+      const internalUrl = 'internal://monitoring/metrics';
+      const resolved = adapter.resolve(internalUrl);
+
+      expect(resolved).toBe('http://api_monitoring:3000/metrics');
+    });
+
+    test('should pass through non-internal URLs unchanged', () => {
+      const normalUrl = 'http://example.com/path';
+      const resolved = adapter.resolve(normalUrl);
+
+      expect(resolved).toBe(normalUrl);
+    });
+
+    test('should handle URLs with query parameters', () => {
+      adapter.dockerNetwork = false;
+      const internalUrl = 'internal://storage/bucket/file?version=2&download=true';
+      const resolved = adapter.resolve(internalUrl);
+
+      expect(resolved).toBe('http://localhost:9000/bucket/file?version=2&download=true');
+    });
+
+    test('should throw error for unknown service', () => {
+      const unknownUrl = 'internal://unknown-service/path';
+
+      expect(() => adapter.resolve(unknownUrl)).toThrow('Unknown service: unknown-service');
+    });
+  });
+
+  describe('Reverse URL Conversion', () => {
+    test('should convert actual URL to internal format', () => {
+      const actualUrl = 'http://api_services_storage:9000/bucket/path/file.json';
+      const internal = adapter.toInternal(actualUrl, 'storage');
+
+      expect(internal).toBe('internal://storage/bucket/path/file.json');
+    });
+
+    test('should preserve query parameters in conversion', () => {
+      const actualUrl = 'http://localhost:9000/bucket/file?version=2';
+      const internal = adapter.toInternal(actualUrl, 'storage');
+
+      expect(internal).toBe('internal://storage/bucket/file?version=2');
+    });
+  });
+
+  describe('Service Registration', () => {
+    test('should register new service', () => {
+      adapter.registerService('custom', 'custom-container:8080', 'localhost:8080');
+
+      const internalUrl = 'internal://custom/api/endpoint';
+      adapter.dockerNetwork = true;
+      const resolved = adapter.resolve(internalUrl);
+
+      expect(resolved).toBe('http://custom-container:8080/api/endpoint');
+    });
+
+    test('should override existing service', () => {
+      adapter.registerService('storage', 'new-storage:9001', 'localhost:9001');
+
+      const internalUrl = 'internal://storage/bucket/file';
+      adapter.dockerNetwork = false;
+      const resolved = adapter.resolve(internalUrl);
+
+      expect(resolved).toBe('http://localhost:9001/bucket/file');
+    });
+  });
+
+  describe('Response Transformation', () => {
+    test('should transform internal URLs in response object', () => {
+      adapter.dockerNetwork = false;
+
+      const response = {
+        url: 'internal://storage/bucket/file.json',
+        backup: 'internal://storage/backup/file.json',
+        metadata: {
+          thumbnail: 'internal://storage/thumbnails/thumb.jpg'
+        }
+      };
+
+      const transformed = adapter.transformResponse(response);
+
+      expect(transformed.url).toBe('http://localhost:9000/bucket/file.json');
+      expect(transformed.backup).toBe('http://localhost:9000/backup/file.json');
+      expect(transformed.metadata.thumbnail).toBe('http://localhost:9000/thumbnails/thumb.jpg');
+    });
+
+    test('should handle arrays in response', () => {
+      adapter.dockerNetwork = false;
+
+      const response = {
+        files: [
+          'internal://storage/file1.json',
+          'internal://storage/file2.json',
+          'http://external.com/file3.json'
+        ]
+      };
+
+      const transformed = adapter.transformResponse(response);
+
+      expect(transformed.files[0]).toBe('http://localhost:9000/file1.json');
+      expect(transformed.files[1]).toBe('http://localhost:9000/file2.json');
+      expect(transformed.files[2]).toBe('http://external.com/file3.json');
+    });
+
+    test('should handle nested objects', () => {
+      adapter.dockerNetwork = true;
+
+      const response = {
+        data: {
+          primary: {
+            location: 'internal://storage/primary/data.json'
+          },
+          secondary: {
+            location: 'internal://storage/secondary/data.json'
+          }
+        }
+      };
+
+      const transformed = adapter.transformResponse(response);
+
+      expect(transformed.data.primary.location).toBe('http://api_services_storage:9000/primary/data.json');
+      expect(transformed.data.secondary.location).toBe('http://api_services_storage:9000/secondary/data.json');
+    });
+  });
+
+  describe('Environment Detection', () => {
+    test('should detect Docker environment from env variable', () => {
+      const originalEnv = process.env.DOCKER_ENV;
+
+      process.env.DOCKER_ENV = 'true';
+      const adapter1 = new InternalUrlAdapter();
+      expect(adapter1.isRunningInDocker()).toBe(true);
+
+      delete process.env.DOCKER_ENV;
+      const adapter2 = new InternalUrlAdapter();
+      // Může být stále true pokud běžíme v Dockeru
+
+      // Obnovit původní hodnotu
+      if (originalEnv) process.env.DOCKER_ENV = originalEnv;
+    });
+  });
+
+  describe('Available Services', () => {
+    test('should return list of available services', () => {
+      const services = adapter.getAvailableServices();
+
+      expect(services).toContain('storage');
+      expect(services).toContain('registry');
+      expect(services).toContain('monitoring');
+      expect(services).toContain('mq');
+      expect(services).toContain('cache');
+    });
+  });
+
+  describe('Custom Configuration', () => {
+    test('should accept custom service mappings', () => {
+      const customAdapter = new InternalUrlAdapter({
+        services: {
+          'my-service': {
+            docker: 'my-container:3000',
+            local: 'localhost:3000'
+          }
+        }
+      });
+
+      customAdapter.dockerNetwork = false;
+      const resolved = customAdapter.resolve('internal://my-service/api');
+
+      expect(resolved).toBe('http://localhost:3000/api');
+    });
+  });
+});