"loc": ["query", "id"],
                    "msg": 'Value error, Invalid ID format, it must start with "isbn-" or "imdb-"',
                    "input": "wtf-yes",
                    "ctx": {"error": {}},
                }
            ]
        }
    )


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text

                "msg": "Input should be a valid datetime or date, invalid character in year",
                "type": "datetime_from_date_parsing",
                "input": "not a date",
                "ctx": {"error": "invalid character in year"},
            }
        ]
    }
    assert "345" not in fake_db


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")

            {
                "loc": ["path", "item_id"],
                "input": "0",
                "msg": "Input should be greater than or equal to 1",
                "type": "greater_than_equal",
                "ctx": {"ge": 1},
            }
        ]
    }


def test_read_items_missing_q(client: TestClient):
    response = client.get("/items/42")
    assert response.status_code == 422, response.text

// CheckPartsHandler - check if a file parts exists.
func (s *storageRESTServer) CheckPartsHandler(ctx context.Context, p *CheckPartsHandlerParams, out chan<- *CheckPartsResp) *grid.RemoteErr {
	if !s.checkID(p.DiskID) {
		return grid.NewRemoteErr(errDiskNotFound)
	}
	volume := p.Volume
	filePath := p.FilePath

	resp, err := s.getStorage().CheckParts(ctx, volume, filePath, p.FI)
	if err != nil {
		return grid.NewRemoteErr(err)
	}

	if strings.Contains(objInfo.ETag, "-") && len(objInfo.Parts) > 0 {
		w.Header()[xhttp.AmzMpPartsCount] = []string{strconv.Itoa(len(objInfo.Parts))}
	}
}

// Write object header
func setObjectHeaders(ctx context.Context, w http.ResponseWriter, objInfo ObjectInfo, rs *HTTPRangeSpec, opts ObjectOptions) (err error) {
	// set common headers
	setCommonHeaders(w)

	// Set last modified time.

                "input": "not a valid url",
                "msg": "Input should be a valid URL, relative URL without a base",
                "type": "url_parsing",
                "ctx": {"error": "relative URL without a base"},
            },
        ]
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")

        "detail": [
            {
                "type": "greater_than",
                "loc": ["body", 0, "age"],
                "msg": "Input should be greater than 0",
                "input": -1.0,
                "ctx": {"gt": 0},
            }
        ]
    }


def test_put_incorrect_body_multiple():
    response = client.post("/items/", json=[{"age": "five"}, {"age": "six"}])

            {
                "type": "greater_than",
                "loc": ["body", "item", "price"],
                "msg": "Input should be greater than 0",
                "input": -3.0,
                "ctx": {"gt": 0.0},
            }
        ]
    }


def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text

		}
	}
}

func TestDoesPresignedSignatureMatch(t *testing.T) {
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()

	obj, fsDir, err := prepareFS(ctx)
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(fsDir)
	if err = newTestConfig(globalMinioDefaultRegion, obj); err != nil {
		t.Fatal(err)
	}

	} else {
		cfg.inlineBlock = 128 * humanize.KiByte
	}

	cfg.initialized = true

	return cfg, nil
}

func configLogOnceIf(ctx context.Context, err error, id string, errKind ...any) {
	logger.LogOnceIf(ctx, "config", err, id, errKind...)