![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

## Build a Docker Image with a Single-File FastAPI { #build-a-docker-image-with-a-single-file-fastapi }

If your FastAPI is a single file, for example, `main.py` without an `./app` directory, your file structure could look like this:

```
.
├── Dockerfile
├── main.py
└── requirements.txt

        testUser.setRoleNames(new String[] {});
        assertFalse(fessUserBean.hasRole("admin"));

        // Test with single role - matching
        testUser.setRoleNames(new String[] { "admin" });
        assertTrue(fessUserBean.hasRole("admin"));

        // Test with single role - not matching
        assertFalse(fessUserBean.hasRole("user"));

        // Test with multiple roles

            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_CONC_MPX), "DCERPC_CONC_MPX should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_DID_NOT_EXECUTE), "DCERPC_DID_NOT_EXECUTE should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_MAYBE), "DCERPC_MAYBE should be a single bit");

   * limits, this call may be executed well before processing the request is able to begin.
   *
   * This will be invoked only once for a single [Call]. Retries of different routes or redirects
   * will be handled within the boundaries of a single [callStart] and [callEnd]/[callFailed] pair.
   */
  open fun callStart(call: Call) {
  }

  /**
   * Invoked prior to a proxy selection.
   *

    public void test_insert_noChains() {
        User user = createTestUser("testuser");
        authenticationManager.insert(user);
        // Should not throw exception even with no chains
    }

    // Test insert with single chain
    public void test_insert_singleChain() {
        User user = createTestUser("testuser");
        TestAuthenticationChain chain = new TestAuthenticationChain();
        authenticationManager.addChain(chain);

<div class="termy">

```console
$ pip install sqlmodel
---> 100%
```

</div>

## Create the App with a Single Model { #create-the-app-with-a-single-model }

We'll create the simplest first version of the app with a single **SQLModel** model first.

Later we'll improve it increasing security and versatility with **multiple models** below. 🤓

### Create Models { #create-models }

        String value;
        String[] result;

        // Single unquoted value
        value = "single";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(1, result.length);
        assertEquals("single", result[0]);

        // Single quoted value - quotes preserved
        value = "\"single quoted\"";
        result = KuromojiCSVUtil.parse(value);

        assertEquals("a\nb\nc", inputsValue);
    }

    public void test_getInputsValue_withSingleInput() {
        // Test with single input
        String[] inputs = { "single" };
        CharMappingItem item = new CharMappingItem(1L, inputs, "output");

        assertEquals("single", item.getInputsValue());
    }

    public void test_getInputsValue_withNullInputs() {

        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <id>create-distro-packages</id>
            <goals>
              <goal>single</goal>
            </goals>
            <phase>package</phase>
            <configuration>
              <descriptors>
                <descriptor>src/assembly/bin.xml</descriptor>
              </descriptors>

But in most cases, you will want to perform these steps only **once**.

So, you will want to have a **single process** to perform those **previous steps**, before starting the application.