imlil 1.0.1

package/agentTestSandbox/parallel-test/src/views/__tests__/Login.test.tsx

@@ -0,0 +1,62 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import { BrowserRouter } from 'react-router-dom';
+import Login from '../Login';
+import { store } from '../../store';
+
+// Mock the auth service
+jest.mock('../../services/auth.service', () => ({
+  login: jest.fn(() => Promise.resolve({ token: 'fake-token' })),
+}));
+
+describe('Login View', () => {
+  const renderLogin = () => {
+    render(
+      <Provider store={store}>
+        <BrowserRouter>
+          <Login />
+        </BrowserRouter>
+      </Provider>
+    );
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('renders login form elements', () => {
+    renderLogin();
+    expect(screen.getByTestId('login-view')).toBeInTheDocument();
+    expect(screen.getByLabelText(/email/i)).toBeInTheDocument();
+    expect(screen.getByLabelText(/password/i)).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /login/i })).toBeInTheDocument();
+  });
+
+  it('handles form submission correctly', async () => {
+    renderLogin();
+    const emailInput = screen.getByLabelText(/email/i);
+    const passwordInput = screen.getByLabelText(/password/i);
+    const submitButton = screen.getByRole('button', { name: /login/i });
+
+    fireEvent.change(emailInput, { target: { value: 'test@example.com' } });
+    fireEvent.change(passwordInput, { target: { value: 'password123' } });
+    fireEvent.click(submitButton);
+
+    await waitFor(() => {
+      expect(screen.queryByText(/invalid credentials/i)).not.toBeInTheDocument();
+    });
+  });
+
+  it('displays validation errors for empty fields', async () => {
+    renderLogin();
+    const submitButton = screen.getByRole('button', { name: /login/i });
+
+    fireEvent.click(submitButton);
+
+    await waitFor(() => {
+      expect(screen.getByText(/email is required/i)).toBeInTheDocument();
+      expect(screen.getByText(/password is required/i)).toBeInTheDocument();
+    });
+  });
+});

package/agentTestSandbox/parallel-test/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/agentTestSandbox/parallel-test/tests/integration/api/auth.test.ts

@@ -0,0 +1,120 @@
+import request from 'supertest';
+import { app } from '../../../server';
+import { prisma } from '../../../server/config/database';
+import { createToken } from '../../../server/utils/jwt';
+
+describe('Authentication API Integration Tests', () => {
+  beforeAll(async () => {
+    // Clear test database
+    await prisma.user.deleteMany();
+  });
+
+  afterAll(async () => {
+    await prisma.$disconnect();
+  });
+
+  describe('POST /api/auth/register', () => {
+    const validUser = {
+      email: 'test@example.com',
+      password: 'Password123!',
+      username: 'testuser',
+    };
+
+    it('should register a new user successfully', async () => {
+      const response = await request(app)
+        .post('/api/auth/register')
+        .send(validUser)
+        .expect(201);
+
+      expect(response.body).toHaveProperty('user');
+      expect(response.body).toHaveProperty('token');
+      expect(response.body.user.email).toBe(validUser.email);
+    });
+
+    it('should return 400 for duplicate email', async () => {
+      await request(app)
+        .post('/api/auth/register')
+        .send(validUser)
+        .expect(400);
+    });
+
+    it('should return 400 for invalid input', async () => {
+      const invalidUser = {
+        email: 'invalid-email',
+        password: '123', // Too short
+      };
+
+      const response = await request(app)
+        .post('/api/auth/register')
+        .send(invalidUser)
+        .expect(400);
+
+      expect(response.body).toHaveProperty('errors');
+    });
+  });
+
+  describe('POST /api/auth/login', () => {
+    const credentials = {
+      email: 'test@example.com',
+      password: 'Password123!',
+    };
+
+    it('should login successfully with valid credentials', async () => {
+      const response = await request(app)
+        .post('/api/auth/login')
+        .send(credentials)
+        .expect(200);
+
+      expect(response.body).toHaveProperty('token');
+      expect(response.body).toHaveProperty('user');
+    });
+
+    it('should return 401 for invalid credentials', async () => {
+      const invalidCredentials = {
+        email: credentials.email,
+        password: 'wrongpassword',
+      };
+
+      await request(app)
+        .post('/api/auth/login')
+        .send(invalidCredentials)
+        .expect(401);
+    });
+  });
+
+  describe('POST /api/auth/forgot-password', () => {
+    it('should send reset password email', async () => {
+      const response = await request(app)
+        .post('/api/auth/forgot-password')
+        .send({ email: 'test@example.com' })
+        .expect(200);
+
+      expect(response.body).toHaveProperty('message');
+    });
+  });
+
+  describe('GET /api/auth/verify-token', () => {
+    let validToken: string;
+
+    beforeAll(async () => {
+      const user = await prisma.user.findFirst({
+        where: { email: 'test@example.com' },
+      });
+      validToken = createToken(user!);
+    });
+
+    it('should verify valid token', async () => {
+      await request(app)
+        .get('/api/auth/verify-token')
+        .set('Authorization', `Bearer ${validToken}`)
+        .expect(200);
+    });
+
+    it('should reject invalid token', async () => {
+      await request(app)
+        .get('/api/auth/verify-token')
+        .set('Authorization', 'Bearer invalid-token')
+        .expect(401);
+    });
+  });
+});

package/agentTestSandbox/parallel-test/tests/unit/components/Button.test.tsx

@@ -0,0 +1,35 @@
+import React from 'react';
+import { render, fireEvent, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Button from '../../../src/components/common/Button/Button';
+
+describe('Button Component', () => {
+  it('renders button with correct text', () => {
+    render(<Button>Click me</Button>);
+    expect(screen.getByText('Click me')).toBeInTheDocument();
+  });
+
+  it('handles click events', () => {
+    const handleClick = jest.fn();
+    render(<Button onClick={handleClick}>Click me</Button>);
+    
+    fireEvent.click(screen.getByText('Click me'));
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('applies variant classes correctly', () => {
+    render(<Button variant="primary">Primary Button</Button>);
+    const button = screen.getByText('Primary Button');
+    expect(button).toHaveClass('btn-primary');
+  });
+
+  it('disables button when disabled prop is true', () => {
+    render(<Button disabled>Disabled Button</Button>);
+    expect(screen.getByText('Disabled Button')).toBeDisabled();
+  });
+
+  it('renders button with custom className', () => {
+    render(<Button className="custom-class">Custom Button</Button>);
+    expect(screen.getByText('Custom Button')).toHaveClass('custom-class');
+  });
+});

package/agentTestSandbox/parallel-test/tests/unit/config/jest.config.test.js

@@ -0,0 +1,62 @@
+describe('Jest Configuration', () => {
+  let jestConfig;
+
+  beforeAll(() => {
+    // Import the jest config
+    jestConfig = require('../../../jest.config.js');
+  });
+
+  test('should have correct root directory configuration', () => {
+    expect(jestConfig.rootDir).toBe('../..');
+  });
+
+  test('should have TypeScript configuration', () => {
+    expect(jestConfig.preset).toBe('ts-jest');
+    expect(jestConfig.testEnvironment).toBe('jsdom');
+  });
+
+  test('should have correct test match patterns', () => {
+    expect(jestConfig.testMatch).toEqual([
+      '<rootDir>/src/**/__tests__/**/*.{js,jsx,ts,tsx}',
+      '<rootDir>/src/**/*.{spec,test}.{js,jsx,ts,tsx}',
+      '<rootDir>/tests/**/*.{spec,test}.{js,jsx,ts,tsx}'
+    ]);
+  });
+
+  test('should have appropriate module name mapper for assets', () => {
+    expect(jestConfig.moduleNameMapper).toEqual(expect.objectContaining({
+      '\\.(css|less|scss|sass)$': 'identity-obj-proxy',
+      '\\.(jpg|jpeg|png|gif|webp|svg)$': '<rootDir>/tests/__mocks__/fileMock.js'
+    }));
+  });
+
+  test('should have correct coverage configuration', () => {
+    expect(jestConfig.collectCoverageFrom).toEqual([
+      'src/**/*.{js,jsx,ts,tsx}',
+      '!src/**/*.d.ts',
+      '!src/vite-env.d.ts'
+    ]);
+    expect(jestConfig.coverageDirectory).toBe('coverage');
+  });
+
+  test('should have setup files configured', () => {
+    expect(jestConfig.setupFilesAfterEnv).toContain('<rootDir>/tests/setupTests.ts');
+  });
+
+  test('should have transform configuration for TypeScript', () => {
+    expect(jestConfig.transform).toEqual(expect.objectContaining({
+      '^.+\\.(ts|tsx)$': 'ts-jest'
+    }));
+  });
+
+  test('should have module file extensions defined', () => {
+    expect(jestConfig.moduleFileExtensions).toEqual([
+      'js',
+      'jsx',
+      'ts',
+      'tsx',
+      'json',
+      'node'
+    ]);
+  });
+});

package/agentTestSandbox/parallel-test/tests/unit/config/jest.setup.test.js

@@ -0,0 +1,52 @@
+const fs = require('fs');
+const path = require('path');
+
+describe('Jest Configuration Tests', () => {
+  let packageJson;
+  
+  beforeAll(() => {
+    // Read the package.json file
+    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  });
+
+  test('package.json should exist', () => {
+    expect(packageJson).toBeDefined();
+  });
+
+  test('should have jest as a dev dependency', () => {
+    expect(packageJson.devDependencies).toBeDefined();
+    expect(packageJson.devDependencies.jest).toBeDefined();
+  });
+
+  test('should have proper test script configuration', () => {
+    expect(packageJson.scripts).toBeDefined();
+    expect(packageJson.scripts.test).toBeDefined();
+    expect(packageJson.scripts.test).toMatch(/jest/);
+  });
+
+  test('jest.config.js should exist', () => {
+    const jestConfigPath = path.resolve(process.cwd(), 'jest.config.js');
+    expect(fs.existsSync(jestConfigPath)).toBeTruthy();
+  });
+
+  test('jest.config.js should have basic required configuration', () => {
+    const jestConfigPath = path.resolve(process.cwd(), 'jest.config.js');
+    const jestConfig = require(jestConfigPath);
+    
+    expect(jestConfig).toEqual(expect.objectContaining({
+      testEnvironment: expect.any(String),
+      setupFilesAfterEnv: expect.any(Array),
+      moduleNameMapper: expect.any(Object),
+      transform: expect.any(Object)
+    }));
+  });
+
+  test('typescript configuration should include jest types', () => {
+    const tsConfigPath = path.resolve(process.cwd(), 'tsconfig.json');
+    const tsConfig = JSON.parse(fs.readFileSync(tsConfigPath, 'utf8'));
+    
+    expect(tsConfig.compilerOptions.types).toBeDefined();
+    expect(tsConfig.compilerOptions.types).toContain('jest');
+  });
+});

package/agentTestSandbox/parallel-test/tests/unit/infrastructure/__tests__/docker-config.test.ts

@@ -0,0 +1,107 @@
+import fs from 'fs';
+import path from 'path';
+import YAML from 'yaml';
+
+describe('Docker and Nginx Configuration Tests', () => {
+  const rootDir = path.resolve(__dirname, '../../../..');
+  
+  describe('docker-compose.yml', () => {
+    let dockerComposeContent: any;
+
+    beforeAll(() => {
+      const filePath = path.join(rootDir, 'docker-compose.yml');
+      const fileContent = fs.readFileSync(filePath, 'utf8');
+      dockerComposeContent = YAML.parse(fileContent);
+    });
+
+    test('docker-compose.yml file exists', () => {
+      const exists = fs.existsSync(path.join(rootDir, 'docker-compose.yml'));
+      expect(exists).toBeTruthy();
+    });
+
+    test('contains required services', () => {
+      expect(dockerComposeContent.services).toBeDefined();
+      expect(dockerComposeContent.services.app).toBeDefined();
+      expect(dockerComposeContent.services.nginx).toBeDefined();
+      expect(dockerComposeContent.services.postgres).toBeDefined();
+      expect(dockerComposeContent.services.redis).toBeDefined();
+    });
+
+    test('app service configuration is correct', () => {
+      const appService = dockerComposeContent.services.app;
+      expect(appService.build).toBeDefined();
+      expect(appService.ports).toBeDefined();
+      expect(appService.environment).toBeDefined();
+      expect(appService.depends_on).toContain('postgres');
+      expect(appService.depends_on).toContain('redis');
+    });
+
+    test('nginx service configuration is correct', () => {
+      const nginxService = dockerComposeContent.services.nginx;
+      expect(nginxService.image).toMatch(/nginx/);
+      expect(nginxService.ports).toContainEqual('80:80');
+      expect(nginxService.volumes).toBeDefined();
+    });
+  });
+
+  describe('Dockerfile', () => {
+    let dockerfileContent: string;
+
+    beforeAll(() => {
+      const filePath = path.join(rootDir, 'Dockerfile');
+      dockerfileContent = fs.readFileSync(filePath, 'utf8');
+    });
+
+    test('Dockerfile exists', () => {
+      const exists = fs.existsSync(path.join(rootDir, 'Dockerfile'));
+      expect(exists).toBeTruthy();
+    });
+
+    test('contains required build stages', () => {
+      expect(dockerfileContent).toMatch(/FROM node:/);
+      expect(dockerfileContent).toMatch(/WORKDIR \/app/);
+      expect(dockerfileContent).toMatch(/COPY package\*.json/);
+      expect(dockerfileContent).toMatch(/RUN npm (ci|install)/);
+      expect(dockerfileContent).toMatch(/COPY \. \./);
+      expect(dockerfileContent).toMatch(/CMD/);
+    });
+
+    test('includes necessary environment setup', () => {
+      expect(dockerfileContent).toMatch(/ENV NODE_ENV=production/);
+      expect(dockerfileContent).toMatch(/EXPOSE/);
+    });
+  });
+
+  describe('nginx.conf', () => {
+    let nginxContent: string;
+
+    beforeAll(() => {
+      const filePath = path.join(rootDir, 'nginx/nginx.conf');
+      nginxContent = fs.readFileSync(filePath, 'utf8');
+    });
+
+    test('nginx.conf file exists', () => {
+      const exists = fs.existsSync(path.join(rootDir, 'nginx/nginx.conf'));
+      expect(exists).toBeTruthy();
+    });
+
+    test('contains required nginx configurations', () => {
+      expect(nginxContent).toMatch(/http {/);
+      expect(nginxContent).toMatch(/server {/);
+      expect(nginxContent).toMatch(/listen 80;/);
+      expect(nginxContent).toMatch(/location \/ {/);
+      expect(nginxContent).toMatch(/proxy_pass/);
+    });
+
+    test('includes security headers', () => {
+      expect(nginxContent).toMatch(/X-Frame-Options/);
+      expect(nginxContent).toMatch(/X-Content-Type-Options/);
+      expect(nginxContent).toMatch(/X-XSS-Protection/);
+    });
+
+    test('configures gzip compression', () => {
+      expect(nginxContent).toMatch(/gzip on;/);
+      expect(nginxContent).toMatch(/gzip_types/);
+    });
+  });
+});

package/agentTestSandbox/zone2/Makefile

@@ -0,0 +1,58 @@
+# Compiler and flags
+CC = gcc
+CFLAGS = -Wall -Wextra -Werror -std=c99 -Iinclude
+
+# Directories
+SRC_DIR = src
+TEST_DIR = tests
+BIN_DIR = bin
+OBJ_DIR = obj
+INCLUDE_DIR = include
+
+# Source files
+SRC_FILES = $(SRC_DIR)/main.c $(SRC_DIR)/parser.c $(SRC_DIR)/operations.c $(SRC_DIR)/utils.c
+OBJ_FILES = $(patsubst $(SRC_DIR)/,$(OBJ_DIR)/,$(SRC_FILES:.c=.o))
+
+# Test files
+TEST_SRC = $(TEST_DIR)/test_parser.c $(TEST_DIR)/test_operations.c $(TEST_DIR)/test_utils.c
+TEST_OBJ = $(patsubst $(TEST_DIR)/,$(OBJ_DIR)/,$(TEST_SRC:.c=.o))
+TEST_BIN = $(BIN_DIR)/test_runner
+
+# Main executable
+MAIN_BIN = $(BIN_DIR)/program
+
+# Create required directories
+DIRS = $(BIN_DIR) $(OBJ_DIR)
+
+# Default target
+all: dirs $(MAIN_BIN)
+
+# Create directories
+dirs:
+	mkdir -p $(DIRS)
+
+# Build main program
+$(MAIN_BIN): $(OBJ_FILES)
+	$(CC) $(CFLAGS) -o $@ $^
+
+# Build object files
+$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+# Build tests
+$(TEST_BIN): $(TEST_OBJ) $(OBJ_FILES:%$(MAIN_BIN).o=)
+	$(CC) $(CFLAGS) -o $@ $^ -lunity
+
+$(OBJ_DIR)/%.o: $(TEST_DIR)/%.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+# Run tests
+test: $(TEST_BIN)
+	$(TEST_BIN)
+
+# Clean build files
+clean:
+	rm -f $(BIN_DIR)/* $(OBJ_DIR)/*
+	rmdir -p $(DIRS)
+
+.PHONY: all dirs test clean

package/agentTestSandbox/zone2/imlil.blueprint.json

@@ -0,0 +1,5 @@
+{
+  "fileStructure": "src/main.c, src/parser.c, src/operations.c, src/utils.c, include/parser.h, include/operations.h, include/utils.h, tests/test_parser.c, tests/test_operations.c, tests/test_utils.c, Makefile",
+  "conventions": "snake_case for functions and variables, UPPER_CASE for constants, function documentation using standard C-style comments, unit tests prefix: test_, header guards using __FILENAME_H__",
+  "techStack": "C99, Make, Unity (for unit testing), GCC compiler"
+}

package/agentTestSandbox/zone2/notes-warning.md

@@ -0,0 +1,3 @@
+# IMLIL Supervisor Notes
+
+This is where I'll drop any warnings or important notes for you.

package/agentTestSandbox/zone2/src/core/__tests__/test_memory.c

@@ -0,0 +1,89 @@
+/**
+ * @test file for memory.c
+ * Tests memory management functions for calculator
+ */
+
+#include "unity.h"
+#include "../../include/memory.h"
+
+/* Global setup and teardown */
+void setUp(void) {
+    memory_clear(); // Reset memory before each test
+}
+
+void tearDown(void) {
+    // Cleanup after each test
+}
+
+/* Test cases */
+void test_memory_clear(void) {
+    // Arrange
+    memory_add(10.0);
+
+    // Act
+    memory_clear();
+
+    // Assert
+    TEST_ASSERT_EQUAL_FLOAT(0.0, memory_recall(), 0.00001);
+}
+
+void test_memory_add(void) {
+    // Arrange
+    memory_clear();
+
+    // Act
+    memory_add(5.0);
+    memory_add(3.0);
+
+    // Assert
+    TEST_ASSERT_EQUAL_FLOAT(8.0, memory_recall(), 0.00001);
+}
+
+void test_memory_subtract(void) {
+    // Arrange
+    memory_clear();
+    memory_add(10.0);
+
+    // Act
+    memory_subtract(3.0);
+
+    // Assert
+    TEST_ASSERT_EQUAL_FLOAT(7.0, memory_recall(), 0.00001);
+}
+
+void test_memory_recall(void) {
+    // Arrange
+    memory_clear();
+    memory_add(15.0);
+
+    // Act & Assert
+    TEST_ASSERT_EQUAL_FLOAT(15.0, memory_recall(), 0.00001);
+    
+    // Verify memory is unchanged after recall
+    TEST_ASSERT_EQUAL_FLOAT(15.0, memory_recall(), 0.00001);
+}
+
+void test_memory_chain_operations(void) {
+    // Arrange
+    memory_clear();
+
+    // Act
+    memory_add(10.0);
+    memory_subtract(5.0);
+    memory_add(3.0);
+
+    // Assert
+    TEST_ASSERT_EQUAL_FLOAT(8.0, memory_recall(), 0.00001);
+}
+
+int main(void) {
+    UNITY_BEGIN();
+
+    RUN_TEST(test_memory_clear);
+    RUN_TEST(test_memory_add);
+    RUN_TEST(test_memory_subtract);
+    RUN_TEST(test_memory_recall);
+    RUN_TEST(test_memory_chain_operations);
+
+    return UNITY_END();
+}

package/agentTestSandbox/zone2/src/core/memory.c

@@ -0,0 +1,60 @@
+/**
+ * @file memory.c
+ * @brief Implements calculator memory functions (M+, M-, MR, MC)
+ * @author AutoGenerated
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "memory.h"
+
+/** Global memory register variable */
+static double g_memory_register = 0.0;
+
+void memory_add(double value) {
+    g_memory_register += value;
+}
+
+void memory_subtract(double value) {
+    g_memory_register -= value;
+}
+
+double memory_recall() {
+    return g_memory_register;
+}
+
+void memory_clear() {
+    g_memory_register = 0.0;
+}
+
+/**
+ * Initializes the calculator memory
+ * @return 0 on success, non-zero on failure
+ */
+int memory_init() {
+    memory_clear();
+    return 0;
+}
+
+/**
+ * Cleans up any memory resources
+ */
+void memory_destroy() {
+    memory_clear();
+}
+
+/**
+ * Checks if the memory register has a non-zero value
+ * @return 1 if memory is non-zero, 0 otherwise
+ */
+int memory_has_value() {
+    return (g_memory_register != 0.0);
+}
+
+/**
+ * Sets the memory register to a specific value
+ * @param value The value to set
+ */
+void memory_set(double value) {
+    g_memory_register = value;
+}