Getting Started with Qwen Code for Coding Tasks

# Download and install nvm:
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

# in lieu of restarting the shell
\. "$HOME/.nvm/nvm.sh"

# Download and install Node.js:
nvm install 24

# Verify the Node.js version:
node -v # Should print "v24.12.0".

# Verify npm version:
npm -v # Should print "11.6.2".

npm install -g @qwen-code/qwen-code@latest

{
  "privacy": {
    "usageStatisticsEnabled": false
  }
}

OPENAI_API_KEY="your-api-key"
OPENAI_BASE_URL="https://localhost:11434/v1"
OPENAI_MODEL="qwen3-coder:30b"

You are an expert code assistant for a professional Java developer. All code examples, reviews, and explanations must be idiomatic to the following tech stack:
* Backend: Java (latest LTS), Spring Boot (latest stable), PostgreSQL.
* Frontend: Vue.js (latest stable), Angular (latest stable).
* Follow modern best practices for RESTful APIs, object-relational mapping, unit testing (JUnit), and frontend-backend integration.
* Prefer Maven for Java dependency management.
* Whenever database code is required, use PostgreSQL syntax and conventions.
* For frontend, use Vue composition API where applicable.
* Always explain your reasoning, and reference documentation when giving architectural advice.
* When unsure, ask clarifying questions before producing code.

"model": {
    "generationConfig": {
      "samplingParams": {
        "temperature": 0
      }
    }
  }

@src/main/java/com/mydeveloperplanet/myaicodeprojectplanet/controller/CustomersController.java

Write a unit test for this code using JUnit. 
Use WebMvcTest. 
Use MockMvc. 
Use AssertJ assertions.

Add the test in this repository

package com.mydeveloperplanet.myaicodeprojectplanet.controller;

import com.mydeveloperplanet.myaicodeprojectplanet.model.Customer;
//import com.mydeveloperplanet.myaicodeprojectplanet.openapi.model.Customer as OpenApiCustomer;
import com.mydeveloperplanet.myaicodeprojectplanet.service.CustomerService;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;

import java.util.List;
import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(CustomersController.class)
class CustomersControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private CustomerService customerService;

    @Test
    @DisplayName("GET /customers returns list of customers")
    void getAllCustomersReturnsList() throws Exception {
        Customer customer = new Customer(1L, "John", "Doe");
        when(customerService.getAllCustomers()).thenReturn(List.of(customer));

        MvcResult result = mockMvc.perform(get("/customers"))
                .andExpect(status().isOk())
                .andReturn();

        String content = result.getResponse().getContentAsString();
        assertThat(content).contains("John");
    }

    @Test
    @DisplayName("GET /customers/{id} returns customer when found")
    void getCustomerByIdFound() throws Exception {
        Customer customer = new Customer(1L, "Jane", "Smith");
        when(customerService.getCustomerById(1L)).thenReturn(Optional.of(customer));

        mockMvc.perform(get("/customers/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.firstName").value("Jane"));
    }

    @Test
    @DisplayName("GET /customers/{id} returns 404 when not found")
    void getCustomerByIdNotFound() throws Exception {
        when(customerService.getCustomerById(99L)).thenReturn(Optional.empty());

        mockMvc.perform(get("/customers/99"))
                .andExpect(status().isNotFound());
    }

    @Test
    @DisplayName("POST /customers creates a customer")
    void createCustomer() throws Exception {
        Customer customer = new Customer(1L, "Alice", "Wonderland");
        when(customerService.createCustomer(any(Customer.class))).thenReturn(customer);

        String json = "{\"id\":1,\"firstName\":\"Alice\",\"lastName\":\"Wonderland\"}";
        mockMvc.perform(post("/customers")
                .contentType(MediaType.APPLICATION_JSON)
                .content(json))
                .andExpect(status().isCreated());
    }

    @Test
    @DisplayName("PUT /customers/{id} updates a customer")
    void updateCustomer() throws Exception {
        Customer customer = new Customer(1L, "Bob", "Builder");
        when(customerService.updateCustomer(anyLong(), any(Customer.class))).thenReturn(customer);

        String json = "{\"id\":1,\"firstName\":\"Bob\",\"lastName\":\"Builder\"}";
        mockMvc.perform(put("/customers/1")
                .contentType(MediaType.APPLICATION_JSON)
                .content(json))
                .andExpect(status().isOk());
    }

    @Test
    @DisplayName("DELETE /customers/{id} deletes a customer")
    void deleteCustomer() throws Exception {
        mockMvc.perform(delete("/customers/1"))
                .andExpect(status().isNoContent());
    }
}

# QWEN.md

## Project Overview

This repository is a **Spring Boot** application written in **Java 21** that exposes a simple **Customer Management API**. It demonstrates:

* RESTful endpoints generated from an OpenAPI specification (`src/main/resources/static/customers.yaml`).
* JOOQ code‑generation for type‑safe database access.
* Liquibase migrations for schema creation.
* Testcontainers integration for integration tests.
* PIT mutation testing.

The application uses a PostgreSQL database (Docker image `postgres:17-alpine`) defined in `compose.yaml`.

## Directory Structure

```
src/
├─ main/
│  ├─ java/com/mydeveloperplanet/myaicodeprojectplanet
│  │  ├─ controller
│  │  ├─ model
│  │  ├─ repository
│  │  ├─ service
│  │  └─ MyAiCodeProjectPlanetApplication.java
│  ├─ resources/
│  │  ├─ db/changelog/migration
│  │  ├─ static/customers.yaml
│  │  └─ application.properties
└─ test/
   └─ java/com/mydeveloperplanet/myaicodeprojectplanet/controller
```

## Build & Run

The project uses **Maven**. The following commands are the typical workflow:

| Action | Command |
|--------|---------|
| Clean & compile | `./mvnw clean compile` |
| Run the application | `./mvnw spring-boot:run` |
| Run tests | `./mvnw test` |
| Generate JOOQ sources | `./mvnw generate-sources` |
| Run mutation tests | `./mvnw test-compile exec:java -Dexec.mainClass=org.pitest.mutationtest.MutationTest` |

> **Note**: The wrapper scripts `mvnw` and `mvnw.cmd` are provided for cross‑platform builds.

## Docker Compose

A `compose.yaml` file is included to spin up a PostgreSQL instance for local development:

```bash
docker compose up -d
```

The database is exposed on port **5432** and is automatically connected via Spring Boot’s `spring-boot-docker-compose` dependency.

## Testing

Unit tests are located under `src/test/java`. They use **JUnit 5** and **Spring MockMvc**. Integration tests can be added using Testcontainers.

Run all tests with:

```bash
./mvnw test
```

## Conventions & Style

* **Java** code follows the standard Spring Boot conventions.
* **Naming**: Packages use lower‑case, classes use PascalCase.
* **Configuration**: All runtime properties are in `application.properties`.
* **OpenAPI**: The API contract is defined in `customers.yaml` and used by the OpenAPI generator plugin.
* **Database**: Liquibase changelogs are in `src/main/resources/db/changelog`.

## Extending the Project

* Add new entities by creating a JOOQ table, updating the Liquibase changelog, and generating JOOQ sources.
* Add new REST endpoints by implementing the corresponding OpenAPI interface and wiring it into the controller.
* Add tests under the appropriate package.

---

*Generated by Qwen Code on 2025‑12‑31.*

~/.qwen/commands$ tree 
.
├── general
│   ├── explain.toml
│   └── javadoc.toml
├── review
│   ├── extended.toml
│   └── simple.toml
└── test
    ├── controller.toml
    ├── integration.toml
    ├── repositoryjooq.toml
    └── service.toml

description = "Create a test for a Spring Boot Controller"
prompt = """
Write a unit test for this code code using JUnit. 
Use WebMvcTest. 
Use MockMvc. 
Use AssertJ assertions.

@src/main/java/com/mydeveloperplanet/myaicodeprojectplanet/controller/CustomersController.java
/test:controller

"mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"],
      "timeout": 15000
    }
  }

$ qwen mcp list
Configured MCP servers:

✓ context7: npx -y @upstash/context7-mcp (stdio) - Connected

/test:controller create the test in this repository, i am using spring boot 3.4, use context7 to retrieve uptodate information