@aicgen/aicgen 1.0.0-beta.1

package/data/language/go/testing.md

@@ -0,0 +1,192 @@
+# Go Testing
+
+## Test File Structure
+
+```
+myproject/
+├── user.go
+├── user_test.go      # Tests alongside source
+├── user_internal_test.go  # Internal tests (same package)
+└── testdata/         # Test fixtures
+    └── fixtures.json
+```
+
+## Test Functions
+
+```go
+// Basic test
+func TestCreateUser(t *testing.T) {
+    user := CreateUser("test@example.com")
+
+    if user.Email != "test@example.com" {
+        t.Errorf("expected email %q, got %q", "test@example.com", user.Email)
+    }
+}
+
+// Table-driven tests (preferred)
+func TestValidateEmail(t *testing.T) {
+    tests := []struct {
+        name    string
+        email   string
+        wantErr bool
+    }{
+        {"valid email", "test@example.com", false},
+        {"missing @", "invalid", true},
+        {"empty", "", true},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            err := ValidateEmail(tt.email)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("ValidateEmail(%q) error = %v, wantErr %v",
+                    tt.email, err, tt.wantErr)
+            }
+        })
+    }
+}
+```
+
+## Subtests and Parallel
+
+```go
+func TestUserService(t *testing.T) {
+    t.Run("Create", func(t *testing.T) {
+        t.Parallel() // Run in parallel
+        // test create
+    })
+
+    t.Run("Update", func(t *testing.T) {
+        t.Parallel()
+        // test update
+    })
+}
+```
+
+## Test Helpers
+
+```go
+// Helper function (call t.Helper() first)
+func createTestUser(t *testing.T, email string) *User {
+    t.Helper()
+    user, err := NewUser(email)
+    if err != nil {
+        t.Fatalf("failed to create test user: %v", err)
+    }
+    return user
+}
+
+// Cleanup
+func TestWithTempFile(t *testing.T) {
+    f, err := os.CreateTemp("", "test")
+    if err != nil {
+        t.Fatal(err)
+    }
+    t.Cleanup(func() { os.Remove(f.Name()) })
+
+    // use f...
+}
+```
+
+## Mocking with Interfaces
+
+```go
+// Define interface for dependency
+type UserRepository interface {
+    Save(user *User) error
+    FindByID(id string) (*User, error)
+}
+
+// Mock implementation
+type mockRepository struct {
+    users map[string]*User
+    saveErr error
+}
+
+func (m *mockRepository) Save(user *User) error {
+    if m.saveErr != nil {
+        return m.saveErr
+    }
+    m.users[user.ID] = user
+    return nil
+}
+
+func (m *mockRepository) FindByID(id string) (*User, error) {
+    if user, ok := m.users[id]; ok {
+        return user, nil
+    }
+    return nil, ErrNotFound
+}
+
+// Use in tests
+func TestUserService_Create(t *testing.T) {
+    repo := &mockRepository{users: make(map[string]*User)}
+    service := NewUserService(repo)
+
+    user, err := service.Create("test@example.com")
+
+    if err != nil {
+        t.Fatalf("unexpected error: %v", err)
+    }
+    if _, exists := repo.users[user.ID]; !exists {
+        t.Error("user not saved to repository")
+    }
+}
+```
+
+## Benchmarks
+
+```go
+func BenchmarkProcessUsers(b *testing.B) {
+    users := generateTestUsers(1000)
+    b.ResetTimer()
+
+    for i := 0; i < b.N; i++ {
+        ProcessUsers(users)
+    }
+}
+
+// Run: go test -bench=. -benchmem
+```
+
+## Test Coverage
+
+```bash
+# Generate coverage
+go test -coverprofile=coverage.out ./...
+
+# View coverage report
+go tool cover -html=coverage.out
+
+# Check coverage percentage
+go test -cover ./...
+```
+
+## Integration Tests
+
+```go
+//go:build integration
+
+package mypackage_test
+
+import (
+    "testing"
+    "database/sql"
+)
+
+func TestDatabaseIntegration(t *testing.T) {
+    if testing.Short() {
+        t.Skip("skipping integration test")
+    }
+
+    db, err := sql.Open("postgres", os.Getenv("TEST_DATABASE_URL"))
+    if err != nil {
+        t.Fatal(err)
+    }
+    t.Cleanup(func() { db.Close() })
+
+    // integration tests...
+}
+
+// Run: go test -tags=integration ./...
+```

package/data/language/index.md

@@ -0,0 +1,14 @@
+# Language-Specific Guidelines
+
+Programming language best practices and idioms.
+
+## Available Languages
+
+- `typescript/` - TypeScript guidelines
+- `javascript/` - JavaScript (ES6+) guidelines
+- `python/` - Python guidelines
+- `go/` - Go guidelines
+- `rust/` - Rust guidelines
+- `java/` - Java guidelines
+- `csharp/` - C# guidelines
+- `ruby/` - Ruby guidelines

package/data/language/java/basics.md

@@ -0,0 +1,184 @@
+# Java Fundamentals
+
+## Project Structure (Maven/Gradle)
+
+```
+myproject/
+├── src/
+│   ├── main/
+│   │   ├── java/
+│   │   │   └── com/example/
+│   │   │       ├── Application.java
+│   │   │       ├── controller/
+│   │   │       ├── service/
+│   │   │       ├── repository/
+│   │   │       └── model/
+│   │   └── resources/
+│   │       └── application.yml
+│   └── test/
+│       └── java/
+├── pom.xml (Maven) or build.gradle (Gradle)
+```
+
+## Naming Conventions
+
+```java
+// Classes: PascalCase
+public class UserService {}
+
+// Interfaces: PascalCase, often -able suffix
+public interface Comparable {}
+public interface UserRepository {}
+
+// Methods/variables: camelCase
+public void createUser() {}
+private String userName;
+
+// Constants: UPPER_SNAKE_CASE
+public static final int MAX_RETRIES = 3;
+
+// Packages: lowercase
+package com.example.service;
+```
+
+## Modern Java Features (17+)
+
+```java
+// Records for immutable data
+public record User(String id, String email, String name) {}
+
+// Pattern matching
+if (obj instanceof String s) {
+    System.out.println(s.length());
+}
+
+// Switch expressions
+String result = switch (status) {
+    case ACTIVE -> "Active";
+    case PENDING -> "Pending";
+    case DELETED -> "Deleted";
+};
+
+// Text blocks
+String json = """
+    {
+        "name": "test",
+        "value": 123
+    }
+    """;
+
+// Sealed classes
+public sealed interface Shape permits Circle, Rectangle {}
+```
+
+## Exception Handling
+
+```java
+// Checked exceptions
+public User findUser(String id) throws UserNotFoundException {
+    return repository.findById(id)
+        .orElseThrow(() -> new UserNotFoundException(id));
+}
+
+// Try-with-resources
+try (var reader = new BufferedReader(new FileReader(path))) {
+    return reader.readLine();
+} catch (IOException e) {
+    throw new DataAccessException("Failed to read file", e);
+}
+
+// Custom exceptions
+public class UserNotFoundException extends RuntimeException {
+    public UserNotFoundException(String id) {
+        super("User not found: " + id);
+    }
+}
+```
+
+## Optional
+
+```java
+// Avoid null, use Optional
+public Optional<User> findUser(String id) {
+    return Optional.ofNullable(repository.find(id));
+}
+
+// Chaining
+findUser(id)
+    .map(User::getEmail)
+    .filter(email -> email.contains("@"))
+    .orElse("unknown@example.com");
+
+// Never use Optional in fields or parameters
+// Only for return types
+```
+
+## Streams
+
+```java
+// Filter, map, collect
+List<String> emails = users.stream()
+    .filter(u -> u.isActive())
+    .map(User::getEmail)
+    .collect(Collectors.toList());
+
+// Grouping
+Map<String, List<User>> byDepartment = users.stream()
+    .collect(Collectors.groupingBy(User::getDepartment));
+
+// Reduce
+int totalAge = users.stream()
+    .mapToInt(User::getAge)
+    .sum();
+```
+
+## Testing (JUnit 5)
+
+```java
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+
+    @Mock
+    private UserRepository repository;
+
+    @InjectMocks
+    private UserService service;
+
+    @Test
+    void shouldCreateUser() {
+        // Arrange
+        var request = new CreateUserRequest("test@example.com");
+        when(repository.save(any())).thenReturn(new User("1", "test@example.com"));
+
+        // Act
+        var user = service.create(request);
+
+        // Assert
+        assertThat(user.getEmail()).isEqualTo("test@example.com");
+        verify(repository).save(any());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"invalid", "no-at", ""})
+    void shouldRejectInvalidEmails(String email) {
+        assertThrows(ValidationException.class,
+            () -> service.create(new CreateUserRequest(email)));
+    }
+}
+```
+
+## Dependency Injection (Spring)
+
+```java
+@Service
+public class UserService {
+    private final UserRepository repository;
+    private final EmailService emailService;
+
+    // Constructor injection (preferred)
+    public UserService(UserRepository repository, EmailService emailService) {
+        this.repository = repository;
+        this.emailService = emailService;
+    }
+}
+```

package/data/language/java/testing.md

@@ -0,0 +1,273 @@
+# Java Testing (JUnit 5)
+
+## Test Structure
+
+```
+src/
+├── main/java/com/example/
+│   └── UserService.java
+└── test/java/com/example/
+    └── UserServiceTest.java
+```
+
+## Basic Tests
+
+```java
+import org.junit.jupiter.api.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserServiceTest {
+
+    private UserService service;
+
+    @BeforeEach
+    void setUp() {
+        service = new UserService();
+    }
+
+    @Test
+    void createUser_WithValidEmail_ReturnsUser() {
+        User user = service.create("test@example.com");
+
+        assertEquals("test@example.com", user.getEmail());
+        assertNotNull(user.getId());
+    }
+
+    @Test
+    void createUser_WithInvalidEmail_ThrowsException() {
+        assertThrows(ValidationException.class, () -> {
+            service.create("invalid");
+        });
+    }
+}
+```
+
+## Assertions
+
+```java
+// Equality
+assertEquals(expected, actual);
+assertNotEquals(unexpected, actual);
+
+// Boolean
+assertTrue(condition);
+assertFalse(condition);
+
+// Null checks
+assertNull(value);
+assertNotNull(value);
+
+// Collections
+assertIterableEquals(expected, actual);
+assertArrayEquals(expectedArray, actualArray);
+
+// Multiple assertions (all run even if some fail)
+assertAll(
+    () -> assertEquals("John", user.getName()),
+    () -> assertEquals("john@example.com", user.getEmail()),
+    () -> assertTrue(user.isActive())
+);
+```
+
+## Parameterized Tests
+
+```java
+@ParameterizedTest
+@ValueSource(strings = {"", " ", "invalid", "no-at-sign"})
+void validateEmail_WithInvalidInput_ReturnsFalse(String email) {
+    assertFalse(validator.isValid(email));
+}
+
+@ParameterizedTest
+@CsvSource({
+    "test@example.com, true",
+    "invalid, false",
+    "'', false"
+})
+void validateEmail_WithVariousInputs(String email, boolean expected) {
+    assertEquals(expected, validator.isValid(email));
+}
+
+@ParameterizedTest
+@MethodSource("provideUsersForTest")
+void processUser_WithVariousUsers(User user, String expectedStatus) {
+    assertEquals(expectedStatus, processor.process(user));
+}
+
+static Stream<Arguments> provideUsersForTest() {
+    return Stream.of(
+        Arguments.of(new User("active@example.com", true), "processed"),
+        Arguments.of(new User("inactive@example.com", false), "skipped")
+    );
+}
+```
+
+## Nested Tests
+
+```java
+@DisplayName("UserService")
+class UserServiceTest {
+
+    @Nested
+    @DisplayName("create")
+    class Create {
+
+        @Test
+        @DisplayName("with valid email creates user")
+        void withValidEmail() {
+            // test
+        }
+
+        @Test
+        @DisplayName("with duplicate email throws exception")
+        void withDuplicateEmail() {
+            // test
+        }
+    }
+
+    @Nested
+    @DisplayName("delete")
+    class Delete {
+        // delete tests
+    }
+}
+```
+
+## Mocking with Mockito
+
+```java
+import org.mockito.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+
+    @Mock
+    private UserRepository repository;
+
+    @InjectMocks
+    private UserService service;
+
+    @Test
+    void create_SavesUserToRepository() {
+        User user = new User("test@example.com");
+        when(repository.save(any(User.class))).thenReturn(user);
+
+        User result = service.create("test@example.com");
+
+        verify(repository).save(any(User.class));
+        assertEquals("test@example.com", result.getEmail());
+    }
+
+    @Test
+    void findById_WhenNotFound_ThrowsException() {
+        when(repository.findById("123")).thenReturn(Optional.empty());
+
+        assertThrows(NotFoundException.class, () -> {
+            service.findById("123");
+        });
+    }
+}
+```
+
+## Lifecycle Hooks
+
+```java
+@BeforeAll
+static void initAll() {
+    // Run once before all tests
+}
+
+@BeforeEach
+void init() {
+    // Run before each test
+}
+
+@AfterEach
+void tearDown() {
+    // Run after each test
+}
+
+@AfterAll
+static void tearDownAll() {
+    // Run once after all tests
+}
+```
+
+## Async Testing
+
+```java
+@Test
+void asyncOperation_CompletesWithinTimeout() {
+    assertTimeout(Duration.ofSeconds(2), () -> {
+        service.longRunningOperation();
+    });
+}
+
+@Test
+void asyncOperation_WithCompletableFuture() throws Exception {
+    CompletableFuture<User> future = service.createAsync("test@example.com");
+
+    User user = future.get(5, TimeUnit.SECONDS);
+    assertEquals("test@example.com", user.getEmail());
+}
+```
+
+## Test Tags and Filtering
+
+```java
+@Tag("integration")
+@Test
+void databaseIntegrationTest() {
+    // integration test
+}
+
+@Tag("slow")
+@Test
+void slowPerformanceTest() {
+    // slow test
+}
+
+// Run: mvn test -Dgroups="integration"
+// Exclude: mvn test -DexcludedGroups="slow"
+```
+
+## Spring Boot Testing
+
+```java
+@SpringBootTest
+class UserServiceIntegrationTest {
+
+    @Autowired
+    private UserService service;
+
+    @MockBean
+    private EmailService emailService;
+
+    @Test
+    void create_SendsWelcomeEmail() {
+        service.create("test@example.com");
+
+        verify(emailService).sendWelcome(any(User.class));
+    }
+}
+
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private UserService service;
+
+    @Test
+    void getUser_ReturnsUser() throws Exception {
+        when(service.findById("1")).thenReturn(new User("1", "test@example.com"));
+
+        mockMvc.perform(get("/users/1"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.email").value("test@example.com"));
+    }
+}
+```