From e2a1ac43a1cdbc70c188fde656153c670b93b2b7 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Fri, 23 Feb 2024 20:04:55 -0500 Subject: [PATCH 01/27] openapi: support validation attributes --- .../ModelValidation/swagger.g.json | 1264 +++++++++++++++++ .../ModelValidation/Fingerprint.cs | 68 + .../ModelValidationDbContext.cs | 11 + .../ModelValidation/ModelValidationFakers.cs | 31 + .../ModelValidation/ModelValidationTests.cs | 256 ++++ 5 files changed, 1630 insertions(+) create mode 100644 test/OpenApiEndToEndTests/ModelValidation/swagger.g.json create mode 100644 test/OpenApiTests/ModelValidation/Fingerprint.cs create mode 100644 test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs create mode 100644 test/OpenApiTests/ModelValidation/ModelValidationFakers.cs create mode 100644 test/OpenApiTests/ModelValidation/ModelValidationTests.cs diff --git a/test/OpenApiEndToEndTests/ModelValidation/swagger.g.json b/test/OpenApiEndToEndTests/ModelValidation/swagger.g.json new file mode 100644 index 0000000000..a32512b6d7 --- /dev/null +++ b/test/OpenApiEndToEndTests/ModelValidation/swagger.g.json @@ -0,0 +1,1264 @@ +{ + "openapi": "3.0.1", + "info": { + "title": "OpenApiTests", + "version": "1.0" + }, + "servers": [ + { + "url": "http://localhost" + } + ], + "paths": { + "/fingerprints": { + "get": { + "tags": [ + "fingerprints" + ], + "summary": "Retrieves a collection of fingerprints.", + "operationId": "getFingerprintCollection", + "parameters": [ + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + }, + { + "name": "If-None-Match", + "in": "header", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Successfully returns the found fingerprints, or an empty array if none were found.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + } + }, + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/fingerprintCollectionResponseDocument" + } + } + } + }, + "304": { + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + } + } + }, + "400": { + "description": "The query string is invalid.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + }, + "head": { + "tags": [ + "fingerprints" + ], + "summary": "Retrieves a collection of fingerprints without returning them.", + "description": "Compare the returned ETag HTTP header with an earlier one to determine if the response has changed since it was fetched.", + "operationId": "headFingerprintCollection", + "parameters": [ + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + }, + { + "name": "If-None-Match", + "in": "header", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "The operation completed successfully.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + }, + "Content-Length": { + "description": "Size of the HTTP response body, in bytes.", + "required": true, + "schema": { + "type": "integer", + "format": "int64" + } + } + } + }, + "304": { + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + } + } + }, + "400": { + "description": "The query string is invalid." + } + } + }, + "post": { + "tags": [ + "fingerprints" + ], + "summary": "Creates a new fingerprint.", + "operationId": "postFingerprint", + "parameters": [ + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + } + ], + "requestBody": { + "description": "The attributes and relationships of the fingerprint to create.", + "content": { + "application/vnd.api+json": { + "schema": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintPostRequestDocument" + } + ] + } + } + } + }, + "responses": { + "201": { + "description": "The fingerprint was successfully created, which resulted in additional changes. The newly created fingerprint is returned.", + "headers": { + "Location": { + "description": "The URL at which the newly created fingerprint can be retrieved.", + "required": true, + "schema": { + "type": "string", + "format": "uri" + } + } + }, + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" + } + } + } + }, + "204": { + "description": "The fingerprint was successfully created, which did not result in additional changes." + }, + "400": { + "description": "The query string is invalid or the request body is missing or malformed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "403": { + "description": "Client-generated IDs cannot be used at this endpoint.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "409": { + "description": "A resource type in the request body is incompatible.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "422": { + "description": "Validation of the request body failed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + } + }, + "/fingerprints/{id}": { + "get": { + "tags": [ + "fingerprints" + ], + "summary": "Retrieves an individual fingerprint by its identifier.", + "operationId": "getFingerprint", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "The identifier of the fingerprint to retrieve.", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + }, + { + "name": "If-None-Match", + "in": "header", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Successfully returns the found fingerprint.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + } + }, + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" + } + } + } + }, + "304": { + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + } + } + }, + "400": { + "description": "The query string is invalid.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "404": { + "description": "The fingerprint does not exist.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + }, + "head": { + "tags": [ + "fingerprints" + ], + "summary": "Retrieves an individual fingerprint by its identifier without returning it.", + "description": "Compare the returned ETag HTTP header with an earlier one to determine if the response has changed since it was fetched.", + "operationId": "headFingerprint", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "The identifier of the fingerprint to retrieve.", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + }, + { + "name": "If-None-Match", + "in": "header", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "The operation completed successfully.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + }, + "Content-Length": { + "description": "Size of the HTTP response body, in bytes.", + "required": true, + "schema": { + "type": "integer", + "format": "int64" + } + } + } + }, + "304": { + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "headers": { + "ETag": { + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "required": true, + "schema": { + "type": "string" + } + } + } + }, + "400": { + "description": "The query string is invalid." + }, + "404": { + "description": "The fingerprint does not exist." + } + } + }, + "patch": { + "tags": [ + "fingerprints" + ], + "summary": "Updates an existing fingerprint.", + "operationId": "patchFingerprint", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "The identifier of the fingerprint to update.", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + } + ], + "requestBody": { + "description": "The attributes and relationships of the fingerprint to update. Omitted fields are left unchanged.", + "content": { + "application/vnd.api+json": { + "schema": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintPatchRequestDocument" + } + ] + } + } + } + }, + "responses": { + "200": { + "description": "The fingerprint was successfully updated, which resulted in additional changes. The updated fingerprint is returned.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" + } + } + } + }, + "204": { + "description": "The fingerprint was successfully updated, which did not result in additional changes." + }, + "400": { + "description": "The query string is invalid or the request body is missing or malformed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "404": { + "description": "The fingerprint or a related resource does not exist.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "409": { + "description": "A resource type or identifier in the request body is incompatible.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "422": { + "description": "Validation of the request body failed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + }, + "delete": { + "tags": [ + "fingerprints" + ], + "summary": "Deletes an existing fingerprint by its identifier.", + "operationId": "deleteFingerprint", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "The identifier of the fingerprint to delete.", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "204": { + "description": "The fingerprint was successfully deleted." + }, + "404": { + "description": "The fingerprint does not exist.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + } + } + }, + "components": { + "schemas": { + "dataInResponse": { + "required": [ + "id", + "type" + ], + "type": "object", + "properties": { + "type": { + "minLength": 1, + "type": "string" + }, + "id": { + "minLength": 1, + "type": "string" + } + }, + "additionalProperties": false, + "discriminator": { + "propertyName": "type", + "mapping": { + "fingerprints": "#/components/schemas/fingerprintDataInResponse" + } + }, + "x-abstract": true + }, + "errorLinks": { + "type": "object", + "properties": { + "about": { + "type": "string", + "nullable": true + }, + "type": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, + "errorObject": { + "type": "object", + "properties": { + "id": { + "type": "string", + "nullable": true + }, + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/errorLinks" + } + ], + "nullable": true + }, + "status": { + "type": "string" + }, + "code": { + "type": "string", + "nullable": true + }, + "title": { + "type": "string", + "nullable": true + }, + "detail": { + "type": "string", + "nullable": true + }, + "source": { + "allOf": [ + { + "$ref": "#/components/schemas/errorSource" + } + ], + "nullable": true + }, + "meta": { + "type": "object", + "additionalProperties": { }, + "nullable": true + } + }, + "additionalProperties": false + }, + "errorResponseDocument": { + "required": [ + "errors" + ], + "type": "object", + "properties": { + "errors": { + "type": "array", + "items": { + "$ref": "#/components/schemas/errorObject" + } + } + }, + "additionalProperties": false + }, + "errorSource": { + "type": "object", + "properties": { + "pointer": { + "type": "string", + "nullable": true + }, + "parameter": { + "type": "string", + "nullable": true + }, + "header": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, + "fingerprintAttributesInPatchRequest": { + "type": "object", + "properties": { + "firstName": { + "type": "string", + "nullable": true + }, + "lastName": { + "minLength": 1, + "type": "string" + }, + "userName": { + "maxLength": 18, + "minLength": 3, + "pattern": "^[a-zA-Z]+$", + "type": "string", + "nullable": true + }, + "creditCard": { + "type": "string", + "format": "credit-card", + "nullable": true + }, + "email": { + "type": "string", + "format": "email", + "nullable": true + }, + "phone": { + "type": "string", + "format": "tel", + "nullable": true + }, + "age": { + "maximum": 123, + "minimum": 0, + "type": "integer", + "format": "int32", + "nullable": true + }, + "tags": { + "type": "array", + "items": { + "type": "string" + } + }, + "profilePicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "nextRevalidation": { + "allOf": [ + { + "$ref": "#/components/schemas/timeSpan" + } + ], + "nullable": true + }, + "validatedAt": { + "type": "string", + "format": "date-time", + "nullable": true + }, + "validatedDateAt": { + "type": "string", + "format": "date", + "nullable": true + }, + "validatedTimeAt": { + "type": "string", + "format": "time", + "nullable": true + }, + "signature": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, + "fingerprintAttributesInPostRequest": { + "required": [ + "lastName", + "tags" + ], + "type": "object", + "properties": { + "firstName": { + "type": "string", + "nullable": true + }, + "lastName": { + "minLength": 1, + "type": "string" + }, + "userName": { + "maxLength": 18, + "minLength": 3, + "pattern": "^[a-zA-Z]+$", + "type": "string", + "nullable": true + }, + "creditCard": { + "type": "string", + "format": "credit-card", + "nullable": true + }, + "email": { + "type": "string", + "format": "email", + "nullable": true + }, + "phone": { + "type": "string", + "format": "tel", + "nullable": true + }, + "age": { + "maximum": 123, + "minimum": 0, + "type": "integer", + "format": "int32", + "nullable": true + }, + "tags": { + "type": "array", + "items": { + "type": "string" + } + }, + "profilePicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "nextRevalidation": { + "allOf": [ + { + "$ref": "#/components/schemas/timeSpan" + } + ], + "nullable": true + }, + "validatedAt": { + "type": "string", + "format": "date-time", + "nullable": true + }, + "validatedDateAt": { + "type": "string", + "format": "date", + "nullable": true + }, + "validatedTimeAt": { + "type": "string", + "format": "time", + "nullable": true + }, + "signature": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, + "fingerprintAttributesInResponse": { + "type": "object", + "properties": { + "firstName": { + "type": "string", + "nullable": true + }, + "lastName": { + "minLength": 1, + "type": "string" + }, + "userName": { + "maxLength": 18, + "minLength": 3, + "pattern": "^[a-zA-Z]+$", + "type": "string", + "nullable": true + }, + "creditCard": { + "type": "string", + "format": "credit-card", + "nullable": true + }, + "email": { + "type": "string", + "format": "email", + "nullable": true + }, + "phone": { + "type": "string", + "format": "tel", + "nullable": true + }, + "age": { + "maximum": 123, + "minimum": 0, + "type": "integer", + "format": "int32", + "nullable": true + }, + "tags": { + "type": "array", + "items": { + "type": "string" + } + }, + "profilePicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "nextRevalidation": { + "allOf": [ + { + "$ref": "#/components/schemas/timeSpan" + } + ], + "nullable": true + }, + "validatedAt": { + "type": "string", + "format": "date-time", + "nullable": true + }, + "validatedDateAt": { + "type": "string", + "format": "date", + "nullable": true + }, + "validatedTimeAt": { + "type": "string", + "format": "time", + "nullable": true + }, + "signature": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, + "fingerprintCollectionResponseDocument": { + "required": [ + "data", + "links" + ], + "type": "object", + "properties": { + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/linksInResourceCollectionDocument" + } + ] + }, + "data": { + "type": "array", + "items": { + "$ref": "#/components/schemas/fingerprintDataInResponse" + } + }, + "included": { + "type": "array", + "items": { + "$ref": "#/components/schemas/dataInResponse" + } + }, + "meta": { + "type": "object", + "additionalProperties": { + "type": "object", + "nullable": true + } + } + }, + "additionalProperties": false + }, + "fingerprintDataInPatchRequest": { + "required": [ + "id", + "type" + ], + "type": "object", + "properties": { + "type": { + "$ref": "#/components/schemas/fingerprintResourceType" + }, + "id": { + "minLength": 1, + "type": "string" + }, + "attributes": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintAttributesInPatchRequest" + } + ] + } + }, + "additionalProperties": false + }, + "fingerprintDataInPostRequest": { + "required": [ + "type" + ], + "type": "object", + "properties": { + "type": { + "$ref": "#/components/schemas/fingerprintResourceType" + }, + "attributes": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintAttributesInPostRequest" + } + ] + } + }, + "additionalProperties": false + }, + "fingerprintDataInResponse": { + "allOf": [ + { + "$ref": "#/components/schemas/dataInResponse" + }, + { + "required": [ + "links" + ], + "type": "object", + "properties": { + "attributes": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintAttributesInResponse" + } + ] + }, + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/linksInResourceData" + } + ] + }, + "meta": { + "type": "object", + "additionalProperties": { + "type": "object", + "nullable": true + } + } + }, + "additionalProperties": false + } + ], + "additionalProperties": false + }, + "fingerprintPatchRequestDocument": { + "required": [ + "data" + ], + "type": "object", + "properties": { + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintDataInPatchRequest" + } + ] + } + }, + "additionalProperties": false + }, + "fingerprintPostRequestDocument": { + "required": [ + "data" + ], + "type": "object", + "properties": { + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintDataInPostRequest" + } + ] + } + }, + "additionalProperties": false + }, + "fingerprintPrimaryResponseDocument": { + "required": [ + "data", + "links" + ], + "type": "object", + "properties": { + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/linksInResourceDocument" + } + ] + }, + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintDataInResponse" + } + ] + }, + "included": { + "type": "array", + "items": { + "$ref": "#/components/schemas/dataInResponse" + } + }, + "meta": { + "type": "object", + "additionalProperties": { + "type": "object", + "nullable": true + } + } + }, + "additionalProperties": false + }, + "fingerprintResourceType": { + "enum": [ + "fingerprints" + ], + "type": "string", + "additionalProperties": false + }, + "linksInResourceCollectionDocument": { + "required": [ + "self" + ], + "type": "object", + "properties": { + "self": { + "minLength": 1, + "type": "string" + }, + "describedby": { + "type": "string" + }, + "first": { + "type": "string" + }, + "last": { + "type": "string" + }, + "prev": { + "type": "string" + }, + "next": { + "type": "string" + } + }, + "additionalProperties": false + }, + "linksInResourceData": { + "required": [ + "self" + ], + "type": "object", + "properties": { + "self": { + "minLength": 1, + "type": "string" + } + }, + "additionalProperties": false + }, + "linksInResourceDocument": { + "required": [ + "self" + ], + "type": "object", + "properties": { + "self": { + "minLength": 1, + "type": "string" + }, + "describedby": { + "type": "string" + } + }, + "additionalProperties": false + }, + "timeSpan": { + "type": "object", + "properties": { + "ticks": { + "type": "integer", + "format": "int64" + }, + "days": { + "type": "integer", + "format": "int32", + "readOnly": true + }, + "hours": { + "type": "integer", + "format": "int32", + "readOnly": true + }, + "milliseconds": { + "type": "integer", + "format": "int32", + "readOnly": true + }, + "microseconds": { + "type": "integer", + "format": "int32", + "readOnly": true + }, + "nanoseconds": { + "type": "integer", + "format": "int32", + "readOnly": true + }, + "minutes": { + "type": "integer", + "format": "int32", + "readOnly": true + }, + "seconds": { + "type": "integer", + "format": "int32", + "readOnly": true + }, + "totalDays": { + "type": "number", + "format": "double", + "readOnly": true + }, + "totalHours": { + "type": "number", + "format": "double", + "readOnly": true + }, + "totalMilliseconds": { + "type": "number", + "format": "double", + "readOnly": true + }, + "totalMicroseconds": { + "type": "number", + "format": "double", + "readOnly": true + }, + "totalNanoseconds": { + "type": "number", + "format": "double", + "readOnly": true + }, + "totalMinutes": { + "type": "number", + "format": "double", + "readOnly": true + }, + "totalSeconds": { + "type": "number", + "format": "double", + "readOnly": true + } + }, + "additionalProperties": false + } + } + } +} \ No newline at end of file diff --git a/test/OpenApiTests/ModelValidation/Fingerprint.cs b/test/OpenApiTests/ModelValidation/Fingerprint.cs new file mode 100644 index 0000000000..9a0dcbc595 --- /dev/null +++ b/test/OpenApiTests/ModelValidation/Fingerprint.cs @@ -0,0 +1,68 @@ +using System.ComponentModel.DataAnnotations; +using JetBrains.Annotations; +using JsonApiDotNetCore.Resources; +using JsonApiDotNetCore.Resources.Annotations; + +namespace OpenApiTests.ModelValidation; + +[UsedImplicitly(ImplicitUseTargetFlags.Members)] +[Resource(ControllerNamespace = "OpenApiTests.ModelValidation")] +public sealed class Fingerprint : Identifiable +{ + [Attr] + public string? FirstName { get; set; } + + [Attr] + [Required(ErrorMessage = "Last name is required")] + public string LastName { get; set; } = default!; + + [Attr] + [StringLength(18, MinimumLength = 3)] + [RegularExpression("^[a-zA-Z]+$", ErrorMessage = "Only letters are allowed")] + public string? UserName { get; set; } + + [Attr] + [CreditCard] + public string? CreditCard { get; set; } + + [Attr] + [EmailAddress] + public string? Email { get; set; } + + [Attr] + [Phone] + public string? Phone { get; set; } + + [Attr] + [Range(0, 123)] + public int? Age { get; set; } + + [Attr] +#if NET8_0_OR_GREATER + [Length(0, 10, ErrorMessage = "{0} length must be between {2} and {1}.")] +#endif + public List Tags { get; set; } = []; + + [Attr] + [Url] + public Uri? ProfilePicture { get; set; } + + [Attr] + [Range(typeof(TimeSpan), "01:00", "05:00")] + public TimeSpan? NextRevalidation { get; set; } + + [Attr] + public DateTime? ValidatedAt { get; set; } + + [Attr] + public DateOnly? ValidatedDateAt { get; set; } + + [Attr] + public TimeOnly? ValidatedTimeAt { get; set; } + + [Attr] +#if NET8_0_OR_GREATER + [Base64String] +#endif + public string? Signature { get; set; } +} diff --git a/test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs b/test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs new file mode 100644 index 0000000000..13351cfbe2 --- /dev/null +++ b/test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs @@ -0,0 +1,11 @@ +using JetBrains.Annotations; +using Microsoft.EntityFrameworkCore; +using TestBuildingBlocks; + +namespace OpenApiTests.ModelValidation; + +[UsedImplicitly(ImplicitUseTargetFlags.Members)] +public sealed class ModelValidationDbContext(DbContextOptions options) : TestableDbContext(options) +{ + public DbSet Fingerprints => Set(); +} diff --git a/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs b/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs new file mode 100644 index 0000000000..3b32dd6ce0 --- /dev/null +++ b/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs @@ -0,0 +1,31 @@ +using Bogus; +using JetBrains.Annotations; +using TestBuildingBlocks; + +// @formatter:wrap_chained_method_calls chop_if_long +// @formatter:wrap_before_first_method_call true + +namespace OpenApiTests.ModelValidation; + +[UsedImplicitly(ImplicitUseTargetFlags.Members)] +public sealed class ModelValidationFakers : FakerContainer +{ + private readonly Lazy> _lazyFingerprintFaker = new(() => new Faker() + .UseSeed(GetFakerSeed()) + .RuleFor(fingerprint => fingerprint.FirstName, faker => faker.Person.FirstName) + .RuleFor(fingerprint => fingerprint.LastName, faker => faker.Person.LastName) + .RuleFor(fingerprint => fingerprint.UserName, faker => faker.Random.String2(3, 18)) + .RuleFor(fingerprint => fingerprint.CreditCard, faker => faker.Finance.CreditCardNumber()) + .RuleFor(fingerprint => fingerprint.Email, faker => faker.Person.Email) + .RuleFor(fingerprint => fingerprint.Phone, faker => faker.Person.Phone) + .RuleFor(fingerprint => fingerprint.Age, faker => faker.Random.Number(0, 123)) + .RuleFor(fingerprint => fingerprint.Tags, faker => faker.Make(faker.Random.Number(0, 10), () => faker.Random.String2(3))) + .RuleFor(fingerprint => fingerprint.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) + .RuleFor(fingerprint => fingerprint.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) + .RuleFor(fingerprint => fingerprint.ValidatedAt, faker => faker.Date.Recent()) + .RuleFor(fingerprint => fingerprint.ValidatedDateAt, faker => DateOnly.FromDateTime(faker.Date.Recent())) + .RuleFor(fingerprint => fingerprint.ValidatedTimeAt, faker => TimeOnly.FromDateTime(faker.Date.Recent())) + .RuleFor(fingerprint => fingerprint.Signature, faker => Convert.ToBase64String(faker.Random.Bytes(10)))); + + public Faker Fingerprint => _lazyFingerprintFaker.Value; +} diff --git a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs new file mode 100644 index 0000000000..9129011e96 --- /dev/null +++ b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs @@ -0,0 +1,256 @@ +using System.Text.Json; +using TestBuildingBlocks; +using Xunit; + +namespace OpenApiTests.ModelValidation; + +public sealed class ModelValidationTests : IClassFixture, ModelValidationDbContext>> +{ + private readonly OpenApiTestContext, ModelValidationDbContext> _testContext; + + public ModelValidationTests(OpenApiTestContext, ModelValidationDbContext> testContext) + { + _testContext = testContext; + + testContext.UseController(); + + testContext.SwaggerDocumentOutputDirectory = "test/OpenApiEndToEndTests/ModelValidation"; + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task String(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.firstName").With(firstNameEl => + { + firstNameEl.Should().HaveProperty("type", "string"); + firstNameEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Non_nullable_string(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.lastName").With(lastNameEl => + { + lastNameEl.Should().HaveProperty("minLength", 1); + lastNameEl.Should().HaveProperty("type", "string"); + lastNameEl.Should().NotContainPath("nullable"); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task String_length_and_regex(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.userName").With(userNameEl => + { + userNameEl.Should().HaveProperty("maxLength", 18); + userNameEl.Should().HaveProperty("minLength", 3); + userNameEl.Should().HaveProperty("pattern", "^[a-zA-Z]+$"); + userNameEl.Should().HaveProperty("type", "string"); + userNameEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Credit_card(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.creditCard").With(creditCardEl => + { + creditCardEl.Should().HaveProperty("type", "string"); + creditCardEl.Should().HaveProperty("format", "credit-card"); + creditCardEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Email(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.email").With(emailEl => + { + emailEl.Should().HaveProperty("type", "string"); + emailEl.Should().HaveProperty("format", "email"); + emailEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Phone(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.phone").With(phoneEl => + { + phoneEl.Should().HaveProperty("type", "string"); + phoneEl.Should().HaveProperty("format", "tel"); + phoneEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Age(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.age").With(ageEl => + { + ageEl.Should().HaveProperty("maximum", 123); + ageEl.Should().HaveProperty("minimum", 0); + ageEl.Should().HaveProperty("type", "integer"); + ageEl.Should().HaveProperty("format", "int32"); + ageEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Tags(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.tags").With(tagsEl => + { + tagsEl.Should().HaveProperty("type", "array"); + tagsEl.Should().ContainPath("items").With(itemsEl => + { + itemsEl.Should().HaveProperty("type", "string"); + // TODO: no length constraint? + }); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Profile_picture(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.profilePicture").With(profilePictureEl => + { + profilePictureEl.Should().HaveProperty("type", "string"); + profilePictureEl.Should().HaveProperty("format", "uri"); + profilePictureEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Next_revalidation(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.nextRevalidation").With(nextRevalidationEl => + { + // TODO: TimeSpan format is an akward object with all the TimeSpan public properties. + nextRevalidationEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Validated_at(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAt").With(validatedAtEl => + { + validatedAtEl.Should().HaveProperty("type", "string"); + validatedAtEl.Should().HaveProperty("format", "date-time"); + validatedAtEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Validated_date_at(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedDateAt").With(validatedDateAtEl => + { + validatedDateAtEl.Should().HaveProperty("type", "string"); + validatedDateAtEl.Should().HaveProperty("format", "date"); + validatedDateAtEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Validated_time_at(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedTimeAt").With(validatedTimeAtEl => + { + validatedTimeAtEl.Should().HaveProperty("type", "string"); + validatedTimeAtEl.Should().HaveProperty("format", "time"); + validatedTimeAtEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Signature(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.signature").With(signatureEl => + { + signatureEl.Should().HaveProperty("type", "string"); + // TODO: no format? + signatureEl.Should().HaveProperty("nullable", true); + }); + } + + public static TheoryData ModelNames => + new() + { + "fingerprintAttributesInPatchRequest", + "fingerprintAttributesInPostRequest", + "fingerprintAttributesInResponse" + }; +} From 9dee70fc3b9e43e6682167612c9fd36e2c6d1a3c Mon Sep 17 00:00:00 2001 From: verdie-g Date: Thu, 11 Apr 2024 13:54:27 -0400 Subject: [PATCH 02/27] wip --- .../ModelValidation/ModelValidationTests.cs | 380 ++++++++++++++++++ .../OpenApiNSwagEndToEndTests.csproj | 7 + .../ModelValidation/Fingerprint.cs | 19 +- .../GeneratedSwagger}/swagger.g.json | 53 +-- .../ModelValidation/ModelValidationFakers.cs | 8 +- .../ModelValidation/ModelValidationTests.cs | 76 ++-- 6 files changed, 424 insertions(+), 119 deletions(-) create mode 100644 test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs rename test/{OpenApiEndToEndTests/ModelValidation => OpenApiTests/ModelValidation/GeneratedSwagger}/swagger.g.json (96%) diff --git a/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs new file mode 100644 index 0000000000..8689a687b8 --- /dev/null +++ b/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs @@ -0,0 +1,380 @@ +using FluentAssertions; +using FluentAssertions.Specialized; +using JsonApiDotNetCore.OpenApi.Client.NSwag; +using Newtonsoft.Json; +using OpenApiNSwagEndToEndTests.ModelValidation.GeneratedCode; +using OpenApiTests; +using OpenApiTests.ModelValidation; +using TestBuildingBlocks; +using Xunit; + +namespace OpenApiEndToEndTests.ModelValidation; + +public sealed class ModelValidationTests : IClassFixture, ModelValidationDbContext>> +{ + private readonly IntegrationTestContext, ModelValidationDbContext> _testContext; + private readonly ModelValidationFakers _fakers = new(); + + public ModelValidationTests(IntegrationTestContext, ModelValidationDbContext> testContext) + { + _testContext = testContext; + + testContext.UseController(); + } + + [Fact] + public async Task Omitting_a_required_attribute_should_return_an_error() + { + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + } + } + }); + + // Assert + ExceptionAssertions assertion = await action.Should().ThrowExactlyAsync(); + assertion.Which.Message.Should().Be("Cannot write a null value for property 'lastName'. Property requires a value. Path 'data.attributes'."); + } + + [Theory] + [InlineData("ab")] + [InlineData("abcdefghijklmnopqrs")] + public async Task imbadathis(string userName) + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + UserName = userName + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field UserName must be a string with a minimum length of 3 and a maximum length of 18."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); + } + + [Fact] + public async Task imbadathis2() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + UserName = "aB1" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("Only letters are allowed."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); + } + + [Fact] + public async Task imbadathis3() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + CreditCard = "123-456" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The CreditCard field is not a valid credit card number."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/creditCard"); + } + + [Fact] + public async Task imbadathis5() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + Email = "abc" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The Email field is not a valid e-mail address."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/email"); + } + + [Theory] + [InlineData(-1)] + [InlineData(124)] + public async Task imbadathis6(int age) + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + Age = age + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field Age must be between 0 and 123."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/age"); + } + + [Fact] + public async Task imbadathis7() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + ProfilePicture = new Uri("/justapath", UriKind.Relative) + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The ProfilePicture field is not a valid fully-qualified http, https, or ftp URL."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/profilePicture"); + } + + [Fact] + public async Task imbadathis8() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + NextRevalidation = new OpenApiNSwagEndToEndTests.ModelValidation.GeneratedCode.TimeSpan { TotalSeconds = 1 } + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be(""); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + } + + [Fact] + public async Task imbadathis10() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + ValidatedAt = DateTimeOffset.MinValue + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be(""); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/"); + } + + [Fact] + public async Task imbadathis11() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + ValidatedDateAt = DateTimeOffset.Now + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be(""); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/"); + } + + [Fact] + public async Task imbadathis9() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + var apiClient = new ModelValidationClient(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + ValidatedTimeAt = System.TimeSpan.FromSeconds(-1) + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be(""); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/"); + } +} diff --git a/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj b/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj index 18ea09354c..b31a7343a7 100644 --- a/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj +++ b/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj @@ -30,6 +30,13 @@ NSwagCSharp /ClientClassAccessModifier:internal /GenerateExceptionClasses:false /AdditionalNamespaceUsages:JsonApiDotNetCore.OpenApi.Client.NSwag /GenerateNullableReferenceTypes:true + + OpenApiNSwagEndToEndTests.ModelValidation.GeneratedCode + ModelValidationClient + ModelValidationClient.cs + NSwagCSharp + /ClientClassAccessModifier:internal /GenerateExceptionClasses:false /AdditionalNamespaceUsages:JsonApiDotNetCore.OpenApi.Client.NSwag /GenerateNullableReferenceTypes:true + OpenApiNSwagEndToEndTests.Headers.GeneratedCode HeadersClient diff --git a/test/OpenApiTests/ModelValidation/Fingerprint.cs b/test/OpenApiTests/ModelValidation/Fingerprint.cs index 9a0dcbc595..34657c2af7 100644 --- a/test/OpenApiTests/ModelValidation/Fingerprint.cs +++ b/test/OpenApiTests/ModelValidation/Fingerprint.cs @@ -1,24 +1,25 @@ using System.ComponentModel.DataAnnotations; using JetBrains.Annotations; +using JsonApiDotNetCore.Controllers; using JsonApiDotNetCore.Resources; using JsonApiDotNetCore.Resources.Annotations; namespace OpenApiTests.ModelValidation; [UsedImplicitly(ImplicitUseTargetFlags.Members)] -[Resource(ControllerNamespace = "OpenApiTests.ModelValidation")] +[Resource(ControllerNamespace = "OpenApiTests.ModelValidation", GenerateControllerEndpoints = JsonApiEndpoints.Post)] public sealed class Fingerprint : Identifiable { [Attr] public string? FirstName { get; set; } [Attr] - [Required(ErrorMessage = "Last name is required")] + [Required(ErrorMessage = "Last name is required.")] public string LastName { get; set; } = default!; [Attr] [StringLength(18, MinimumLength = 3)] - [RegularExpression("^[a-zA-Z]+$", ErrorMessage = "Only letters are allowed")] + [RegularExpression("^[a-zA-Z]+$", ErrorMessage = "Only letters are allowed.")] public string? UserName { get; set; } [Attr] @@ -37,12 +38,6 @@ public sealed class Fingerprint : Identifiable [Range(0, 123)] public int? Age { get; set; } - [Attr] -#if NET8_0_OR_GREATER - [Length(0, 10, ErrorMessage = "{0} length must be between {2} and {1}.")] -#endif - public List Tags { get; set; } = []; - [Attr] [Url] public Uri? ProfilePicture { get; set; } @@ -59,10 +54,4 @@ public sealed class Fingerprint : Identifiable [Attr] public TimeOnly? ValidatedTimeAt { get; set; } - - [Attr] -#if NET8_0_OR_GREATER - [Base64String] -#endif - public string? Signature { get; set; } } diff --git a/test/OpenApiEndToEndTests/ModelValidation/swagger.g.json b/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json similarity index 96% rename from test/OpenApiEndToEndTests/ModelValidation/swagger.g.json rename to test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json index a32512b6d7..909c5cca4f 100644 --- a/test/OpenApiEndToEndTests/ModelValidation/swagger.g.json +++ b/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json @@ -722,12 +722,6 @@ "format": "int32", "nullable": true }, - "tags": { - "type": "array", - "items": { - "type": "string" - } - }, "profilePicture": { "type": "string", "format": "uri", @@ -755,18 +749,13 @@ "type": "string", "format": "time", "nullable": true - }, - "signature": { - "type": "string", - "nullable": true } }, "additionalProperties": false }, "fingerprintAttributesInPostRequest": { "required": [ - "lastName", - "tags" + "lastName" ], "type": "object", "properties": { @@ -807,12 +796,6 @@ "format": "int32", "nullable": true }, - "tags": { - "type": "array", - "items": { - "type": "string" - } - }, "profilePicture": { "type": "string", "format": "uri", @@ -840,10 +823,6 @@ "type": "string", "format": "time", "nullable": true - }, - "signature": { - "type": "string", - "nullable": true } }, "additionalProperties": false @@ -888,12 +867,6 @@ "format": "int32", "nullable": true }, - "tags": { - "type": "array", - "items": { - "type": "string" - } - }, "profilePicture": { "type": "string", "format": "uri", @@ -921,10 +894,6 @@ "type": "string", "format": "time", "nullable": true - }, - "signature": { - "type": "string", - "nullable": true } }, "additionalProperties": false @@ -1201,16 +1170,6 @@ "format": "int32", "readOnly": true }, - "microseconds": { - "type": "integer", - "format": "int32", - "readOnly": true - }, - "nanoseconds": { - "type": "integer", - "format": "int32", - "readOnly": true - }, "minutes": { "type": "integer", "format": "int32", @@ -1236,16 +1195,6 @@ "format": "double", "readOnly": true }, - "totalMicroseconds": { - "type": "number", - "format": "double", - "readOnly": true - }, - "totalNanoseconds": { - "type": "number", - "format": "double", - "readOnly": true - }, "totalMinutes": { "type": "number", "format": "double", diff --git a/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs b/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs index 3b32dd6ce0..ad31218e2f 100644 --- a/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs +++ b/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs @@ -8,10 +8,10 @@ namespace OpenApiTests.ModelValidation; [UsedImplicitly(ImplicitUseTargetFlags.Members)] -public sealed class ModelValidationFakers : FakerContainer +public sealed class ModelValidationFakers { private readonly Lazy> _lazyFingerprintFaker = new(() => new Faker() - .UseSeed(GetFakerSeed()) + .MakeDeterministic() .RuleFor(fingerprint => fingerprint.FirstName, faker => faker.Person.FirstName) .RuleFor(fingerprint => fingerprint.LastName, faker => faker.Person.LastName) .RuleFor(fingerprint => fingerprint.UserName, faker => faker.Random.String2(3, 18)) @@ -19,13 +19,11 @@ public sealed class ModelValidationFakers : FakerContainer .RuleFor(fingerprint => fingerprint.Email, faker => faker.Person.Email) .RuleFor(fingerprint => fingerprint.Phone, faker => faker.Person.Phone) .RuleFor(fingerprint => fingerprint.Age, faker => faker.Random.Number(0, 123)) - .RuleFor(fingerprint => fingerprint.Tags, faker => faker.Make(faker.Random.Number(0, 10), () => faker.Random.String2(3))) .RuleFor(fingerprint => fingerprint.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) .RuleFor(fingerprint => fingerprint.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) .RuleFor(fingerprint => fingerprint.ValidatedAt, faker => faker.Date.Recent()) .RuleFor(fingerprint => fingerprint.ValidatedDateAt, faker => DateOnly.FromDateTime(faker.Date.Recent())) - .RuleFor(fingerprint => fingerprint.ValidatedTimeAt, faker => TimeOnly.FromDateTime(faker.Date.Recent())) - .RuleFor(fingerprint => fingerprint.Signature, faker => Convert.ToBase64String(faker.Random.Bytes(10)))); + .RuleFor(fingerprint => fingerprint.ValidatedTimeAt, faker => TimeOnly.FromDateTime(faker.Date.Recent()))); public Faker Fingerprint => _lazyFingerprintFaker.Value; } diff --git a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs index 9129011e96..c96842515c 100644 --- a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs +++ b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs @@ -19,7 +19,7 @@ public ModelValidationTests(OpenApiTestContext + { userNameEl.Should().HaveProperty("pattern", "^[a-zA-Z]+$"); userNameEl.Should().HaveProperty("type", "string"); userNameEl.Should().HaveProperty("nullable", true); @@ -68,7 +83,7 @@ public async Task String_length_and_regex(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Credit_card(string modelName) + public async Task CreditCard_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -84,7 +99,7 @@ public async Task Credit_card(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Email(string modelName) + public async Task Email_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -100,7 +115,7 @@ public async Task Email(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Phone(string modelName) + public async Task Phone_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -116,7 +131,7 @@ public async Task Phone(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Age(string modelName) + public async Task Range_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -125,7 +140,9 @@ public async Task Age(string modelName) document.Should().ContainPath($"components.schemas.{modelName}.properties.age").With(ageEl => { ageEl.Should().HaveProperty("maximum", 123); + ageEl.Should().NotContainPath("exclusiveMaximum"); ageEl.Should().HaveProperty("minimum", 0); + ageEl.Should().NotContainPath("exclusiveMinimum"); ageEl.Should().HaveProperty("type", "integer"); ageEl.Should().HaveProperty("format", "int32"); ageEl.Should().HaveProperty("nullable", true); @@ -134,26 +151,7 @@ public async Task Age(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Tags(string modelName) - { - // Act - JsonElement document = await _testContext.GetSwaggerDocumentAsync(); - - // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.tags").With(tagsEl => - { - tagsEl.Should().HaveProperty("type", "array"); - tagsEl.Should().ContainPath("items").With(itemsEl => - { - itemsEl.Should().HaveProperty("type", "string"); - // TODO: no length constraint? - }); - }); - } - - [Theory] - [MemberData(nameof(ModelNames))] - public async Task Profile_picture(string modelName) + public async Task Url_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -169,7 +167,7 @@ public async Task Profile_picture(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Next_revalidation(string modelName) + public async Task TimeSpan_range_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -184,7 +182,7 @@ public async Task Next_revalidation(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Validated_at(string modelName) + public async Task DateTime_type_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -200,7 +198,7 @@ public async Task Validated_at(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Validated_date_at(string modelName) + public async Task DateOnly_type_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -216,7 +214,7 @@ public async Task Validated_date_at(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Validated_time_at(string modelName) + public async Task TimeOnly_type_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -230,22 +228,6 @@ public async Task Validated_time_at(string modelName) }); } - [Theory] - [MemberData(nameof(ModelNames))] - public async Task Signature(string modelName) - { - // Act - JsonElement document = await _testContext.GetSwaggerDocumentAsync(); - - // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.signature").With(signatureEl => - { - signatureEl.Should().HaveProperty("type", "string"); - // TODO: no format? - signatureEl.Should().HaveProperty("nullable", true); - }); - } - public static TheoryData ModelNames => new() { From 07c9d7dfd96f784a734282221ba6051785430ca4 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Mon, 27 May 2024 17:20:25 -0400 Subject: [PATCH 03/27] Improve NSwag tests --- .../ModelValidation/ModelValidationTests.cs | 126 ++- .../ModelValidation/Fingerprint.cs | 7 +- .../GeneratedSwagger/swagger.g.json | 760 ++---------------- .../ModelValidation/ModelValidationFakers.cs | 1 + .../ModelValidation/ModelValidationTests.cs | 20 +- 5 files changed, 176 insertions(+), 738 deletions(-) diff --git a/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs index 8689a687b8..03f378e026 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs @@ -8,7 +8,7 @@ using TestBuildingBlocks; using Xunit; -namespace OpenApiEndToEndTests.ModelValidation; +namespace OpenApiNSwagEndToEndTests.ModelValidation; public sealed class ModelValidationTests : IClassFixture, ModelValidationDbContext>> { @@ -26,7 +26,7 @@ public ModelValidationTests(IntegrationTestContext> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -47,13 +47,13 @@ public async Task Omitting_a_required_attribute_should_return_an_error() [Theory] [InlineData("ab")] [InlineData("abcdefghijklmnopqrs")] - public async Task imbadathis(string userName) + public async Task Not_fitting_the_length_constraint_should_return_an_error(string userName) { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -80,13 +80,13 @@ public async Task imbadathis(string userName) } [Fact] - public async Task imbadathis2() + public async Task Not_matching_a_regex_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -113,13 +113,13 @@ public async Task imbadathis2() } [Fact] - public async Task imbadathis3() + public async Task Invalid_credit_card_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -146,13 +146,13 @@ public async Task imbadathis3() } [Fact] - public async Task imbadathis5() + public async Task Invalid_email_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -181,13 +181,13 @@ public async Task imbadathis5() [Theory] [InlineData(-1)] [InlineData(124)] - public async Task imbadathis6(int age) + public async Task Out_of_range_integer_should_return_an_error(int age) { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -214,13 +214,13 @@ public async Task imbadathis6(int age) } [Fact] - public async Task imbadathis7() + public async Task Invalid_url_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -247,13 +247,13 @@ public async Task imbadathis7() } [Fact] - public async Task imbadathis8() + public async Task Invalid_url_as_string_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -263,7 +263,7 @@ public async Task imbadathis8() Attributes = new FingerprintAttributesInPostRequest { LastName = fingerprint.LastName, - NextRevalidation = new OpenApiNSwagEndToEndTests.ModelValidation.GeneratedCode.TimeSpan { TotalSeconds = 1 } + BackgroundPicture = new Uri("/justapath", UriKind.Relative) } } }); @@ -274,19 +274,52 @@ public async Task imbadathis8() ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be(""); + errorObject.Detail.Should().Be("The BackgroundPicture field is not a valid fully-qualified http, https, or ftp URL."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/backgroundPicture"); + } + + [Fact] + public async Task Out_of_range_timespan_should_return_an_error() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + ModelValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + LastName = fingerprint.LastName, + NextRevalidation = "00:00:01", + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field NextRevalidation must be between 01:00:00 and 05:00:00."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); } [Fact] - public async Task imbadathis10() + public async Task Invalid_datetime_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -313,13 +346,13 @@ public async Task imbadathis10() } [Fact] - public async Task imbadathis11() + public async Task Invalid_date_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -346,13 +379,13 @@ public async Task imbadathis11() } [Fact] - public async Task imbadathis9() + public async Task Invalid_time_only_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); using HttpClient httpClient = _testContext.Factory.CreateClient(); - var apiClient = new ModelValidationClient(httpClient); + ModelValidationClient apiClient = new(httpClient); // Act Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument @@ -362,7 +395,7 @@ public async Task imbadathis9() Attributes = new FingerprintAttributesInPostRequest { LastName = fingerprint.LastName, - ValidatedTimeAt = System.TimeSpan.FromSeconds(-1) + ValidatedTimeAt = TimeSpan.FromSeconds(-1) } } }); @@ -372,9 +405,46 @@ public async Task imbadathis9() document.Errors.ShouldHaveCount(1); ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be(""); + errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); + errorObject.Detail.Should().Be("Failed to convert attribute 'validatedTimeAt' with value '-00:00:01' of type 'String' to type 'Nullable'."); errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/"); + errorObject.Source.Pointer.Should().Be("/data/attributes/validatedTimeAt"); + } + + [Fact] + public async Task Fitting_all_the_constraints_should_work() + { + // Arrange + Fingerprint fingerprint = _fakers.Fingerprint.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateClient(); + ModelValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument + { + Data = new FingerprintDataInPostRequest + { + Attributes = new FingerprintAttributesInPostRequest + { + FirstName = fingerprint.FirstName, + LastName = fingerprint.LastName, + UserName = fingerprint.UserName, + CreditCard = fingerprint.CreditCard, + Email = fingerprint.Email, + Phone = fingerprint.Phone, + Age = fingerprint.Age, + ProfilePicture = fingerprint.ProfilePicture, + BackgroundPicture = new Uri(fingerprint.BackgroundPicture!), + NextRevalidation = "02:00:00", + ValidatedAt = fingerprint.ValidatedAt!.Value.ToUniversalTime(), + // TODO: ValidatedDateAt = new DateTimeOffset(fingerprint.ValidatedDateAt!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), + ValidatedTimeAt = fingerprint.ValidatedTimeAt!.Value.ToTimeSpan() + } + } + }); + + // Assert + await action.Should().NotThrowAsync(); } } diff --git a/test/OpenApiTests/ModelValidation/Fingerprint.cs b/test/OpenApiTests/ModelValidation/Fingerprint.cs index 34657c2af7..6177830c89 100644 --- a/test/OpenApiTests/ModelValidation/Fingerprint.cs +++ b/test/OpenApiTests/ModelValidation/Fingerprint.cs @@ -7,7 +7,7 @@ namespace OpenApiTests.ModelValidation; [UsedImplicitly(ImplicitUseTargetFlags.Members)] -[Resource(ControllerNamespace = "OpenApiTests.ModelValidation", GenerateControllerEndpoints = JsonApiEndpoints.Post)] +[Resource(ControllerNamespace = "OpenApiTests.ModelValidation", GenerateControllerEndpoints = JsonApiEndpoints.Post | JsonApiEndpoints.Patch)] public sealed class Fingerprint : Identifiable { [Attr] @@ -39,9 +39,12 @@ public sealed class Fingerprint : Identifiable public int? Age { get; set; } [Attr] - [Url] public Uri? ProfilePicture { get; set; } + [Attr] + [Url] + public string? BackgroundPicture { get; set; } + [Attr] [Range(typeof(TimeSpan), "01:00", "05:00")] public TimeSpan? NextRevalidation { get; set; } diff --git a/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json index 909c5cca4f..7d10597451 100644 --- a/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json @@ -11,147 +11,6 @@ ], "paths": { "/fingerprints": { - "get": { - "tags": [ - "fingerprints" - ], - "summary": "Retrieves a collection of fingerprints.", - "operationId": "getFingerprintCollection", - "parameters": [ - { - "name": "query", - "in": "query", - "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", - "schema": { - "type": "object", - "additionalProperties": { - "type": "string", - "nullable": true - }, - "example": "" - } - }, - { - "name": "If-None-Match", - "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", - "schema": { - "type": "string" - } - } - ], - "responses": { - "200": { - "description": "Successfully returns the found fingerprints, or an empty array if none were found.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - } - }, - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/fingerprintCollectionResponseDocument" - } - } - } - }, - "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - } - } - }, - "400": { - "description": "The query string is invalid.", - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/errorResponseDocument" - } - } - } - } - } - }, - "head": { - "tags": [ - "fingerprints" - ], - "summary": "Retrieves a collection of fingerprints without returning them.", - "description": "Compare the returned ETag HTTP header with an earlier one to determine if the response has changed since it was fetched.", - "operationId": "headFingerprintCollection", - "parameters": [ - { - "name": "query", - "in": "query", - "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", - "schema": { - "type": "object", - "additionalProperties": { - "type": "string", - "nullable": true - }, - "example": "" - } - }, - { - "name": "If-None-Match", - "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", - "schema": { - "type": "string" - } - } - ], - "responses": { - "200": { - "description": "The operation completed successfully.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - }, - "Content-Length": { - "description": "Size of the HTTP response body, in bytes.", - "required": true, - "schema": { - "type": "integer", - "format": "int64" - } - } - } - }, - "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - } - } - }, - "400": { - "description": "The query string is invalid." - } - } - }, "post": { "tags": [ "fingerprints" @@ -185,7 +44,8 @@ ] } } - } + }, + "required": true }, "responses": { "201": { @@ -194,286 +54,12 @@ "Location": { "description": "The URL at which the newly created fingerprint can be retrieved.", "required": true, - "schema": { - "type": "string", - "format": "uri" - } - } - }, - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" - } - } - } - }, - "204": { - "description": "The fingerprint was successfully created, which did not result in additional changes." - }, - "400": { - "description": "The query string is invalid or the request body is missing or malformed.", - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/errorResponseDocument" - } - } - } - }, - "403": { - "description": "Client-generated IDs cannot be used at this endpoint.", - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/errorResponseDocument" - } - } - } - }, - "409": { - "description": "A resource type in the request body is incompatible.", - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/errorResponseDocument" - } - } - } - }, - "422": { - "description": "Validation of the request body failed.", - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/errorResponseDocument" - } - } - } - } - } - } - }, - "/fingerprints/{id}": { - "get": { - "tags": [ - "fingerprints" - ], - "summary": "Retrieves an individual fingerprint by its identifier.", - "operationId": "getFingerprint", - "parameters": [ - { - "name": "id", - "in": "path", - "description": "The identifier of the fingerprint to retrieve.", - "required": true, - "schema": { - "type": "string" - } - }, - { - "name": "query", - "in": "query", - "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", - "schema": { - "type": "object", - "additionalProperties": { - "type": "string", - "nullable": true - }, - "example": "" - } - }, - { - "name": "If-None-Match", - "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", - "schema": { - "type": "string" - } - } - ], - "responses": { - "200": { - "description": "Successfully returns the found fingerprint.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - } - }, - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" - } - } - } - }, - "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - } - } - }, - "400": { - "description": "The query string is invalid.", - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/errorResponseDocument" - } - } - } - }, - "404": { - "description": "The fingerprint does not exist.", - "content": { - "application/vnd.api+json": { - "schema": { - "$ref": "#/components/schemas/errorResponseDocument" - } - } - } - } - } - }, - "head": { - "tags": [ - "fingerprints" - ], - "summary": "Retrieves an individual fingerprint by its identifier without returning it.", - "description": "Compare the returned ETag HTTP header with an earlier one to determine if the response has changed since it was fetched.", - "operationId": "headFingerprint", - "parameters": [ - { - "name": "id", - "in": "path", - "description": "The identifier of the fingerprint to retrieve.", - "required": true, - "schema": { - "type": "string" - } - }, - { - "name": "query", - "in": "query", - "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", - "schema": { - "type": "object", - "additionalProperties": { - "type": "string", - "nullable": true - }, - "example": "" - } - }, - { - "name": "If-None-Match", - "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", - "schema": { - "type": "string" - } - } - ], - "responses": { - "200": { - "description": "The operation completed successfully.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - }, - "Content-Length": { - "description": "Size of the HTTP response body, in bytes.", - "required": true, - "schema": { - "type": "integer", - "format": "int64" - } - } - } - }, - "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", - "headers": { - "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", - "required": true, - "schema": { - "type": "string" - } - } - } - }, - "400": { - "description": "The query string is invalid." - }, - "404": { - "description": "The fingerprint does not exist." - } - } - }, - "patch": { - "tags": [ - "fingerprints" - ], - "summary": "Updates an existing fingerprint.", - "operationId": "patchFingerprint", - "parameters": [ - { - "name": "id", - "in": "path", - "description": "The identifier of the fingerprint to update.", - "required": true, - "schema": { - "type": "string" - } - }, - { - "name": "query", - "in": "query", - "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", - "schema": { - "type": "object", - "additionalProperties": { - "type": "string", - "nullable": true - }, - "example": "" - } - } - ], - "requestBody": { - "description": "The attributes and relationships of the fingerprint to update. Omitted fields are left unchanged.", - "content": { - "application/vnd.api+json": { - "schema": { - "allOf": [ - { - "$ref": "#/components/schemas/fingerprintPatchRequestDocument" - } - ] + "schema": { + "type": "string", + "format": "uri" + } } - } - } - }, - "responses": { - "200": { - "description": "The fingerprint was successfully updated, which resulted in additional changes. The updated fingerprint is returned.", + }, "content": { "application/vnd.api+json": { "schema": { @@ -483,7 +69,7 @@ } }, "204": { - "description": "The fingerprint was successfully updated, which did not result in additional changes." + "description": "The fingerprint was successfully created, which did not result in additional changes." }, "400": { "description": "The query string is invalid or the request body is missing or malformed.", @@ -495,8 +81,8 @@ } } }, - "404": { - "description": "The fingerprint or a related resource does not exist.", + "403": { + "description": "Client-generated IDs cannot be used at this endpoint.", "content": { "application/vnd.api+json": { "schema": { @@ -505,8 +91,8 @@ } } }, - "409": { - "description": "A resource type or identifier in the request body is incompatible.", + "404": { + "description": "A related resource does not exist.", "content": { "application/vnd.api+json": { "schema": { @@ -515,8 +101,8 @@ } } }, - "422": { - "description": "Validation of the request body failed.", + "409": { + "description": "The request body contains conflicting information or another resource with the same ID already exists.", "content": { "application/vnd.api+json": { "schema": { @@ -524,32 +110,9 @@ } } } - } - } - }, - "delete": { - "tags": [ - "fingerprints" - ], - "summary": "Deletes an existing fingerprint by its identifier.", - "operationId": "deleteFingerprint", - "parameters": [ - { - "name": "id", - "in": "path", - "description": "The identifier of the fingerprint to delete.", - "required": true, - "schema": { - "type": "string" - } - } - ], - "responses": { - "204": { - "description": "The fingerprint was successfully deleted." }, - "404": { - "description": "The fingerprint does not exist.", + "422": { + "description": "Validation of the request body failed.", "content": { "application/vnd.api+json": { "schema": { @@ -651,15 +214,30 @@ }, "errorResponseDocument": { "required": [ - "errors" + "errors", + "links" ], "type": "object", "properties": { + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/errorTopLevelLinks" + } + ] + }, "errors": { "type": "array", "items": { "$ref": "#/components/schemas/errorObject" } + }, + "meta": { + "type": "object", + "additionalProperties": { + "type": "object", + "nullable": true + } } }, "additionalProperties": false @@ -682,73 +260,14 @@ }, "additionalProperties": false }, - "fingerprintAttributesInPatchRequest": { + "errorTopLevelLinks": { "type": "object", "properties": { - "firstName": { - "type": "string", - "nullable": true - }, - "lastName": { - "minLength": 1, + "self": { "type": "string" }, - "userName": { - "maxLength": 18, - "minLength": 3, - "pattern": "^[a-zA-Z]+$", - "type": "string", - "nullable": true - }, - "creditCard": { - "type": "string", - "format": "credit-card", - "nullable": true - }, - "email": { - "type": "string", - "format": "email", - "nullable": true - }, - "phone": { - "type": "string", - "format": "tel", - "nullable": true - }, - "age": { - "maximum": 123, - "minimum": 0, - "type": "integer", - "format": "int32", - "nullable": true - }, - "profilePicture": { - "type": "string", - "format": "uri", - "nullable": true - }, - "nextRevalidation": { - "allOf": [ - { - "$ref": "#/components/schemas/timeSpan" - } - ], - "nullable": true - }, - "validatedAt": { - "type": "string", - "format": "date-time", - "nullable": true - }, - "validatedDateAt": { - "type": "string", - "format": "date", - "nullable": true - }, - "validatedTimeAt": { - "type": "string", - "format": "time", - "nullable": true + "describedby": { + "type": "string" } }, "additionalProperties": false @@ -801,12 +320,14 @@ "format": "uri", "nullable": true }, + "backgroundPicture": { + "type": "string", + "format": "uri", + "nullable": true + }, "nextRevalidation": { - "allOf": [ - { - "$ref": "#/components/schemas/timeSpan" - } - ], + "type": "string", + "format": "date-span", "nullable": true }, "validatedAt": { @@ -872,12 +393,14 @@ "format": "uri", "nullable": true }, + "backgroundPicture": { + "type": "string", + "format": "uri", + "nullable": true + }, "nextRevalidation": { - "allOf": [ - { - "$ref": "#/components/schemas/timeSpan" - } - ], + "type": "string", + "format": "date-span", "nullable": true }, "validatedAt": { @@ -898,66 +421,6 @@ }, "additionalProperties": false }, - "fingerprintCollectionResponseDocument": { - "required": [ - "data", - "links" - ], - "type": "object", - "properties": { - "links": { - "allOf": [ - { - "$ref": "#/components/schemas/linksInResourceCollectionDocument" - } - ] - }, - "data": { - "type": "array", - "items": { - "$ref": "#/components/schemas/fingerprintDataInResponse" - } - }, - "included": { - "type": "array", - "items": { - "$ref": "#/components/schemas/dataInResponse" - } - }, - "meta": { - "type": "object", - "additionalProperties": { - "type": "object", - "nullable": true - } - } - }, - "additionalProperties": false - }, - "fingerprintDataInPatchRequest": { - "required": [ - "id", - "type" - ], - "type": "object", - "properties": { - "type": { - "$ref": "#/components/schemas/fingerprintResourceType" - }, - "id": { - "minLength": 1, - "type": "string" - }, - "attributes": { - "allOf": [ - { - "$ref": "#/components/schemas/fingerprintAttributesInPatchRequest" - } - ] - } - }, - "additionalProperties": false - }, "fingerprintDataInPostRequest": { "required": [ "type" @@ -983,9 +446,6 @@ "$ref": "#/components/schemas/dataInResponse" }, { - "required": [ - "links" - ], "type": "object", "properties": { "attributes": { @@ -998,7 +458,7 @@ "links": { "allOf": [ { - "$ref": "#/components/schemas/linksInResourceData" + "$ref": "#/components/schemas/resourceLinks" } ] }, @@ -1015,22 +475,6 @@ ], "additionalProperties": false }, - "fingerprintPatchRequestDocument": { - "required": [ - "data" - ], - "type": "object", - "properties": { - "data": { - "allOf": [ - { - "$ref": "#/components/schemas/fingerprintDataInPatchRequest" - } - ] - } - }, - "additionalProperties": false - }, "fingerprintPostRequestDocument": { "required": [ "data" @@ -1057,7 +501,7 @@ "links": { "allOf": [ { - "$ref": "#/components/schemas/linksInResourceDocument" + "$ref": "#/components/schemas/resourceTopLevelLinks" } ] }, @@ -1091,55 +535,19 @@ "type": "string", "additionalProperties": false }, - "linksInResourceCollectionDocument": { - "required": [ - "self" - ], - "type": "object", - "properties": { - "self": { - "minLength": 1, - "type": "string" - }, - "describedby": { - "type": "string" - }, - "first": { - "type": "string" - }, - "last": { - "type": "string" - }, - "prev": { - "type": "string" - }, - "next": { - "type": "string" - } - }, - "additionalProperties": false - }, - "linksInResourceData": { - "required": [ - "self" - ], + "resourceLinks": { "type": "object", "properties": { "self": { - "minLength": 1, "type": "string" } }, "additionalProperties": false }, - "linksInResourceDocument": { - "required": [ - "self" - ], + "resourceTopLevelLinks": { "type": "object", "properties": { "self": { - "minLength": 1, "type": "string" }, "describedby": { @@ -1147,66 +555,6 @@ } }, "additionalProperties": false - }, - "timeSpan": { - "type": "object", - "properties": { - "ticks": { - "type": "integer", - "format": "int64" - }, - "days": { - "type": "integer", - "format": "int32", - "readOnly": true - }, - "hours": { - "type": "integer", - "format": "int32", - "readOnly": true - }, - "milliseconds": { - "type": "integer", - "format": "int32", - "readOnly": true - }, - "minutes": { - "type": "integer", - "format": "int32", - "readOnly": true - }, - "seconds": { - "type": "integer", - "format": "int32", - "readOnly": true - }, - "totalDays": { - "type": "number", - "format": "double", - "readOnly": true - }, - "totalHours": { - "type": "number", - "format": "double", - "readOnly": true - }, - "totalMilliseconds": { - "type": "number", - "format": "double", - "readOnly": true - }, - "totalMinutes": { - "type": "number", - "format": "double", - "readOnly": true - }, - "totalSeconds": { - "type": "number", - "format": "double", - "readOnly": true - } - }, - "additionalProperties": false } } } diff --git a/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs b/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs index ad31218e2f..59882a52a8 100644 --- a/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs +++ b/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs @@ -20,6 +20,7 @@ public sealed class ModelValidationFakers .RuleFor(fingerprint => fingerprint.Phone, faker => faker.Person.Phone) .RuleFor(fingerprint => fingerprint.Age, faker => faker.Random.Number(0, 123)) .RuleFor(fingerprint => fingerprint.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) + .RuleFor(fingerprint => fingerprint.BackgroundPicture, faker => faker.Image.LoremFlickrUrl()) .RuleFor(fingerprint => fingerprint.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) .RuleFor(fingerprint => fingerprint.ValidatedAt, faker => faker.Date.Recent()) .RuleFor(fingerprint => fingerprint.ValidatedDateAt, faker => DateOnly.FromDateTime(faker.Date.Recent())) diff --git a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs index c96842515c..90ee1c3d62 100644 --- a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs +++ b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs @@ -14,7 +14,7 @@ public ModelValidationTests(OpenApiTestContext(); - testContext.SwaggerDocumentOutputDirectory = "test/OpenApiEndToEndTests/ModelValidation"; + testContext.SwaggerDocumentOutputDirectory = $"{GetType().Namespace!.Replace('.', '/')}/GeneratedSwagger"; } [Theory] @@ -165,6 +165,22 @@ public async Task Url_annotation_on_resource_property_produces_expected_schema(s }); } + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Uri_type_on_resource_property_produces_expected_schema(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.backgroundPicture").With(backgroundPictureEl => + { + backgroundPictureEl.Should().HaveProperty("type", "string"); + backgroundPictureEl.Should().HaveProperty("format", "uri"); + backgroundPictureEl.Should().HaveProperty("nullable", true); + }); + } + [Theory] [MemberData(nameof(ModelNames))] public async Task TimeSpan_range_annotation_on_resource_property_produces_expected_schema(string modelName) @@ -231,8 +247,8 @@ public async Task TimeOnly_type_produces_expected_schema(string modelName) public static TheoryData ModelNames => new() { - "fingerprintAttributesInPatchRequest", "fingerprintAttributesInPostRequest", + "fingerprintAttributesInPatchRequest", "fingerprintAttributesInResponse" }; } From 43bae110e1d42bf396d9bab00a4eb79d88207ee1 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Mon, 27 May 2024 17:57:55 -0400 Subject: [PATCH 04/27] Fix some warnings --- .../ModelValidation/ModelValidationTests.cs | 6 +- .../GeneratedSwagger/swagger.g.json | 216 ++++++++++++++++++ .../ModelValidation/ModelValidationTests.cs | 3 +- 3 files changed, 221 insertions(+), 4 deletions(-) diff --git a/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs index 03f378e026..02c2fe5664 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs @@ -214,7 +214,7 @@ public async Task Out_of_range_integer_should_return_an_error(int age) } [Fact] - public async Task Invalid_url_should_return_an_error() + public async Task Invalid_uri_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); @@ -247,7 +247,7 @@ public async Task Invalid_url_should_return_an_error() } [Fact] - public async Task Invalid_url_as_string_should_return_an_error() + public async Task Invalid_url_should_return_an_error() { // Arrange Fingerprint fingerprint = _fakers.Fingerprint.Generate(); @@ -438,7 +438,7 @@ public async Task Fitting_all_the_constraints_should_work() BackgroundPicture = new Uri(fingerprint.BackgroundPicture!), NextRevalidation = "02:00:00", ValidatedAt = fingerprint.ValidatedAt!.Value.ToUniversalTime(), - // TODO: ValidatedDateAt = new DateTimeOffset(fingerprint.ValidatedDateAt!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), + ValidatedDateAt = new DateTimeOffset(fingerprint.ValidatedDateAt!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), ValidatedTimeAt = fingerprint.ValidatedTimeAt!.Value.ToTimeSpan() } } diff --git a/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json index 7d10597451..37505cd221 100644 --- a/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json @@ -123,6 +123,109 @@ } } } + }, + "/fingerprints/{id}": { + "patch": { + "tags": [ + "fingerprints" + ], + "summary": "Updates an existing fingerprint.", + "operationId": "patchFingerprint", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "The identifier of the fingerprint to update.", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + } + ], + "requestBody": { + "description": "The attributes and relationships of the fingerprint to update. Omitted fields are left unchanged.", + "content": { + "application/vnd.api+json": { + "schema": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintPatchRequestDocument" + } + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "The fingerprint was successfully updated, which resulted in additional changes. The updated fingerprint is returned.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" + } + } + } + }, + "204": { + "description": "The fingerprint was successfully updated, which did not result in additional changes." + }, + "400": { + "description": "The query string is invalid or the request body is missing or malformed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "404": { + "description": "The fingerprint or a related resource does not exist.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "409": { + "description": "A resource type or identifier in the request body is incompatible.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "422": { + "description": "Validation of the request body failed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + } } }, "components": { @@ -272,6 +375,79 @@ }, "additionalProperties": false }, + "fingerprintAttributesInPatchRequest": { + "type": "object", + "properties": { + "firstName": { + "type": "string", + "nullable": true + }, + "lastName": { + "minLength": 1, + "type": "string" + }, + "userName": { + "maxLength": 18, + "minLength": 3, + "pattern": "^[a-zA-Z]+$", + "type": "string", + "nullable": true + }, + "creditCard": { + "type": "string", + "format": "credit-card", + "nullable": true + }, + "email": { + "type": "string", + "format": "email", + "nullable": true + }, + "phone": { + "type": "string", + "format": "tel", + "nullable": true + }, + "age": { + "maximum": 123, + "minimum": 0, + "type": "integer", + "format": "int32", + "nullable": true + }, + "profilePicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "backgroundPicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "nextRevalidation": { + "type": "string", + "format": "date-span", + "nullable": true + }, + "validatedAt": { + "type": "string", + "format": "date-time", + "nullable": true + }, + "validatedDateAt": { + "type": "string", + "format": "date", + "nullable": true + }, + "validatedTimeAt": { + "type": "string", + "format": "time", + "nullable": true + } + }, + "additionalProperties": false + }, "fingerprintAttributesInPostRequest": { "required": [ "lastName" @@ -421,6 +597,30 @@ }, "additionalProperties": false }, + "fingerprintDataInPatchRequest": { + "required": [ + "id", + "type" + ], + "type": "object", + "properties": { + "type": { + "$ref": "#/components/schemas/fingerprintResourceType" + }, + "id": { + "minLength": 1, + "type": "string" + }, + "attributes": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintAttributesInPatchRequest" + } + ] + } + }, + "additionalProperties": false + }, "fingerprintDataInPostRequest": { "required": [ "type" @@ -475,6 +675,22 @@ ], "additionalProperties": false }, + "fingerprintPatchRequestDocument": { + "required": [ + "data" + ], + "type": "object", + "properties": { + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/fingerprintDataInPatchRequest" + } + ] + } + }, + "additionalProperties": false + }, "fingerprintPostRequestDocument": { "required": [ "data" diff --git a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs index 90ee1c3d62..ed7b995324 100644 --- a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs +++ b/test/OpenApiTests/ModelValidation/ModelValidationTests.cs @@ -191,7 +191,8 @@ public async Task TimeSpan_range_annotation_on_resource_property_produces_expect // Assert document.Should().ContainPath($"components.schemas.{modelName}.properties.nextRevalidation").With(nextRevalidationEl => { - // TODO: TimeSpan format is an akward object with all the TimeSpan public properties. + nextRevalidationEl.Should().HaveProperty("type", "string"); + nextRevalidationEl.Should().HaveProperty("format", "date-span"); nextRevalidationEl.Should().HaveProperty("nullable", true); }); } From 0812983ae25ee9f17ecf77dac8ac213e556b4b87 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Tue, 28 May 2024 21:03:50 -0400 Subject: [PATCH 05/27] Address some comments --- .../ModelStateValidationTests.cs | 358 ++++++++++++++ .../ModelValidation/ModelValidationTests.cs | 450 ------------------ .../OpenApiNSwagEndToEndTests.csproj | 10 +- .../Documentation/DocumentationTests.cs | 96 ++-- .../Headers/GeneratedSwagger/swagger.g.json | 64 +-- test/OpenApiTests/Headers/HeaderTests.cs | 4 +- .../GeneratedSwagger/swagger.g.json | 352 +++++++------- .../LegacyOpenApi/expected-swagger.json | 352 +++++++------- .../Enabled/GeneratedSwagger/swagger.g.json | 224 ++++----- .../GeneratedSwagger/net8.0}/swagger.g.json | 223 +++++---- .../ModelStateValidationDbContext.cs | 11 + .../ModelStateValidationFakers.cs | 36 ++ .../ModelStateValidationTests.cs} | 107 +++-- .../SocialMediaAccount.cs} | 40 +- .../ModelValidationDbContext.cs | 11 - .../ModelValidation/ModelValidationFakers.cs | 30 -- .../CamelCase/GeneratedSwagger/swagger.g.json | 160 +++---- .../KebabCase/GeneratedSwagger/swagger.g.json | 160 +++---- .../GeneratedSwagger/swagger.g.json | 160 +++---- .../GeneratedSwagger/swagger.g.json | 192 ++++---- .../GeneratedSwagger/swagger.g.json | 160 +++---- .../GeneratedSwagger/swagger.g.json | 160 +++---- .../GeneratedSwagger/swagger.g.json | 224 ++++----- .../GeneratedSwagger/swagger.g.json | 224 ++++----- .../GeneratedSwagger/swagger.g.json | 288 +++++------ .../JsonElementAssertionExtensions.cs | 5 + 26 files changed, 2074 insertions(+), 2027 deletions(-) create mode 100644 test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs delete mode 100644 test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs rename test/OpenApiTests/{ModelValidation/GeneratedSwagger => ModelStateValidation/GeneratedSwagger/net8.0}/swagger.g.json (78%) create mode 100644 test/OpenApiTests/ModelStateValidation/ModelStateValidationDbContext.cs create mode 100644 test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs rename test/OpenApiTests/{ModelValidation/ModelValidationTests.cs => ModelStateValidation/ModelStateValidationTests.cs} (68%) rename test/OpenApiTests/{ModelValidation/Fingerprint.cs => ModelStateValidation/SocialMediaAccount.cs} (52%) delete mode 100644 test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs delete mode 100644 test/OpenApiTests/ModelValidation/ModelValidationFakers.cs diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs new file mode 100644 index 0000000000..b5ef8b6074 --- /dev/null +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -0,0 +1,358 @@ +using FluentAssertions; +using FluentAssertions.Specialized; +using JsonApiDotNetCore.OpenApi.Client.NSwag; +using Newtonsoft.Json; +using OpenApiNSwagEndToEndTests.ModelStateValidation.GeneratedCode; +using OpenApiTests; +using OpenApiTests.ModelStateValidation; +using TestBuildingBlocks; +using Xunit; +using Xunit.Abstractions; + +namespace OpenApiNSwagEndToEndTests.ModelStateValidation; + +public sealed class ModelStateValidationTests : IClassFixture, ModelStateValidationDbContext>> +{ + private readonly IntegrationTestContext, ModelStateValidationDbContext> _testContext; + private readonly XUnitLogHttpMessageHandler _logHttpMessageHandler; + private readonly ModelStateValidationFakers _fakers = new(); + + public ModelStateValidationTests(IntegrationTestContext, ModelStateValidationDbContext> testContext, ITestOutputHelper testOutputHelper) + { + _testContext = testContext; + _logHttpMessageHandler = new XUnitLogHttpMessageHandler(testOutputHelper); + + testContext.UseController(); + } + + [Fact] + public async Task xxx() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest() + } + }); + + // Assert + ExceptionAssertions assertion = await action.Should().ThrowExactlyAsync(); + assertion.Which.Message.Should().Be("Cannot write a null value for property 'lastName'. Property requires a value. Path 'data.attributes'."); + } + + [Theory] + [InlineData("ab")] + [InlineData("abcdefghijklmnopqrs")] + public async Task Cannot_exceed_length_constraint(string userName) + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + UserName = userName + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field UserName must be a string with a minimum length of 3 and a maximum length of 18."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); + } + + [Fact] + public async Task Cannot_violate_regular_expression_constraint() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + UserName = "aB1" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("Only letters are allowed."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); + } + + [Fact] + public async Task Cannot_use_invalid_credit_card() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + CreditCard = "123-456" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The CreditCard field is not a valid credit card number."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/creditCard"); + } + + [Fact] + public async Task Cannot_use_invalid_email() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + Email = "abc" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The Email field is not a valid e-mail address."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/email"); + } + + [Theory] + [InlineData(-1)] + [InlineData(-0.56)] + [InlineData(123.98)] + [InlineData(124)] + public async Task Cannot_use_double_outside_of_valid_range(int age) + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + Age = age + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field Age must be between 0 and 123."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/age"); + } + + [Fact] + public async Task Cannot_use_invalid_url() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + BackgroundPicture = new Uri("/justapath", UriKind.Relative) + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The BackgroundPicture field is not a valid fully-qualified http, https, or ftp URL."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/backgroundPicture"); + } + + [Fact] + public async Task Cannot_use_TimeSpan_outside_of_valid_range() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + NextRevalidation = "00:00:01" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field NextRevalidation must be between 01:00:00 and 05:00:00."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + } + + [Fact] + public async Task Cannot_use_invalid_TimeOnly() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + ValidatedAtTime = TimeSpan.FromSeconds(-1) + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); + errorObject.Detail.Should().Be("Failed to convert attribute 'validatedAtTime' with value '-00:00:01' of type 'String' to type 'Nullable'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/validatedAtTime"); + } + + [Fact] + public async Task Can_create_resource_with_valid_properties() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + FirstName = socialMediaAccount.FirstName, + GivenName = socialMediaAccount.GivenName, + LastName = socialMediaAccount.LastName, + UserName = socialMediaAccount.UserName, + CreditCard = socialMediaAccount.CreditCard, + Email = socialMediaAccount.Email, + Phone = socialMediaAccount.Phone, + Age = socialMediaAccount.Age, + ProfilePicture = socialMediaAccount.ProfilePicture, + BackgroundPicture = new Uri(socialMediaAccount.BackgroundPicture!), + NextRevalidation = "02:00:00", + ValidatedAt = socialMediaAccount.ValidatedAt!, + ValidatedAtDate = new DateTimeOffset(socialMediaAccount.ValidatedAtDate!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), + ValidatedAtTime = socialMediaAccount.ValidatedAtTime!.Value.ToTimeSpan() + } + } + }); + + // Assert + await action.Should().NotThrowAsync(); + } +} diff --git a/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs deleted file mode 100644 index 02c2fe5664..0000000000 --- a/test/OpenApiNSwagEndToEndTests/ModelValidation/ModelValidationTests.cs +++ /dev/null @@ -1,450 +0,0 @@ -using FluentAssertions; -using FluentAssertions.Specialized; -using JsonApiDotNetCore.OpenApi.Client.NSwag; -using Newtonsoft.Json; -using OpenApiNSwagEndToEndTests.ModelValidation.GeneratedCode; -using OpenApiTests; -using OpenApiTests.ModelValidation; -using TestBuildingBlocks; -using Xunit; - -namespace OpenApiNSwagEndToEndTests.ModelValidation; - -public sealed class ModelValidationTests : IClassFixture, ModelValidationDbContext>> -{ - private readonly IntegrationTestContext, ModelValidationDbContext> _testContext; - private readonly ModelValidationFakers _fakers = new(); - - public ModelValidationTests(IntegrationTestContext, ModelValidationDbContext> testContext) - { - _testContext = testContext; - - testContext.UseController(); - } - - [Fact] - public async Task Omitting_a_required_attribute_should_return_an_error() - { - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - } - } - }); - - // Assert - ExceptionAssertions assertion = await action.Should().ThrowExactlyAsync(); - assertion.Which.Message.Should().Be("Cannot write a null value for property 'lastName'. Property requires a value. Path 'data.attributes'."); - } - - [Theory] - [InlineData("ab")] - [InlineData("abcdefghijklmnopqrs")] - public async Task Not_fitting_the_length_constraint_should_return_an_error(string userName) - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - UserName = userName - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field UserName must be a string with a minimum length of 3 and a maximum length of 18."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); - } - - [Fact] - public async Task Not_matching_a_regex_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - UserName = "aB1" - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("Only letters are allowed."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); - } - - [Fact] - public async Task Invalid_credit_card_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - CreditCard = "123-456" - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The CreditCard field is not a valid credit card number."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/creditCard"); - } - - [Fact] - public async Task Invalid_email_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - Email = "abc" - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The Email field is not a valid e-mail address."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/email"); - } - - [Theory] - [InlineData(-1)] - [InlineData(124)] - public async Task Out_of_range_integer_should_return_an_error(int age) - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - Age = age - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0 and 123."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/age"); - } - - [Fact] - public async Task Invalid_uri_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - ProfilePicture = new Uri("/justapath", UriKind.Relative) - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The ProfilePicture field is not a valid fully-qualified http, https, or ftp URL."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/profilePicture"); - } - - [Fact] - public async Task Invalid_url_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - BackgroundPicture = new Uri("/justapath", UriKind.Relative) - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The BackgroundPicture field is not a valid fully-qualified http, https, or ftp URL."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/backgroundPicture"); - } - - [Fact] - public async Task Out_of_range_timespan_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - NextRevalidation = "00:00:01", - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field NextRevalidation must be between 01:00:00 and 05:00:00."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); - } - - [Fact] - public async Task Invalid_datetime_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - ValidatedAt = DateTimeOffset.MinValue - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be(""); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/"); - } - - [Fact] - public async Task Invalid_date_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - ValidatedDateAt = DateTimeOffset.Now - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be(""); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/"); - } - - [Fact] - public async Task Invalid_time_only_should_return_an_error() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - LastName = fingerprint.LastName, - ValidatedTimeAt = TimeSpan.FromSeconds(-1) - } - } - }); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); - errorObject.Detail.Should().Be("Failed to convert attribute 'validatedTimeAt' with value '-00:00:01' of type 'String' to type 'Nullable'."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/validatedTimeAt"); - } - - [Fact] - public async Task Fitting_all_the_constraints_should_work() - { - // Arrange - Fingerprint fingerprint = _fakers.Fingerprint.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateClient(); - ModelValidationClient apiClient = new(httpClient); - - // Act - Func> action = () => apiClient.PostFingerprintAsync(null, new FingerprintPostRequestDocument - { - Data = new FingerprintDataInPostRequest - { - Attributes = new FingerprintAttributesInPostRequest - { - FirstName = fingerprint.FirstName, - LastName = fingerprint.LastName, - UserName = fingerprint.UserName, - CreditCard = fingerprint.CreditCard, - Email = fingerprint.Email, - Phone = fingerprint.Phone, - Age = fingerprint.Age, - ProfilePicture = fingerprint.ProfilePicture, - BackgroundPicture = new Uri(fingerprint.BackgroundPicture!), - NextRevalidation = "02:00:00", - ValidatedAt = fingerprint.ValidatedAt!.Value.ToUniversalTime(), - ValidatedDateAt = new DateTimeOffset(fingerprint.ValidatedDateAt!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), - ValidatedTimeAt = fingerprint.ValidatedTimeAt!.Value.ToTimeSpan() - } - } - }); - - // Assert - await action.Should().NotThrowAsync(); - } -} diff --git a/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj b/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj index b31a7343a7..8277343c19 100644 --- a/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj +++ b/test/OpenApiNSwagEndToEndTests/OpenApiNSwagEndToEndTests.csproj @@ -30,12 +30,12 @@ NSwagCSharp /ClientClassAccessModifier:internal /GenerateExceptionClasses:false /AdditionalNamespaceUsages:JsonApiDotNetCore.OpenApi.Client.NSwag /GenerateNullableReferenceTypes:true - - OpenApiNSwagEndToEndTests.ModelValidation.GeneratedCode - ModelValidationClient - ModelValidationClient.cs + + OpenApiNSwagEndToEndTests.ModelStateValidation.GeneratedCode + ModelStateValidationClient + ModelStateValidationClient.cs NSwagCSharp - /ClientClassAccessModifier:internal /GenerateExceptionClasses:false /AdditionalNamespaceUsages:JsonApiDotNetCore.OpenApi.Client.NSwag /GenerateNullableReferenceTypes:true + /ClientClassAccessModifier:internal /GenerateExceptionClasses:false /AdditionalNamespaceUsages:JsonApiDotNetCore.OpenApi.Client.NSwag /GenerateNullableReferenceTypes:true /GenerateOptionalParameters:true OpenApiNSwagEndToEndTests.Headers.GeneratedCode diff --git a/test/OpenApiTests/Documentation/DocumentationTests.cs b/test/OpenApiTests/Documentation/DocumentationTests.cs index 9a254968e7..3a071eb88e 100644 --- a/test/OpenApiTests/Documentation/DocumentationTests.cs +++ b/test/OpenApiTests/Documentation/DocumentationTests.cs @@ -72,16 +72,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[0].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[1].name", "If-None-Match"); parametersElement.Should().HaveProperty("[1].in", "header"); - parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(3); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found skyscrapers, or an empty array if none were found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); }); }); @@ -98,17 +98,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[0].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[1].name", "If-None-Match"); parametersElement.Should().HaveProperty("[1].in", "header"); - parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(3); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); }); }); @@ -153,16 +153,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found skyscraper."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -182,17 +182,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -260,16 +260,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found elevator, or `null` if it was not found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -289,17 +289,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -321,16 +321,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found elevator identity, or `null` if it was not found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -350,17 +350,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -405,16 +405,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found spaces, or an empty array if none were found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -434,17 +434,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -466,16 +466,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found space identities, or an empty array if none were found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -495,17 +495,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); diff --git a/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json index c8e1735b6b..4d8248c33c 100644 --- a/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found countries, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found country.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found languages, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found language identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/Headers/HeaderTests.cs b/test/OpenApiTests/Headers/HeaderTests.cs index d900092ad2..95983b038e 100644 --- a/test/OpenApiTests/Headers/HeaderTests.cs +++ b/test/OpenApiTests/Headers/HeaderTests.cs @@ -42,7 +42,7 @@ public async Task Endpoints_have_caching_headers(string endpointPath) parameterElement.Should().NotContainPath("required"); parameterElement.Should().HaveProperty("description", - "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); + "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); parameterElement.Should().ContainPath("schema").With(schemaElement => { @@ -59,7 +59,7 @@ public async Task Endpoints_have_caching_headers(string endpointPath) static void AssertETag(JsonElement etagElement) { etagElement.Should().HaveProperty("description", - "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); etagElement.Should().HaveProperty("required", true); diff --git a/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json index 2112a1cf5c..10d4aaf5b2 100644 --- a/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found airplanes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found airplane.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1149,7 +1149,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1160,7 +1160,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1176,10 +1176,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,7 +1223,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1234,7 +1234,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,10 +1251,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1413,7 +1413,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1424,7 +1424,7 @@ "description": "Successfully returns the found flight-attendant.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1440,10 +1440,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1506,7 +1506,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1517,7 +1517,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1534,10 +1534,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1721,7 +1721,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1732,7 +1732,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,10 +1748,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1814,7 +1814,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1825,7 +1825,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1842,10 +1842,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1895,7 +1895,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1906,7 +1906,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1922,10 +1922,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1988,7 +1988,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1999,7 +1999,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2016,10 +2016,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2273,7 +2273,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2284,7 +2284,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,10 +2300,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2366,7 +2366,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2377,7 +2377,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2394,10 +2394,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2447,7 +2447,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2458,7 +2458,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2474,10 +2474,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2540,7 +2540,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2551,7 +2551,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2568,10 +2568,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2816,7 +2816,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2827,7 +2827,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2843,10 +2843,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2890,7 +2890,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2901,7 +2901,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2918,10 +2918,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3080,7 +3080,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3091,7 +3091,7 @@ "description": "Successfully returns the found flight.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3107,10 +3107,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3173,7 +3173,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3184,7 +3184,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3201,10 +3201,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3388,7 +3388,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3399,7 +3399,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3415,10 +3415,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3481,7 +3481,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3492,7 +3492,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3509,10 +3509,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3562,7 +3562,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3573,7 +3573,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3589,10 +3589,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3655,7 +3655,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3666,7 +3666,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3683,10 +3683,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3804,7 +3804,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3815,7 +3815,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3831,10 +3831,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3897,7 +3897,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3908,7 +3908,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3925,10 +3925,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3978,7 +3978,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3989,7 +3989,7 @@ "description": "Successfully returns the found flight-attendant identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4005,10 +4005,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4071,7 +4071,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4082,7 +4082,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4099,10 +4099,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4356,7 +4356,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4367,7 +4367,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4383,10 +4383,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4449,7 +4449,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4460,7 +4460,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4477,10 +4477,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4530,7 +4530,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4541,7 +4541,7 @@ "description": "Successfully returns the found passenger identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4557,10 +4557,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4623,7 +4623,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4634,7 +4634,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4651,10 +4651,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4908,7 +4908,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4919,7 +4919,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4935,10 +4935,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5001,7 +5001,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5012,7 +5012,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5029,10 +5029,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5082,7 +5082,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5093,7 +5093,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5109,10 +5109,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5175,7 +5175,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5186,7 +5186,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5203,10 +5203,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5315,7 +5315,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5326,7 +5326,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5342,10 +5342,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5389,7 +5389,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5400,7 +5400,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5417,10 +5417,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5579,7 +5579,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5590,7 +5590,7 @@ "description": "Successfully returns the found passenger.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5606,10 +5606,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5672,7 +5672,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5683,7 +5683,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5700,10 +5700,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/LegacyOpenApi/expected-swagger.json b/test/OpenApiTests/LegacyOpenApi/expected-swagger.json index 2112a1cf5c..10d4aaf5b2 100644 --- a/test/OpenApiTests/LegacyOpenApi/expected-swagger.json +++ b/test/OpenApiTests/LegacyOpenApi/expected-swagger.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found airplanes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found airplane.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1149,7 +1149,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1160,7 +1160,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1176,10 +1176,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,7 +1223,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1234,7 +1234,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,10 +1251,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1413,7 +1413,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1424,7 +1424,7 @@ "description": "Successfully returns the found flight-attendant.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1440,10 +1440,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1506,7 +1506,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1517,7 +1517,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1534,10 +1534,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1721,7 +1721,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1732,7 +1732,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,10 +1748,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1814,7 +1814,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1825,7 +1825,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1842,10 +1842,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1895,7 +1895,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1906,7 +1906,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1922,10 +1922,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1988,7 +1988,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1999,7 +1999,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2016,10 +2016,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2273,7 +2273,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2284,7 +2284,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,10 +2300,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2366,7 +2366,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2377,7 +2377,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2394,10 +2394,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2447,7 +2447,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2458,7 +2458,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2474,10 +2474,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2540,7 +2540,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2551,7 +2551,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2568,10 +2568,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2816,7 +2816,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2827,7 +2827,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2843,10 +2843,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2890,7 +2890,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2901,7 +2901,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2918,10 +2918,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3080,7 +3080,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3091,7 +3091,7 @@ "description": "Successfully returns the found flight.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3107,10 +3107,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3173,7 +3173,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3184,7 +3184,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3201,10 +3201,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3388,7 +3388,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3399,7 +3399,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3415,10 +3415,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3481,7 +3481,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3492,7 +3492,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3509,10 +3509,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3562,7 +3562,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3573,7 +3573,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3589,10 +3589,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3655,7 +3655,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3666,7 +3666,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3683,10 +3683,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3804,7 +3804,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3815,7 +3815,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3831,10 +3831,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3897,7 +3897,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3908,7 +3908,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3925,10 +3925,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3978,7 +3978,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3989,7 +3989,7 @@ "description": "Successfully returns the found flight-attendant identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4005,10 +4005,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4071,7 +4071,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4082,7 +4082,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4099,10 +4099,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4356,7 +4356,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4367,7 +4367,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4383,10 +4383,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4449,7 +4449,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4460,7 +4460,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4477,10 +4477,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4530,7 +4530,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4541,7 +4541,7 @@ "description": "Successfully returns the found passenger identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4557,10 +4557,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4623,7 +4623,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4634,7 +4634,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4651,10 +4651,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4908,7 +4908,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -4919,7 +4919,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4935,10 +4935,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5001,7 +5001,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5012,7 +5012,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5029,10 +5029,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5082,7 +5082,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5093,7 +5093,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5109,10 +5109,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5175,7 +5175,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5186,7 +5186,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5203,10 +5203,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5315,7 +5315,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5326,7 +5326,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5342,10 +5342,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5389,7 +5389,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5400,7 +5400,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5417,10 +5417,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5579,7 +5579,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5590,7 +5590,7 @@ "description": "Successfully returns the found passenger.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5606,10 +5606,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5672,7 +5672,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -5683,7 +5683,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5700,10 +5700,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json index adcd8418ba..a0fe80c81c 100644 --- a/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found accommodations, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found accommodation.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found excursions, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found excursion.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1160,7 +1160,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1171,7 +1171,7 @@ "description": "Successfully returns the found transports, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1187,10 +1187,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1234,7 +1234,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1245,7 +1245,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,10 +1262,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1424,7 +1424,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1435,7 +1435,7 @@ "description": "Successfully returns the found transport.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1451,10 +1451,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1517,7 +1517,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1528,7 +1528,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1545,10 +1545,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1723,7 +1723,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1734,7 +1734,7 @@ "description": "Successfully returns the found vacations, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1750,10 +1750,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1797,7 +1797,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1808,7 +1808,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1825,10 +1825,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1987,7 +1987,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1998,7 +1998,7 @@ "description": "Successfully returns the found vacation.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2014,10 +2014,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2080,7 +2080,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2091,7 +2091,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2108,10 +2108,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2295,7 +2295,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2306,7 +2306,7 @@ "description": "Successfully returns the found accommodation, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2322,10 +2322,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2388,7 +2388,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2399,7 +2399,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2416,10 +2416,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2469,7 +2469,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2480,7 +2480,7 @@ "description": "Successfully returns the found accommodation identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2496,10 +2496,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2562,7 +2562,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2573,7 +2573,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2590,10 +2590,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2711,7 +2711,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2722,7 +2722,7 @@ "description": "Successfully returns the found excursions, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2738,10 +2738,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2804,7 +2804,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2815,7 +2815,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2832,10 +2832,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2885,7 +2885,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2896,7 +2896,7 @@ "description": "Successfully returns the found excursion identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2912,10 +2912,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2978,7 +2978,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2989,7 +2989,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3006,10 +3006,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3263,7 +3263,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3274,7 +3274,7 @@ "description": "Successfully returns the found transport, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3290,10 +3290,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3356,7 +3356,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3367,7 +3367,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3384,10 +3384,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3437,7 +3437,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3448,7 +3448,7 @@ "description": "Successfully returns the found transport identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3464,10 +3464,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3530,7 +3530,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3541,7 +3541,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3558,10 +3558,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json similarity index 78% rename from test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json rename to test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json index 37505cd221..f4ffba94ae 100644 --- a/test/OpenApiTests/ModelValidation/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json @@ -10,13 +10,13 @@ } ], "paths": { - "/fingerprints": { + "/socialMediaAccounts": { "post": { "tags": [ - "fingerprints" + "socialMediaAccounts" ], - "summary": "Creates a new fingerprint.", - "operationId": "postFingerprint", + "summary": "Creates a new socialMediaAccount.", + "operationId": "postSocialMediaAccount", "parameters": [ { "name": "query", @@ -33,13 +33,13 @@ } ], "requestBody": { - "description": "The attributes and relationships of the fingerprint to create.", + "description": "The attributes and relationships of the socialMediaAccount to create.", "content": { "application/vnd.api+json": { "schema": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintPostRequestDocument" + "$ref": "#/components/schemas/socialMediaAccountPostRequestDocument" } ] } @@ -49,10 +49,10 @@ }, "responses": { "201": { - "description": "The fingerprint was successfully created, which resulted in additional changes. The newly created fingerprint is returned.", + "description": "The socialMediaAccount was successfully created, which resulted in additional changes. The newly created socialMediaAccount is returned.", "headers": { "Location": { - "description": "The URL at which the newly created fingerprint can be retrieved.", + "description": "The URL at which the newly created socialMediaAccount can be retrieved.", "required": true, "schema": { "type": "string", @@ -63,13 +63,13 @@ "content": { "application/vnd.api+json": { "schema": { - "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" + "$ref": "#/components/schemas/socialMediaAccountPrimaryResponseDocument" } } } }, "204": { - "description": "The fingerprint was successfully created, which did not result in additional changes." + "description": "The socialMediaAccount was successfully created, which did not result in additional changes." }, "400": { "description": "The query string is invalid or the request body is missing or malformed.", @@ -124,18 +124,18 @@ } } }, - "/fingerprints/{id}": { + "/socialMediaAccounts/{id}": { "patch": { "tags": [ - "fingerprints" + "socialMediaAccounts" ], - "summary": "Updates an existing fingerprint.", - "operationId": "patchFingerprint", + "summary": "Updates an existing socialMediaAccount.", + "operationId": "patchSocialMediaAccount", "parameters": [ { "name": "id", "in": "path", - "description": "The identifier of the fingerprint to update.", + "description": "The identifier of the socialMediaAccount to update.", "required": true, "schema": { "type": "string" @@ -156,13 +156,13 @@ } ], "requestBody": { - "description": "The attributes and relationships of the fingerprint to update. Omitted fields are left unchanged.", + "description": "The attributes and relationships of the socialMediaAccount to update. Omitted fields are left unchanged.", "content": { "application/vnd.api+json": { "schema": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintPatchRequestDocument" + "$ref": "#/components/schemas/socialMediaAccountPatchRequestDocument" } ] } @@ -172,17 +172,17 @@ }, "responses": { "200": { - "description": "The fingerprint was successfully updated, which resulted in additional changes. The updated fingerprint is returned.", + "description": "The socialMediaAccount was successfully updated, which resulted in additional changes. The updated socialMediaAccount is returned.", "content": { "application/vnd.api+json": { "schema": { - "$ref": "#/components/schemas/fingerprintPrimaryResponseDocument" + "$ref": "#/components/schemas/socialMediaAccountPrimaryResponseDocument" } } } }, "204": { - "description": "The fingerprint was successfully updated, which did not result in additional changes." + "description": "The socialMediaAccount was successfully updated, which did not result in additional changes." }, "400": { "description": "The query string is invalid or the request body is missing or malformed.", @@ -195,7 +195,7 @@ } }, "404": { - "description": "The fingerprint or a related resource does not exist.", + "description": "The socialMediaAccount or a related resource does not exist.", "content": { "application/vnd.api+json": { "schema": { @@ -250,7 +250,7 @@ "discriminator": { "propertyName": "type", "mapping": { - "fingerprints": "#/components/schemas/fingerprintDataInResponse" + "socialMediaAccounts": "#/components/schemas/socialMediaAccountDataInResponse" } }, "x-abstract": true @@ -375,13 +375,43 @@ }, "additionalProperties": false }, - "fingerprintAttributesInPatchRequest": { + "resourceLinks": { + "type": "object", + "properties": { + "self": { + "type": "string" + } + }, + "additionalProperties": false + }, + "resourceTopLevelLinks": { + "type": "object", + "properties": { + "self": { + "type": "string" + }, + "describedby": { + "type": "string" + } + }, + "additionalProperties": false + }, + "socialMediaAccountAttributesInPatchRequest": { "type": "object", "properties": { + "alternativeId": { + "type": "string", + "format": "uuid", + "nullable": true + }, "firstName": { "type": "string", "nullable": true }, + "givenName": { + "type": "string", + "nullable": true + }, "lastName": { "minLength": 1, "type": "string" @@ -403,16 +433,20 @@ "format": "email", "nullable": true }, + "password": { + "type": "string", + "nullable": true + }, "phone": { "type": "string", "format": "tel", "nullable": true }, "age": { - "maximum": 123, - "minimum": 0, - "type": "integer", - "format": "int32", + "maximum": 122.9, + "minimum": 0.1, + "type": "number", + "format": "double", "nullable": true }, "profilePicture": { @@ -425,6 +459,14 @@ "format": "uri", "nullable": true }, + "tags": { + "uniqueItems": true, + "type": "array", + "items": { + "type": "string" + }, + "nullable": true + }, "nextRevalidation": { "type": "string", "format": "date-span", @@ -435,12 +477,12 @@ "format": "date-time", "nullable": true }, - "validatedDateAt": { + "validatedAtDate": { "type": "string", "format": "date", "nullable": true }, - "validatedTimeAt": { + "validatedAtTime": { "type": "string", "format": "time", "nullable": true @@ -448,16 +490,25 @@ }, "additionalProperties": false }, - "fingerprintAttributesInPostRequest": { + "socialMediaAccountAttributesInPostRequest": { "required": [ "lastName" ], "type": "object", "properties": { + "alternativeId": { + "type": "string", + "format": "uuid", + "nullable": true + }, "firstName": { "type": "string", "nullable": true }, + "givenName": { + "type": "string", + "nullable": true + }, "lastName": { "minLength": 1, "type": "string" @@ -479,16 +530,20 @@ "format": "email", "nullable": true }, + "password": { + "type": "string", + "nullable": true + }, "phone": { "type": "string", "format": "tel", "nullable": true }, "age": { - "maximum": 123, - "minimum": 0, - "type": "integer", - "format": "int32", + "maximum": 122.9, + "minimum": 0.1, + "type": "number", + "format": "double", "nullable": true }, "profilePicture": { @@ -501,6 +556,14 @@ "format": "uri", "nullable": true }, + "tags": { + "uniqueItems": true, + "type": "array", + "items": { + "type": "string" + }, + "nullable": true + }, "nextRevalidation": { "type": "string", "format": "date-span", @@ -511,12 +574,12 @@ "format": "date-time", "nullable": true }, - "validatedDateAt": { + "validatedAtDate": { "type": "string", "format": "date", "nullable": true }, - "validatedTimeAt": { + "validatedAtTime": { "type": "string", "format": "time", "nullable": true @@ -524,13 +587,22 @@ }, "additionalProperties": false }, - "fingerprintAttributesInResponse": { + "socialMediaAccountAttributesInResponse": { "type": "object", "properties": { + "alternativeId": { + "type": "string", + "format": "uuid", + "nullable": true + }, "firstName": { "type": "string", "nullable": true }, + "givenName": { + "type": "string", + "nullable": true + }, "lastName": { "minLength": 1, "type": "string" @@ -552,16 +624,20 @@ "format": "email", "nullable": true }, + "password": { + "type": "string", + "nullable": true + }, "phone": { "type": "string", "format": "tel", "nullable": true }, "age": { - "maximum": 123, - "minimum": 0, - "type": "integer", - "format": "int32", + "maximum": 122.9, + "minimum": 0.1, + "type": "number", + "format": "double", "nullable": true }, "profilePicture": { @@ -574,6 +650,14 @@ "format": "uri", "nullable": true }, + "tags": { + "uniqueItems": true, + "type": "array", + "items": { + "type": "string" + }, + "nullable": true + }, "nextRevalidation": { "type": "string", "format": "date-span", @@ -584,12 +668,12 @@ "format": "date-time", "nullable": true }, - "validatedDateAt": { + "validatedAtDate": { "type": "string", "format": "date", "nullable": true }, - "validatedTimeAt": { + "validatedAtTime": { "type": "string", "format": "time", "nullable": true @@ -597,7 +681,7 @@ }, "additionalProperties": false }, - "fingerprintDataInPatchRequest": { + "socialMediaAccountDataInPatchRequest": { "required": [ "id", "type" @@ -605,7 +689,7 @@ "type": "object", "properties": { "type": { - "$ref": "#/components/schemas/fingerprintResourceType" + "$ref": "#/components/schemas/socialMediaAccountResourceType" }, "id": { "minLength": 1, @@ -614,33 +698,33 @@ "attributes": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintAttributesInPatchRequest" + "$ref": "#/components/schemas/socialMediaAccountAttributesInPatchRequest" } ] } }, "additionalProperties": false }, - "fingerprintDataInPostRequest": { + "socialMediaAccountDataInPostRequest": { "required": [ "type" ], "type": "object", "properties": { "type": { - "$ref": "#/components/schemas/fingerprintResourceType" + "$ref": "#/components/schemas/socialMediaAccountResourceType" }, "attributes": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintAttributesInPostRequest" + "$ref": "#/components/schemas/socialMediaAccountAttributesInPostRequest" } ] } }, "additionalProperties": false }, - "fingerprintDataInResponse": { + "socialMediaAccountDataInResponse": { "allOf": [ { "$ref": "#/components/schemas/dataInResponse" @@ -651,7 +735,7 @@ "attributes": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintAttributesInResponse" + "$ref": "#/components/schemas/socialMediaAccountAttributesInResponse" } ] }, @@ -675,7 +759,7 @@ ], "additionalProperties": false }, - "fingerprintPatchRequestDocument": { + "socialMediaAccountPatchRequestDocument": { "required": [ "data" ], @@ -684,14 +768,14 @@ "data": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintDataInPatchRequest" + "$ref": "#/components/schemas/socialMediaAccountDataInPatchRequest" } ] } }, "additionalProperties": false }, - "fingerprintPostRequestDocument": { + "socialMediaAccountPostRequestDocument": { "required": [ "data" ], @@ -700,14 +784,14 @@ "data": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintDataInPostRequest" + "$ref": "#/components/schemas/socialMediaAccountDataInPostRequest" } ] } }, "additionalProperties": false }, - "fingerprintPrimaryResponseDocument": { + "socialMediaAccountPrimaryResponseDocument": { "required": [ "data", "links" @@ -724,7 +808,7 @@ "data": { "allOf": [ { - "$ref": "#/components/schemas/fingerprintDataInResponse" + "$ref": "#/components/schemas/socialMediaAccountDataInResponse" } ] }, @@ -744,33 +828,12 @@ }, "additionalProperties": false }, - "fingerprintResourceType": { + "socialMediaAccountResourceType": { "enum": [ - "fingerprints" + "socialMediaAccounts" ], "type": "string", "additionalProperties": false - }, - "resourceLinks": { - "type": "object", - "properties": { - "self": { - "type": "string" - } - }, - "additionalProperties": false - }, - "resourceTopLevelLinks": { - "type": "object", - "properties": { - "self": { - "type": "string" - }, - "describedby": { - "type": "string" - } - }, - "additionalProperties": false } } } diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationDbContext.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationDbContext.cs new file mode 100644 index 0000000000..2823efdb46 --- /dev/null +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationDbContext.cs @@ -0,0 +1,11 @@ +using JetBrains.Annotations; +using Microsoft.EntityFrameworkCore; +using TestBuildingBlocks; + +namespace OpenApiTests.ModelStateValidation; + +[UsedImplicitly(ImplicitUseTargetFlags.Members)] +public sealed class ModelStateValidationDbContext(DbContextOptions options) : TestableDbContext(options) +{ + public DbSet SocialMediaAccounts => Set(); +} diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs new file mode 100644 index 0000000000..5998cbbd15 --- /dev/null +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -0,0 +1,36 @@ +using System; +using System.Net; +using Bogus; +using JetBrains.Annotations; +using TestBuildingBlocks; + +// @formatter:wrap_chained_method_calls chop_if_long +// @formatter:wrap_before_first_method_call true + +namespace OpenApiTests.ModelStateValidation; + +[UsedImplicitly(ImplicitUseTargetFlags.Members)] +public sealed class ModelStateValidationFakers +{ + private readonly Lazy> _lazySocialMediaAccountFaker = new(() => new Faker() + .MakeDeterministic() + .RuleFor(socialMediaAccount => socialMediaAccount.AlternativeId, faker => faker.Random.Guid()) + .RuleFor(socialMediaAccount => socialMediaAccount.FirstName, faker => faker.Person.FirstName) + .RuleFor(socialMediaAccount => socialMediaAccount.GivenName, (_, socialMediaAccount) => socialMediaAccount.FirstName) + .RuleFor(socialMediaAccount => socialMediaAccount.LastName, faker => faker.Person.LastName) + .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Random.String2(3, 18)) + .RuleFor(socialMediaAccount => socialMediaAccount.CreditCard, faker => faker.Finance.CreditCardNumber()) + .RuleFor(socialMediaAccount => socialMediaAccount.Email, faker => faker.Person.Email) + .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => Convert.ToBase64String(faker.Random.Bytes(20))) + .RuleFor(socialMediaAccount => socialMediaAccount.Phone, faker => faker.Person.Phone) + .RuleFor(socialMediaAccount => socialMediaAccount.Age, faker => faker.Random.Double(0.1, 122.9)) + .RuleFor(socialMediaAccount => socialMediaAccount.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) + .RuleFor(socialMediaAccount => socialMediaAccount.BackgroundPicture, faker => faker.Image.LoremFlickrUrl()) + .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => [..faker.Make(faker.Random.Number(), () => faker.Random.String2(2, 8))]) + .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) + .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAt, faker => faker.Date.Recent().ToUniversalTime()) + .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtDate, faker => DateOnly.FromDateTime(faker.Date.Recent())) + .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtTime, faker => TimeOnly.FromDateTime(faker.Date.Recent()))); + + public Faker SocialMediaAccount => _lazySocialMediaAccountFaker.Value; +} diff --git a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs similarity index 68% rename from test/OpenApiTests/ModelValidation/ModelValidationTests.cs rename to test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index ed7b995324..5824cb4d1f 100644 --- a/test/OpenApiTests/ModelValidation/ModelValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -2,39 +2,59 @@ using TestBuildingBlocks; using Xunit; -namespace OpenApiTests.ModelValidation; +namespace OpenApiTests.ModelStateValidation; -public sealed class ModelValidationTests : IClassFixture, ModelValidationDbContext>> +public sealed class ModelStateValidationTests : IClassFixture, ModelStateValidationDbContext>> { - private readonly OpenApiTestContext, ModelValidationDbContext> _testContext; + private readonly OpenApiTestContext, ModelStateValidationDbContext> _testContext; - public ModelValidationTests(OpenApiTestContext, ModelValidationDbContext> testContext) + public ModelStateValidationTests(OpenApiTestContext, ModelStateValidationDbContext> testContext) { _testContext = testContext; - testContext.UseController(); + testContext.UseController(); - testContext.SwaggerDocumentOutputDirectory = $"{GetType().Namespace!.Replace('.', '/')}/GeneratedSwagger"; + const string targetFramework = +#if NET8_0_OR_GREATER + "net8.0"; +#else + "net6.0"; +#endif + testContext.SwaggerDocumentOutputDirectory = $"{GetType().Namespace!.Replace('.', '/')}/GeneratedSwagger/{targetFramework}"; } [Theory] [MemberData(nameof(ModelNames))] - public async Task Nullable_annotation_on_resource_property_produces_expected_schema(string modelName) + public async Task Guid_type_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.firstName").With(firstNameEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.alternativeId").With(alternativeIdEl => { - firstNameEl.Should().HaveProperty("type", "string"); - firstNameEl.Should().HaveProperty("nullable", true); + alternativeIdEl.Should().HaveProperty("type", "string"); + alternativeIdEl.Should().HaveProperty("format", "uuid"); }); } [Theory] [MemberData(nameof(ModelNames))] - public async Task Required_annotation_on_resource_property_produces_expected_schema(string modelName) + public async Task Compare_annotation_on_resource_property_produces_expected_schema(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.givenName").With(surnameEl => + { + surnameEl.Should().HaveProperty("type", "string"); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Required_annotation_with_AllowEmptyStrings_disabled_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -44,7 +64,6 @@ public async Task Required_annotation_on_resource_property_produces_expected_sch { lastNameEl.Should().HaveProperty("minLength", 1); lastNameEl.Should().HaveProperty("type", "string"); - lastNameEl.Should().NotContainPath("nullable"); }); } @@ -61,7 +80,6 @@ public async Task StringLength_annotation_on_resource_property_produces_expected userNameEl.Should().HaveProperty("maxLength", 18); userNameEl.Should().HaveProperty("minLength", 3); userNameEl.Should().HaveProperty("type", "string"); - userNameEl.Should().HaveProperty("nullable", true); }); } @@ -77,7 +95,6 @@ public async Task RegularExpression_annotation_on_resource_property_produces_exp { userNameEl.Should().HaveProperty("pattern", "^[a-zA-Z]+$"); userNameEl.Should().HaveProperty("type", "string"); - userNameEl.Should().HaveProperty("nullable", true); }); } @@ -93,7 +110,6 @@ public async Task CreditCard_annotation_on_resource_property_produces_expected_s { creditCardEl.Should().HaveProperty("type", "string"); creditCardEl.Should().HaveProperty("format", "credit-card"); - creditCardEl.Should().HaveProperty("nullable", true); }); } @@ -109,7 +125,20 @@ public async Task Email_annotation_on_resource_property_produces_expected_schema { emailEl.Should().HaveProperty("type", "string"); emailEl.Should().HaveProperty("format", "email"); - emailEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Base64String_annotation_on_resource_property_produces_expected_schema(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.password").With(passwordEl => + { + passwordEl.Should().HaveProperty("type", "string"); }); } @@ -125,7 +154,6 @@ public async Task Phone_annotation_on_resource_property_produces_expected_schema { phoneEl.Should().HaveProperty("type", "string"); phoneEl.Should().HaveProperty("format", "tel"); - phoneEl.Should().HaveProperty("nullable", true); }); } @@ -139,13 +167,12 @@ public async Task Range_annotation_on_resource_property_produces_expected_schema // Assert document.Should().ContainPath($"components.schemas.{modelName}.properties.age").With(ageEl => { - ageEl.Should().HaveProperty("maximum", 123); + ageEl.Should().HaveProperty("maximum", 122.9); ageEl.Should().NotContainPath("exclusiveMaximum"); - ageEl.Should().HaveProperty("minimum", 0); + ageEl.Should().HaveProperty("minimum", 0.1); ageEl.Should().NotContainPath("exclusiveMinimum"); - ageEl.Should().HaveProperty("type", "integer"); - ageEl.Should().HaveProperty("format", "int32"); - ageEl.Should().HaveProperty("nullable", true); + ageEl.Should().HaveProperty("type", "number"); + ageEl.Should().HaveProperty("format", "double"); }); } @@ -161,7 +188,6 @@ public async Task Url_annotation_on_resource_property_produces_expected_schema(s { profilePictureEl.Should().HaveProperty("type", "string"); profilePictureEl.Should().HaveProperty("format", "uri"); - profilePictureEl.Should().HaveProperty("nullable", true); }); } @@ -177,7 +203,25 @@ public async Task Uri_type_on_resource_property_produces_expected_schema(string { backgroundPictureEl.Should().HaveProperty("type", "string"); backgroundPictureEl.Should().HaveProperty("format", "uri"); - backgroundPictureEl.Should().HaveProperty("nullable", true); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task HashSet_annotated_with_Length_AllowedValues_DeniedValues_on_resource_property_produces_expected_schema(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.tags").With(tagsEl => + { + tagsEl.Should().HaveProperty("uniqueItems", true); + tagsEl.Should().HaveProperty("type", "array"); + tagsEl.Should().ContainPath("items").With(itemsEl => + { + itemsEl.Should().HaveProperty("type", "string"); + }); }); } @@ -193,7 +237,6 @@ public async Task TimeSpan_range_annotation_on_resource_property_produces_expect { nextRevalidationEl.Should().HaveProperty("type", "string"); nextRevalidationEl.Should().HaveProperty("format", "date-span"); - nextRevalidationEl.Should().HaveProperty("nullable", true); }); } @@ -209,7 +252,6 @@ public async Task DateTime_type_produces_expected_schema(string modelName) { validatedAtEl.Should().HaveProperty("type", "string"); validatedAtEl.Should().HaveProperty("format", "date-time"); - validatedAtEl.Should().HaveProperty("nullable", true); }); } @@ -221,11 +263,10 @@ public async Task DateOnly_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedDateAt").With(validatedDateAtEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAtDate").With(validatedDateAtEl => { validatedDateAtEl.Should().HaveProperty("type", "string"); validatedDateAtEl.Should().HaveProperty("format", "date"); - validatedDateAtEl.Should().HaveProperty("nullable", true); }); } @@ -237,19 +278,19 @@ public async Task TimeOnly_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedTimeAt").With(validatedTimeAtEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAtTime").With(validatedTimeAtEl => { validatedTimeAtEl.Should().HaveProperty("type", "string"); validatedTimeAtEl.Should().HaveProperty("format", "time"); - validatedTimeAtEl.Should().HaveProperty("nullable", true); }); } public static TheoryData ModelNames => + // ReSharper disable once UseCollectionExpression new() { - "fingerprintAttributesInPostRequest", - "fingerprintAttributesInPatchRequest", - "fingerprintAttributesInResponse" + "socialMediaAccountAttributesInPostRequest", + "socialMediaAccountAttributesInPatchRequest", + "socialMediaAccountAttributesInResponse" }; } diff --git a/test/OpenApiTests/ModelValidation/Fingerprint.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs similarity index 52% rename from test/OpenApiTests/ModelValidation/Fingerprint.cs rename to test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index 6177830c89..f5edd9a8b9 100644 --- a/test/OpenApiTests/ModelValidation/Fingerprint.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -4,17 +4,27 @@ using JsonApiDotNetCore.Resources; using JsonApiDotNetCore.Resources.Annotations; -namespace OpenApiTests.ModelValidation; +namespace OpenApiTests.ModelStateValidation; [UsedImplicitly(ImplicitUseTargetFlags.Members)] -[Resource(ControllerNamespace = "OpenApiTests.ModelValidation", GenerateControllerEndpoints = JsonApiEndpoints.Post | JsonApiEndpoints.Patch)] -public sealed class Fingerprint : Identifiable +[Resource(ControllerNamespace = "OpenApiTests.ModelStateValidation", GenerateControllerEndpoints = JsonApiEndpoints.Post | JsonApiEndpoints.Patch)] +public sealed class SocialMediaAccount : Identifiable { [Attr] + public Guid? AlternativeId { get; set; } + + [Attr] +#if NET8_0_OR_GREATER + [Length(2, 20)] +#endif public string? FirstName { get; set; } [Attr] - [Required(ErrorMessage = "Last name is required.")] + [Compare(nameof(FirstName))] + public string? GivenName { get; set; } + + [Attr] + [Required(AllowEmptyStrings = false)] public string LastName { get; set; } = default!; [Attr] @@ -30,13 +40,19 @@ public sealed class Fingerprint : Identifiable [EmailAddress] public string? Email { get; set; } + [Attr] +#if NET8_0_OR_GREATER + [Base64String] +#endif + public string? Password { get; set; } + [Attr] [Phone] public string? Phone { get; set; } [Attr] - [Range(0, 123)] - public int? Age { get; set; } + [Range(0.1, 122.9, ConvertValueInInvariantCulture = true, ParseLimitsInInvariantCulture = true)] + public double? Age { get; set; } [Attr] public Uri? ProfilePicture { get; set; } @@ -45,6 +61,14 @@ public sealed class Fingerprint : Identifiable [Url] public string? BackgroundPicture { get; set; } + [Attr] +#if NET8_0_OR_GREATER + [AllowedValues("tag1", "tag2")] + [DeniedValues("tag3")] + [Length(0, 10)] +#endif + public HashSet? Tags { get; set; } + [Attr] [Range(typeof(TimeSpan), "01:00", "05:00")] public TimeSpan? NextRevalidation { get; set; } @@ -53,8 +77,8 @@ public sealed class Fingerprint : Identifiable public DateTime? ValidatedAt { get; set; } [Attr] - public DateOnly? ValidatedDateAt { get; set; } + public DateOnly? ValidatedAtDate { get; set; } [Attr] - public TimeOnly? ValidatedTimeAt { get; set; } + public TimeOnly? ValidatedAtTime { get; set; } } diff --git a/test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs b/test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs deleted file mode 100644 index 13351cfbe2..0000000000 --- a/test/OpenApiTests/ModelValidation/ModelValidationDbContext.cs +++ /dev/null @@ -1,11 +0,0 @@ -using JetBrains.Annotations; -using Microsoft.EntityFrameworkCore; -using TestBuildingBlocks; - -namespace OpenApiTests.ModelValidation; - -[UsedImplicitly(ImplicitUseTargetFlags.Members)] -public sealed class ModelValidationDbContext(DbContextOptions options) : TestableDbContext(options) -{ - public DbSet Fingerprints => Set(); -} diff --git a/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs b/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs deleted file mode 100644 index 59882a52a8..0000000000 --- a/test/OpenApiTests/ModelValidation/ModelValidationFakers.cs +++ /dev/null @@ -1,30 +0,0 @@ -using Bogus; -using JetBrains.Annotations; -using TestBuildingBlocks; - -// @formatter:wrap_chained_method_calls chop_if_long -// @formatter:wrap_before_first_method_call true - -namespace OpenApiTests.ModelValidation; - -[UsedImplicitly(ImplicitUseTargetFlags.Members)] -public sealed class ModelValidationFakers -{ - private readonly Lazy> _lazyFingerprintFaker = new(() => new Faker() - .MakeDeterministic() - .RuleFor(fingerprint => fingerprint.FirstName, faker => faker.Person.FirstName) - .RuleFor(fingerprint => fingerprint.LastName, faker => faker.Person.LastName) - .RuleFor(fingerprint => fingerprint.UserName, faker => faker.Random.String2(3, 18)) - .RuleFor(fingerprint => fingerprint.CreditCard, faker => faker.Finance.CreditCardNumber()) - .RuleFor(fingerprint => fingerprint.Email, faker => faker.Person.Email) - .RuleFor(fingerprint => fingerprint.Phone, faker => faker.Person.Phone) - .RuleFor(fingerprint => fingerprint.Age, faker => faker.Random.Number(0, 123)) - .RuleFor(fingerprint => fingerprint.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) - .RuleFor(fingerprint => fingerprint.BackgroundPicture, faker => faker.Image.LoremFlickrUrl()) - .RuleFor(fingerprint => fingerprint.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) - .RuleFor(fingerprint => fingerprint.ValidatedAt, faker => faker.Date.Recent()) - .RuleFor(fingerprint => fingerprint.ValidatedDateAt, faker => DateOnly.FromDateTime(faker.Date.Recent())) - .RuleFor(fingerprint => fingerprint.ValidatedTimeAt, faker => TimeOnly.FromDateTime(faker.Date.Recent()))); - - public Faker Fingerprint => _lazyFingerprintFaker.Value; -} diff --git a/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json index 3fae1e7323..eafe4e103a 100644 --- a/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found staffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found staffMember.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found supermarkets, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found supermarket.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1169,7 +1169,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1180,7 +1180,7 @@ "description": "Successfully returns the found staffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,10 +1196,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,7 +1262,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1273,7 +1273,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1290,10 +1290,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1343,7 +1343,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1354,7 +1354,7 @@ "description": "Successfully returns the found staffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,10 +1370,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1436,7 +1436,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1447,7 +1447,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1464,10 +1464,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found staffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found staffMember identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found staffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found staffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json index f3ee10e406..35abe26923 100644 --- a/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found staff-members, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found staff-member.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found supermarkets, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found supermarket.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1169,7 +1169,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1180,7 +1180,7 @@ "description": "Successfully returns the found staff-member, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,10 +1196,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,7 +1262,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1273,7 +1273,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1290,10 +1290,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1343,7 +1343,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1354,7 +1354,7 @@ "description": "Successfully returns the found staff-member identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,10 +1370,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1436,7 +1436,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1447,7 +1447,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1464,10 +1464,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found staff-members, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found staff-member identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found staff-member, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found staff-member identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json index cbbd39fce4..67e5ec6cf0 100644 --- a/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found StaffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found StaffMember.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found Supermarkets, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found Supermarket.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1169,7 +1169,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1180,7 +1180,7 @@ "description": "Successfully returns the found StaffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,10 +1196,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,7 +1262,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1273,7 +1273,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1290,10 +1290,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1343,7 +1343,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1354,7 +1354,7 @@ "description": "Successfully returns the found StaffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,10 +1370,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1436,7 +1436,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1447,7 +1447,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1464,10 +1464,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found StaffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found StaffMember identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found StaffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found StaffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json index 54ad046fdc..1c042a23be 100644 --- a/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found nameValuePairs, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found nameValuePair.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found node, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found node identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1013,7 +1013,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1024,7 +1024,7 @@ "description": "Successfully returns the found nodes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1040,10 +1040,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1087,7 +1087,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1098,7 +1098,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1115,10 +1115,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1277,7 +1277,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1288,7 +1288,7 @@ "description": "Successfully returns the found node.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1304,10 +1304,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,7 +1370,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1381,7 +1381,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1398,10 +1398,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found nodes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found node identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found node, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found node identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2553,7 +2553,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2564,7 +2564,7 @@ "description": "Successfully returns the found nameValuePairs, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2580,10 +2580,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2646,7 +2646,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2657,7 +2657,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2674,10 +2674,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2727,7 +2727,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2738,7 +2738,7 @@ "description": "Successfully returns the found nameValuePair identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2754,10 +2754,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2820,7 +2820,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2831,7 +2831,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2848,10 +2848,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json index f3714fc69b..3d8db65d54 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1158,7 +1158,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1169,7 +1169,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1185,10 +1185,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,7 +1251,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1262,7 +1262,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1279,10 +1279,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1332,7 +1332,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1343,7 +1343,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1359,10 +1359,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1425,7 +1425,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1436,7 +1436,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1453,10 +1453,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1574,7 +1574,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1585,7 +1585,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1601,10 +1601,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1667,7 +1667,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1678,7 +1678,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1695,10 +1695,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,7 +1748,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1759,7 +1759,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1775,10 +1775,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1841,7 +1841,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1852,7 +1852,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1869,10 +1869,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2126,7 +2126,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2137,7 +2137,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2153,10 +2153,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2219,7 +2219,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2230,7 +2230,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2247,10 +2247,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,7 +2300,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2311,7 +2311,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2327,10 +2327,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2393,7 +2393,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2404,7 +2404,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2421,10 +2421,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json index a395b78d1d..48825ed514 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1158,7 +1158,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1169,7 +1169,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1185,10 +1185,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,7 +1251,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1262,7 +1262,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1279,10 +1279,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1332,7 +1332,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1343,7 +1343,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1359,10 +1359,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1425,7 +1425,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1436,7 +1436,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1453,10 +1453,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1574,7 +1574,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1585,7 +1585,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1601,10 +1601,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1667,7 +1667,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1678,7 +1678,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1695,10 +1695,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,7 +1748,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1759,7 +1759,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1775,10 +1775,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1841,7 +1841,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1852,7 +1852,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1869,10 +1869,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2126,7 +2126,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2137,7 +2137,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2153,10 +2153,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2219,7 +2219,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2230,7 +2230,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2247,10 +2247,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,7 +2300,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2311,7 +2311,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2327,10 +2327,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2393,7 +2393,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2404,7 +2404,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2421,10 +2421,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json index e2943dc939..ce0e4b034c 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1022,7 +1022,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1033,7 +1033,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1049,10 +1049,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1115,7 +1115,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1126,7 +1126,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1143,10 +1143,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,7 +1196,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1207,7 +1207,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,10 +1223,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1289,7 +1289,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1300,7 +1300,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1317,10 +1317,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1438,7 +1438,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1449,7 +1449,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1465,10 +1465,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1531,7 +1531,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1542,7 +1542,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1559,10 +1559,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,7 +1612,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1623,7 +1623,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1639,10 +1639,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1705,7 +1705,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1716,7 +1716,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1733,10 +1733,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1854,7 +1854,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1865,7 +1865,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1881,10 +1881,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1947,7 +1947,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1958,7 +1958,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1975,10 +1975,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2028,7 +2028,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2039,7 +2039,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2055,10 +2055,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2121,7 +2121,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2132,7 +2132,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2149,10 +2149,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2270,7 +2270,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2281,7 +2281,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2297,10 +2297,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2363,7 +2363,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2374,7 +2374,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2391,10 +2391,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2444,7 +2444,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2455,7 +2455,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2471,10 +2471,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2537,7 +2537,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2548,7 +2548,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2565,10 +2565,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2822,7 +2822,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2833,7 +2833,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2849,10 +2849,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2915,7 +2915,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2926,7 +2926,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2943,10 +2943,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2996,7 +2996,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3007,7 +3007,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3023,10 +3023,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3089,7 +3089,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3100,7 +3100,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3117,10 +3117,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json index 5dbc8dc824..3debfa8b5f 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1022,7 +1022,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1033,7 +1033,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1049,10 +1049,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1115,7 +1115,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1126,7 +1126,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1143,10 +1143,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,7 +1196,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1207,7 +1207,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,10 +1223,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1289,7 +1289,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1300,7 +1300,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1317,10 +1317,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1438,7 +1438,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1449,7 +1449,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1465,10 +1465,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1531,7 +1531,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1542,7 +1542,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1559,10 +1559,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,7 +1612,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1623,7 +1623,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1639,10 +1639,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1705,7 +1705,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1716,7 +1716,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1733,10 +1733,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1854,7 +1854,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1865,7 +1865,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1881,10 +1881,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1947,7 +1947,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1958,7 +1958,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1975,10 +1975,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2028,7 +2028,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2039,7 +2039,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2055,10 +2055,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2121,7 +2121,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2132,7 +2132,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2149,10 +2149,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2270,7 +2270,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2281,7 +2281,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2297,10 +2297,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2363,7 +2363,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2374,7 +2374,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2391,10 +2391,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2444,7 +2444,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2455,7 +2455,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2471,10 +2471,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2537,7 +2537,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2548,7 +2548,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2565,10 +2565,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2822,7 +2822,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2833,7 +2833,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2849,10 +2849,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2915,7 +2915,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2926,7 +2926,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2943,10 +2943,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2996,7 +2996,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3007,7 +3007,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3023,10 +3023,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3089,7 +3089,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3100,7 +3100,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3117,10 +3117,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json index fc15aeb53d..7abddcb438 100644 --- a/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found dataStreams, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -186,7 +186,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -197,7 +197,7 @@ "description": "Successfully returns the found dataStream.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -213,10 +213,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -279,7 +279,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -290,7 +290,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -307,10 +307,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -351,7 +351,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -362,7 +362,7 @@ "description": "Successfully returns the found readOnlyChannels, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -378,10 +378,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -425,7 +425,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -436,7 +436,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -453,10 +453,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -503,7 +503,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -514,7 +514,7 @@ "description": "Successfully returns the found readOnlyChannel.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -530,10 +530,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -596,7 +596,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -607,7 +607,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -677,7 +677,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -688,7 +688,7 @@ "description": "Successfully returns the found dataStreams, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -704,10 +704,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -770,7 +770,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -781,7 +781,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -798,10 +798,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -851,7 +851,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -862,7 +862,7 @@ "description": "Successfully returns the found dataStream identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -878,10 +878,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -944,7 +944,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -955,7 +955,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -972,10 +972,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1025,7 +1025,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1036,7 +1036,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1052,10 +1052,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1118,7 +1118,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1129,7 +1129,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1146,10 +1146,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1199,7 +1199,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1210,7 +1210,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1226,10 +1226,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1292,7 +1292,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1303,7 +1303,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1320,10 +1320,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1373,7 +1373,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1384,7 +1384,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1400,10 +1400,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1466,7 +1466,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1477,7 +1477,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1494,10 +1494,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1547,7 +1547,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1558,7 +1558,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1574,10 +1574,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1640,7 +1640,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1651,7 +1651,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1668,10 +1668,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1712,7 +1712,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1723,7 +1723,7 @@ "description": "Successfully returns the found readOnlyResourceChannels, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1739,10 +1739,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,7 +1786,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1797,7 +1797,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1814,10 +1814,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1864,7 +1864,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1875,7 +1875,7 @@ "description": "Successfully returns the found readOnlyResourceChannel.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1891,10 +1891,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1957,7 +1957,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -1968,7 +1968,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1985,10 +1985,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2038,7 +2038,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2049,7 +2049,7 @@ "description": "Successfully returns the found dataStreams, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2065,10 +2065,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2131,7 +2131,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2142,7 +2142,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2159,10 +2159,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2212,7 +2212,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2223,7 +2223,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2239,10 +2239,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2305,7 +2305,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2316,7 +2316,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2333,10 +2333,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2386,7 +2386,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2397,7 +2397,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2413,10 +2413,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2479,7 +2479,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2490,7 +2490,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2507,10 +2507,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2560,7 +2560,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2571,7 +2571,7 @@ "description": "Successfully returns the found dataStream identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2587,10 +2587,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2653,7 +2653,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2664,7 +2664,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2681,10 +2681,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2938,7 +2938,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -2949,7 +2949,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2965,10 +2965,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3031,7 +3031,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3042,7 +3042,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3059,10 +3059,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3180,7 +3180,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3191,7 +3191,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3207,10 +3207,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3273,7 +3273,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", "schema": { "type": "string" } @@ -3284,7 +3284,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3301,10 +3301,10 @@ } }, "304": { - "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/TestBuildingBlocks/JsonElementAssertionExtensions.cs b/test/TestBuildingBlocks/JsonElementAssertionExtensions.cs index e9688234b1..412148c26a 100644 --- a/test/TestBuildingBlocks/JsonElementAssertionExtensions.cs +++ b/test/TestBuildingBlocks/JsonElementAssertionExtensions.cs @@ -107,6 +107,11 @@ public void Be(object? value) _subject.ValueKind.Should().Be(JsonValueKind.Number); _subject.GetInt32().Should().Be(intValue); } + else if (value is double doubleValue) + { + _subject.ValueKind.Should().Be(JsonValueKind.Number); + _subject.GetDouble().Should().Be(doubleValue); + } else if (value is string stringValue) { _subject.ValueKind.Should().Be(JsonValueKind.String); From f04ec264621ae342cc6e619bb5c3f87049238c6f Mon Sep 17 00:00:00 2001 From: verdie-g Date: Wed, 29 May 2024 22:00:46 -0400 Subject: [PATCH 06/27] more stuff --- .../ModelStateValidationTests.cs | 169 +++- .../GeneratedSwagger/net6.0/swagger.g.json | 858 ++++++++++++++++++ .../GeneratedSwagger/net8.0/swagger.g.json | 30 +- .../ModelStateValidationFakers.cs | 5 +- .../ModelStateValidationTests.cs | 25 +- .../SocialMediaAccount.cs | 18 +- 6 files changed, 1050 insertions(+), 55 deletions(-) create mode 100644 test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index b5ef8b6074..78db643b99 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -26,7 +26,7 @@ public ModelStateValidationTests(IntegrationTestContext>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("'GivenName' and 'FirstName' do not match."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/givenName"); + } + + [Theory] + [InlineData("a")] + [InlineData("abcdefghijklmnopqrstu")] + public async Task Cannot_exceed_length_constraint(string firstName) + { + // Arrange + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + FirstName = firstName, + GivenName = firstName, + LastName = "" + } } }); // Assert - ExceptionAssertions assertion = await action.Should().ThrowExactlyAsync(); - assertion.Which.Message.Should().Be("Cannot write a null value for property 'lastName'. Property requires a value. Path 'data.attributes'."); + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field FirstName must be a string or collection type with a minimum length of '2' and maximum length of '20'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/firstName"); } [Theory] [InlineData("ab")] [InlineData("abcdefghijklmnopqrs")] - public async Task Cannot_exceed_length_constraint(string userName) + public async Task Cannot_exceed_string_length_constraint(string userName) { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -66,8 +109,8 @@ public async Task Cannot_exceed_length_constraint(string userName) { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - UserName = userName + LastName = "", + UserName = userName, } } }); @@ -87,8 +130,6 @@ public async Task Cannot_exceed_length_constraint(string userName) public async Task Cannot_violate_regular_expression_constraint() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -99,8 +140,8 @@ public async Task Cannot_violate_regular_expression_constraint() { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - UserName = "aB1" + LastName = "", + UserName = "aB1", } } }); @@ -120,8 +161,6 @@ public async Task Cannot_violate_regular_expression_constraint() public async Task Cannot_use_invalid_credit_card() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -132,8 +171,8 @@ public async Task Cannot_use_invalid_credit_card() { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - CreditCard = "123-456" + LastName = "", + CreditCard = "123-456", } } }); @@ -153,8 +192,6 @@ public async Task Cannot_use_invalid_credit_card() public async Task Cannot_use_invalid_email() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -165,8 +202,8 @@ public async Task Cannot_use_invalid_email() { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - Email = "abc" + LastName = "", + Email = "abc", } } }); @@ -190,8 +227,6 @@ public async Task Cannot_use_invalid_email() public async Task Cannot_use_double_outside_of_valid_range(int age) { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -202,8 +237,8 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - Age = age + LastName = "", + Age = age, } } }); @@ -214,7 +249,7 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0 and 123."); + errorObject.Detail.Should().Be("The field Age must be between 0.1 and 122.9."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } @@ -223,8 +258,6 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) public async Task Cannot_use_invalid_url() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -235,8 +268,8 @@ public async Task Cannot_use_invalid_url() { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - BackgroundPicture = new Uri("/justapath", UriKind.Relative) + LastName = "", + BackgroundPicture = new Uri("/justapath", UriKind.Relative), } } }); @@ -253,11 +286,40 @@ public async Task Cannot_use_invalid_url() } [Fact] - public async Task Cannot_use_TimeSpan_outside_of_valid_range() + public async Task Cannot_use_non_allowed_value() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = "", + CountryCode = "US" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The CountryCode field does not equal any of the values specified in AllowedValuesAttribute."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/countryCode"); + } + [Fact] + public async Task Cannot_use_denied_value() + { + // Arrange using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -268,8 +330,39 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - NextRevalidation = "00:00:01" + LastName = "", + Planet = "pluto" + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The Planet field equals one of the values specified in DeniedValuesAttribute."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/planet"); + } + + [Fact] + public async Task Cannot_use_TimeSpan_outside_of_valid_range() + { + // Arrange + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = "", + NextRevalidation = "00:00:01", } } }); @@ -289,8 +382,6 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() public async Task Cannot_use_invalid_TimeOnly() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); @@ -301,8 +392,8 @@ public async Task Cannot_use_invalid_TimeOnly() { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, - ValidatedAtTime = TimeSpan.FromSeconds(-1) + LastName = "", + ValidatedAtTime = TimeSpan.FromSeconds(-1), } } }); @@ -344,6 +435,8 @@ public async Task Can_create_resource_with_valid_properties() Age = socialMediaAccount.Age, ProfilePicture = socialMediaAccount.ProfilePicture, BackgroundPicture = new Uri(socialMediaAccount.BackgroundPicture!), + Tags = socialMediaAccount.Tags, + Planet = socialMediaAccount.Planet, NextRevalidation = "02:00:00", ValidatedAt = socialMediaAccount.ValidatedAt!, ValidatedAtDate = new DateTimeOffset(socialMediaAccount.ValidatedAtDate!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), diff --git a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json new file mode 100644 index 0000000000..14b880aead --- /dev/null +++ b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json @@ -0,0 +1,858 @@ +{ + "openapi": "3.0.1", + "info": { + "title": "OpenApiTests", + "version": "1.0" + }, + "servers": [ + { + "url": "http://localhost" + } + ], + "paths": { + "/socialMediaAccounts": { + "post": { + "tags": [ + "socialMediaAccounts" + ], + "summary": "Creates a new socialMediaAccount.", + "operationId": "postSocialMediaAccount", + "parameters": [ + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + } + ], + "requestBody": { + "description": "The attributes and relationships of the socialMediaAccount to create.", + "content": { + "application/vnd.api+json": { + "schema": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountPostRequestDocument" + } + ] + } + } + }, + "required": true + }, + "responses": { + "201": { + "description": "The socialMediaAccount was successfully created, which resulted in additional changes. The newly created socialMediaAccount is returned.", + "headers": { + "Location": { + "description": "The URL at which the newly created socialMediaAccount can be retrieved.", + "required": true, + "schema": { + "type": "string", + "format": "uri" + } + } + }, + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/socialMediaAccountPrimaryResponseDocument" + } + } + } + }, + "204": { + "description": "The socialMediaAccount was successfully created, which did not result in additional changes." + }, + "400": { + "description": "The query string is invalid or the request body is missing or malformed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "403": { + "description": "Client-generated IDs cannot be used at this endpoint.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "404": { + "description": "A related resource does not exist.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "409": { + "description": "The request body contains conflicting information or another resource with the same ID already exists.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "422": { + "description": "Validation of the request body failed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + } + }, + "/socialMediaAccounts/{id}": { + "patch": { + "tags": [ + "socialMediaAccounts" + ], + "summary": "Updates an existing socialMediaAccount.", + "operationId": "patchSocialMediaAccount", + "parameters": [ + { + "name": "id", + "in": "path", + "description": "The identifier of the socialMediaAccount to update.", + "required": true, + "schema": { + "type": "string" + } + }, + { + "name": "query", + "in": "query", + "description": "For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters.", + "schema": { + "type": "object", + "additionalProperties": { + "type": "string", + "nullable": true + }, + "example": "" + } + } + ], + "requestBody": { + "description": "The attributes and relationships of the socialMediaAccount to update. Omitted fields are left unchanged.", + "content": { + "application/vnd.api+json": { + "schema": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountPatchRequestDocument" + } + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "The socialMediaAccount was successfully updated, which resulted in additional changes. The updated socialMediaAccount is returned.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/socialMediaAccountPrimaryResponseDocument" + } + } + } + }, + "204": { + "description": "The socialMediaAccount was successfully updated, which did not result in additional changes." + }, + "400": { + "description": "The query string is invalid or the request body is missing or malformed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "404": { + "description": "The socialMediaAccount or a related resource does not exist.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "409": { + "description": "A resource type or identifier in the request body is incompatible.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + }, + "422": { + "description": "Validation of the request body failed.", + "content": { + "application/vnd.api+json": { + "schema": { + "$ref": "#/components/schemas/errorResponseDocument" + } + } + } + } + } + } + } + }, + "components": { + "schemas": { + "dataInResponse": { + "required": [ + "id", + "type" + ], + "type": "object", + "properties": { + "type": { + "minLength": 1, + "type": "string" + }, + "id": { + "minLength": 1, + "type": "string" + } + }, + "additionalProperties": false, + "discriminator": { + "propertyName": "type", + "mapping": { + "socialMediaAccounts": "#/components/schemas/socialMediaAccountDataInResponse" + } + }, + "x-abstract": true + }, + "errorLinks": { + "type": "object", + "properties": { + "about": { + "type": "string", + "nullable": true + }, + "type": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, + "errorObject": { + "type": "object", + "properties": { + "id": { + "type": "string", + "nullable": true + }, + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/errorLinks" + } + ], + "nullable": true + }, + "status": { + "type": "string" + }, + "code": { + "type": "string", + "nullable": true + }, + "title": { + "type": "string", + "nullable": true + }, + "detail": { + "type": "string", + "nullable": true + }, + "source": { + "allOf": [ + { + "$ref": "#/components/schemas/errorSource" + } + ], + "nullable": true + }, + "meta": { + "type": "object", + "additionalProperties": { }, + "nullable": true + } + }, + "additionalProperties": false + }, + "errorResponseDocument": { + "required": [ + "errors", + "links" + ], + "type": "object", + "properties": { + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/errorTopLevelLinks" + } + ] + }, + "errors": { + "type": "array", + "items": { + "$ref": "#/components/schemas/errorObject" + } + }, + "meta": { + "type": "object", + "additionalProperties": { + "type": "object", + "nullable": true + } + } + }, + "additionalProperties": false + }, + "errorSource": { + "type": "object", + "properties": { + "pointer": { + "type": "string", + "nullable": true + }, + "parameter": { + "type": "string", + "nullable": true + }, + "header": { + "type": "string", + "nullable": true + } + }, + "additionalProperties": false + }, + "errorTopLevelLinks": { + "type": "object", + "properties": { + "self": { + "type": "string" + }, + "describedby": { + "type": "string" + } + }, + "additionalProperties": false + }, + "resourceLinks": { + "type": "object", + "properties": { + "self": { + "type": "string" + } + }, + "additionalProperties": false + }, + "resourceTopLevelLinks": { + "type": "object", + "properties": { + "self": { + "type": "string" + }, + "describedby": { + "type": "string" + } + }, + "additionalProperties": false + }, + "socialMediaAccountAttributesInPatchRequest": { + "type": "object", + "properties": { + "alternativeId": { + "type": "string", + "format": "uuid", + "nullable": true + }, + "firstName": { + "type": "string", + "nullable": true + }, + "givenName": { + "type": "string", + "nullable": true + }, + "lastName": { + "type": "string" + }, + "userName": { + "maxLength": 18, + "minLength": 3, + "pattern": "^[a-zA-Z]+$", + "type": "string", + "nullable": true + }, + "creditCard": { + "type": "string", + "format": "credit-card", + "nullable": true + }, + "email": { + "type": "string", + "format": "email", + "nullable": true + }, + "password": { + "type": "string", + "nullable": true + }, + "phone": { + "type": "string", + "format": "tel", + "nullable": true + }, + "age": { + "maximum": 122.9, + "minimum": 0.1, + "type": "number", + "format": "double", + "nullable": true + }, + "profilePicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "backgroundPicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "tags": { + "type": "array", + "items": { + "type": "string" + }, + "nullable": true + }, + "countryCode": { + "type": "string", + "nullable": true + }, + "planet": { + "type": "string", + "nullable": true + }, + "nextRevalidation": { + "type": "string", + "format": "date-span", + "nullable": true + }, + "validatedAt": { + "type": "string", + "format": "date-time", + "nullable": true + }, + "validatedAtDate": { + "type": "string", + "format": "date", + "nullable": true + }, + "validatedAtTime": { + "type": "string", + "format": "time", + "nullable": true + } + }, + "additionalProperties": false + }, + "socialMediaAccountAttributesInPostRequest": { + "required": [ + "lastName" + ], + "type": "object", + "properties": { + "alternativeId": { + "type": "string", + "format": "uuid", + "nullable": true + }, + "firstName": { + "type": "string", + "nullable": true + }, + "givenName": { + "type": "string", + "nullable": true + }, + "lastName": { + "type": "string" + }, + "userName": { + "maxLength": 18, + "minLength": 3, + "pattern": "^[a-zA-Z]+$", + "type": "string", + "nullable": true + }, + "creditCard": { + "type": "string", + "format": "credit-card", + "nullable": true + }, + "email": { + "type": "string", + "format": "email", + "nullable": true + }, + "password": { + "type": "string", + "nullable": true + }, + "phone": { + "type": "string", + "format": "tel", + "nullable": true + }, + "age": { + "maximum": 122.9, + "minimum": 0.1, + "type": "number", + "format": "double", + "nullable": true + }, + "profilePicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "backgroundPicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "tags": { + "type": "array", + "items": { + "type": "string" + }, + "nullable": true + }, + "countryCode": { + "type": "string", + "nullable": true + }, + "planet": { + "type": "string", + "nullable": true + }, + "nextRevalidation": { + "type": "string", + "format": "date-span", + "nullable": true + }, + "validatedAt": { + "type": "string", + "format": "date-time", + "nullable": true + }, + "validatedAtDate": { + "type": "string", + "format": "date", + "nullable": true + }, + "validatedAtTime": { + "type": "string", + "format": "time", + "nullable": true + } + }, + "additionalProperties": false + }, + "socialMediaAccountAttributesInResponse": { + "type": "object", + "properties": { + "alternativeId": { + "type": "string", + "format": "uuid", + "nullable": true + }, + "firstName": { + "type": "string", + "nullable": true + }, + "givenName": { + "type": "string", + "nullable": true + }, + "lastName": { + "type": "string" + }, + "userName": { + "maxLength": 18, + "minLength": 3, + "pattern": "^[a-zA-Z]+$", + "type": "string", + "nullable": true + }, + "creditCard": { + "type": "string", + "format": "credit-card", + "nullable": true + }, + "email": { + "type": "string", + "format": "email", + "nullable": true + }, + "password": { + "type": "string", + "nullable": true + }, + "phone": { + "type": "string", + "format": "tel", + "nullable": true + }, + "age": { + "maximum": 122.9, + "minimum": 0.1, + "type": "number", + "format": "double", + "nullable": true + }, + "profilePicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "backgroundPicture": { + "type": "string", + "format": "uri", + "nullable": true + }, + "tags": { + "type": "array", + "items": { + "type": "string" + }, + "nullable": true + }, + "countryCode": { + "type": "string", + "nullable": true + }, + "planet": { + "type": "string", + "nullable": true + }, + "nextRevalidation": { + "type": "string", + "format": "date-span", + "nullable": true + }, + "validatedAt": { + "type": "string", + "format": "date-time", + "nullable": true + }, + "validatedAtDate": { + "type": "string", + "format": "date", + "nullable": true + }, + "validatedAtTime": { + "type": "string", + "format": "time", + "nullable": true + } + }, + "additionalProperties": false + }, + "socialMediaAccountDataInPatchRequest": { + "required": [ + "id", + "type" + ], + "type": "object", + "properties": { + "type": { + "$ref": "#/components/schemas/socialMediaAccountResourceType" + }, + "id": { + "minLength": 1, + "type": "string" + }, + "attributes": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountAttributesInPatchRequest" + } + ] + } + }, + "additionalProperties": false + }, + "socialMediaAccountDataInPostRequest": { + "required": [ + "type" + ], + "type": "object", + "properties": { + "type": { + "$ref": "#/components/schemas/socialMediaAccountResourceType" + }, + "attributes": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountAttributesInPostRequest" + } + ] + } + }, + "additionalProperties": false + }, + "socialMediaAccountDataInResponse": { + "allOf": [ + { + "$ref": "#/components/schemas/dataInResponse" + }, + { + "type": "object", + "properties": { + "attributes": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountAttributesInResponse" + } + ] + }, + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/resourceLinks" + } + ] + }, + "meta": { + "type": "object", + "additionalProperties": { + "type": "object", + "nullable": true + } + } + }, + "additionalProperties": false + } + ], + "additionalProperties": false + }, + "socialMediaAccountPatchRequestDocument": { + "required": [ + "data" + ], + "type": "object", + "properties": { + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountDataInPatchRequest" + } + ] + } + }, + "additionalProperties": false + }, + "socialMediaAccountPostRequestDocument": { + "required": [ + "data" + ], + "type": "object", + "properties": { + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountDataInPostRequest" + } + ] + } + }, + "additionalProperties": false + }, + "socialMediaAccountPrimaryResponseDocument": { + "required": [ + "data", + "links" + ], + "type": "object", + "properties": { + "links": { + "allOf": [ + { + "$ref": "#/components/schemas/resourceTopLevelLinks" + } + ] + }, + "data": { + "allOf": [ + { + "$ref": "#/components/schemas/socialMediaAccountDataInResponse" + } + ] + }, + "included": { + "type": "array", + "items": { + "$ref": "#/components/schemas/dataInResponse" + } + }, + "meta": { + "type": "object", + "additionalProperties": { + "type": "object", + "nullable": true + } + } + }, + "additionalProperties": false + }, + "socialMediaAccountResourceType": { + "enum": [ + "socialMediaAccounts" + ], + "type": "string", + "additionalProperties": false + } + } + } +} \ No newline at end of file diff --git a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json index f4ffba94ae..14b880aead 100644 --- a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json +++ b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json @@ -413,7 +413,6 @@ "nullable": true }, "lastName": { - "minLength": 1, "type": "string" }, "userName": { @@ -460,13 +459,20 @@ "nullable": true }, "tags": { - "uniqueItems": true, "type": "array", "items": { "type": "string" }, "nullable": true }, + "countryCode": { + "type": "string", + "nullable": true + }, + "planet": { + "type": "string", + "nullable": true + }, "nextRevalidation": { "type": "string", "format": "date-span", @@ -510,7 +516,6 @@ "nullable": true }, "lastName": { - "minLength": 1, "type": "string" }, "userName": { @@ -557,13 +562,20 @@ "nullable": true }, "tags": { - "uniqueItems": true, "type": "array", "items": { "type": "string" }, "nullable": true }, + "countryCode": { + "type": "string", + "nullable": true + }, + "planet": { + "type": "string", + "nullable": true + }, "nextRevalidation": { "type": "string", "format": "date-span", @@ -604,7 +616,6 @@ "nullable": true }, "lastName": { - "minLength": 1, "type": "string" }, "userName": { @@ -651,13 +662,20 @@ "nullable": true }, "tags": { - "uniqueItems": true, "type": "array", "items": { "type": "string" }, "nullable": true }, + "countryCode": { + "type": "string", + "nullable": true + }, + "planet": { + "type": "string", + "nullable": true + }, "nextRevalidation": { "type": "string", "format": "date-span", diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 5998cbbd15..64d39cc6d6 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -21,12 +21,15 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Random.String2(3, 18)) .RuleFor(socialMediaAccount => socialMediaAccount.CreditCard, faker => faker.Finance.CreditCardNumber()) .RuleFor(socialMediaAccount => socialMediaAccount.Email, faker => faker.Person.Email) + .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => faker.Random.String2(8, 32)) .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => Convert.ToBase64String(faker.Random.Bytes(20))) .RuleFor(socialMediaAccount => socialMediaAccount.Phone, faker => faker.Person.Phone) .RuleFor(socialMediaAccount => socialMediaAccount.Age, faker => faker.Random.Double(0.1, 122.9)) .RuleFor(socialMediaAccount => socialMediaAccount.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) .RuleFor(socialMediaAccount => socialMediaAccount.BackgroundPicture, faker => faker.Image.LoremFlickrUrl()) - .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => [..faker.Make(faker.Random.Number(), () => faker.Random.String2(2, 8))]) + .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => faker.Make(faker.Random.Number(0, 10), () => faker.Random.String2(2, 10))) + .RuleFor(socialMediaAccount => socialMediaAccount.CountryCode, faker => faker.Random.ListItem(["NL", "FR"])) + .RuleFor(socialMediaAccount => socialMediaAccount.Planet, faker => faker.Random.String2(2, 8)) .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAt, faker => faker.Date.Recent().ToUniversalTime()) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtDate, faker => DateOnly.FromDateTime(faker.Date.Recent())) diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index 5824cb4d1f..1506e63983 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -25,7 +25,7 @@ public ModelStateValidationTests(OpenApiTestContext { - lastNameEl.Should().HaveProperty("minLength", 1); + lastNameEl.Should().NotContainPath("minLength"); lastNameEl.Should().HaveProperty("type", "string"); }); } @@ -193,7 +193,7 @@ public async Task Url_annotation_on_resource_property_produces_expected_schema(s [Theory] [MemberData(nameof(ModelNames))] - public async Task Uri_type_on_resource_property_produces_expected_schema(string modelName) + public async Task Uri_type_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -208,7 +208,7 @@ public async Task Uri_type_on_resource_property_produces_expected_schema(string [Theory] [MemberData(nameof(ModelNames))] - public async Task HashSet_annotated_with_Length_AllowedValues_DeniedValues_on_resource_property_produces_expected_schema(string modelName) + public async Task HashSet_type_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -216,7 +216,6 @@ public async Task HashSet_annotated_with_Length_AllowedValues_DeniedValues_on_re // Assert document.Should().ContainPath($"components.schemas.{modelName}.properties.tags").With(tagsEl => { - tagsEl.Should().HaveProperty("uniqueItems", true); tagsEl.Should().HaveProperty("type", "array"); tagsEl.Should().ContainPath("items").With(itemsEl => { @@ -225,6 +224,20 @@ public async Task HashSet_annotated_with_Length_AllowedValues_DeniedValues_on_re }); } + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Allowed_denied_annotations_on_resource_property_produces_expected_schema(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.planet").With(planetEl => + { + planetEl.Should().HaveProperty("type", "string"); + }); + } + [Theory] [MemberData(nameof(ModelNames))] public async Task TimeSpan_range_annotation_on_resource_property_produces_expected_schema(string modelName) diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index f5edd9a8b9..db9d75107c 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -24,7 +24,7 @@ public sealed class SocialMediaAccount : Identifiable public string? GivenName { get; set; } [Attr] - [Required(AllowEmptyStrings = false)] + [Required(AllowEmptyStrings = true)] public string LastName { get; set; } = default!; [Attr] @@ -63,11 +63,21 @@ public sealed class SocialMediaAccount : Identifiable [Attr] #if NET8_0_OR_GREATER - [AllowedValues("tag1", "tag2")] - [DeniedValues("tag3")] [Length(0, 10)] #endif - public HashSet? Tags { get; set; } + public List? Tags { get; set; } + + [Attr] +#if NET8_0_OR_GREATER + [AllowedValues(null, "NL", "FR")] +#endif + public string? CountryCode { get; set; } + + [Attr] +#if NET8_0_OR_GREATER + [DeniedValues("pluto")] +#endif + public string? Planet { get; set; } [Attr] [Range(typeof(TimeSpan), "01:00", "05:00")] From 2e28ac0557e33bc30822a05d596b7bbf51d2283b Mon Sep 17 00:00:00 2001 From: verdie-g Date: Wed, 29 May 2024 22:08:00 -0400 Subject: [PATCH 07/27] Discard unrelated changes --- .../Documentation/DocumentationTests.cs | 96 ++--- test/OpenApiTests/Headers/HeaderTests.cs | 4 +- .../LegacyOpenApi/expected-swagger.json | 352 +++++++++--------- 3 files changed, 226 insertions(+), 226 deletions(-) diff --git a/test/OpenApiTests/Documentation/DocumentationTests.cs b/test/OpenApiTests/Documentation/DocumentationTests.cs index 3a071eb88e..9a254968e7 100644 --- a/test/OpenApiTests/Documentation/DocumentationTests.cs +++ b/test/OpenApiTests/Documentation/DocumentationTests.cs @@ -72,16 +72,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[0].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[1].name", "If-None-Match"); parametersElement.Should().HaveProperty("[1].in", "header"); - parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(3); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found skyscrapers, or an empty array if none were found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); }); }); @@ -98,17 +98,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[0].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[1].name", "If-None-Match"); parametersElement.Should().HaveProperty("[1].in", "header"); - parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[1].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(3); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); }); }); @@ -153,16 +153,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found skyscraper."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -182,17 +182,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -260,16 +260,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found elevator, or `null` if it was not found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -289,17 +289,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -321,16 +321,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found elevator identity, or `null` if it was not found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -350,17 +350,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -405,16 +405,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found spaces, or an empty array if none were found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -434,17 +434,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", ResourceTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -466,16 +466,16 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); getElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "Successfully returns the found space identities, or an empty array if none were found."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); @@ -495,17 +495,17 @@ public async Task Endpoints_are_documented() parametersElement.Should().HaveProperty("[1].description", RelationshipTextQueryString); parametersElement.Should().HaveProperty("[2].name", "If-None-Match"); parametersElement.Should().HaveProperty("[2].in", "header"); - parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + parametersElement.Should().HaveProperty("[2].description", "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); }); headElement.Should().ContainPath("responses").With(responsesElement => { responsesElement.EnumerateObject().ShouldHaveCount(4); responsesElement.Should().HaveProperty("200.description", "The operation completed successfully."); - responsesElement.Should().HaveProperty("200.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("200.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("200.headers.Content-Length.description", "Size of the HTTP response body, in bytes."); - responsesElement.Should().HaveProperty("304.description", "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header."); - responsesElement.Should().HaveProperty("304.headers.ETag.description", "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + responsesElement.Should().HaveProperty("304.description", "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header."); + responsesElement.Should().HaveProperty("304.headers.ETag.description", "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); responsesElement.Should().HaveProperty("400.description", "The query string is invalid."); responsesElement.Should().HaveProperty("404.description", "The skyscraper does not exist."); }); diff --git a/test/OpenApiTests/Headers/HeaderTests.cs b/test/OpenApiTests/Headers/HeaderTests.cs index 95983b038e..d900092ad2 100644 --- a/test/OpenApiTests/Headers/HeaderTests.cs +++ b/test/OpenApiTests/Headers/HeaderTests.cs @@ -42,7 +42,7 @@ public async Task Endpoints_have_caching_headers(string endpointPath) parameterElement.Should().NotContainPath("required"); parameterElement.Should().HaveProperty("description", - "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount."); + "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint."); parameterElement.Should().ContainPath("schema").With(schemaElement => { @@ -59,7 +59,7 @@ public async Task Endpoints_have_caching_headers(string endpointPath) static void AssertETag(JsonElement etagElement) { etagElement.Should().HaveProperty("description", - "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); + "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes."); etagElement.Should().HaveProperty("required", true); diff --git a/test/OpenApiTests/LegacyOpenApi/expected-swagger.json b/test/OpenApiTests/LegacyOpenApi/expected-swagger.json index 10d4aaf5b2..2112a1cf5c 100644 --- a/test/OpenApiTests/LegacyOpenApi/expected-swagger.json +++ b/test/OpenApiTests/LegacyOpenApi/expected-swagger.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found airplanes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found airplane.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1149,7 +1149,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1160,7 +1160,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1176,10 +1176,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,7 +1223,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1234,7 +1234,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,10 +1251,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1413,7 +1413,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1424,7 +1424,7 @@ "description": "Successfully returns the found flight-attendant.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1440,10 +1440,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1506,7 +1506,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1517,7 +1517,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1534,10 +1534,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1721,7 +1721,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1732,7 +1732,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,10 +1748,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1814,7 +1814,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1825,7 +1825,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1842,10 +1842,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1895,7 +1895,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1906,7 +1906,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1922,10 +1922,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1988,7 +1988,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1999,7 +1999,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2016,10 +2016,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2273,7 +2273,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2284,7 +2284,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,10 +2300,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2366,7 +2366,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2377,7 +2377,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2394,10 +2394,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2447,7 +2447,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2458,7 +2458,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2474,10 +2474,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2540,7 +2540,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2551,7 +2551,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2568,10 +2568,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2816,7 +2816,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2827,7 +2827,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2843,10 +2843,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2890,7 +2890,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2901,7 +2901,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2918,10 +2918,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3080,7 +3080,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3091,7 +3091,7 @@ "description": "Successfully returns the found flight.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3107,10 +3107,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3173,7 +3173,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3184,7 +3184,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3201,10 +3201,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3388,7 +3388,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3399,7 +3399,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3415,10 +3415,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3481,7 +3481,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3492,7 +3492,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3509,10 +3509,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3562,7 +3562,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3573,7 +3573,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3589,10 +3589,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3655,7 +3655,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3666,7 +3666,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3683,10 +3683,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3804,7 +3804,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3815,7 +3815,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3831,10 +3831,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3897,7 +3897,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3908,7 +3908,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3925,10 +3925,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3978,7 +3978,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3989,7 +3989,7 @@ "description": "Successfully returns the found flight-attendant identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4005,10 +4005,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4071,7 +4071,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4082,7 +4082,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4099,10 +4099,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4356,7 +4356,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4367,7 +4367,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4383,10 +4383,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4449,7 +4449,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4460,7 +4460,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4477,10 +4477,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4530,7 +4530,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4541,7 +4541,7 @@ "description": "Successfully returns the found passenger identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4557,10 +4557,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4623,7 +4623,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4634,7 +4634,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4651,10 +4651,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4908,7 +4908,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4919,7 +4919,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4935,10 +4935,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5001,7 +5001,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5012,7 +5012,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5029,10 +5029,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5082,7 +5082,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5093,7 +5093,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5109,10 +5109,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5175,7 +5175,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5186,7 +5186,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5203,10 +5203,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5315,7 +5315,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5326,7 +5326,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5342,10 +5342,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5389,7 +5389,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5400,7 +5400,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5417,10 +5417,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5579,7 +5579,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5590,7 +5590,7 @@ "description": "Successfully returns the found passenger.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5606,10 +5606,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5672,7 +5672,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5683,7 +5683,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5700,10 +5700,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" From 6c78d76b9ffef25c4728b6cb02125ad75bd1deb8 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Wed, 29 May 2024 22:09:07 -0400 Subject: [PATCH 08/27] Discard more unrealted changes --- .../Headers/GeneratedSwagger/swagger.g.json | 64 ++-- .../GeneratedSwagger/swagger.g.json | 352 +++++++++--------- .../Enabled/GeneratedSwagger/swagger.g.json | 224 +++++------ .../CamelCase/GeneratedSwagger/swagger.g.json | 160 ++++---- .../KebabCase/GeneratedSwagger/swagger.g.json | 160 ++++---- .../GeneratedSwagger/swagger.g.json | 160 ++++---- .../GeneratedSwagger/swagger.g.json | 192 +++++----- .../GeneratedSwagger/swagger.g.json | 160 ++++---- .../GeneratedSwagger/swagger.g.json | 160 ++++---- .../GeneratedSwagger/swagger.g.json | 224 +++++------ .../GeneratedSwagger/swagger.g.json | 224 +++++------ .../GeneratedSwagger/swagger.g.json | 288 +++++++------- 12 files changed, 1184 insertions(+), 1184 deletions(-) diff --git a/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json index 4d8248c33c..c8e1735b6b 100644 --- a/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/Headers/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found countries, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found country.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found languages, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found language identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json index 10d4aaf5b2..2112a1cf5c 100644 --- a/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/LegacyOpenApi/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found airplanes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found airplane.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1149,7 +1149,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1160,7 +1160,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1176,10 +1176,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,7 +1223,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1234,7 +1234,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,10 +1251,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1413,7 +1413,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1424,7 +1424,7 @@ "description": "Successfully returns the found flight-attendant.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1440,10 +1440,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1506,7 +1506,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1517,7 +1517,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1534,10 +1534,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1721,7 +1721,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1732,7 +1732,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,10 +1748,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1814,7 +1814,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1825,7 +1825,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1842,10 +1842,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1895,7 +1895,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1906,7 +1906,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1922,10 +1922,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1988,7 +1988,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1999,7 +1999,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2016,10 +2016,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2273,7 +2273,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2284,7 +2284,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,10 +2300,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2366,7 +2366,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2377,7 +2377,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2394,10 +2394,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2447,7 +2447,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2458,7 +2458,7 @@ "description": "Successfully returns the found flight identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2474,10 +2474,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2540,7 +2540,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2551,7 +2551,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2568,10 +2568,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2816,7 +2816,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2827,7 +2827,7 @@ "description": "Successfully returns the found flights, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2843,10 +2843,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2890,7 +2890,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2901,7 +2901,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2918,10 +2918,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3080,7 +3080,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3091,7 +3091,7 @@ "description": "Successfully returns the found flight.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3107,10 +3107,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3173,7 +3173,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3184,7 +3184,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3201,10 +3201,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3388,7 +3388,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3399,7 +3399,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3415,10 +3415,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3481,7 +3481,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3492,7 +3492,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3509,10 +3509,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3562,7 +3562,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3573,7 +3573,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3589,10 +3589,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3655,7 +3655,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3666,7 +3666,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3683,10 +3683,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3804,7 +3804,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3815,7 +3815,7 @@ "description": "Successfully returns the found flight-attendants, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3831,10 +3831,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3897,7 +3897,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3908,7 +3908,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3925,10 +3925,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3978,7 +3978,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3989,7 +3989,7 @@ "description": "Successfully returns the found flight-attendant identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4005,10 +4005,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4071,7 +4071,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4082,7 +4082,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4099,10 +4099,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4356,7 +4356,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4367,7 +4367,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4383,10 +4383,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4449,7 +4449,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4460,7 +4460,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4477,10 +4477,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4530,7 +4530,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4541,7 +4541,7 @@ "description": "Successfully returns the found passenger identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4557,10 +4557,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4623,7 +4623,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4634,7 +4634,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4651,10 +4651,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4908,7 +4908,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -4919,7 +4919,7 @@ "description": "Successfully returns the found flight-attendant, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -4935,10 +4935,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5001,7 +5001,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5012,7 +5012,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5029,10 +5029,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5082,7 +5082,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5093,7 +5093,7 @@ "description": "Successfully returns the found flight-attendant identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5109,10 +5109,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5175,7 +5175,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5186,7 +5186,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5203,10 +5203,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5315,7 +5315,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5326,7 +5326,7 @@ "description": "Successfully returns the found passengers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5342,10 +5342,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5389,7 +5389,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5400,7 +5400,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5417,10 +5417,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5579,7 +5579,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5590,7 +5590,7 @@ "description": "Successfully returns the found passenger.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5606,10 +5606,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5672,7 +5672,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -5683,7 +5683,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -5700,10 +5700,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json index a0fe80c81c..adcd8418ba 100644 --- a/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/Links/Enabled/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found accommodations, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found accommodation.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found excursions, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found excursion.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1160,7 +1160,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1171,7 +1171,7 @@ "description": "Successfully returns the found transports, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1187,10 +1187,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1234,7 +1234,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1245,7 +1245,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,10 +1262,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1424,7 +1424,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1435,7 +1435,7 @@ "description": "Successfully returns the found transport.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1451,10 +1451,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1517,7 +1517,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1528,7 +1528,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1545,10 +1545,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1723,7 +1723,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1734,7 +1734,7 @@ "description": "Successfully returns the found vacations, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1750,10 +1750,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1797,7 +1797,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1808,7 +1808,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1825,10 +1825,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1987,7 +1987,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1998,7 +1998,7 @@ "description": "Successfully returns the found vacation.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2014,10 +2014,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2080,7 +2080,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2091,7 +2091,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2108,10 +2108,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2295,7 +2295,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2306,7 +2306,7 @@ "description": "Successfully returns the found accommodation, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2322,10 +2322,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2388,7 +2388,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2399,7 +2399,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2416,10 +2416,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2469,7 +2469,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2480,7 +2480,7 @@ "description": "Successfully returns the found accommodation identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2496,10 +2496,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2562,7 +2562,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2573,7 +2573,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2590,10 +2590,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2711,7 +2711,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2722,7 +2722,7 @@ "description": "Successfully returns the found excursions, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2738,10 +2738,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2804,7 +2804,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2815,7 +2815,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2832,10 +2832,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2885,7 +2885,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2896,7 +2896,7 @@ "description": "Successfully returns the found excursion identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2912,10 +2912,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2978,7 +2978,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2989,7 +2989,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3006,10 +3006,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3263,7 +3263,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3274,7 +3274,7 @@ "description": "Successfully returns the found transport, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3290,10 +3290,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3356,7 +3356,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3367,7 +3367,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3384,10 +3384,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3437,7 +3437,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3448,7 +3448,7 @@ "description": "Successfully returns the found transport identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3464,10 +3464,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3530,7 +3530,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3541,7 +3541,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3558,10 +3558,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json index eafe4e103a..3fae1e7323 100644 --- a/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/NamingConventions/CamelCase/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found staffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found staffMember.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found supermarkets, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found supermarket.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1169,7 +1169,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1180,7 +1180,7 @@ "description": "Successfully returns the found staffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,10 +1196,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,7 +1262,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1273,7 +1273,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1290,10 +1290,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1343,7 +1343,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1354,7 +1354,7 @@ "description": "Successfully returns the found staffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,10 +1370,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1436,7 +1436,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1447,7 +1447,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1464,10 +1464,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found staffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found staffMember identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found staffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found staffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json index 35abe26923..f3ee10e406 100644 --- a/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/NamingConventions/KebabCase/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found staff-members, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found staff-member.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found supermarkets, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found supermarket.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1169,7 +1169,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1180,7 +1180,7 @@ "description": "Successfully returns the found staff-member, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,10 +1196,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,7 +1262,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1273,7 +1273,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1290,10 +1290,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1343,7 +1343,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1354,7 +1354,7 @@ "description": "Successfully returns the found staff-member identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,10 +1370,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1436,7 +1436,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1447,7 +1447,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1464,10 +1464,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found staff-members, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found staff-member identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found staff-member, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found staff-member identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json index 67e5ec6cf0..cbbd39fce4 100644 --- a/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/NamingConventions/PascalCase/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found StaffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found StaffMember.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -597,7 +597,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -608,7 +608,7 @@ "description": "Successfully returns the found Supermarkets, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -671,7 +671,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -682,7 +682,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,10 +699,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -861,7 +861,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -872,7 +872,7 @@ "description": "Successfully returns the found Supermarket.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -888,10 +888,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -954,7 +954,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -965,7 +965,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -982,10 +982,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1169,7 +1169,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1180,7 +1180,7 @@ "description": "Successfully returns the found StaffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,10 +1196,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1262,7 +1262,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1273,7 +1273,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1290,10 +1290,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1343,7 +1343,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1354,7 +1354,7 @@ "description": "Successfully returns the found StaffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,10 +1370,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1436,7 +1436,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1447,7 +1447,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1464,10 +1464,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found StaffMembers, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found StaffMember identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found StaffMember, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found StaffMember identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json index 1c042a23be..54ad046fdc 100644 --- a/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found nameValuePairs, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found nameValuePair.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found node, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found node identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1013,7 +1013,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1024,7 +1024,7 @@ "description": "Successfully returns the found nodes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1040,10 +1040,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1087,7 +1087,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1098,7 +1098,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1115,10 +1115,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1277,7 +1277,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1288,7 +1288,7 @@ "description": "Successfully returns the found node.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1304,10 +1304,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1370,7 +1370,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1381,7 +1381,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1398,10 +1398,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1585,7 +1585,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1596,7 +1596,7 @@ "description": "Successfully returns the found nodes, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,10 +1612,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1678,7 +1678,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1689,7 +1689,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1706,10 +1706,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1759,7 +1759,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1770,7 +1770,7 @@ "description": "Successfully returns the found node identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,10 +1786,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1852,7 +1852,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1863,7 +1863,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1880,10 +1880,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2137,7 +2137,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2148,7 +2148,7 @@ "description": "Successfully returns the found node, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2164,10 +2164,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2230,7 +2230,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2241,7 +2241,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2258,10 +2258,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2311,7 +2311,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2322,7 +2322,7 @@ "description": "Successfully returns the found node identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2338,10 +2338,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2404,7 +2404,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2415,7 +2415,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2432,10 +2432,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2553,7 +2553,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2564,7 +2564,7 @@ "description": "Successfully returns the found nameValuePairs, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2580,10 +2580,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2646,7 +2646,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2657,7 +2657,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2674,10 +2674,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2727,7 +2727,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2738,7 +2738,7 @@ "description": "Successfully returns the found nameValuePair identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2754,10 +2754,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2820,7 +2820,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2831,7 +2831,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2848,10 +2848,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json index 3d8db65d54..f3714fc69b 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOff/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1158,7 +1158,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1169,7 +1169,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1185,10 +1185,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,7 +1251,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1262,7 +1262,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1279,10 +1279,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1332,7 +1332,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1343,7 +1343,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1359,10 +1359,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1425,7 +1425,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1436,7 +1436,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1453,10 +1453,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1574,7 +1574,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1585,7 +1585,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1601,10 +1601,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1667,7 +1667,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1678,7 +1678,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1695,10 +1695,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,7 +1748,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1759,7 +1759,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1775,10 +1775,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1841,7 +1841,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1852,7 +1852,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1869,10 +1869,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2126,7 +2126,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2137,7 +2137,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2153,10 +2153,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2219,7 +2219,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2230,7 +2230,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2247,10 +2247,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,7 +2300,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2311,7 +2311,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2327,10 +2327,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2393,7 +2393,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2404,7 +2404,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2421,10 +2421,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json index 48825ed514..a395b78d1d 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOff/ModelStateValidationOn/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1158,7 +1158,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1169,7 +1169,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1185,10 +1185,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1251,7 +1251,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1262,7 +1262,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1279,10 +1279,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1332,7 +1332,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1343,7 +1343,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1359,10 +1359,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1425,7 +1425,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1436,7 +1436,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1453,10 +1453,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1574,7 +1574,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1585,7 +1585,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1601,10 +1601,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1667,7 +1667,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1678,7 +1678,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1695,10 +1695,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1748,7 +1748,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1759,7 +1759,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1775,10 +1775,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1841,7 +1841,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1852,7 +1852,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1869,10 +1869,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2126,7 +2126,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2137,7 +2137,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2153,10 +2153,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2219,7 +2219,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2230,7 +2230,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2247,10 +2247,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2300,7 +2300,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2311,7 +2311,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2327,10 +2327,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2393,7 +2393,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2404,7 +2404,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2421,10 +2421,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json index ce0e4b034c..e2943dc939 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOff/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1022,7 +1022,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1033,7 +1033,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1049,10 +1049,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1115,7 +1115,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1126,7 +1126,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1143,10 +1143,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,7 +1196,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1207,7 +1207,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,10 +1223,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1289,7 +1289,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1300,7 +1300,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1317,10 +1317,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1438,7 +1438,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1449,7 +1449,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1465,10 +1465,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1531,7 +1531,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1542,7 +1542,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1559,10 +1559,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,7 +1612,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1623,7 +1623,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1639,10 +1639,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1705,7 +1705,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1716,7 +1716,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1733,10 +1733,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1854,7 +1854,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1865,7 +1865,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1881,10 +1881,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1947,7 +1947,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1958,7 +1958,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1975,10 +1975,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2028,7 +2028,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2039,7 +2039,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2055,10 +2055,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2121,7 +2121,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2132,7 +2132,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2149,10 +2149,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2270,7 +2270,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2281,7 +2281,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2297,10 +2297,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2363,7 +2363,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2374,7 +2374,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2391,10 +2391,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2444,7 +2444,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2455,7 +2455,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2471,10 +2471,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2537,7 +2537,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2548,7 +2548,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2565,10 +2565,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2822,7 +2822,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2833,7 +2833,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2849,10 +2849,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2915,7 +2915,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2926,7 +2926,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2943,10 +2943,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2996,7 +2996,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3007,7 +3007,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3023,10 +3023,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3089,7 +3089,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3100,7 +3100,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3117,10 +3117,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json index 3debfa8b5f..5dbc8dc824 100644 --- a/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/ResourceFieldValidation/NullableReferenceTypesOn/ModelStateValidationOn/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found resources, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -298,7 +298,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -309,7 +309,7 @@ "description": "Successfully returns the found resource.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -325,10 +325,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -391,7 +391,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -402,7 +402,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -419,10 +419,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -606,7 +606,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -617,7 +617,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -633,10 +633,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -699,7 +699,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -710,7 +710,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -727,10 +727,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -780,7 +780,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -791,7 +791,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -807,10 +807,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -873,7 +873,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -884,7 +884,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -901,10 +901,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1022,7 +1022,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1033,7 +1033,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1049,10 +1049,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1115,7 +1115,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1126,7 +1126,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1143,10 +1143,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1196,7 +1196,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1207,7 +1207,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1223,10 +1223,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1289,7 +1289,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1300,7 +1300,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1317,10 +1317,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1438,7 +1438,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1449,7 +1449,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1465,10 +1465,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1531,7 +1531,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1542,7 +1542,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1559,10 +1559,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1612,7 +1612,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1623,7 +1623,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1639,10 +1639,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1705,7 +1705,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1716,7 +1716,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1733,10 +1733,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1854,7 +1854,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1865,7 +1865,7 @@ "description": "Successfully returns the found empty, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1881,10 +1881,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1947,7 +1947,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1958,7 +1958,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1975,10 +1975,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2028,7 +2028,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2039,7 +2039,7 @@ "description": "Successfully returns the found empty identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2055,10 +2055,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2121,7 +2121,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2132,7 +2132,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2149,10 +2149,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2270,7 +2270,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2281,7 +2281,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2297,10 +2297,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2363,7 +2363,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2374,7 +2374,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2391,10 +2391,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2444,7 +2444,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2455,7 +2455,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2471,10 +2471,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2537,7 +2537,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2548,7 +2548,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2565,10 +2565,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2822,7 +2822,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2833,7 +2833,7 @@ "description": "Successfully returns the found empties, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2849,10 +2849,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2915,7 +2915,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2926,7 +2926,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2943,10 +2943,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2996,7 +2996,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3007,7 +3007,7 @@ "description": "Successfully returns the found empty identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3023,10 +3023,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3089,7 +3089,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3100,7 +3100,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3117,10 +3117,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" diff --git a/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json b/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json index 7abddcb438..fc15aeb53d 100644 --- a/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json +++ b/test/OpenApiTests/RestrictedControllers/GeneratedSwagger/swagger.g.json @@ -34,7 +34,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -45,7 +45,7 @@ "description": "Successfully returns the found dataStreams, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -61,10 +61,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -108,7 +108,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -119,7 +119,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -136,10 +136,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -186,7 +186,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -197,7 +197,7 @@ "description": "Successfully returns the found dataStream.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -213,10 +213,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -279,7 +279,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -290,7 +290,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -307,10 +307,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -351,7 +351,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -362,7 +362,7 @@ "description": "Successfully returns the found readOnlyChannels, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -378,10 +378,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -425,7 +425,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -436,7 +436,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -453,10 +453,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -503,7 +503,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -514,7 +514,7 @@ "description": "Successfully returns the found readOnlyChannel.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -530,10 +530,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -596,7 +596,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -607,7 +607,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -624,10 +624,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -677,7 +677,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -688,7 +688,7 @@ "description": "Successfully returns the found dataStreams, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -704,10 +704,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -770,7 +770,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -781,7 +781,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -798,10 +798,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -851,7 +851,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -862,7 +862,7 @@ "description": "Successfully returns the found dataStream identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -878,10 +878,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -944,7 +944,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -955,7 +955,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -972,10 +972,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1025,7 +1025,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1036,7 +1036,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1052,10 +1052,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1118,7 +1118,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1129,7 +1129,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1146,10 +1146,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1199,7 +1199,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1210,7 +1210,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1226,10 +1226,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1292,7 +1292,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1303,7 +1303,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1320,10 +1320,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1373,7 +1373,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1384,7 +1384,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1400,10 +1400,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1466,7 +1466,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1477,7 +1477,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1494,10 +1494,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1547,7 +1547,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1558,7 +1558,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1574,10 +1574,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1640,7 +1640,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1651,7 +1651,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1668,10 +1668,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1712,7 +1712,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1723,7 +1723,7 @@ "description": "Successfully returns the found readOnlyResourceChannels, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1739,10 +1739,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1786,7 +1786,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1797,7 +1797,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1814,10 +1814,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1864,7 +1864,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1875,7 +1875,7 @@ "description": "Successfully returns the found readOnlyResourceChannel.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1891,10 +1891,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1957,7 +1957,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -1968,7 +1968,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -1985,10 +1985,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2038,7 +2038,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2049,7 +2049,7 @@ "description": "Successfully returns the found dataStreams, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2065,10 +2065,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2131,7 +2131,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2142,7 +2142,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2159,10 +2159,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2212,7 +2212,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2223,7 +2223,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2239,10 +2239,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2305,7 +2305,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2316,7 +2316,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2333,10 +2333,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2386,7 +2386,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2397,7 +2397,7 @@ "description": "Successfully returns the found dataStream, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2413,10 +2413,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2479,7 +2479,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2490,7 +2490,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2507,10 +2507,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2560,7 +2560,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2571,7 +2571,7 @@ "description": "Successfully returns the found dataStream identities, or an empty array if none were found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2587,10 +2587,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2653,7 +2653,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2664,7 +2664,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2681,10 +2681,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2938,7 +2938,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -2949,7 +2949,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -2965,10 +2965,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3031,7 +3031,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3042,7 +3042,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3059,10 +3059,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3180,7 +3180,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3191,7 +3191,7 @@ "description": "Successfully returns the found dataStream identity, or `null` if it was not found.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3207,10 +3207,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3273,7 +3273,7 @@ { "name": "If-None-Match", "in": "header", - "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current socialMediaAccount.", + "description": "A list of ETags, resulting in HTTP status 304 without a body, if one of them matches the current fingerprint.", "schema": { "type": "string" } @@ -3284,7 +3284,7 @@ "description": "The operation completed successfully.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" @@ -3301,10 +3301,10 @@ } }, "304": { - "description": "The socialMediaAccount of the HTTP response matches one of the ETags from the incoming If-None-Match header.", + "description": "The fingerprint of the HTTP response matches one of the ETags from the incoming If-None-Match header.", "headers": { "ETag": { - "description": "A socialMediaAccount of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", + "description": "A fingerprint of the HTTP response, which can be used in an If-None-Match header to only fetch changes.", "required": true, "schema": { "type": "string" From 90fd171583979c84d743321b18b2f7c88a8d6328 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Wed, 29 May 2024 22:21:04 -0400 Subject: [PATCH 09/27] Add test for length attribute on collection --- .../ModelStateValidationTests.cs | 35 ++++++++++++++++++- .../ModelStateValidationFakers.cs | 2 +- .../SocialMediaAccount.cs | 2 +- 3 files changed, 36 insertions(+), 3 deletions(-) diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 78db643b99..8527dda4b9 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -285,6 +285,39 @@ public async Task Cannot_use_invalid_url() errorObject.Source.Pointer.Should().Be("/data/attributes/backgroundPicture"); } + [Theory] + [InlineData(0)] + [InlineData(11)] + public async Task Cannot_exceed_collection_length_constraint(int length) + { + // Arrange + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = "", + Tags = Enumerable.Repeat("", length).ToArray(), + } + } + }); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field Tags must be a string or collection type with a minimum length of '1' and maximum length of '10'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/tags"); + } + [Fact] public async Task Cannot_use_non_allowed_value() { @@ -300,7 +333,7 @@ public async Task Cannot_use_non_allowed_value() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = "", - CountryCode = "US" + CountryCode = "XX" } } }); diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 64d39cc6d6..1ddf5b7eca 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -27,7 +27,7 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.Age, faker => faker.Random.Double(0.1, 122.9)) .RuleFor(socialMediaAccount => socialMediaAccount.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) .RuleFor(socialMediaAccount => socialMediaAccount.BackgroundPicture, faker => faker.Image.LoremFlickrUrl()) - .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => faker.Make(faker.Random.Number(0, 10), () => faker.Random.String2(2, 10))) + .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => faker.Make(faker.Random.Number(1, 10), () => faker.Random.String2(2, 10))) .RuleFor(socialMediaAccount => socialMediaAccount.CountryCode, faker => faker.Random.ListItem(["NL", "FR"])) .RuleFor(socialMediaAccount => socialMediaAccount.Planet, faker => faker.Random.String2(2, 8)) .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index db9d75107c..0905b291b4 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -63,7 +63,7 @@ public sealed class SocialMediaAccount : Identifiable [Attr] #if NET8_0_OR_GREATER - [Length(0, 10)] + [Length(1, 10)] #endif public List? Tags { get; set; } From 3dd960eac165b17799121f1f5d011940c8751847 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Fri, 7 Jun 2024 15:47:03 -0400 Subject: [PATCH 10/27] Address PR comments --- .../ModelStateValidationTests.cs | 128 +++++++++++------ .../ModelStateValidationFakers.cs | 4 +- .../ModelStateValidationTests.cs | 133 +++++++++--------- 3 files changed, 149 insertions(+), 116 deletions(-) diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 8527dda4b9..b4bcef9b61 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,7 +1,5 @@ using FluentAssertions; -using FluentAssertions.Specialized; using JsonApiDotNetCore.OpenApi.Client.NSwag; -using Newtonsoft.Json; using OpenApiNSwagEndToEndTests.ModelStateValidation.GeneratedCode; using OpenApiTests; using OpenApiTests.ModelStateValidation; @@ -35,7 +33,7 @@ public async Task Cannot_violate_compare_constraint() ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { @@ -43,10 +41,11 @@ public async Task Cannot_violate_compare_constraint() { FirstName = socialMediaAccount.FirstName, GivenName = "something else", - LastName = "" + LastName = socialMediaAccount.LastName } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -65,11 +64,13 @@ public async Task Cannot_violate_compare_constraint() public async Task Cannot_exceed_length_constraint(string firstName) { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { @@ -77,10 +78,11 @@ public async Task Cannot_exceed_length_constraint(string firstName) { FirstName = firstName, GivenName = firstName, - LastName = "" + LastName = socialMediaAccount.LastName } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -99,21 +101,24 @@ public async Task Cannot_exceed_length_constraint(string firstName) public async Task Cannot_exceed_string_length_constraint(string userName) { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, UserName = userName, } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -130,21 +135,24 @@ public async Task Cannot_exceed_string_length_constraint(string userName) public async Task Cannot_violate_regular_expression_constraint() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, UserName = "aB1", } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -158,24 +166,27 @@ public async Task Cannot_violate_regular_expression_constraint() } [Fact] - public async Task Cannot_use_invalid_credit_card() + public async Task Cannot_use_invalid_credit_card_number() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, CreditCard = "123-456", } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -192,21 +203,24 @@ public async Task Cannot_use_invalid_credit_card() public async Task Cannot_use_invalid_email() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, Email = "abc", } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -227,21 +241,24 @@ public async Task Cannot_use_invalid_email() public async Task Cannot_use_double_outside_of_valid_range(int age) { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, Age = age, } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -255,24 +272,27 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) } [Fact] - public async Task Cannot_use_invalid_url() + public async Task Cannot_use_relative_url() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, BackgroundPicture = new Uri("/justapath", UriKind.Relative), } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -291,21 +311,24 @@ public async Task Cannot_use_invalid_url() public async Task Cannot_exceed_collection_length_constraint(int length) { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", - Tags = Enumerable.Repeat("", length).ToArray(), + LastName = socialMediaAccount.LastName, + Tags = Enumerable.Repeat("-", length).ToArray(), } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -322,21 +345,24 @@ public async Task Cannot_exceed_collection_length_constraint(int length) public async Task Cannot_use_non_allowed_value() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, CountryCode = "XX" } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -353,21 +379,24 @@ public async Task Cannot_use_non_allowed_value() public async Task Cannot_use_denied_value() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, Planet = "pluto" } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -384,21 +413,24 @@ public async Task Cannot_use_denied_value() public async Task Cannot_use_TimeSpan_outside_of_valid_range() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, NextRevalidation = "00:00:01", } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -415,21 +447,24 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() public async Task Cannot_use_invalid_TimeOnly() { // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = "", + LastName = socialMediaAccount.LastName, ValidatedAtTime = TimeSpan.FromSeconds(-1), } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -452,7 +487,7 @@ public async Task Can_create_resource_with_valid_properties() ModelStateValidationClient apiClient = new(httpClient); // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(new SocialMediaAccountPostRequestDocument + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { @@ -476,7 +511,8 @@ public async Task Can_create_resource_with_valid_properties() ValidatedAtTime = socialMediaAccount.ValidatedAtTime!.Value.ToTimeSpan() } } - }); + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert await action.Should().NotThrowAsync(); diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 1ddf5b7eca..1d5171380e 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -1,5 +1,3 @@ -using System; -using System.Net; using Bogus; using JetBrains.Annotations; using TestBuildingBlocks; @@ -18,7 +16,7 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.FirstName, faker => faker.Person.FirstName) .RuleFor(socialMediaAccount => socialMediaAccount.GivenName, (_, socialMediaAccount) => socialMediaAccount.FirstName) .RuleFor(socialMediaAccount => socialMediaAccount.LastName, faker => faker.Person.LastName) - .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Random.String2(3, 18)) + .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Person.UserName) .RuleFor(socialMediaAccount => socialMediaAccount.CreditCard, faker => faker.Finance.CreditCardNumber()) .RuleFor(socialMediaAccount => socialMediaAccount.Email, faker => faker.Person.Email) .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => faker.Random.String2(8, 32)) diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index 1506e63983..db6376dcb7 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -15,10 +15,10 @@ public ModelStateValidationTests(OpenApiTestContext(); const string targetFramework = -#if NET8_0_OR_GREATER - "net8.0"; -#else +#if NET6_0 "net6.0"; +#else + "net8.0"; #endif testContext.SwaggerDocumentOutputDirectory = $"{GetType().Namespace!.Replace('.', '/')}/GeneratedSwagger/{targetFramework}"; } @@ -31,10 +31,10 @@ public async Task Guid_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.alternativeId").With(alternativeIdEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.alternativeId").With(alternativeIdElement => { - alternativeIdEl.Should().HaveProperty("type", "string"); - alternativeIdEl.Should().HaveProperty("format", "uuid"); + alternativeIdElement.Should().HaveProperty("type", "string"); + alternativeIdElement.Should().HaveProperty("format", "uuid"); }); } @@ -46,9 +46,9 @@ public async Task Compare_annotation_on_resource_property_produces_expected_sche JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.givenName").With(surnameEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.givenName").With(surnameElement => { - surnameEl.Should().HaveProperty("type", "string"); + surnameElement.Should().HaveProperty("type", "string"); }); } @@ -60,10 +60,10 @@ public async Task Required_annotation_with_AllowEmptyStrings_on_resource_propert JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.lastName").With(lastNameEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.lastName").With(lastNameElement => { - lastNameEl.Should().NotContainPath("minLength"); - lastNameEl.Should().HaveProperty("type", "string"); + lastNameElement.Should().NotContainPath("minLength"); + lastNameElement.Should().HaveProperty("type", "string"); }); } @@ -75,11 +75,11 @@ public async Task StringLength_annotation_on_resource_property_produces_expected JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.userName").With(userNameEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.userName").With(userNameElement => { - userNameEl.Should().HaveProperty("maxLength", 18); - userNameEl.Should().HaveProperty("minLength", 3); - userNameEl.Should().HaveProperty("type", "string"); + userNameElement.Should().HaveProperty("maxLength", 18); + userNameElement.Should().HaveProperty("minLength", 3); + userNameElement.Should().HaveProperty("type", "string"); }); } @@ -91,10 +91,10 @@ public async Task RegularExpression_annotation_on_resource_property_produces_exp JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.userName").With(userNameEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.userName").With(userNameElement => { - userNameEl.Should().HaveProperty("pattern", "^[a-zA-Z]+$"); - userNameEl.Should().HaveProperty("type", "string"); + userNameElement.Should().HaveProperty("pattern", "^[a-zA-Z]+$"); + userNameElement.Should().HaveProperty("type", "string"); }); } @@ -106,10 +106,10 @@ public async Task CreditCard_annotation_on_resource_property_produces_expected_s JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.creditCard").With(creditCardEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.creditCard").With(creditCardElement => { - creditCardEl.Should().HaveProperty("type", "string"); - creditCardEl.Should().HaveProperty("format", "credit-card"); + creditCardElement.Should().HaveProperty("type", "string"); + creditCardElement.Should().HaveProperty("format", "credit-card"); }); } @@ -121,10 +121,10 @@ public async Task Email_annotation_on_resource_property_produces_expected_schema JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.email").With(emailEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.email").With(emailElement => { - emailEl.Should().HaveProperty("type", "string"); - emailEl.Should().HaveProperty("format", "email"); + emailElement.Should().HaveProperty("type", "string"); + emailElement.Should().HaveProperty("format", "email"); }); } @@ -136,9 +136,9 @@ public async Task Base64String_annotation_on_resource_property_produces_expected JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.password").With(passwordEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.password").With(passwordElement => { - passwordEl.Should().HaveProperty("type", "string"); + passwordElement.Should().HaveProperty("type", "string"); }); } @@ -150,10 +150,10 @@ public async Task Phone_annotation_on_resource_property_produces_expected_schema JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.phone").With(phoneEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.phone").With(phoneElement => { - phoneEl.Should().HaveProperty("type", "string"); - phoneEl.Should().HaveProperty("format", "tel"); + phoneElement.Should().HaveProperty("type", "string"); + phoneElement.Should().HaveProperty("format", "tel"); }); } @@ -165,14 +165,14 @@ public async Task Range_annotation_on_resource_property_produces_expected_schema JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.age").With(ageEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.age").With(ageElement => { - ageEl.Should().HaveProperty("maximum", 122.9); - ageEl.Should().NotContainPath("exclusiveMaximum"); - ageEl.Should().HaveProperty("minimum", 0.1); - ageEl.Should().NotContainPath("exclusiveMinimum"); - ageEl.Should().HaveProperty("type", "number"); - ageEl.Should().HaveProperty("format", "double"); + ageElement.Should().HaveProperty("maximum", 122.9); + ageElement.Should().NotContainPath("exclusiveMaximum"); + ageElement.Should().HaveProperty("minimum", 0.1); + ageElement.Should().NotContainPath("exclusiveMinimum"); + ageElement.Should().HaveProperty("type", "number"); + ageElement.Should().HaveProperty("format", "double"); }); } @@ -184,10 +184,10 @@ public async Task Url_annotation_on_resource_property_produces_expected_schema(s JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.profilePicture").With(profilePictureEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.profilePicture").With(profilePictureElement => { - profilePictureEl.Should().HaveProperty("type", "string"); - profilePictureEl.Should().HaveProperty("format", "uri"); + profilePictureElement.Should().HaveProperty("type", "string"); + profilePictureElement.Should().HaveProperty("format", "uri"); }); } @@ -199,10 +199,10 @@ public async Task Uri_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.backgroundPicture").With(backgroundPictureEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.backgroundPicture").With(backgroundPictureElement => { - backgroundPictureEl.Should().HaveProperty("type", "string"); - backgroundPictureEl.Should().HaveProperty("format", "uri"); + backgroundPictureElement.Should().HaveProperty("type", "string"); + backgroundPictureElement.Should().HaveProperty("format", "uri"); }); } @@ -214,10 +214,10 @@ public async Task HashSet_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.tags").With(tagsEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.tags").With(tagsElement => { - tagsEl.Should().HaveProperty("type", "array"); - tagsEl.Should().ContainPath("items").With(itemsEl => + tagsElement.Should().HaveProperty("type", "array"); + tagsElement.Should().ContainPath("items").With(itemsEl => { itemsEl.Should().HaveProperty("type", "string"); }); @@ -232,9 +232,9 @@ public async Task Allowed_denied_annotations_on_resource_property_produces_expec JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.planet").With(planetEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.planet").With(planetElement => { - planetEl.Should().HaveProperty("type", "string"); + planetElement.Should().HaveProperty("type", "string"); }); } @@ -246,10 +246,10 @@ public async Task TimeSpan_range_annotation_on_resource_property_produces_expect JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.nextRevalidation").With(nextRevalidationEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.nextRevalidation").With(nextRevalidationElement => { - nextRevalidationEl.Should().HaveProperty("type", "string"); - nextRevalidationEl.Should().HaveProperty("format", "date-span"); + nextRevalidationElement.Should().HaveProperty("type", "string"); + nextRevalidationElement.Should().HaveProperty("format", "date-span"); }); } @@ -261,10 +261,10 @@ public async Task DateTime_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAt").With(validatedAtEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAt").With(validatedAtElement => { - validatedAtEl.Should().HaveProperty("type", "string"); - validatedAtEl.Should().HaveProperty("format", "date-time"); + validatedAtElement.Should().HaveProperty("type", "string"); + validatedAtElement.Should().HaveProperty("format", "date-time"); }); } @@ -276,10 +276,10 @@ public async Task DateOnly_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAtDate").With(validatedDateAtEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAtDate").With(validatedDateAtElement => { - validatedDateAtEl.Should().HaveProperty("type", "string"); - validatedDateAtEl.Should().HaveProperty("format", "date"); + validatedDateAtElement.Should().HaveProperty("type", "string"); + validatedDateAtElement.Should().HaveProperty("format", "date"); }); } @@ -291,19 +291,18 @@ public async Task TimeOnly_type_produces_expected_schema(string modelName) JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAtTime").With(validatedTimeAtEl => + document.Should().ContainPath($"components.schemas.{modelName}.properties.validatedAtTime").With(validatedTimeAtElement => { - validatedTimeAtEl.Should().HaveProperty("type", "string"); - validatedTimeAtEl.Should().HaveProperty("format", "time"); + validatedTimeAtElement.Should().HaveProperty("type", "string"); + validatedTimeAtElement.Should().HaveProperty("format", "time"); }); } - public static TheoryData ModelNames => - // ReSharper disable once UseCollectionExpression - new() - { - "socialMediaAccountAttributesInPostRequest", - "socialMediaAccountAttributesInPatchRequest", - "socialMediaAccountAttributesInResponse" - }; + // ReSharper disable once UseCollectionExpression (https://youtrack.jetbrains.com/issue/RSRP-497450) + public static readonly TheoryData ModelNames = new() + { + "socialMediaAccountAttributesInPostRequest", + "socialMediaAccountAttributesInPatchRequest", + "socialMediaAccountAttributesInResponse" + }; } From 0b7976b0d24f77d7888ce95a303012722a4339b5 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Fri, 7 Jun 2024 17:21:22 -0400 Subject: [PATCH 11/27] stuff --- .../ModelStateValidationTests.cs | 39 ++++++++++++++++++- .../ModelStateValidationFakers.cs | 3 +- 2 files changed, 38 insertions(+), 4 deletions(-) diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index b4bcef9b61..37a0aa1d55 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,3 +1,4 @@ +using System.Globalization; using FluentAssertions; using JsonApiDotNetCore.OpenApi.Client.NSwag; using OpenApiNSwagEndToEndTests.ModelStateValidation.GeneratedCode; @@ -200,7 +201,7 @@ public async Task Cannot_use_invalid_credit_card_number() } [Fact] - public async Task Cannot_use_invalid_email() + public async Task Cannot_use_invalid_email_address() { // Arrange SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); @@ -426,7 +427,7 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = socialMediaAccount.LastName, - NextRevalidation = "00:00:01", + NextRevalidation = TimeSpan.FromSeconds(1).ToString() } } }; @@ -443,6 +444,40 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); } + [Fact] + public async Task Cannot_use_culture_sensitive_TimeSpan() + { + // Arrange + SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + // Act + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = socialMediaAccount.LastName, + NextRevalidation = new TimeSpan(0, 2, 0, 0, 1).ToString("g", new CultureInfo("fr-FR")) + } + } + }; + Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); + errorObject.Detail.Should().Be("Failed to convert attribute 'nextRevalidation' with value '2:00:00,001' of type 'String' to type 'Nullable'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + } + [Fact] public async Task Cannot_use_invalid_TimeOnly() { diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 1d5171380e..d8f9b77f94 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -16,10 +16,9 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.FirstName, faker => faker.Person.FirstName) .RuleFor(socialMediaAccount => socialMediaAccount.GivenName, (_, socialMediaAccount) => socialMediaAccount.FirstName) .RuleFor(socialMediaAccount => socialMediaAccount.LastName, faker => faker.Person.LastName) - .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Person.UserName) + .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Random.String2(3, 18)) .RuleFor(socialMediaAccount => socialMediaAccount.CreditCard, faker => faker.Finance.CreditCardNumber()) .RuleFor(socialMediaAccount => socialMediaAccount.Email, faker => faker.Person.Email) - .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => faker.Random.String2(8, 32)) .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => Convert.ToBase64String(faker.Random.Bytes(20))) .RuleFor(socialMediaAccount => socialMediaAccount.Phone, faker => faker.Person.Phone) .RuleFor(socialMediaAccount => socialMediaAccount.Age, faker => faker.Random.Double(0.1, 122.9)) From 10fe4ac66d3300a9a1eda56873a88c21dc493ae1 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Sun, 9 Jun 2024 20:08:17 -0400 Subject: [PATCH 12/27] More stuff --- .../ModelStateValidationTests.cs | 167 ++++++++---------- .../ModelStateValidationFakers.cs | 2 +- .../ModelStateValidationTests.cs | 20 ++- .../SocialMediaAccount.cs | 10 +- 4 files changed, 100 insertions(+), 99 deletions(-) diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 37a0aa1d55..8f860ec2f3 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -28,24 +28,23 @@ public ModelStateValidationTests(IntegrationTestContext> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -65,12 +64,9 @@ public async Task Cannot_violate_compare_constraint() public async Task Cannot_exceed_length_constraint(string firstName) { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -79,10 +75,12 @@ public async Task Cannot_exceed_length_constraint(string firstName) { FirstName = firstName, GivenName = firstName, - LastName = socialMediaAccount.LastName + LastName = newAccount.LastName } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -102,23 +100,22 @@ public async Task Cannot_exceed_length_constraint(string firstName) public async Task Cannot_exceed_string_length_constraint(string userName) { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, UserName = userName, } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -136,23 +133,22 @@ public async Task Cannot_exceed_string_length_constraint(string userName) public async Task Cannot_violate_regular_expression_constraint() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, UserName = "aB1", } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -170,23 +166,22 @@ public async Task Cannot_violate_regular_expression_constraint() public async Task Cannot_use_invalid_credit_card_number() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, CreditCard = "123-456", } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -204,23 +199,22 @@ public async Task Cannot_use_invalid_credit_card_number() public async Task Cannot_use_invalid_email_address() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, Email = "abc", } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -242,23 +236,22 @@ public async Task Cannot_use_invalid_email_address() public async Task Cannot_use_double_outside_of_valid_range(int age) { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, Age = age, } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -276,23 +269,22 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) public async Task Cannot_use_relative_url() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, BackgroundPicture = new Uri("/justapath", UriKind.Relative), } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -312,23 +304,22 @@ public async Task Cannot_use_relative_url() public async Task Cannot_exceed_collection_length_constraint(int length) { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, Tags = Enumerable.Repeat("-", length).ToArray(), } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -346,23 +337,22 @@ public async Task Cannot_exceed_collection_length_constraint(int length) public async Task Cannot_use_non_allowed_value() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, CountryCode = "XX" } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -380,23 +370,22 @@ public async Task Cannot_use_non_allowed_value() public async Task Cannot_use_denied_value() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, Planet = "pluto" } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -414,23 +403,22 @@ public async Task Cannot_use_denied_value() public async Task Cannot_use_TimeSpan_outside_of_valid_range() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, NextRevalidation = TimeSpan.FromSeconds(1).ToString() } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -448,23 +436,22 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() public async Task Cannot_use_culture_sensitive_TimeSpan() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, NextRevalidation = new TimeSpan(0, 2, 0, 0, 1).ToString("g", new CultureInfo("fr-FR")) } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -482,23 +469,22 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() public async Task Cannot_use_invalid_TimeOnly() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - LastName = socialMediaAccount.LastName, + LastName = newAccount.LastName, ValidatedAtTime = TimeSpan.FromSeconds(-1), } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert @@ -516,37 +502,36 @@ public async Task Cannot_use_invalid_TimeOnly() public async Task Can_create_resource_with_valid_properties() { // Arrange - SocialMediaAccount socialMediaAccount = _fakers.SocialMediaAccount.Generate(); - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - - // Act + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest { Attributes = new SocialMediaAccountAttributesInPostRequest { - FirstName = socialMediaAccount.FirstName, - GivenName = socialMediaAccount.GivenName, - LastName = socialMediaAccount.LastName, - UserName = socialMediaAccount.UserName, - CreditCard = socialMediaAccount.CreditCard, - Email = socialMediaAccount.Email, - Phone = socialMediaAccount.Phone, - Age = socialMediaAccount.Age, - ProfilePicture = socialMediaAccount.ProfilePicture, - BackgroundPicture = new Uri(socialMediaAccount.BackgroundPicture!), - Tags = socialMediaAccount.Tags, - Planet = socialMediaAccount.Planet, - NextRevalidation = "02:00:00", - ValidatedAt = socialMediaAccount.ValidatedAt!, - ValidatedAtDate = new DateTimeOffset(socialMediaAccount.ValidatedAtDate!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), - ValidatedAtTime = socialMediaAccount.ValidatedAtTime!.Value.ToTimeSpan() + FirstName = newAccount.FirstName, + GivenName = newAccount.GivenName, + LastName = newAccount.LastName, + UserName = newAccount.UserName, + CreditCard = newAccount.CreditCard, + Email = newAccount.Email, + Phone = newAccount.Phone, + Age = newAccount.Age, + ProfilePicture = newAccount.ProfilePicture, + BackgroundPicture = new Uri(newAccount.BackgroundPicture!), + Tags = newAccount.Tags, + Planet = newAccount.Planet, + NextRevalidation = newAccount.NextRevalidation!.Value.ToString(), + ValidatedAt = newAccount.ValidatedAt!, + ValidatedAtDate = new DateTimeOffset(newAccount.ValidatedAtDate!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), + ValidatedAtTime = newAccount.ValidatedAtTime!.Value.ToTimeSpan() } } }; + + // Act Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index d8f9b77f94..9f8381dd30 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -27,7 +27,7 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => faker.Make(faker.Random.Number(1, 10), () => faker.Random.String2(2, 10))) .RuleFor(socialMediaAccount => socialMediaAccount.CountryCode, faker => faker.Random.ListItem(["NL", "FR"])) .RuleFor(socialMediaAccount => socialMediaAccount.Planet, faker => faker.Random.String2(2, 8)) - .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromMinutes(faker.Random.Number(1, 5))) + .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromHours(faker.Random.Number(1, 5))) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAt, faker => faker.Date.Recent().ToUniversalTime()) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtDate, faker => DateOnly.FromDateTime(faker.Date.Recent())) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtTime, faker => TimeOnly.FromDateTime(faker.Date.Recent()))); diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index db6376dcb7..c8bbc684ac 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,3 +1,4 @@ +using System.Globalization; using System.Text.Json; using TestBuildingBlocks; using Xunit; @@ -10,6 +11,7 @@ public sealed class ModelStateValidationTests : IClassFixture, ModelStateValidationDbContext> testContext) { + CultureInfo.CurrentCulture = new CultureInfo("fr-FR"); _testContext = testContext; testContext.UseController(); @@ -38,6 +40,20 @@ public async Task Guid_type_produces_expected_schema(string modelName) }); } + [Theory] + [MemberData(nameof(ModelNames))] + public async Task Length_annotation_on_resource_property_produces_expected_schema(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.firstName").With(firstName => + { + firstName.Should().HaveProperty("type", "string"); + }); + } + [Theory] [MemberData(nameof(ModelNames))] public async Task Compare_annotation_on_resource_property_produces_expected_schema(string modelName) @@ -46,9 +62,9 @@ public async Task Compare_annotation_on_resource_property_produces_expected_sche JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.givenName").With(surnameElement => + document.Should().ContainPath($"components.schemas.{modelName}.properties.givenName").With(givenNameElement => { - surnameElement.Should().HaveProperty("type", "string"); + givenNameElement.Should().HaveProperty("type", "string"); }); } diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index 0905b291b4..91ea491d62 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -14,7 +14,7 @@ public sealed class SocialMediaAccount : Identifiable public Guid? AlternativeId { get; set; } [Attr] -#if NET8_0_OR_GREATER +#if !NET6_0 [Length(2, 20)] #endif public string? FirstName { get; set; } @@ -41,7 +41,7 @@ public sealed class SocialMediaAccount : Identifiable public string? Email { get; set; } [Attr] -#if NET8_0_OR_GREATER +#if !NET6_0 [Base64String] #endif public string? Password { get; set; } @@ -62,19 +62,19 @@ public sealed class SocialMediaAccount : Identifiable public string? BackgroundPicture { get; set; } [Attr] -#if NET8_0_OR_GREATER +#if !NET6_0 [Length(1, 10)] #endif public List? Tags { get; set; } [Attr] -#if NET8_0_OR_GREATER +#if !NET6_0 [AllowedValues(null, "NL", "FR")] #endif public string? CountryCode { get; set; } [Attr] -#if NET8_0_OR_GREATER +#if !NET6_0 [DeniedValues("pluto")] #endif public string? Planet { get; set; } From 0cfe1f70747becc824dd074be3126456ba76328f Mon Sep 17 00:00:00 2001 From: verdie-g Date: Sun, 9 Jun 2024 20:56:07 -0400 Subject: [PATCH 13/27] Fix .NET 8 things --- package-versions.props | 2 +- .../GeneratedSwagger/net8.0/swagger.g.json | 12 +++++++ .../ModelStateValidationTests.cs | 32 ++++++++++++++++--- 3 files changed, 40 insertions(+), 6 deletions(-) diff --git a/package-versions.props b/package-versions.props index 5edd2d7ab3..41238fcf3e 100644 --- a/package-versions.props +++ b/package-versions.props @@ -4,7 +4,7 @@ 4.1.0 0.4.1 2.14.1 - 6.6.1 + 6.6.2 13.0.3 diff --git a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json index 14b880aead..d8e584340c 100644 --- a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json +++ b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json @@ -405,6 +405,8 @@ "nullable": true }, "firstName": { + "maxLength": 20, + "minLength": 2, "type": "string", "nullable": true }, @@ -459,6 +461,8 @@ "nullable": true }, "tags": { + "maxItems": 10, + "minItems": 1, "type": "array", "items": { "type": "string" @@ -508,6 +512,8 @@ "nullable": true }, "firstName": { + "maxLength": 20, + "minLength": 2, "type": "string", "nullable": true }, @@ -562,6 +568,8 @@ "nullable": true }, "tags": { + "maxItems": 10, + "minItems": 1, "type": "array", "items": { "type": "string" @@ -608,6 +616,8 @@ "nullable": true }, "firstName": { + "maxLength": 20, + "minLength": 2, "type": "string", "nullable": true }, @@ -662,6 +672,8 @@ "nullable": true }, "tags": { + "maxItems": 10, + "minItems": 1, "type": "array", "items": { "type": "string" diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index c8bbc684ac..a957ea41e5 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -42,15 +42,19 @@ public async Task Guid_type_produces_expected_schema(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Length_annotation_on_resource_property_produces_expected_schema(string modelName) + public async Task Length_annotation_on_resource_string_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.firstName").With(firstName => + document.Should().ContainPath($"components.schemas.{modelName}.properties.firstName").With(firstNameElement => { - firstName.Should().HaveProperty("type", "string"); +#if !NET6_0 + firstNameElement.Should().HaveProperty("maxLength", 20); + firstNameElement.Should().HaveProperty("minLength", 2); +#endif + firstNameElement.Should().HaveProperty("type", "string"); }); } @@ -224,7 +228,7 @@ public async Task Uri_type_produces_expected_schema(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task HashSet_type_produces_expected_schema(string modelName) + public async Task Length_annotation_on_resource_list_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); @@ -232,6 +236,10 @@ public async Task HashSet_type_produces_expected_schema(string modelName) // Assert document.Should().ContainPath($"components.schemas.{modelName}.properties.tags").With(tagsElement => { +#if !NET6_0 + tagsElement.Should().HaveProperty("maxItems", 10); + tagsElement.Should().HaveProperty("minItems", 1); +#endif tagsElement.Should().HaveProperty("type", "array"); tagsElement.Should().ContainPath("items").With(itemsEl => { @@ -242,7 +250,21 @@ public async Task HashSet_type_produces_expected_schema(string modelName) [Theory] [MemberData(nameof(ModelNames))] - public async Task Allowed_denied_annotations_on_resource_property_produces_expected_schema(string modelName) + public async Task AllowedValues_annotation_on_resource_list_property_produces_expected_schema(string modelName) + { + // Act + JsonElement document = await _testContext.GetSwaggerDocumentAsync(); + + // Assert + document.Should().ContainPath($"components.schemas.{modelName}.properties.countryCode").With(countryCodeElement => + { + countryCodeElement.Should().HaveProperty("type", "string"); + }); + } + + [Theory] + [MemberData(nameof(ModelNames))] + public async Task DeniedValues_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); From 894c385b715e26386a6deead15fa1a0285a943d4 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Sun, 9 Jun 2024 21:09:19 -0400 Subject: [PATCH 14/27] Fix coding style --- .../ModelStateValidationTests.cs | 42 ++++++++++++++----- .../ModelStateValidationFakers.cs | 5 ++- .../ModelStateValidationTests.cs | 17 ++++---- 3 files changed, 44 insertions(+), 20 deletions(-) diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 8f860ec2f3..24f3a7cd8f 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -10,13 +10,15 @@ namespace OpenApiNSwagEndToEndTests.ModelStateValidation; -public sealed class ModelStateValidationTests : IClassFixture, ModelStateValidationDbContext>> +public sealed class ModelStateValidationTests + : IClassFixture, ModelStateValidationDbContext>> { private readonly IntegrationTestContext, ModelStateValidationDbContext> _testContext; private readonly XUnitLogHttpMessageHandler _logHttpMessageHandler; private readonly ModelStateValidationFakers _fakers = new(); - public ModelStateValidationTests(IntegrationTestContext, ModelStateValidationDbContext> testContext, ITestOutputHelper testOutputHelper) + public ModelStateValidationTests(IntegrationTestContext, ModelStateValidationDbContext> testContext, + ITestOutputHelper testOutputHelper) { _testContext = testContext; _logHttpMessageHandler = new XUnitLogHttpMessageHandler(testOutputHelper); @@ -31,6 +33,7 @@ public async Task Cannot_violate_compare_constraint() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -67,6 +70,7 @@ public async Task Cannot_exceed_length_constraint(string firstName) using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -103,6 +107,7 @@ public async Task Cannot_exceed_string_length_constraint(string userName) using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -110,7 +115,7 @@ public async Task Cannot_exceed_string_length_constraint(string userName) Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - UserName = userName, + UserName = userName } } }; @@ -136,6 +141,7 @@ public async Task Cannot_violate_regular_expression_constraint() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -143,7 +149,7 @@ public async Task Cannot_violate_regular_expression_constraint() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - UserName = "aB1", + UserName = "aB1" } } }; @@ -169,6 +175,7 @@ public async Task Cannot_use_invalid_credit_card_number() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -176,7 +183,7 @@ public async Task Cannot_use_invalid_credit_card_number() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - CreditCard = "123-456", + CreditCard = "123-456" } } }; @@ -202,6 +209,7 @@ public async Task Cannot_use_invalid_email_address() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -209,7 +217,7 @@ public async Task Cannot_use_invalid_email_address() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - Email = "abc", + Email = "abc" } } }; @@ -239,6 +247,7 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -246,7 +255,7 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - Age = age, + Age = age } } }; @@ -272,6 +281,7 @@ public async Task Cannot_use_relative_url() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -279,7 +289,7 @@ public async Task Cannot_use_relative_url() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - BackgroundPicture = new Uri("/justapath", UriKind.Relative), + BackgroundPicture = new Uri("/justapath", UriKind.Relative) } } }; @@ -307,6 +317,7 @@ public async Task Cannot_exceed_collection_length_constraint(int length) using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -314,7 +325,7 @@ public async Task Cannot_exceed_collection_length_constraint(int length) Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - Tags = Enumerable.Repeat("-", length).ToArray(), + Tags = Enumerable.Repeat("-", length).ToArray() } } }; @@ -340,6 +351,7 @@ public async Task Cannot_use_non_allowed_value() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -373,6 +385,7 @@ public async Task Cannot_use_denied_value() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -406,6 +419,7 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -439,6 +453,7 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -460,7 +475,10 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); - errorObject.Detail.Should().Be("Failed to convert attribute 'nextRevalidation' with value '2:00:00,001' of type 'String' to type 'Nullable'."); + + errorObject.Detail.Should() + .Be("Failed to convert attribute 'nextRevalidation' with value '2:00:00,001' of type 'String' to type 'Nullable'."); + errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); } @@ -472,6 +490,7 @@ public async Task Cannot_use_invalid_TimeOnly() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest @@ -479,7 +498,7 @@ public async Task Cannot_use_invalid_TimeOnly() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - ValidatedAtTime = TimeSpan.FromSeconds(-1), + ValidatedAtTime = TimeSpan.FromSeconds(-1) } } }; @@ -505,6 +524,7 @@ public async Task Can_create_resource_with_valid_properties() using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + SocialMediaAccountPostRequestDocument requestBody = new() { Data = new SocialMediaAccountDataInPostRequest diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 9f8381dd30..02ee441e4d 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -25,7 +25,10 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) .RuleFor(socialMediaAccount => socialMediaAccount.BackgroundPicture, faker => faker.Image.LoremFlickrUrl()) .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => faker.Make(faker.Random.Number(1, 10), () => faker.Random.String2(2, 10))) - .RuleFor(socialMediaAccount => socialMediaAccount.CountryCode, faker => faker.Random.ListItem(["NL", "FR"])) + .RuleFor(socialMediaAccount => socialMediaAccount.CountryCode, faker => faker.Random.ListItem([ + "NL", + "FR" + ])) .RuleFor(socialMediaAccount => socialMediaAccount.Planet, faker => faker.Random.String2(2, 8)) .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromHours(faker.Random.Number(1, 5))) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAt, faker => faker.Date.Recent().ToUniversalTime()) diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index a957ea41e5..efed5c1dbf 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -7,6 +7,14 @@ namespace OpenApiTests.ModelStateValidation; public sealed class ModelStateValidationTests : IClassFixture, ModelStateValidationDbContext>> { + // ReSharper disable once UseCollectionExpression (https://youtrack.jetbrains.com/issue/RSRP-497450) + public static readonly TheoryData ModelNames = new() + { + "socialMediaAccountAttributesInPostRequest", + "socialMediaAccountAttributesInPatchRequest", + "socialMediaAccountAttributesInResponse" + }; + private readonly OpenApiTestContext, ModelStateValidationDbContext> _testContext; public ModelStateValidationTests(OpenApiTestContext, ModelStateValidationDbContext> testContext) @@ -241,6 +249,7 @@ public async Task Length_annotation_on_resource_list_property_produces_expected_ tagsElement.Should().HaveProperty("minItems", 1); #endif tagsElement.Should().HaveProperty("type", "array"); + tagsElement.Should().ContainPath("items").With(itemsEl => { itemsEl.Should().HaveProperty("type", "string"); @@ -335,12 +344,4 @@ public async Task TimeOnly_type_produces_expected_schema(string modelName) validatedTimeAtElement.Should().HaveProperty("format", "time"); }); } - - // ReSharper disable once UseCollectionExpression (https://youtrack.jetbrains.com/issue/RSRP-497450) - public static readonly TheoryData ModelNames = new() - { - "socialMediaAccountAttributesInPostRequest", - "socialMediaAccountAttributesInPatchRequest", - "socialMediaAccountAttributesInResponse" - }; } From bd283c39f556ca2042905bc6fd97d697ffcfca59 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Mon, 10 Jun 2024 19:55:25 -0400 Subject: [PATCH 15/27] Set ConvertValueInInvariantCulture --- test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index 91ea491d62..5de8903992 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -80,7 +80,7 @@ public sealed class SocialMediaAccount : Identifiable public string? Planet { get; set; } [Attr] - [Range(typeof(TimeSpan), "01:00", "05:00")] + [Range(typeof(TimeSpan), "01:00", "05:00", ConvertValueInInvariantCulture = true)] public TimeSpan? NextRevalidation { get; set; } [Attr] From a7bc74af982ea8c161ca973506e377d0d8fdc865 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Mon, 10 Jun 2024 22:39:58 -0400 Subject: [PATCH 16/27] Add Kiota tests --- .../ModelStateValidationClient.cs | 48 ++ .../GeneratedCode/Models/DataInResponse.cs | 88 +++ .../GeneratedCode/Models/ErrorLinks.cs | 83 +++ .../GeneratedCode/Models/ErrorObject.cs | 179 ++++++ .../GeneratedCode/Models/ErrorObject_meta.cs | 58 ++ .../Models/ErrorResponseDocument.cs | 102 ++++ .../Models/ErrorResponseDocument_meta.cs | 58 ++ .../GeneratedCode/Models/ErrorSource.cs | 99 ++++ .../Models/ErrorTopLevelLinks.cs | 83 +++ .../GeneratedCode/Models/ResourceLinks.cs | 67 +++ .../Models/ResourceTopLevelLinks.cs | 83 +++ ...ialMediaAccountAttributesInPatchRequest.cs | 311 ++++++++++ ...cialMediaAccountAttributesInPostRequest.cs | 311 ++++++++++ .../SocialMediaAccountAttributesInResponse.cs | 311 ++++++++++ .../SocialMediaAccountDataInPatchRequest.cs | 90 +++ .../SocialMediaAccountDataInPostRequest.cs | 74 +++ .../SocialMediaAccountDataInResponse.cs | 90 +++ .../SocialMediaAccountDataInResponse_meta.cs | 58 ++ .../SocialMediaAccountPatchRequestDocument.cs | 67 +++ .../SocialMediaAccountPostRequestDocument.cs | 67 +++ ...cialMediaAccountPrimaryResponseDocument.cs | 115 ++++ ...ediaAccountPrimaryResponseDocument_meta.cs | 58 ++ .../Models/SocialMediaAccountResourceType.cs | 14 + .../Models/SocialMediaAccounts.cs | 90 +++ .../Models/SocialMediaAccounts_meta.cs | 58 ++ .../SocialMediaAccountsItemRequestBuilder.cs | 112 ++++ .../SocialMediaAccountsRequestBuilder.cs | 127 ++++ .../ModelStateValidationTests.cs | 541 ++++++++++++++++++ .../OpenApiKiotaEndToEndTests.csproj | 2 + 29 files changed, 3444 insertions(+) create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/ModelStateValidationClient.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/DataInResponse.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorLinks.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject_meta.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument_meta.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorSource.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorTopLevelLinks.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceLinks.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceTopLevelLinks.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPatchRequest.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPostRequest.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse_meta.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPatchRequestDocument.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPostRequestDocument.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument_meta.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountResourceType.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts_meta.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/Item/SocialMediaAccountsItemRequestBuilder.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/SocialMediaAccountsRequestBuilder.cs create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/ModelStateValidationClient.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/ModelStateValidationClient.cs new file mode 100644 index 0000000000..bf9e33ae22 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/ModelStateValidationClient.cs @@ -0,0 +1,48 @@ +// +using Microsoft.Kiota.Abstractions.Extensions; +using Microsoft.Kiota.Abstractions.Store; +using Microsoft.Kiota.Abstractions; +using Microsoft.Kiota.Serialization.Form; +using Microsoft.Kiota.Serialization.Json; +using Microsoft.Kiota.Serialization.Multipart; +using Microsoft.Kiota.Serialization.Text; +using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.SocialMediaAccounts; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading.Tasks; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode { + /// + /// The main entry point of the SDK, exposes the configuration and the fluent API. + /// + public class ModelStateValidationClient : BaseRequestBuilder + { + /// The socialMediaAccounts property + public SocialMediaAccountsRequestBuilder SocialMediaAccounts + { + get => new SocialMediaAccountsRequestBuilder(PathParameters, RequestAdapter); + } + /// + /// Instantiates a new and sets the default values. + /// + /// The backing store to use for the models. + /// The request adapter to use to execute the requests. + public ModelStateValidationClient(IRequestAdapter requestAdapter, IBackingStoreFactory backingStore = default) : base(requestAdapter, "{+baseurl}", new Dictionary()) + { + ApiClientBuilder.RegisterDefaultSerializer(); + ApiClientBuilder.RegisterDefaultSerializer(); + ApiClientBuilder.RegisterDefaultSerializer(); + ApiClientBuilder.RegisterDefaultSerializer(); + ApiClientBuilder.RegisterDefaultDeserializer(); + ApiClientBuilder.RegisterDefaultDeserializer(); + ApiClientBuilder.RegisterDefaultDeserializer(); + if (string.IsNullOrEmpty(RequestAdapter.BaseUrl)) + { + RequestAdapter.BaseUrl = "http://localhost"; + } + PathParameters.TryAdd("baseurl", RequestAdapter.BaseUrl); + RequestAdapter.EnableBackingStore(backingStore); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/DataInResponse.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/DataInResponse.cs new file mode 100644 index 0000000000..932e4dc2c8 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/DataInResponse.cs @@ -0,0 +1,88 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class DataInResponse : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The id property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Id { + get { return BackingStore?.Get("id"); } + set { BackingStore?.Set("id", value); } + } +#nullable restore +#else + public string Id { + get { return BackingStore?.Get("id"); } + set { BackingStore?.Set("id", value); } + } +#endif + /// The type property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Type { + get { return BackingStore?.Get("type"); } + set { BackingStore?.Set("type", value); } + } +#nullable restore +#else + public string Type { + get { return BackingStore?.Get("type"); } + set { BackingStore?.Set("type", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public DataInResponse() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static DataInResponse CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + var mappingValue = parseNode.GetChildNode("type")?.GetStringValue(); + return mappingValue switch + { + "socialMediaAccounts" => new SocialMediaAccountDataInResponse(), + _ => new DataInResponse(), + }; + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"id", n => { Id = n.GetStringValue(); } }, + {"type", n => { Type = n.GetStringValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("id", Id); + writer.WriteStringValue("type", Type); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorLinks.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorLinks.cs new file mode 100644 index 0000000000..3a332296fe --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorLinks.cs @@ -0,0 +1,83 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ErrorLinks : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// The about property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? About { + get { return BackingStore?.Get("about"); } + set { BackingStore?.Set("about", value); } + } +#nullable restore +#else + public string About { + get { return BackingStore?.Get("about"); } + set { BackingStore?.Set("about", value); } + } +#endif + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The type property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Type { + get { return BackingStore?.Get("type"); } + set { BackingStore?.Set("type", value); } + } +#nullable restore +#else + public string Type { + get { return BackingStore?.Get("type"); } + set { BackingStore?.Set("type", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public ErrorLinks() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ErrorLinks CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ErrorLinks(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"about", n => { About = n.GetStringValue(); } }, + {"type", n => { Type = n.GetStringValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("about", About); + writer.WriteStringValue("type", Type); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject.cs new file mode 100644 index 0000000000..16e5269395 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject.cs @@ -0,0 +1,179 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ErrorObject : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The code property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Code { + get { return BackingStore?.Get("code"); } + set { BackingStore?.Set("code", value); } + } +#nullable restore +#else + public string Code { + get { return BackingStore?.Get("code"); } + set { BackingStore?.Set("code", value); } + } +#endif + /// The detail property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Detail { + get { return BackingStore?.Get("detail"); } + set { BackingStore?.Set("detail", value); } + } +#nullable restore +#else + public string Detail { + get { return BackingStore?.Get("detail"); } + set { BackingStore?.Set("detail", value); } + } +#endif + /// The id property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Id { + get { return BackingStore?.Get("id"); } + set { BackingStore?.Set("id", value); } + } +#nullable restore +#else + public string Id { + get { return BackingStore?.Get("id"); } + set { BackingStore?.Set("id", value); } + } +#endif + /// The links property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ErrorLinks? Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#nullable restore +#else + public ErrorLinks Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#endif + /// The meta property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ErrorObject_meta? Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#nullable restore +#else + public ErrorObject_meta Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#endif + /// The source property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ErrorSource? Source { + get { return BackingStore?.Get("source"); } + set { BackingStore?.Set("source", value); } + } +#nullable restore +#else + public ErrorSource Source { + get { return BackingStore?.Get("source"); } + set { BackingStore?.Set("source", value); } + } +#endif + /// The status property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Status { + get { return BackingStore?.Get("status"); } + set { BackingStore?.Set("status", value); } + } +#nullable restore +#else + public string Status { + get { return BackingStore?.Get("status"); } + set { BackingStore?.Set("status", value); } + } +#endif + /// The title property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Title { + get { return BackingStore?.Get("title"); } + set { BackingStore?.Set("title", value); } + } +#nullable restore +#else + public string Title { + get { return BackingStore?.Get("title"); } + set { BackingStore?.Set("title", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public ErrorObject() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ErrorObject CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ErrorObject(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"code", n => { Code = n.GetStringValue(); } }, + {"detail", n => { Detail = n.GetStringValue(); } }, + {"id", n => { Id = n.GetStringValue(); } }, + {"links", n => { Links = n.GetObjectValue(ErrorLinks.CreateFromDiscriminatorValue); } }, + {"meta", n => { Meta = n.GetObjectValue(ErrorObject_meta.CreateFromDiscriminatorValue); } }, + {"source", n => { Source = n.GetObjectValue(ErrorSource.CreateFromDiscriminatorValue); } }, + {"status", n => { Status = n.GetStringValue(); } }, + {"title", n => { Title = n.GetStringValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("code", Code); + writer.WriteStringValue("detail", Detail); + writer.WriteStringValue("id", Id); + writer.WriteObjectValue("links", Links); + writer.WriteObjectValue("meta", Meta); + writer.WriteObjectValue("source", Source); + writer.WriteStringValue("status", Status); + writer.WriteStringValue("title", Title); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject_meta.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject_meta.cs new file mode 100644 index 0000000000..6edceb8215 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorObject_meta.cs @@ -0,0 +1,58 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ErrorObject_meta : IAdditionalDataHolder, IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { + get { return BackingStore.Get>("AdditionalData") ?? throw new InvalidOperationException("AdditionalData can not be null"); } + set { BackingStore.Set("AdditionalData", value); } + } + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// + /// Instantiates a new and sets the default values. + /// + public ErrorObject_meta() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ErrorObject_meta CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ErrorObject_meta(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteAdditionalData(AdditionalData); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument.cs new file mode 100644 index 0000000000..dfba3e4512 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument.cs @@ -0,0 +1,102 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using Microsoft.Kiota.Abstractions; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ErrorResponseDocument : ApiException, IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The errors property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? Errors { + get { return BackingStore?.Get?>("errors"); } + set { BackingStore?.Set("errors", value); } + } +#nullable restore +#else + public List Errors { + get { return BackingStore?.Get>("errors"); } + set { BackingStore?.Set("errors", value); } + } +#endif + /// The links property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ErrorTopLevelLinks? Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#nullable restore +#else + public ErrorTopLevelLinks Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#endif + /// The primary error message. + public override string Message { get => base.Message; } + /// The meta property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ErrorResponseDocument_meta? Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#nullable restore +#else + public ErrorResponseDocument_meta Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public ErrorResponseDocument() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ErrorResponseDocument CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ErrorResponseDocument(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"errors", n => { Errors = n.GetCollectionOfObjectValues(ErrorObject.CreateFromDiscriminatorValue)?.ToList(); } }, + {"links", n => { Links = n.GetObjectValue(ErrorTopLevelLinks.CreateFromDiscriminatorValue); } }, + {"meta", n => { Meta = n.GetObjectValue(ErrorResponseDocument_meta.CreateFromDiscriminatorValue); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteCollectionOfObjectValues("errors", Errors); + writer.WriteObjectValue("links", Links); + writer.WriteObjectValue("meta", Meta); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument_meta.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument_meta.cs new file mode 100644 index 0000000000..6c77bba3df --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorResponseDocument_meta.cs @@ -0,0 +1,58 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ErrorResponseDocument_meta : IAdditionalDataHolder, IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { + get { return BackingStore.Get>("AdditionalData") ?? throw new InvalidOperationException("AdditionalData can not be null"); } + set { BackingStore.Set("AdditionalData", value); } + } + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// + /// Instantiates a new and sets the default values. + /// + public ErrorResponseDocument_meta() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ErrorResponseDocument_meta CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ErrorResponseDocument_meta(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteAdditionalData(AdditionalData); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorSource.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorSource.cs new file mode 100644 index 0000000000..8a4df7fed9 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorSource.cs @@ -0,0 +1,99 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ErrorSource : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The header property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Header { + get { return BackingStore?.Get("header"); } + set { BackingStore?.Set("header", value); } + } +#nullable restore +#else + public string Header { + get { return BackingStore?.Get("header"); } + set { BackingStore?.Set("header", value); } + } +#endif + /// The parameter property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Parameter { + get { return BackingStore?.Get("parameter"); } + set { BackingStore?.Set("parameter", value); } + } +#nullable restore +#else + public string Parameter { + get { return BackingStore?.Get("parameter"); } + set { BackingStore?.Set("parameter", value); } + } +#endif + /// The pointer property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Pointer { + get { return BackingStore?.Get("pointer"); } + set { BackingStore?.Set("pointer", value); } + } +#nullable restore +#else + public string Pointer { + get { return BackingStore?.Get("pointer"); } + set { BackingStore?.Set("pointer", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public ErrorSource() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ErrorSource CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ErrorSource(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"header", n => { Header = n.GetStringValue(); } }, + {"parameter", n => { Parameter = n.GetStringValue(); } }, + {"pointer", n => { Pointer = n.GetStringValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("header", Header); + writer.WriteStringValue("parameter", Parameter); + writer.WriteStringValue("pointer", Pointer); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorTopLevelLinks.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorTopLevelLinks.cs new file mode 100644 index 0000000000..15ce3b1b93 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ErrorTopLevelLinks.cs @@ -0,0 +1,83 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ErrorTopLevelLinks : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The describedby property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Describedby { + get { return BackingStore?.Get("describedby"); } + set { BackingStore?.Set("describedby", value); } + } +#nullable restore +#else + public string Describedby { + get { return BackingStore?.Get("describedby"); } + set { BackingStore?.Set("describedby", value); } + } +#endif + /// The self property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Self { + get { return BackingStore?.Get("self"); } + set { BackingStore?.Set("self", value); } + } +#nullable restore +#else + public string Self { + get { return BackingStore?.Get("self"); } + set { BackingStore?.Set("self", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public ErrorTopLevelLinks() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ErrorTopLevelLinks CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ErrorTopLevelLinks(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"describedby", n => { Describedby = n.GetStringValue(); } }, + {"self", n => { Self = n.GetStringValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("describedby", Describedby); + writer.WriteStringValue("self", Self); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceLinks.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceLinks.cs new file mode 100644 index 0000000000..c9a5c80608 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceLinks.cs @@ -0,0 +1,67 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ResourceLinks : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The self property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Self { + get { return BackingStore?.Get("self"); } + set { BackingStore?.Set("self", value); } + } +#nullable restore +#else + public string Self { + get { return BackingStore?.Get("self"); } + set { BackingStore?.Set("self", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public ResourceLinks() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ResourceLinks CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ResourceLinks(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"self", n => { Self = n.GetStringValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("self", Self); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceTopLevelLinks.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceTopLevelLinks.cs new file mode 100644 index 0000000000..b13259fe7c --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/ResourceTopLevelLinks.cs @@ -0,0 +1,83 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class ResourceTopLevelLinks : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The describedby property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Describedby { + get { return BackingStore?.Get("describedby"); } + set { BackingStore?.Set("describedby", value); } + } +#nullable restore +#else + public string Describedby { + get { return BackingStore?.Get("describedby"); } + set { BackingStore?.Set("describedby", value); } + } +#endif + /// The self property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Self { + get { return BackingStore?.Get("self"); } + set { BackingStore?.Set("self", value); } + } +#nullable restore +#else + public string Self { + get { return BackingStore?.Get("self"); } + set { BackingStore?.Set("self", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public ResourceTopLevelLinks() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static ResourceTopLevelLinks CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new ResourceTopLevelLinks(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"describedby", n => { Describedby = n.GetStringValue(); } }, + {"self", n => { Self = n.GetStringValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteStringValue("describedby", Describedby); + writer.WriteStringValue("self", Self); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs new file mode 100644 index 0000000000..bd7aeb6a06 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs @@ -0,0 +1,311 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using Microsoft.Kiota.Abstractions; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountAttributesInPatchRequest : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// The age property + public double? Age { + get { return BackingStore?.Get("age"); } + set { BackingStore?.Set("age", value); } + } + /// The alternativeId property + public Guid? AlternativeId { + get { return BackingStore?.Get("alternativeId"); } + set { BackingStore?.Set("alternativeId", value); } + } + /// The backgroundPicture property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? BackgroundPicture { + get { return BackingStore?.Get("backgroundPicture"); } + set { BackingStore?.Set("backgroundPicture", value); } + } +#nullable restore +#else + public string BackgroundPicture { + get { return BackingStore?.Get("backgroundPicture"); } + set { BackingStore?.Set("backgroundPicture", value); } + } +#endif + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The countryCode property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? CountryCode { + get { return BackingStore?.Get("countryCode"); } + set { BackingStore?.Set("countryCode", value); } + } +#nullable restore +#else + public string CountryCode { + get { return BackingStore?.Get("countryCode"); } + set { BackingStore?.Set("countryCode", value); } + } +#endif + /// The creditCard property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? CreditCard { + get { return BackingStore?.Get("creditCard"); } + set { BackingStore?.Set("creditCard", value); } + } +#nullable restore +#else + public string CreditCard { + get { return BackingStore?.Get("creditCard"); } + set { BackingStore?.Set("creditCard", value); } + } +#endif + /// The email property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Email { + get { return BackingStore?.Get("email"); } + set { BackingStore?.Set("email", value); } + } +#nullable restore +#else + public string Email { + get { return BackingStore?.Get("email"); } + set { BackingStore?.Set("email", value); } + } +#endif + /// The firstName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? FirstName { + get { return BackingStore?.Get("firstName"); } + set { BackingStore?.Set("firstName", value); } + } +#nullable restore +#else + public string FirstName { + get { return BackingStore?.Get("firstName"); } + set { BackingStore?.Set("firstName", value); } + } +#endif + /// The givenName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? GivenName { + get { return BackingStore?.Get("givenName"); } + set { BackingStore?.Set("givenName", value); } + } +#nullable restore +#else + public string GivenName { + get { return BackingStore?.Get("givenName"); } + set { BackingStore?.Set("givenName", value); } + } +#endif + /// The lastName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? LastName { + get { return BackingStore?.Get("lastName"); } + set { BackingStore?.Set("lastName", value); } + } +#nullable restore +#else + public string LastName { + get { return BackingStore?.Get("lastName"); } + set { BackingStore?.Set("lastName", value); } + } +#endif + /// The nextRevalidation property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? NextRevalidation { + get { return BackingStore?.Get("nextRevalidation"); } + set { BackingStore?.Set("nextRevalidation", value); } + } +#nullable restore +#else + public string NextRevalidation { + get { return BackingStore?.Get("nextRevalidation"); } + set { BackingStore?.Set("nextRevalidation", value); } + } +#endif + /// The password property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Password { + get { return BackingStore?.Get("password"); } + set { BackingStore?.Set("password", value); } + } +#nullable restore +#else + public string Password { + get { return BackingStore?.Get("password"); } + set { BackingStore?.Set("password", value); } + } +#endif + /// The phone property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Phone { + get { return BackingStore?.Get("phone"); } + set { BackingStore?.Set("phone", value); } + } +#nullable restore +#else + public string Phone { + get { return BackingStore?.Get("phone"); } + set { BackingStore?.Set("phone", value); } + } +#endif + /// The planet property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Planet { + get { return BackingStore?.Get("planet"); } + set { BackingStore?.Set("planet", value); } + } +#nullable restore +#else + public string Planet { + get { return BackingStore?.Get("planet"); } + set { BackingStore?.Set("planet", value); } + } +#endif + /// The profilePicture property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? ProfilePicture { + get { return BackingStore?.Get("profilePicture"); } + set { BackingStore?.Set("profilePicture", value); } + } +#nullable restore +#else + public string ProfilePicture { + get { return BackingStore?.Get("profilePicture"); } + set { BackingStore?.Set("profilePicture", value); } + } +#endif + /// The tags property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? Tags { + get { return BackingStore?.Get?>("tags"); } + set { BackingStore?.Set("tags", value); } + } +#nullable restore +#else + public List Tags { + get { return BackingStore?.Get>("tags"); } + set { BackingStore?.Set("tags", value); } + } +#endif + /// The userName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? UserName { + get { return BackingStore?.Get("userName"); } + set { BackingStore?.Set("userName", value); } + } +#nullable restore +#else + public string UserName { + get { return BackingStore?.Get("userName"); } + set { BackingStore?.Set("userName", value); } + } +#endif + /// The validatedAt property + public DateTimeOffset? ValidatedAt { + get { return BackingStore?.Get("validatedAt"); } + set { BackingStore?.Set("validatedAt", value); } + } + /// The validatedAtDate property + public Date? ValidatedAtDate { + get { return BackingStore?.Get("validatedAtDate"); } + set { BackingStore?.Set("validatedAtDate", value); } + } + /// The validatedAtTime property + public Time? ValidatedAtTime { + get { return BackingStore?.Get("validatedAtTime"); } + set { BackingStore?.Set("validatedAtTime", value); } + } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountAttributesInPatchRequest() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountAttributesInPatchRequest CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountAttributesInPatchRequest(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"age", n => { Age = n.GetDoubleValue(); } }, + {"alternativeId", n => { AlternativeId = n.GetGuidValue(); } }, + {"backgroundPicture", n => { BackgroundPicture = n.GetStringValue(); } }, + {"countryCode", n => { CountryCode = n.GetStringValue(); } }, + {"creditCard", n => { CreditCard = n.GetStringValue(); } }, + {"email", n => { Email = n.GetStringValue(); } }, + {"firstName", n => { FirstName = n.GetStringValue(); } }, + {"givenName", n => { GivenName = n.GetStringValue(); } }, + {"lastName", n => { LastName = n.GetStringValue(); } }, + {"nextRevalidation", n => { NextRevalidation = n.GetStringValue(); } }, + {"password", n => { Password = n.GetStringValue(); } }, + {"phone", n => { Phone = n.GetStringValue(); } }, + {"planet", n => { Planet = n.GetStringValue(); } }, + {"profilePicture", n => { ProfilePicture = n.GetStringValue(); } }, + {"tags", n => { Tags = n.GetCollectionOfPrimitiveValues()?.ToList(); } }, + {"userName", n => { UserName = n.GetStringValue(); } }, + {"validatedAt", n => { ValidatedAt = n.GetDateTimeOffsetValue(); } }, + {"validatedAtDate", n => { ValidatedAtDate = n.GetDateValue(); } }, + {"validatedAtTime", n => { ValidatedAtTime = n.GetTimeValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteDoubleValue("age", Age); + writer.WriteGuidValue("alternativeId", AlternativeId); + writer.WriteStringValue("backgroundPicture", BackgroundPicture); + writer.WriteStringValue("countryCode", CountryCode); + writer.WriteStringValue("creditCard", CreditCard); + writer.WriteStringValue("email", Email); + writer.WriteStringValue("firstName", FirstName); + writer.WriteStringValue("givenName", GivenName); + writer.WriteStringValue("lastName", LastName); + writer.WriteStringValue("nextRevalidation", NextRevalidation); + writer.WriteStringValue("password", Password); + writer.WriteStringValue("phone", Phone); + writer.WriteStringValue("planet", Planet); + writer.WriteStringValue("profilePicture", ProfilePicture); + writer.WriteCollectionOfPrimitiveValues("tags", Tags); + writer.WriteStringValue("userName", UserName); + writer.WriteDateTimeOffsetValue("validatedAt", ValidatedAt); + writer.WriteDateValue("validatedAtDate", ValidatedAtDate); + writer.WriteTimeValue("validatedAtTime", ValidatedAtTime); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs new file mode 100644 index 0000000000..680f3d1615 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs @@ -0,0 +1,311 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using Microsoft.Kiota.Abstractions; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountAttributesInPostRequest : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// The age property + public double? Age { + get { return BackingStore?.Get("age"); } + set { BackingStore?.Set("age", value); } + } + /// The alternativeId property + public Guid? AlternativeId { + get { return BackingStore?.Get("alternativeId"); } + set { BackingStore?.Set("alternativeId", value); } + } + /// The backgroundPicture property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? BackgroundPicture { + get { return BackingStore?.Get("backgroundPicture"); } + set { BackingStore?.Set("backgroundPicture", value); } + } +#nullable restore +#else + public string BackgroundPicture { + get { return BackingStore?.Get("backgroundPicture"); } + set { BackingStore?.Set("backgroundPicture", value); } + } +#endif + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The countryCode property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? CountryCode { + get { return BackingStore?.Get("countryCode"); } + set { BackingStore?.Set("countryCode", value); } + } +#nullable restore +#else + public string CountryCode { + get { return BackingStore?.Get("countryCode"); } + set { BackingStore?.Set("countryCode", value); } + } +#endif + /// The creditCard property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? CreditCard { + get { return BackingStore?.Get("creditCard"); } + set { BackingStore?.Set("creditCard", value); } + } +#nullable restore +#else + public string CreditCard { + get { return BackingStore?.Get("creditCard"); } + set { BackingStore?.Set("creditCard", value); } + } +#endif + /// The email property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Email { + get { return BackingStore?.Get("email"); } + set { BackingStore?.Set("email", value); } + } +#nullable restore +#else + public string Email { + get { return BackingStore?.Get("email"); } + set { BackingStore?.Set("email", value); } + } +#endif + /// The firstName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? FirstName { + get { return BackingStore?.Get("firstName"); } + set { BackingStore?.Set("firstName", value); } + } +#nullable restore +#else + public string FirstName { + get { return BackingStore?.Get("firstName"); } + set { BackingStore?.Set("firstName", value); } + } +#endif + /// The givenName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? GivenName { + get { return BackingStore?.Get("givenName"); } + set { BackingStore?.Set("givenName", value); } + } +#nullable restore +#else + public string GivenName { + get { return BackingStore?.Get("givenName"); } + set { BackingStore?.Set("givenName", value); } + } +#endif + /// The lastName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? LastName { + get { return BackingStore?.Get("lastName"); } + set { BackingStore?.Set("lastName", value); } + } +#nullable restore +#else + public string LastName { + get { return BackingStore?.Get("lastName"); } + set { BackingStore?.Set("lastName", value); } + } +#endif + /// The nextRevalidation property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? NextRevalidation { + get { return BackingStore?.Get("nextRevalidation"); } + set { BackingStore?.Set("nextRevalidation", value); } + } +#nullable restore +#else + public string NextRevalidation { + get { return BackingStore?.Get("nextRevalidation"); } + set { BackingStore?.Set("nextRevalidation", value); } + } +#endif + /// The password property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Password { + get { return BackingStore?.Get("password"); } + set { BackingStore?.Set("password", value); } + } +#nullable restore +#else + public string Password { + get { return BackingStore?.Get("password"); } + set { BackingStore?.Set("password", value); } + } +#endif + /// The phone property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Phone { + get { return BackingStore?.Get("phone"); } + set { BackingStore?.Set("phone", value); } + } +#nullable restore +#else + public string Phone { + get { return BackingStore?.Get("phone"); } + set { BackingStore?.Set("phone", value); } + } +#endif + /// The planet property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Planet { + get { return BackingStore?.Get("planet"); } + set { BackingStore?.Set("planet", value); } + } +#nullable restore +#else + public string Planet { + get { return BackingStore?.Get("planet"); } + set { BackingStore?.Set("planet", value); } + } +#endif + /// The profilePicture property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? ProfilePicture { + get { return BackingStore?.Get("profilePicture"); } + set { BackingStore?.Set("profilePicture", value); } + } +#nullable restore +#else + public string ProfilePicture { + get { return BackingStore?.Get("profilePicture"); } + set { BackingStore?.Set("profilePicture", value); } + } +#endif + /// The tags property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? Tags { + get { return BackingStore?.Get?>("tags"); } + set { BackingStore?.Set("tags", value); } + } +#nullable restore +#else + public List Tags { + get { return BackingStore?.Get>("tags"); } + set { BackingStore?.Set("tags", value); } + } +#endif + /// The userName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? UserName { + get { return BackingStore?.Get("userName"); } + set { BackingStore?.Set("userName", value); } + } +#nullable restore +#else + public string UserName { + get { return BackingStore?.Get("userName"); } + set { BackingStore?.Set("userName", value); } + } +#endif + /// The validatedAt property + public DateTimeOffset? ValidatedAt { + get { return BackingStore?.Get("validatedAt"); } + set { BackingStore?.Set("validatedAt", value); } + } + /// The validatedAtDate property + public Date? ValidatedAtDate { + get { return BackingStore?.Get("validatedAtDate"); } + set { BackingStore?.Set("validatedAtDate", value); } + } + /// The validatedAtTime property + public Time? ValidatedAtTime { + get { return BackingStore?.Get("validatedAtTime"); } + set { BackingStore?.Set("validatedAtTime", value); } + } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountAttributesInPostRequest() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountAttributesInPostRequest CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountAttributesInPostRequest(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"age", n => { Age = n.GetDoubleValue(); } }, + {"alternativeId", n => { AlternativeId = n.GetGuidValue(); } }, + {"backgroundPicture", n => { BackgroundPicture = n.GetStringValue(); } }, + {"countryCode", n => { CountryCode = n.GetStringValue(); } }, + {"creditCard", n => { CreditCard = n.GetStringValue(); } }, + {"email", n => { Email = n.GetStringValue(); } }, + {"firstName", n => { FirstName = n.GetStringValue(); } }, + {"givenName", n => { GivenName = n.GetStringValue(); } }, + {"lastName", n => { LastName = n.GetStringValue(); } }, + {"nextRevalidation", n => { NextRevalidation = n.GetStringValue(); } }, + {"password", n => { Password = n.GetStringValue(); } }, + {"phone", n => { Phone = n.GetStringValue(); } }, + {"planet", n => { Planet = n.GetStringValue(); } }, + {"profilePicture", n => { ProfilePicture = n.GetStringValue(); } }, + {"tags", n => { Tags = n.GetCollectionOfPrimitiveValues()?.ToList(); } }, + {"userName", n => { UserName = n.GetStringValue(); } }, + {"validatedAt", n => { ValidatedAt = n.GetDateTimeOffsetValue(); } }, + {"validatedAtDate", n => { ValidatedAtDate = n.GetDateValue(); } }, + {"validatedAtTime", n => { ValidatedAtTime = n.GetTimeValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteDoubleValue("age", Age); + writer.WriteGuidValue("alternativeId", AlternativeId); + writer.WriteStringValue("backgroundPicture", BackgroundPicture); + writer.WriteStringValue("countryCode", CountryCode); + writer.WriteStringValue("creditCard", CreditCard); + writer.WriteStringValue("email", Email); + writer.WriteStringValue("firstName", FirstName); + writer.WriteStringValue("givenName", GivenName); + writer.WriteStringValue("lastName", LastName); + writer.WriteStringValue("nextRevalidation", NextRevalidation); + writer.WriteStringValue("password", Password); + writer.WriteStringValue("phone", Phone); + writer.WriteStringValue("planet", Planet); + writer.WriteStringValue("profilePicture", ProfilePicture); + writer.WriteCollectionOfPrimitiveValues("tags", Tags); + writer.WriteStringValue("userName", UserName); + writer.WriteDateTimeOffsetValue("validatedAt", ValidatedAt); + writer.WriteDateValue("validatedAtDate", ValidatedAtDate); + writer.WriteTimeValue("validatedAtTime", ValidatedAtTime); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs new file mode 100644 index 0000000000..0b7fc7ae8c --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs @@ -0,0 +1,311 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using Microsoft.Kiota.Abstractions; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountAttributesInResponse : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// The age property + public double? Age { + get { return BackingStore?.Get("age"); } + set { BackingStore?.Set("age", value); } + } + /// The alternativeId property + public Guid? AlternativeId { + get { return BackingStore?.Get("alternativeId"); } + set { BackingStore?.Set("alternativeId", value); } + } + /// The backgroundPicture property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? BackgroundPicture { + get { return BackingStore?.Get("backgroundPicture"); } + set { BackingStore?.Set("backgroundPicture", value); } + } +#nullable restore +#else + public string BackgroundPicture { + get { return BackingStore?.Get("backgroundPicture"); } + set { BackingStore?.Set("backgroundPicture", value); } + } +#endif + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The countryCode property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? CountryCode { + get { return BackingStore?.Get("countryCode"); } + set { BackingStore?.Set("countryCode", value); } + } +#nullable restore +#else + public string CountryCode { + get { return BackingStore?.Get("countryCode"); } + set { BackingStore?.Set("countryCode", value); } + } +#endif + /// The creditCard property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? CreditCard { + get { return BackingStore?.Get("creditCard"); } + set { BackingStore?.Set("creditCard", value); } + } +#nullable restore +#else + public string CreditCard { + get { return BackingStore?.Get("creditCard"); } + set { BackingStore?.Set("creditCard", value); } + } +#endif + /// The email property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Email { + get { return BackingStore?.Get("email"); } + set { BackingStore?.Set("email", value); } + } +#nullable restore +#else + public string Email { + get { return BackingStore?.Get("email"); } + set { BackingStore?.Set("email", value); } + } +#endif + /// The firstName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? FirstName { + get { return BackingStore?.Get("firstName"); } + set { BackingStore?.Set("firstName", value); } + } +#nullable restore +#else + public string FirstName { + get { return BackingStore?.Get("firstName"); } + set { BackingStore?.Set("firstName", value); } + } +#endif + /// The givenName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? GivenName { + get { return BackingStore?.Get("givenName"); } + set { BackingStore?.Set("givenName", value); } + } +#nullable restore +#else + public string GivenName { + get { return BackingStore?.Get("givenName"); } + set { BackingStore?.Set("givenName", value); } + } +#endif + /// The lastName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? LastName { + get { return BackingStore?.Get("lastName"); } + set { BackingStore?.Set("lastName", value); } + } +#nullable restore +#else + public string LastName { + get { return BackingStore?.Get("lastName"); } + set { BackingStore?.Set("lastName", value); } + } +#endif + /// The nextRevalidation property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? NextRevalidation { + get { return BackingStore?.Get("nextRevalidation"); } + set { BackingStore?.Set("nextRevalidation", value); } + } +#nullable restore +#else + public string NextRevalidation { + get { return BackingStore?.Get("nextRevalidation"); } + set { BackingStore?.Set("nextRevalidation", value); } + } +#endif + /// The password property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Password { + get { return BackingStore?.Get("password"); } + set { BackingStore?.Set("password", value); } + } +#nullable restore +#else + public string Password { + get { return BackingStore?.Get("password"); } + set { BackingStore?.Set("password", value); } + } +#endif + /// The phone property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Phone { + get { return BackingStore?.Get("phone"); } + set { BackingStore?.Set("phone", value); } + } +#nullable restore +#else + public string Phone { + get { return BackingStore?.Get("phone"); } + set { BackingStore?.Set("phone", value); } + } +#endif + /// The planet property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Planet { + get { return BackingStore?.Get("planet"); } + set { BackingStore?.Set("planet", value); } + } +#nullable restore +#else + public string Planet { + get { return BackingStore?.Get("planet"); } + set { BackingStore?.Set("planet", value); } + } +#endif + /// The profilePicture property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? ProfilePicture { + get { return BackingStore?.Get("profilePicture"); } + set { BackingStore?.Set("profilePicture", value); } + } +#nullable restore +#else + public string ProfilePicture { + get { return BackingStore?.Get("profilePicture"); } + set { BackingStore?.Set("profilePicture", value); } + } +#endif + /// The tags property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? Tags { + get { return BackingStore?.Get?>("tags"); } + set { BackingStore?.Set("tags", value); } + } +#nullable restore +#else + public List Tags { + get { return BackingStore?.Get>("tags"); } + set { BackingStore?.Set("tags", value); } + } +#endif + /// The userName property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? UserName { + get { return BackingStore?.Get("userName"); } + set { BackingStore?.Set("userName", value); } + } +#nullable restore +#else + public string UserName { + get { return BackingStore?.Get("userName"); } + set { BackingStore?.Set("userName", value); } + } +#endif + /// The validatedAt property + public DateTimeOffset? ValidatedAt { + get { return BackingStore?.Get("validatedAt"); } + set { BackingStore?.Set("validatedAt", value); } + } + /// The validatedAtDate property + public Date? ValidatedAtDate { + get { return BackingStore?.Get("validatedAtDate"); } + set { BackingStore?.Set("validatedAtDate", value); } + } + /// The validatedAtTime property + public Time? ValidatedAtTime { + get { return BackingStore?.Get("validatedAtTime"); } + set { BackingStore?.Set("validatedAtTime", value); } + } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountAttributesInResponse() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountAttributesInResponse CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountAttributesInResponse(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"age", n => { Age = n.GetDoubleValue(); } }, + {"alternativeId", n => { AlternativeId = n.GetGuidValue(); } }, + {"backgroundPicture", n => { BackgroundPicture = n.GetStringValue(); } }, + {"countryCode", n => { CountryCode = n.GetStringValue(); } }, + {"creditCard", n => { CreditCard = n.GetStringValue(); } }, + {"email", n => { Email = n.GetStringValue(); } }, + {"firstName", n => { FirstName = n.GetStringValue(); } }, + {"givenName", n => { GivenName = n.GetStringValue(); } }, + {"lastName", n => { LastName = n.GetStringValue(); } }, + {"nextRevalidation", n => { NextRevalidation = n.GetStringValue(); } }, + {"password", n => { Password = n.GetStringValue(); } }, + {"phone", n => { Phone = n.GetStringValue(); } }, + {"planet", n => { Planet = n.GetStringValue(); } }, + {"profilePicture", n => { ProfilePicture = n.GetStringValue(); } }, + {"tags", n => { Tags = n.GetCollectionOfPrimitiveValues()?.ToList(); } }, + {"userName", n => { UserName = n.GetStringValue(); } }, + {"validatedAt", n => { ValidatedAt = n.GetDateTimeOffsetValue(); } }, + {"validatedAtDate", n => { ValidatedAtDate = n.GetDateValue(); } }, + {"validatedAtTime", n => { ValidatedAtTime = n.GetTimeValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteDoubleValue("age", Age); + writer.WriteGuidValue("alternativeId", AlternativeId); + writer.WriteStringValue("backgroundPicture", BackgroundPicture); + writer.WriteStringValue("countryCode", CountryCode); + writer.WriteStringValue("creditCard", CreditCard); + writer.WriteStringValue("email", Email); + writer.WriteStringValue("firstName", FirstName); + writer.WriteStringValue("givenName", GivenName); + writer.WriteStringValue("lastName", LastName); + writer.WriteStringValue("nextRevalidation", NextRevalidation); + writer.WriteStringValue("password", Password); + writer.WriteStringValue("phone", Phone); + writer.WriteStringValue("planet", Planet); + writer.WriteStringValue("profilePicture", ProfilePicture); + writer.WriteCollectionOfPrimitiveValues("tags", Tags); + writer.WriteStringValue("userName", UserName); + writer.WriteDateTimeOffsetValue("validatedAt", ValidatedAt); + writer.WriteDateValue("validatedAtDate", ValidatedAtDate); + writer.WriteTimeValue("validatedAtTime", ValidatedAtTime); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPatchRequest.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPatchRequest.cs new file mode 100644 index 0000000000..ab2367b343 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPatchRequest.cs @@ -0,0 +1,90 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountDataInPatchRequest : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// The attributes property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountAttributesInPatchRequest? Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#nullable restore +#else + public SocialMediaAccountAttributesInPatchRequest Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#endif + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The id property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public string? Id { + get { return BackingStore?.Get("id"); } + set { BackingStore?.Set("id", value); } + } +#nullable restore +#else + public string Id { + get { return BackingStore?.Get("id"); } + set { BackingStore?.Set("id", value); } + } +#endif + /// The type property + public SocialMediaAccountResourceType? Type { + get { return BackingStore?.Get("type"); } + set { BackingStore?.Set("type", value); } + } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountDataInPatchRequest() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountDataInPatchRequest CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountDataInPatchRequest(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"attributes", n => { Attributes = n.GetObjectValue(SocialMediaAccountAttributesInPatchRequest.CreateFromDiscriminatorValue); } }, + {"id", n => { Id = n.GetStringValue(); } }, + {"type", n => { Type = n.GetEnumValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteObjectValue("attributes", Attributes); + writer.WriteStringValue("id", Id); + writer.WriteEnumValue("type", Type); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPostRequest.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPostRequest.cs new file mode 100644 index 0000000000..a6cf4814d5 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInPostRequest.cs @@ -0,0 +1,74 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountDataInPostRequest : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// The attributes property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountAttributesInPostRequest? Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#nullable restore +#else + public SocialMediaAccountAttributesInPostRequest Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#endif + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The type property + public SocialMediaAccountResourceType? Type { + get { return BackingStore?.Get("type"); } + set { BackingStore?.Set("type", value); } + } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountDataInPostRequest() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountDataInPostRequest CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountDataInPostRequest(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"attributes", n => { Attributes = n.GetObjectValue(SocialMediaAccountAttributesInPostRequest.CreateFromDiscriminatorValue); } }, + {"type", n => { Type = n.GetEnumValue(); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteObjectValue("attributes", Attributes); + writer.WriteEnumValue("type", Type); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse.cs new file mode 100644 index 0000000000..7344e1f916 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse.cs @@ -0,0 +1,90 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountDataInResponse : DataInResponse, IParsable + #pragma warning restore CS1591 + { + /// The attributes property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountAttributesInResponse? Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#nullable restore +#else + public SocialMediaAccountAttributesInResponse Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#endif + /// The links property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ResourceLinks? Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#nullable restore +#else + public ResourceLinks Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#endif + /// The meta property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountDataInResponse_meta? Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#nullable restore +#else + public SocialMediaAccountDataInResponse_meta Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#endif + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static new SocialMediaAccountDataInResponse CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountDataInResponse(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public override IDictionary> GetFieldDeserializers() + { + return new Dictionary>(base.GetFieldDeserializers()) + { + {"attributes", n => { Attributes = n.GetObjectValue(SocialMediaAccountAttributesInResponse.CreateFromDiscriminatorValue); } }, + {"links", n => { Links = n.GetObjectValue(ResourceLinks.CreateFromDiscriminatorValue); } }, + {"meta", n => { Meta = n.GetObjectValue(SocialMediaAccountDataInResponse_meta.CreateFromDiscriminatorValue); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public override void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + base.Serialize(writer); + writer.WriteObjectValue("attributes", Attributes); + writer.WriteObjectValue("links", Links); + writer.WriteObjectValue("meta", Meta); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse_meta.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse_meta.cs new file mode 100644 index 0000000000..daa2f4eaf2 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountDataInResponse_meta.cs @@ -0,0 +1,58 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountDataInResponse_meta : IAdditionalDataHolder, IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { + get { return BackingStore.Get>("AdditionalData") ?? throw new InvalidOperationException("AdditionalData can not be null"); } + set { BackingStore.Set("AdditionalData", value); } + } + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountDataInResponse_meta() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountDataInResponse_meta CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountDataInResponse_meta(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteAdditionalData(AdditionalData); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPatchRequestDocument.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPatchRequestDocument.cs new file mode 100644 index 0000000000..4dbdff98e6 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPatchRequestDocument.cs @@ -0,0 +1,67 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountPatchRequestDocument : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The data property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountDataInPatchRequest? Data { + get { return BackingStore?.Get("data"); } + set { BackingStore?.Set("data", value); } + } +#nullable restore +#else + public SocialMediaAccountDataInPatchRequest Data { + get { return BackingStore?.Get("data"); } + set { BackingStore?.Set("data", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountPatchRequestDocument() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountPatchRequestDocument CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountPatchRequestDocument(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"data", n => { Data = n.GetObjectValue(SocialMediaAccountDataInPatchRequest.CreateFromDiscriminatorValue); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteObjectValue("data", Data); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPostRequestDocument.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPostRequestDocument.cs new file mode 100644 index 0000000000..91c75791bf --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPostRequestDocument.cs @@ -0,0 +1,67 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountPostRequestDocument : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The data property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountDataInPostRequest? Data { + get { return BackingStore?.Get("data"); } + set { BackingStore?.Set("data", value); } + } +#nullable restore +#else + public SocialMediaAccountDataInPostRequest Data { + get { return BackingStore?.Get("data"); } + set { BackingStore?.Set("data", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountPostRequestDocument() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountPostRequestDocument CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountPostRequestDocument(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"data", n => { Data = n.GetObjectValue(SocialMediaAccountDataInPostRequest.CreateFromDiscriminatorValue); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteObjectValue("data", Data); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument.cs new file mode 100644 index 0000000000..8bcf6b5010 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument.cs @@ -0,0 +1,115 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountPrimaryResponseDocument : IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// The data property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccounts? Data { + get { return BackingStore?.Get("data"); } + set { BackingStore?.Set("data", value); } + } +#nullable restore +#else + public SocialMediaAccounts Data { + get { return BackingStore?.Get("data"); } + set { BackingStore?.Set("data", value); } + } +#endif + /// The included property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public List? Included { + get { return BackingStore?.Get?>("included"); } + set { BackingStore?.Set("included", value); } + } +#nullable restore +#else + public List Included { + get { return BackingStore?.Get>("included"); } + set { BackingStore?.Set("included", value); } + } +#endif + /// The links property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ResourceTopLevelLinks? Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#nullable restore +#else + public ResourceTopLevelLinks Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#endif + /// The meta property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountPrimaryResponseDocument_meta? Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#nullable restore +#else + public SocialMediaAccountPrimaryResponseDocument_meta Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#endif + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountPrimaryResponseDocument() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountPrimaryResponseDocument CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountPrimaryResponseDocument(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + {"data", n => { Data = n.GetObjectValue(SocialMediaAccounts.CreateFromDiscriminatorValue); } }, + {"included", n => { Included = n.GetCollectionOfObjectValues(DataInResponse.CreateFromDiscriminatorValue)?.ToList(); } }, + {"links", n => { Links = n.GetObjectValue(ResourceTopLevelLinks.CreateFromDiscriminatorValue); } }, + {"meta", n => { Meta = n.GetObjectValue(SocialMediaAccountPrimaryResponseDocument_meta.CreateFromDiscriminatorValue); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteObjectValue("data", Data); + writer.WriteCollectionOfObjectValues("included", Included); + writer.WriteObjectValue("links", Links); + writer.WriteObjectValue("meta", Meta); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument_meta.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument_meta.cs new file mode 100644 index 0000000000..94efbdee26 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountPrimaryResponseDocument_meta.cs @@ -0,0 +1,58 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccountPrimaryResponseDocument_meta : IAdditionalDataHolder, IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { + get { return BackingStore.Get>("AdditionalData") ?? throw new InvalidOperationException("AdditionalData can not be null"); } + set { BackingStore.Set("AdditionalData", value); } + } + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccountPrimaryResponseDocument_meta() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccountPrimaryResponseDocument_meta CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccountPrimaryResponseDocument_meta(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteAdditionalData(AdditionalData); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountResourceType.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountResourceType.cs new file mode 100644 index 0000000000..da2c2ce427 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountResourceType.cs @@ -0,0 +1,14 @@ +// +using System.Runtime.Serialization; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public enum SocialMediaAccountResourceType + #pragma warning restore CS1591 + { + [EnumMember(Value = "socialMediaAccounts")] + #pragma warning disable CS1591 + SocialMediaAccounts, + #pragma warning restore CS1591 + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts.cs new file mode 100644 index 0000000000..9c56d76975 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts.cs @@ -0,0 +1,90 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccounts : DataInResponse, IParsable + #pragma warning restore CS1591 + { + /// The attributes property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccountAttributesInResponse? Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#nullable restore +#else + public SocialMediaAccountAttributesInResponse Attributes { + get { return BackingStore?.Get("attributes"); } + set { BackingStore?.Set("attributes", value); } + } +#endif + /// The links property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public ResourceLinks? Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#nullable restore +#else + public ResourceLinks Links { + get { return BackingStore?.Get("links"); } + set { BackingStore?.Set("links", value); } + } +#endif + /// The meta property +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public SocialMediaAccounts_meta? Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#nullable restore +#else + public SocialMediaAccounts_meta Meta { + get { return BackingStore?.Get("meta"); } + set { BackingStore?.Set("meta", value); } + } +#endif + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static new SocialMediaAccounts CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccounts(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public override IDictionary> GetFieldDeserializers() + { + return new Dictionary>(base.GetFieldDeserializers()) + { + {"attributes", n => { Attributes = n.GetObjectValue(SocialMediaAccountAttributesInResponse.CreateFromDiscriminatorValue); } }, + {"links", n => { Links = n.GetObjectValue(ResourceLinks.CreateFromDiscriminatorValue); } }, + {"meta", n => { Meta = n.GetObjectValue(SocialMediaAccounts_meta.CreateFromDiscriminatorValue); } }, + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public override void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + base.Serialize(writer); + writer.WriteObjectValue("attributes", Attributes); + writer.WriteObjectValue("links", Links); + writer.WriteObjectValue("meta", Meta); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts_meta.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts_meta.cs new file mode 100644 index 0000000000..0f2bcb4057 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccounts_meta.cs @@ -0,0 +1,58 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions.Store; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models { + #pragma warning disable CS1591 + public class SocialMediaAccounts_meta : IAdditionalDataHolder, IBackedModel, IParsable + #pragma warning restore CS1591 + { + /// Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + public IDictionary AdditionalData { + get { return BackingStore.Get>("AdditionalData") ?? throw new InvalidOperationException("AdditionalData can not be null"); } + set { BackingStore.Set("AdditionalData", value); } + } + /// Stores model information. + public IBackingStore BackingStore { get; private set; } + /// + /// Instantiates a new and sets the default values. + /// + public SocialMediaAccounts_meta() + { + BackingStore = BackingStoreFactorySingleton.Instance.CreateBackingStore(); + AdditionalData = new Dictionary(); + } + /// + /// Creates a new instance of the appropriate class based on discriminator value + /// + /// A + /// The parse node to use to read the discriminator value and create the object + public static SocialMediaAccounts_meta CreateFromDiscriminatorValue(IParseNode parseNode) + { + _ = parseNode ?? throw new ArgumentNullException(nameof(parseNode)); + return new SocialMediaAccounts_meta(); + } + /// + /// The deserialization information for the current model + /// + /// A IDictionary<string, Action<IParseNode>> + public virtual IDictionary> GetFieldDeserializers() + { + return new Dictionary> + { + }; + } + /// + /// Serializes information the current object + /// + /// Serialization writer to use to serialize this model + public virtual void Serialize(ISerializationWriter writer) + { + _ = writer ?? throw new ArgumentNullException(nameof(writer)); + writer.WriteAdditionalData(AdditionalData); + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/Item/SocialMediaAccountsItemRequestBuilder.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/Item/SocialMediaAccountsItemRequestBuilder.cs new file mode 100644 index 0000000000..0f32286f7e --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/Item/SocialMediaAccountsItemRequestBuilder.cs @@ -0,0 +1,112 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions; +using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading.Tasks; +using System.Threading; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.SocialMediaAccounts.Item { + /// + /// Builds and executes requests for operations under \socialMediaAccounts\{id} + /// + public class SocialMediaAccountsItemRequestBuilder : BaseRequestBuilder + { + /// + /// Instantiates a new and sets the default values. + /// + /// Path parameters for the request + /// The request adapter to use to execute the requests. + public SocialMediaAccountsItemRequestBuilder(Dictionary pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/socialMediaAccounts/{id}{?query*}", pathParameters) + { + } + /// + /// Instantiates a new and sets the default values. + /// + /// The raw URL to use for the request builder. + /// The request adapter to use to execute the requests. + public SocialMediaAccountsItemRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/socialMediaAccounts/{id}{?query*}", rawUrl) + { + } + /// + /// Updates an existing socialMediaAccount. + /// + /// A + /// The request body + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 400 status code + /// When receiving a 404 status code + /// When receiving a 409 status code + /// When receiving a 422 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task PatchAsync(SocialMediaAccountPatchRequestDocument body, Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task PatchAsync(SocialMediaAccountPatchRequestDocument body, Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = ToPatchRequestInformation(body, requestConfiguration); + var errorMapping = new Dictionary> + { + {"400", ErrorResponseDocument.CreateFromDiscriminatorValue}, + {"404", ErrorResponseDocument.CreateFromDiscriminatorValue}, + {"409", ErrorResponseDocument.CreateFromDiscriminatorValue}, + {"422", ErrorResponseDocument.CreateFromDiscriminatorValue}, + }; + return await RequestAdapter.SendAsync(requestInfo, SocialMediaAccountPrimaryResponseDocument.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// Updates an existing socialMediaAccount. + /// + /// A + /// The request body + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToPatchRequestInformation(SocialMediaAccountPatchRequestDocument body, Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToPatchRequestInformation(SocialMediaAccountPatchRequestDocument body, Action> requestConfiguration = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = new RequestInformation(Method.PATCH, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/vnd.api+json"); + requestInfo.SetContentFromParsable(RequestAdapter, "application/vnd.api+json", body); + return requestInfo; + } + /// + /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + /// + /// A + /// The raw URL to use for the request builder. + public SocialMediaAccountsItemRequestBuilder WithUrl(string rawUrl) + { + return new SocialMediaAccountsItemRequestBuilder(rawUrl, RequestAdapter); + } + /// + /// Updates an existing socialMediaAccount. + /// + public class SocialMediaAccountsItemRequestBuilderPatchQueryParameters + { + /// For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + [QueryParameter("query")] + public string? Query { get; set; } +#nullable restore +#else + [QueryParameter("query")] + public string Query { get; set; } +#endif + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/SocialMediaAccountsRequestBuilder.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/SocialMediaAccountsRequestBuilder.cs new file mode 100644 index 0000000000..57524088f0 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/SocialMediaAccounts/SocialMediaAccountsRequestBuilder.cs @@ -0,0 +1,127 @@ +// +using Microsoft.Kiota.Abstractions.Serialization; +using Microsoft.Kiota.Abstractions; +using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models; +using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.SocialMediaAccounts.Item; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading.Tasks; +using System.Threading; +using System; +namespace OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.SocialMediaAccounts { + /// + /// Builds and executes requests for operations under \socialMediaAccounts + /// + public class SocialMediaAccountsRequestBuilder : BaseRequestBuilder + { + /// Gets an item from the OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.socialMediaAccounts.item collection + /// The identifier of the socialMediaAccount to update. + /// A + public SocialMediaAccountsItemRequestBuilder this[string position] + { + get + { + var urlTplParams = new Dictionary(PathParameters); + urlTplParams.Add("id", position); + return new SocialMediaAccountsItemRequestBuilder(urlTplParams, RequestAdapter); + } + } + /// + /// Instantiates a new and sets the default values. + /// + /// Path parameters for the request + /// The request adapter to use to execute the requests. + public SocialMediaAccountsRequestBuilder(Dictionary pathParameters, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/socialMediaAccounts{?query*}", pathParameters) + { + } + /// + /// Instantiates a new and sets the default values. + /// + /// The raw URL to use for the request builder. + /// The request adapter to use to execute the requests. + public SocialMediaAccountsRequestBuilder(string rawUrl, IRequestAdapter requestAdapter) : base(requestAdapter, "{+baseurl}/socialMediaAccounts{?query*}", rawUrl) + { + } + /// + /// Creates a new socialMediaAccount. + /// + /// A + /// The request body + /// Cancellation token to use when cancelling requests + /// Configuration for the request such as headers, query parameters, and middleware options. + /// When receiving a 400 status code + /// When receiving a 403 status code + /// When receiving a 404 status code + /// When receiving a 409 status code + /// When receiving a 422 status code +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public async Task PostAsync(SocialMediaAccountPostRequestDocument body, Action>? requestConfiguration = default, CancellationToken cancellationToken = default) + { +#nullable restore +#else + public async Task PostAsync(SocialMediaAccountPostRequestDocument body, Action> requestConfiguration = default, CancellationToken cancellationToken = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = ToPostRequestInformation(body, requestConfiguration); + var errorMapping = new Dictionary> + { + {"400", ErrorResponseDocument.CreateFromDiscriminatorValue}, + {"403", ErrorResponseDocument.CreateFromDiscriminatorValue}, + {"404", ErrorResponseDocument.CreateFromDiscriminatorValue}, + {"409", ErrorResponseDocument.CreateFromDiscriminatorValue}, + {"422", ErrorResponseDocument.CreateFromDiscriminatorValue}, + }; + return await RequestAdapter.SendAsync(requestInfo, SocialMediaAccountPrimaryResponseDocument.CreateFromDiscriminatorValue, errorMapping, cancellationToken).ConfigureAwait(false); + } + /// + /// Creates a new socialMediaAccount. + /// + /// A + /// The request body + /// Configuration for the request such as headers, query parameters, and middleware options. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + public RequestInformation ToPostRequestInformation(SocialMediaAccountPostRequestDocument body, Action>? requestConfiguration = default) + { +#nullable restore +#else + public RequestInformation ToPostRequestInformation(SocialMediaAccountPostRequestDocument body, Action> requestConfiguration = default) + { +#endif + _ = body ?? throw new ArgumentNullException(nameof(body)); + var requestInfo = new RequestInformation(Method.POST, UrlTemplate, PathParameters); + requestInfo.Configure(requestConfiguration); + requestInfo.Headers.TryAdd("Accept", "application/vnd.api+json"); + requestInfo.SetContentFromParsable(RequestAdapter, "application/vnd.api+json", body); + return requestInfo; + } + /// + /// Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + /// + /// A + /// The raw URL to use for the request builder. + public SocialMediaAccountsRequestBuilder WithUrl(string rawUrl) + { + return new SocialMediaAccountsRequestBuilder(rawUrl, RequestAdapter); + } + /// + /// Creates a new socialMediaAccount. + /// + public class SocialMediaAccountsRequestBuilderPostQueryParameters + { + /// For syntax, see the documentation for the [`include`](https://www.jsonapi.net/usage/reading/including-relationships.html)/[`filter`](https://www.jsonapi.net/usage/reading/filtering.html)/[`sort`](https://www.jsonapi.net/usage/reading/sorting.html)/[`page`](https://www.jsonapi.net/usage/reading/pagination.html)/[`fields`](https://www.jsonapi.net/usage/reading/sparse-fieldset-selection.html) query string parameters. +#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER +#nullable enable + [QueryParameter("query")] + public string? Query { get; set; } +#nullable restore +#else + [QueryParameter("query")] + public string Query { get; set; } +#endif + } + } +} diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs new file mode 100644 index 0000000000..8a9b5669e8 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -0,0 +1,541 @@ +using System.Globalization; +using FluentAssertions; +using Microsoft.Kiota.Http.HttpClientLibrary; +using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode; +using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models; +using OpenApiTests; +using OpenApiTests.ModelStateValidation; +using TestBuildingBlocks; +using Xunit; +using Xunit.Abstractions; + +namespace OpenApiKiotaEndToEndTests.ModelStateValidation; + +public sealed class ModelStateValidationTests + : IClassFixture, ModelStateValidationDbContext>> +{ + private readonly IntegrationTestContext, ModelStateValidationDbContext> _testContext; + private readonly TestableHttpClientRequestAdapterFactory _requestAdapterFactory; + private readonly ModelStateValidationFakers _fakers = new(); + + public ModelStateValidationTests(IntegrationTestContext, ModelStateValidationDbContext> testContext, + ITestOutputHelper testOutputHelper) + { + _testContext = testContext; + _requestAdapterFactory = new TestableHttpClientRequestAdapterFactory(testOutputHelper); + + testContext.UseController(); + } + + [Fact] + public async Task Cannot_violate_compare_constraint() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + FirstName = newAccount.FirstName, + GivenName = "something else", + LastName = newAccount.LastName + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("'GivenName' and 'FirstName' do not match."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/givenName"); + } + + [Theory] + [InlineData("a")] + [InlineData("abcdefghijklmnopqrstu")] + public async Task Cannot_exceed_length_constraint(string firstName) + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + FirstName = firstName, + GivenName = firstName, + LastName = newAccount.LastName + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field FirstName must be a string or collection type with a minimum length of '2' and maximum length of '20'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/firstName"); + } + + [Theory] + [InlineData("ab")] + [InlineData("abcdefghijklmnopqrs")] + public async Task Cannot_exceed_string_length_constraint(string userName) + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + UserName = userName + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field UserName must be a string with a minimum length of 3 and a maximum length of 18."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); + } + + [Fact] + public async Task Cannot_violate_regular_expression_constraint() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + UserName = "aB1" + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("Only letters are allowed."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/userName"); + } + + [Fact] + public async Task Cannot_use_invalid_credit_card_number() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + CreditCard = "123-456" + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The CreditCard field is not a valid credit card number."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/creditCard"); + } + + [Fact] + public async Task Cannot_use_invalid_email_address() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + Email = "abc" + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The Email field is not a valid e-mail address."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/email"); + } + + [Theory] + [InlineData(-1)] + [InlineData(-0.56)] + [InlineData(123.98)] + [InlineData(124)] + public async Task Cannot_use_double_outside_of_valid_range(int age) + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + Age = age + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field Age must be between 0.1 and 122.9."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/age"); + } + + [Fact] + public async Task Cannot_use_relative_url() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + BackgroundPicture = "/justapath" + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The BackgroundPicture field is not a valid fully-qualified http, https, or ftp URL."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/backgroundPicture"); + } + + [Theory] + [InlineData(0)] + [InlineData(11)] + public async Task Cannot_exceed_collection_length_constraint(int length) + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + Tags = Enumerable.Repeat("-", length).ToList() + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field Tags must be a string or collection type with a minimum length of '1' and maximum length of '10'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/tags"); + } + + [Fact] + public async Task Cannot_use_non_allowed_value() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + CountryCode = "XX" + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The CountryCode field does not equal any of the values specified in AllowedValuesAttribute."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/countryCode"); + } + + [Fact] + public async Task Cannot_use_denied_value() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + Planet = "pluto" + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The Planet field equals one of the values specified in DeniedValuesAttribute."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/planet"); + } + + [Fact] + public async Task Cannot_use_TimeSpan_outside_of_valid_range() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + NextRevalidation = TimeSpan.FromSeconds(1).ToString() + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field NextRevalidation must be between 01:00:00 and 05:00:00."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + } + + [Fact] + public async Task Cannot_use_culture_sensitive_TimeSpan() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + NextRevalidation = new TimeSpan(0, 2, 0, 0, 1).ToString("g", new CultureInfo("fr-FR")) + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); + + errorObject.Detail.Should() + .Be("Failed to convert attribute 'nextRevalidation' with value '2:00:00,001' of type 'String' to type 'Nullable'."); + + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + } + + [Fact] + public async Task Can_create_resource_with_valid_properties() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + FirstName = newAccount.FirstName, + GivenName = newAccount.GivenName, + LastName = newAccount.LastName, + UserName = newAccount.UserName, + CreditCard = newAccount.CreditCard, + Email = newAccount.Email, + Phone = newAccount.Phone, + Age = newAccount.Age, + ProfilePicture = newAccount.ProfilePicture!.ToString(), + BackgroundPicture = newAccount.BackgroundPicture, + Tags = newAccount.Tags, + Planet = newAccount.Planet, + NextRevalidation = newAccount.NextRevalidation!.Value.ToString(), + ValidatedAt = newAccount.ValidatedAt!, + ValidatedAtDate = newAccount.ValidatedAtDate!.Value, + ValidatedAtTime = newAccount.ValidatedAtTime!.Value + } + } + }; + + // Act + Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + await action.Should().NotThrowAsync(); + } +} diff --git a/test/OpenApiKiotaEndToEndTests/OpenApiKiotaEndToEndTests.csproj b/test/OpenApiKiotaEndToEndTests/OpenApiKiotaEndToEndTests.csproj index a66c69869b..abb1cd95ce 100644 --- a/test/OpenApiKiotaEndToEndTests/OpenApiKiotaEndToEndTests.csproj +++ b/test/OpenApiKiotaEndToEndTests/OpenApiKiotaEndToEndTests.csproj @@ -32,6 +32,8 @@ Command="dotnet kiota generate --language CSharp --class-name QueryStringsClient --namespace-name OpenApiKiotaEndToEndTests.QueryStrings.GeneratedCode --output ./QueryStrings/GeneratedCode --backing-store --exclude-backward-compatible --clean-output --clear-cache --log-level Error --openapi ../OpenApiTests/QueryStrings/GeneratedSwagger/swagger.g.json" /> + Date: Wed, 12 Jun 2024 21:26:49 -0400 Subject: [PATCH 17/27] Address some PR comments --- ...ialMediaAccountAttributesInPatchRequest.cs | 16 --- ...cialMediaAccountAttributesInPostRequest.cs | 16 --- .../SocialMediaAccountAttributesInResponse.cs | 16 --- .../ModelStateValidationTests.cs | 134 +++++++++++------- .../ModelStateValidationTests.cs | 39 +---- .../GeneratedSwagger/net6.0/swagger.g.json | 12 -- .../GeneratedSwagger/net8.0/swagger.g.json | 12 -- .../ModelStateValidationFakers.cs | 7 +- .../ModelStateValidationTests.cs | 14 -- .../SocialMediaAccount.cs | 6 +- 10 files changed, 88 insertions(+), 184 deletions(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs index bd7aeb6a06..75688fb5f1 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPatchRequest.cs @@ -92,20 +92,6 @@ public string FirstName { get { return BackingStore?.Get("firstName"); } set { BackingStore?.Set("firstName", value); } } -#endif - /// The givenName property -#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER -#nullable enable - public string? GivenName { - get { return BackingStore?.Get("givenName"); } - set { BackingStore?.Set("givenName", value); } - } -#nullable restore -#else - public string GivenName { - get { return BackingStore?.Get("givenName"); } - set { BackingStore?.Set("givenName", value); } - } #endif /// The lastName property #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER @@ -266,7 +252,6 @@ public virtual IDictionary> GetFieldDeserializers() {"creditCard", n => { CreditCard = n.GetStringValue(); } }, {"email", n => { Email = n.GetStringValue(); } }, {"firstName", n => { FirstName = n.GetStringValue(); } }, - {"givenName", n => { GivenName = n.GetStringValue(); } }, {"lastName", n => { LastName = n.GetStringValue(); } }, {"nextRevalidation", n => { NextRevalidation = n.GetStringValue(); } }, {"password", n => { Password = n.GetStringValue(); } }, @@ -294,7 +279,6 @@ public virtual void Serialize(ISerializationWriter writer) writer.WriteStringValue("creditCard", CreditCard); writer.WriteStringValue("email", Email); writer.WriteStringValue("firstName", FirstName); - writer.WriteStringValue("givenName", GivenName); writer.WriteStringValue("lastName", LastName); writer.WriteStringValue("nextRevalidation", NextRevalidation); writer.WriteStringValue("password", Password); diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs index 680f3d1615..f904b499d0 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInPostRequest.cs @@ -92,20 +92,6 @@ public string FirstName { get { return BackingStore?.Get("firstName"); } set { BackingStore?.Set("firstName", value); } } -#endif - /// The givenName property -#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER -#nullable enable - public string? GivenName { - get { return BackingStore?.Get("givenName"); } - set { BackingStore?.Set("givenName", value); } - } -#nullable restore -#else - public string GivenName { - get { return BackingStore?.Get("givenName"); } - set { BackingStore?.Set("givenName", value); } - } #endif /// The lastName property #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER @@ -266,7 +252,6 @@ public virtual IDictionary> GetFieldDeserializers() {"creditCard", n => { CreditCard = n.GetStringValue(); } }, {"email", n => { Email = n.GetStringValue(); } }, {"firstName", n => { FirstName = n.GetStringValue(); } }, - {"givenName", n => { GivenName = n.GetStringValue(); } }, {"lastName", n => { LastName = n.GetStringValue(); } }, {"nextRevalidation", n => { NextRevalidation = n.GetStringValue(); } }, {"password", n => { Password = n.GetStringValue(); } }, @@ -294,7 +279,6 @@ public virtual void Serialize(ISerializationWriter writer) writer.WriteStringValue("creditCard", CreditCard); writer.WriteStringValue("email", Email); writer.WriteStringValue("firstName", FirstName); - writer.WriteStringValue("givenName", GivenName); writer.WriteStringValue("lastName", LastName); writer.WriteStringValue("nextRevalidation", NextRevalidation); writer.WriteStringValue("password", Password); diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs index 0b7fc7ae8c..1b759d3605 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/GeneratedCode/Models/SocialMediaAccountAttributesInResponse.cs @@ -92,20 +92,6 @@ public string FirstName { get { return BackingStore?.Get("firstName"); } set { BackingStore?.Set("firstName", value); } } -#endif - /// The givenName property -#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER -#nullable enable - public string? GivenName { - get { return BackingStore?.Get("givenName"); } - set { BackingStore?.Set("givenName", value); } - } -#nullable restore -#else - public string GivenName { - get { return BackingStore?.Get("givenName"); } - set { BackingStore?.Set("givenName", value); } - } #endif /// The lastName property #if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER @@ -266,7 +252,6 @@ public virtual IDictionary> GetFieldDeserializers() {"creditCard", n => { CreditCard = n.GetStringValue(); } }, {"email", n => { Email = n.GetStringValue(); } }, {"firstName", n => { FirstName = n.GetStringValue(); } }, - {"givenName", n => { GivenName = n.GetStringValue(); } }, {"lastName", n => { LastName = n.GetStringValue(); } }, {"nextRevalidation", n => { NextRevalidation = n.GetStringValue(); } }, {"password", n => { Password = n.GetStringValue(); } }, @@ -294,7 +279,6 @@ public virtual void Serialize(ISerializationWriter writer) writer.WriteStringValue("creditCard", CreditCard); writer.WriteStringValue("email", Email); writer.WriteStringValue("firstName", FirstName); - writer.WriteStringValue("givenName", GivenName); writer.WriteStringValue("lastName", LastName); writer.WriteStringValue("nextRevalidation", NextRevalidation); writer.WriteStringValue("password", Password); diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 8a9b5669e8..c170dcb0ee 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -27,42 +27,6 @@ public ModelStateValidationTests(IntegrationTestContext(); } - [Fact] - public async Task Cannot_violate_compare_constraint() - { - // Arrange - using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); - ModelStateValidationClient apiClient = new(requestAdapter); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); - - SocialMediaAccountPostRequestDocument requestBody = new() - { - Data = new SocialMediaAccountDataInPostRequest - { - Type = SocialMediaAccountResourceType.SocialMediaAccounts, - Attributes = new SocialMediaAccountAttributesInPostRequest - { - FirstName = newAccount.FirstName, - GivenName = "something else", - LastName = newAccount.LastName - } - } - }; - - // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("'GivenName' and 'FirstName' do not match."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/givenName"); - } - [Theory] [InlineData("a")] [InlineData("abcdefghijklmnopqrstu")] @@ -81,14 +45,13 @@ public async Task Cannot_exceed_length_constraint(string firstName) Attributes = new SocialMediaAccountAttributesInPostRequest { FirstName = firstName, - GivenName = firstName, LastName = newAccount.LastName } } }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -125,7 +88,7 @@ public async Task Cannot_exceed_string_length_constraint(string userName) }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -160,7 +123,7 @@ public async Task Cannot_violate_regular_expression_constraint() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -195,7 +158,7 @@ public async Task Cannot_use_invalid_credit_card_number() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -230,7 +193,7 @@ public async Task Cannot_use_invalid_email_address() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -269,7 +232,7 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -282,6 +245,41 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } + [Fact] + public async Task Cannot_use_invalid_url() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + ProfilePicture = "http://:example.com" + } + } + }; + + // Act + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); + errorObject.Detail.Should().Be("Failed to convert attribute 'profilePicture' with value 'http://:example.com' of type 'String' to type 'Uri'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/profilePicture"); + } + [Fact] public async Task Cannot_use_relative_url() { @@ -304,7 +302,7 @@ public async Task Cannot_use_relative_url() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -341,7 +339,7 @@ public async Task Cannot_exceed_collection_length_constraint(int length) }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -376,7 +374,7 @@ public async Task Cannot_use_non_allowed_value() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -411,7 +409,7 @@ public async Task Cannot_use_denied_value() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -424,6 +422,41 @@ public async Task Cannot_use_denied_value() errorObject.Source.Pointer.Should().Be("/data/attributes/planet"); } + [Fact] + public async Task Cannot_use_invalid_TimeSpan() + { + // Arrange + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); + ModelStateValidationClient apiClient = new(requestAdapter); + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + NextRevalidation = "not a TimeSpan" + } + } + }; + + // Act + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); + errorObject.Detail.Should().Be("Failed to convert attribute 'nextRevalidation' with value 'not a TimeSpan' of type 'String' to type 'Nullable'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + } + [Fact] public async Task Cannot_use_TimeSpan_outside_of_valid_range() { @@ -446,7 +479,7 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -481,7 +514,7 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync()).Which; @@ -513,7 +546,6 @@ public async Task Can_create_resource_with_valid_properties() Attributes = new SocialMediaAccountAttributesInPostRequest { FirstName = newAccount.FirstName, - GivenName = newAccount.GivenName, LastName = newAccount.LastName, UserName = newAccount.UserName, CreditCard = newAccount.CreditCard, @@ -533,7 +565,7 @@ public async Task Can_create_resource_with_valid_properties() }; // Act - Func> action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); + Func action = () => apiClient.SocialMediaAccounts.PostAsync(requestBody); // Assert await action.Should().NotThrowAsync(); diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 24f3a7cd8f..ca36dad861 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -26,41 +26,6 @@ public ModelStateValidationTests(IntegrationTestContext(); } - [Fact] - public async Task Cannot_violate_compare_constraint() - { - // Arrange - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); - ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); - - SocialMediaAccountPostRequestDocument requestBody = new() - { - Data = new SocialMediaAccountDataInPostRequest - { - Attributes = new SocialMediaAccountAttributesInPostRequest - { - FirstName = newAccount.FirstName, - GivenName = "something else", - LastName = newAccount.LastName - } - } - }; - - // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("'GivenName' and 'FirstName' do not match."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/givenName"); - } - [Theory] [InlineData("a")] [InlineData("abcdefghijklmnopqrstu")] @@ -78,7 +43,6 @@ public async Task Cannot_exceed_length_constraint(string firstName) Attributes = new SocialMediaAccountAttributesInPostRequest { FirstName = firstName, - GivenName = firstName, LastName = newAccount.LastName } } @@ -532,7 +496,6 @@ public async Task Can_create_resource_with_valid_properties() Attributes = new SocialMediaAccountAttributesInPostRequest { FirstName = newAccount.FirstName, - GivenName = newAccount.GivenName, LastName = newAccount.LastName, UserName = newAccount.UserName, CreditCard = newAccount.CreditCard, @@ -545,7 +508,7 @@ public async Task Can_create_resource_with_valid_properties() Planet = newAccount.Planet, NextRevalidation = newAccount.NextRevalidation!.Value.ToString(), ValidatedAt = newAccount.ValidatedAt!, - ValidatedAtDate = new DateTimeOffset(newAccount.ValidatedAtDate!.Value.ToDateTime(new TimeOnly()).ToUniversalTime()), + ValidatedAtDate = new DateTimeOffset(newAccount.ValidatedAtDate!.Value.ToDateTime(new TimeOnly()), TimeSpan.Zero), ValidatedAtTime = newAccount.ValidatedAtTime!.Value.ToTimeSpan() } } diff --git a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json index 14b880aead..efc8773a85 100644 --- a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json +++ b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net6.0/swagger.g.json @@ -408,10 +408,6 @@ "type": "string", "nullable": true }, - "givenName": { - "type": "string", - "nullable": true - }, "lastName": { "type": "string" }, @@ -511,10 +507,6 @@ "type": "string", "nullable": true }, - "givenName": { - "type": "string", - "nullable": true - }, "lastName": { "type": "string" }, @@ -611,10 +603,6 @@ "type": "string", "nullable": true }, - "givenName": { - "type": "string", - "nullable": true - }, "lastName": { "type": "string" }, diff --git a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json index d8e584340c..d3dcecd32e 100644 --- a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json +++ b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json @@ -410,10 +410,6 @@ "type": "string", "nullable": true }, - "givenName": { - "type": "string", - "nullable": true - }, "lastName": { "type": "string" }, @@ -517,10 +513,6 @@ "type": "string", "nullable": true }, - "givenName": { - "type": "string", - "nullable": true - }, "lastName": { "type": "string" }, @@ -621,10 +613,6 @@ "type": "string", "nullable": true }, - "givenName": { - "type": "string", - "nullable": true - }, "lastName": { "type": "string" }, diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 02ee441e4d..6101f25290 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -14,7 +14,6 @@ public sealed class ModelStateValidationFakers .MakeDeterministic() .RuleFor(socialMediaAccount => socialMediaAccount.AlternativeId, faker => faker.Random.Guid()) .RuleFor(socialMediaAccount => socialMediaAccount.FirstName, faker => faker.Person.FirstName) - .RuleFor(socialMediaAccount => socialMediaAccount.GivenName, (_, socialMediaAccount) => socialMediaAccount.FirstName) .RuleFor(socialMediaAccount => socialMediaAccount.LastName, faker => faker.Person.LastName) .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Random.String2(3, 18)) .RuleFor(socialMediaAccount => socialMediaAccount.CreditCard, faker => faker.Finance.CreditCardNumber()) @@ -24,14 +23,14 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.Age, faker => faker.Random.Double(0.1, 122.9)) .RuleFor(socialMediaAccount => socialMediaAccount.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) .RuleFor(socialMediaAccount => socialMediaAccount.BackgroundPicture, faker => faker.Image.LoremFlickrUrl()) - .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => faker.Make(faker.Random.Number(1, 10), () => faker.Random.String2(2, 10))) + .RuleFor(socialMediaAccount => socialMediaAccount.Tags, faker => faker.Make(faker.Random.Number(1, 10), () => faker.Random.Word())) .RuleFor(socialMediaAccount => socialMediaAccount.CountryCode, faker => faker.Random.ListItem([ "NL", "FR" ])) - .RuleFor(socialMediaAccount => socialMediaAccount.Planet, faker => faker.Random.String2(2, 8)) + .RuleFor(socialMediaAccount => socialMediaAccount.Planet, faker => faker.Random.Word()) .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromHours(faker.Random.Number(1, 5))) - .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAt, faker => faker.Date.Recent().ToUniversalTime()) + .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAt, faker => faker.Date.Recent().ToUniversalTime().TruncateToWholeMilliseconds()) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtDate, faker => DateOnly.FromDateTime(faker.Date.Recent())) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtTime, faker => TimeOnly.FromDateTime(faker.Date.Recent()))); diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index efed5c1dbf..41c3067ee9 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -66,20 +66,6 @@ public async Task Length_annotation_on_resource_string_property_produces_expecte }); } - [Theory] - [MemberData(nameof(ModelNames))] - public async Task Compare_annotation_on_resource_property_produces_expected_schema(string modelName) - { - // Act - JsonElement document = await _testContext.GetSwaggerDocumentAsync(); - - // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.givenName").With(givenNameElement => - { - givenNameElement.Should().HaveProperty("type", "string"); - }); - } - [Theory] [MemberData(nameof(ModelNames))] public async Task Required_annotation_with_AllowEmptyStrings_on_resource_property_produces_expected_schema(string modelName) diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index 5de8903992..2ee5729424 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -19,10 +19,6 @@ public sealed class SocialMediaAccount : Identifiable #endif public string? FirstName { get; set; } - [Attr] - [Compare(nameof(FirstName))] - public string? GivenName { get; set; } - [Attr] [Required(AllowEmptyStrings = true)] public string LastName { get; set; } = default!; @@ -51,7 +47,7 @@ public sealed class SocialMediaAccount : Identifiable public string? Phone { get; set; } [Attr] - [Range(0.1, 122.9, ConvertValueInInvariantCulture = true, ParseLimitsInInvariantCulture = true)] + [Range(0.1, 122.9)] public double? Age { get; set; } [Attr] From a9501ff86bd9f6ae5a130df6f66aeb65f49df426 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Wed, 12 Jun 2024 21:44:27 -0400 Subject: [PATCH 18/27] Add missing properties in happy test --- .../ModelStateValidation/ModelStateValidationTests.cs | 3 +++ .../ModelStateValidation/ModelStateValidationTests.cs | 3 +++ 2 files changed, 6 insertions(+) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index c170dcb0ee..8f1c62d110 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -545,16 +545,19 @@ public async Task Can_create_resource_with_valid_properties() Type = SocialMediaAccountResourceType.SocialMediaAccounts, Attributes = new SocialMediaAccountAttributesInPostRequest { + AlternativeId = newAccount.AlternativeId, FirstName = newAccount.FirstName, LastName = newAccount.LastName, UserName = newAccount.UserName, CreditCard = newAccount.CreditCard, Email = newAccount.Email, + Password = newAccount.Password, Phone = newAccount.Phone, Age = newAccount.Age, ProfilePicture = newAccount.ProfilePicture!.ToString(), BackgroundPicture = newAccount.BackgroundPicture, Tags = newAccount.Tags, + CountryCode = newAccount.CountryCode, Planet = newAccount.Planet, NextRevalidation = newAccount.NextRevalidation!.Value.ToString(), ValidatedAt = newAccount.ValidatedAt!, diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index ca36dad861..32b3836681 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -495,16 +495,19 @@ public async Task Can_create_resource_with_valid_properties() { Attributes = new SocialMediaAccountAttributesInPostRequest { + AlternativeId = newAccount.AlternativeId, FirstName = newAccount.FirstName, LastName = newAccount.LastName, UserName = newAccount.UserName, CreditCard = newAccount.CreditCard, Email = newAccount.Email, + Password = newAccount.Password, Phone = newAccount.Phone, Age = newAccount.Age, ProfilePicture = newAccount.ProfilePicture, BackgroundPicture = new Uri(newAccount.BackgroundPicture!), Tags = newAccount.Tags, + CountryCode = newAccount.CountryCode, Planet = newAccount.Planet, NextRevalidation = newAccount.NextRevalidation!.Value.ToString(), ValidatedAt = newAccount.ValidatedAt!, From 15facbf5c702ab98db06cbb7298382e6f11c5769 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Wed, 12 Jun 2024 22:12:19 -0400 Subject: [PATCH 19/27] Fix CS --- .../ModelStateValidation/ModelStateValidationTests.cs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 8f1c62d110..59f776de78 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -452,7 +452,10 @@ public async Task Cannot_use_invalid_TimeSpan() ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); - errorObject.Detail.Should().Be("Failed to convert attribute 'nextRevalidation' with value 'not a TimeSpan' of type 'String' to type 'Nullable'."); + + errorObject.Detail.Should() + .Be("Failed to convert attribute 'nextRevalidation' with value 'not a TimeSpan' of type 'String' to type 'Nullable'."); + errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); } From 159a6c27a1ddd8528bb6a7db6a48bf7d2d8c990b Mon Sep 17 00:00:00 2001 From: verdie-g Date: Sat, 15 Jun 2024 16:42:30 -0400 Subject: [PATCH 20/27] Convert DateTime to UTC server-side --- .../ModelStateValidationTests.cs | 3 +++ .../UtcDateTimeJsonConverter.cs | 18 ++++++++++++++++++ .../ModelStateValidationTests.cs | 3 +++ .../UtcDateTimeJsonConverter.cs | 18 ++++++++++++++++++ 4 files changed, 42 insertions(+) create mode 100644 test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs create mode 100644 test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 59f776de78..62a26c38f8 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,5 +1,7 @@ using System.Globalization; using FluentAssertions; +using JsonApiDotNetCore.Configuration; +using Microsoft.Extensions.DependencyInjection; using Microsoft.Kiota.Http.HttpClientLibrary; using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode; using OpenApiKiotaEndToEndTests.ModelStateValidation.GeneratedCode.Models; @@ -25,6 +27,7 @@ public ModelStateValidationTests(IntegrationTestContext(); + testContext.Factory.Services.GetRequiredService().SerializerOptions.Converters.Add(new UtcDateTimeJsonConverter()); } [Theory] diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs new file mode 100644 index 0000000000..387c84f7e9 --- /dev/null +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs @@ -0,0 +1,18 @@ +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace OpenApiKiotaEndToEndTests.ModelStateValidation; + +internal class UtcDateTimeJsonConverter : JsonConverter +{ + public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + DateTimeOffset dateTimeOffset = DateTimeOffset.Parse(reader.GetString()!); + return dateTimeOffset.UtcDateTime; + } + + public override void Write(Utf8JsonWriter writer, DateTime val, JsonSerializerOptions options) + { + writer.WriteStringValue(val.ToUniversalTime().ToString("O")); + } +} diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 32b3836681..30283affba 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,6 +1,8 @@ using System.Globalization; using FluentAssertions; +using JsonApiDotNetCore.Configuration; using JsonApiDotNetCore.OpenApi.Client.NSwag; +using Microsoft.Extensions.DependencyInjection; using OpenApiNSwagEndToEndTests.ModelStateValidation.GeneratedCode; using OpenApiTests; using OpenApiTests.ModelStateValidation; @@ -24,6 +26,7 @@ public ModelStateValidationTests(IntegrationTestContext(); + testContext.Factory.Services.GetRequiredService().SerializerOptions.Converters.Add(new UtcDateTimeJsonConverter()); } [Theory] diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs new file mode 100644 index 0000000000..cb8174c2ce --- /dev/null +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs @@ -0,0 +1,18 @@ +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace OpenApiNSwagEndToEndTests.ModelStateValidation; + +internal class UtcDateTimeJsonConverter : JsonConverter +{ + public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + DateTimeOffset dateTimeOffset = DateTimeOffset.Parse(reader.GetString()!); + return dateTimeOffset.UtcDateTime; + } + + public override void Write(Utf8JsonWriter writer, DateTime val, JsonSerializerOptions options) + { + writer.WriteStringValue(val.ToUniversalTime().ToString("O")); + } +} From 225143b252c181e71a0c6188622de481dfcdb7c5 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Sat, 15 Jun 2024 16:57:49 -0400 Subject: [PATCH 21/27] Seal classes --- .../ModelStateValidation/UtcDateTimeJsonConverter.cs | 2 +- .../ModelStateValidation/UtcDateTimeJsonConverter.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs index 387c84f7e9..b7877a680c 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs @@ -3,7 +3,7 @@ namespace OpenApiKiotaEndToEndTests.ModelStateValidation; -internal class UtcDateTimeJsonConverter : JsonConverter +internal sealed class UtcDateTimeJsonConverter : JsonConverter { public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs index cb8174c2ce..f9f2f1fb09 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs @@ -3,7 +3,7 @@ namespace OpenApiNSwagEndToEndTests.ModelStateValidation; -internal class UtcDateTimeJsonConverter : JsonConverter +internal sealed class UtcDateTimeJsonConverter : JsonConverter { public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { From 8f0e849cb05e8eac04ebc6559695193c2688faeb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gr=C3=A9goire?= Date: Wed, 19 Jun 2024 18:23:58 -0400 Subject: [PATCH 22/27] Apply suggestions from code review Co-authored-by: Bart Koelman <10324372+bkoelman@users.noreply.github.com> --- .../ModelStateValidation/ModelStateValidationTests.cs | 4 +++- .../ModelStateValidation/ModelStateValidationTests.cs | 4 +++- .../ModelStateValidation/ModelStateValidationFakers.cs | 2 +- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 62a26c38f8..ee35ab5eb1 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -27,7 +27,9 @@ public ModelStateValidationTests(IntegrationTestContext(); - testContext.Factory.Services.GetRequiredService().SerializerOptions.Converters.Add(new UtcDateTimeJsonConverter()); + + var options = testContext.Factory.Services.GetRequiredService(); + options.SerializerOptions.Converters.Add(new UtcDateTimeJsonConverter()); } [Theory] diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 30283affba..ff40efe701 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -26,7 +26,9 @@ public ModelStateValidationTests(IntegrationTestContext(); - testContext.Factory.Services.GetRequiredService().SerializerOptions.Converters.Add(new UtcDateTimeJsonConverter()); + + var options = testContext.Factory.Services.GetRequiredService(); + options.SerializerOptions.Converters.Add(new UtcDateTimeJsonConverter()); } [Theory] diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 6101f25290..90a16d9d4c 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -32,7 +32,7 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.NextRevalidation, faker => TimeSpan.FromHours(faker.Random.Number(1, 5))) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAt, faker => faker.Date.Recent().ToUniversalTime().TruncateToWholeMilliseconds()) .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtDate, faker => DateOnly.FromDateTime(faker.Date.Recent())) - .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtTime, faker => TimeOnly.FromDateTime(faker.Date.Recent()))); + .RuleFor(socialMediaAccount => socialMediaAccount.ValidatedAtTime, faker => TimeOnly.FromDateTime(faker.Date.Recent().TruncateToWholeMilliseconds()))); public Faker SocialMediaAccount => _lazySocialMediaAccountFaker.Value; } From f7ba49d89f7062bf326620ced735e30d990a1e04 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Wed, 19 Jun 2024 19:15:06 -0400 Subject: [PATCH 23/27] Address PR comments --- .../ModelStateValidationTests.cs | 144 +++++++------- .../UtcDateTimeJsonConverter.cs | 4 +- .../ModelStateValidationTests.cs | 186 +++++++++++++++--- .../UtcDateTimeJsonConverter.cs | 4 +- .../GeneratedSwagger/net8.0/swagger.g.json | 6 + .../ModelStateValidationFakers.cs | 2 +- .../ModelStateValidationTests.cs | 70 +++---- .../SocialMediaAccount.cs | 6 + 8 files changed, 270 insertions(+), 152 deletions(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index ee35ab5eb1..7d8eb25e75 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,4 +1,3 @@ -using System.Globalization; using FluentAssertions; using JsonApiDotNetCore.Configuration; using Microsoft.Extensions.DependencyInjection; @@ -38,9 +37,10 @@ public ModelStateValidationTests(IntegrationTestContext'."); - + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The CountryCode field does not equal any of the values specified in AllowedValuesAttribute."); errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + errorObject.Source.Pointer.Should().Be("/data/attributes/countryCode"); } [Fact] - public async Task Cannot_use_TimeSpan_outside_of_valid_range() + public async Task Cannot_use_denied_value() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); ModelStateValidationClient apiClient = new(requestAdapter); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -481,7 +490,7 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - NextRevalidation = TimeSpan.FromSeconds(1).ToString() + Planet = "pluto" } } }; @@ -495,18 +504,19 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field NextRevalidation must be between 01:00:00 and 05:00:00."); + errorObject.Detail.Should().Be("The Planet field equals one of the values specified in DeniedValuesAttribute."); errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); + errorObject.Source.Pointer.Should().Be("/data/attributes/planet"); } [Fact] - public async Task Cannot_use_culture_sensitive_TimeSpan() + public async Task Cannot_use_TimeSpan_outside_of_valid_range() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); ModelStateValidationClient apiClient = new(requestAdapter); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -516,7 +526,7 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - NextRevalidation = new TimeSpan(0, 2, 0, 0, 1).ToString("g", new CultureInfo("fr-FR")) + NextRevalidation = TimeSpan.FromSeconds(1).ToString() } } }; @@ -529,11 +539,8 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() document.Errors.ShouldHaveCount(1); ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); - - errorObject.Detail.Should() - .Be("Failed to convert attribute 'nextRevalidation' with value '2:00:00,001' of type 'String' to type 'Nullable'."); - + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field NextRevalidation must be between 01:00:00 and 05:00:00."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); } @@ -542,9 +549,10 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() public async Task Can_create_resource_with_valid_properties() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClientRequestAdapter requestAdapter = _requestAdapterFactory.CreateAdapter(_testContext.Factory); ModelStateValidationClient apiClient = new(requestAdapter); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs index b7877a680c..d4d22fa27e 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs @@ -11,8 +11,8 @@ public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, Jso return dateTimeOffset.UtcDateTime; } - public override void Write(Utf8JsonWriter writer, DateTime val, JsonSerializerOptions options) + public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options) { - writer.WriteStringValue(val.ToUniversalTime().ToString("O")); + writer.WriteStringValue(value.ToUniversalTime().ToString("O")); } } diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index ff40efe701..65404f15ee 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -37,9 +37,10 @@ public ModelStateValidationTests(IntegrationTestContext> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -73,9 +74,10 @@ public async Task Cannot_exceed_length_constraint(string firstName) public async Task Cannot_exceed_string_length_constraint(string userName) { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -90,7 +92,7 @@ public async Task Cannot_exceed_string_length_constraint(string userName) }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -107,9 +109,10 @@ public async Task Cannot_exceed_string_length_constraint(string userName) public async Task Cannot_violate_regular_expression_constraint() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -124,7 +127,7 @@ public async Task Cannot_violate_regular_expression_constraint() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -141,9 +144,10 @@ public async Task Cannot_violate_regular_expression_constraint() public async Task Cannot_use_invalid_credit_card_number() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -158,7 +162,7 @@ public async Task Cannot_use_invalid_credit_card_number() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -175,9 +179,10 @@ public async Task Cannot_use_invalid_credit_card_number() public async Task Cannot_use_invalid_email_address() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -192,7 +197,7 @@ public async Task Cannot_use_invalid_email_address() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -205,17 +210,126 @@ public async Task Cannot_use_invalid_email_address() errorObject.Source.Pointer.Should().Be("/data/attributes/email"); } + [Fact] + public async Task Cannot_exceed_min_length_constraint() + { + // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + Password = "YQ==" + } + } + }; + + // Act + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field Password must be a string or array type with a minimum length of '5'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/password"); + } + + [Fact] + public async Task Cannot_exceed_max_length_constraint() + { + // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + Password = "YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYQ==" + } + } + }; + + // Act + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The field Password must be a string or array type with a maximum length of '100'."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/password"); + } + + [Fact] + public async Task Cannot_use_invalid_base64() + { + // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); + ModelStateValidationClient apiClient = new(httpClient); + + SocialMediaAccountPostRequestDocument requestBody = new() + { + Data = new SocialMediaAccountDataInPostRequest + { + Type = SocialMediaAccountResourceType.SocialMediaAccounts, + Attributes = new SocialMediaAccountAttributesInPostRequest + { + LastName = newAccount.LastName, + Password = "not_base_64" + } + } + }; + + // Act + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + + // Assert + ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; + document.Errors.ShouldHaveCount(1); + + ErrorObject errorObject = document.Errors.First(); + errorObject.Title.Should().Be("Input validation failed."); + errorObject.Detail.Should().Be("The Password field is not a valid Base64 encoding."); + errorObject.Source.ShouldNotBeNull(); + errorObject.Source.Pointer.Should().Be("/data/attributes/password"); + } + [Theory] [InlineData(-1)] [InlineData(-0.56)] [InlineData(123.98)] [InlineData(124)] - public async Task Cannot_use_double_outside_of_valid_range(int age) + public async Task Cannot_use_double_outside_of_valid_range(double age) { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -230,7 +344,7 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -238,7 +352,7 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0.1 and 122.9."); + errorObject.Detail.Should().Be("The field Age must be between 0.1 exclusive and 122.9 exclusive."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } @@ -247,9 +361,10 @@ public async Task Cannot_use_double_outside_of_valid_range(int age) public async Task Cannot_use_relative_url() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -258,13 +373,13 @@ public async Task Cannot_use_relative_url() Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - BackgroundPicture = new Uri("/justapath", UriKind.Relative) + BackgroundPicture = new Uri("relativeurl", UriKind.Relative) } } }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -283,9 +398,10 @@ public async Task Cannot_use_relative_url() public async Task Cannot_exceed_collection_length_constraint(int length) { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -294,13 +410,13 @@ public async Task Cannot_exceed_collection_length_constraint(int length) Attributes = new SocialMediaAccountAttributesInPostRequest { LastName = newAccount.LastName, - Tags = Enumerable.Repeat("-", length).ToArray() + Tags = Enumerable.Repeat("-", length).ToList() } } }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -317,9 +433,10 @@ public async Task Cannot_exceed_collection_length_constraint(int length) public async Task Cannot_use_non_allowed_value() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -334,7 +451,7 @@ public async Task Cannot_use_non_allowed_value() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -351,9 +468,10 @@ public async Task Cannot_use_non_allowed_value() public async Task Cannot_use_denied_value() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -368,7 +486,7 @@ public async Task Cannot_use_denied_value() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -385,9 +503,10 @@ public async Task Cannot_use_denied_value() public async Task Cannot_use_TimeSpan_outside_of_valid_range() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -402,7 +521,7 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -419,9 +538,10 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() public async Task Cannot_use_culture_sensitive_TimeSpan() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -436,7 +556,7 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -456,9 +576,10 @@ public async Task Cannot_use_culture_sensitive_TimeSpan() public async Task Cannot_use_invalid_TimeOnly() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -473,7 +594,7 @@ public async Task Cannot_use_invalid_TimeOnly() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; @@ -490,9 +611,10 @@ public async Task Cannot_use_invalid_TimeOnly() public async Task Can_create_resource_with_valid_properties() { // Arrange + SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); + using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); ModelStateValidationClient apiClient = new(httpClient); - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); SocialMediaAccountPostRequestDocument requestBody = new() { @@ -523,7 +645,7 @@ public async Task Can_create_resource_with_valid_properties() }; // Act - Func> action = () => apiClient.PostSocialMediaAccountAsync(requestBody); + Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); // Assert await action.Should().NotThrowAsync(); diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs index f9f2f1fb09..c0c1d04ffb 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/UtcDateTimeJsonConverter.cs @@ -11,8 +11,8 @@ public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, Jso return dateTimeOffset.UtcDateTime; } - public override void Write(Utf8JsonWriter writer, DateTime val, JsonSerializerOptions options) + public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options) { - writer.WriteStringValue(val.ToUniversalTime().ToString("O")); + writer.WriteStringValue(value.ToUniversalTime().ToString("O")); } } diff --git a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json index d3dcecd32e..eaf1c6dd5c 100644 --- a/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json +++ b/test/OpenApiTests/ModelStateValidation/GeneratedSwagger/net8.0/swagger.g.json @@ -431,6 +431,8 @@ "nullable": true }, "password": { + "maxLength": 100, + "minLength": 5, "type": "string", "nullable": true }, @@ -534,6 +536,8 @@ "nullable": true }, "password": { + "maxLength": 100, + "minLength": 5, "type": "string", "nullable": true }, @@ -634,6 +638,8 @@ "nullable": true }, "password": { + "maxLength": 100, + "minLength": 5, "type": "string", "nullable": true }, diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs index 90a16d9d4c..0427b52532 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationFakers.cs @@ -18,7 +18,7 @@ public sealed class ModelStateValidationFakers .RuleFor(socialMediaAccount => socialMediaAccount.UserName, faker => faker.Random.String2(3, 18)) .RuleFor(socialMediaAccount => socialMediaAccount.CreditCard, faker => faker.Finance.CreditCardNumber()) .RuleFor(socialMediaAccount => socialMediaAccount.Email, faker => faker.Person.Email) - .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => Convert.ToBase64String(faker.Random.Bytes(20))) + .RuleFor(socialMediaAccount => socialMediaAccount.Password, faker => Convert.ToBase64String(faker.Random.Bytes(faker.Random.Number(4, 75)))) .RuleFor(socialMediaAccount => socialMediaAccount.Phone, faker => faker.Person.Phone) .RuleFor(socialMediaAccount => socialMediaAccount.Age, faker => faker.Random.Double(0.1, 122.9)) .RuleFor(socialMediaAccount => socialMediaAccount.ProfilePicture, faker => new Uri(faker.Image.LoremFlickrUrl())) diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index 41c3067ee9..bc8494e44e 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -8,7 +8,7 @@ namespace OpenApiTests.ModelStateValidation; public sealed class ModelStateValidationTests : IClassFixture, ModelStateValidationDbContext>> { // ReSharper disable once UseCollectionExpression (https://youtrack.jetbrains.com/issue/RSRP-497450) - public static readonly TheoryData ModelNames = new() + public static readonly TheoryData SchemaNames = new() { "socialMediaAccountAttributesInPostRequest", "socialMediaAccountAttributesInPatchRequest", @@ -34,7 +34,7 @@ public ModelStateValidationTests(OpenApiTestContext { +#if !NET6_0 + passwordElement.Should().HaveProperty("maxLength", 100); + passwordElement.Should().HaveProperty("minLength", 5); +#endif passwordElement.Should().HaveProperty("type", "string"); }); } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task Phone_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act @@ -172,7 +176,7 @@ public async Task Phone_annotation_on_resource_property_produces_expected_schema } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task Range_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act @@ -191,7 +195,7 @@ public async Task Range_annotation_on_resource_property_produces_expected_schema } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task Url_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act @@ -206,7 +210,7 @@ public async Task Url_annotation_on_resource_property_produces_expected_schema(s } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task Uri_type_produces_expected_schema(string modelName) { // Act @@ -221,7 +225,7 @@ public async Task Uri_type_produces_expected_schema(string modelName) } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task Length_annotation_on_resource_list_property_produces_expected_schema(string modelName) { // Act @@ -244,35 +248,7 @@ public async Task Length_annotation_on_resource_list_property_produces_expected_ } [Theory] - [MemberData(nameof(ModelNames))] - public async Task AllowedValues_annotation_on_resource_list_property_produces_expected_schema(string modelName) - { - // Act - JsonElement document = await _testContext.GetSwaggerDocumentAsync(); - - // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.countryCode").With(countryCodeElement => - { - countryCodeElement.Should().HaveProperty("type", "string"); - }); - } - - [Theory] - [MemberData(nameof(ModelNames))] - public async Task DeniedValues_annotation_on_resource_property_produces_expected_schema(string modelName) - { - // Act - JsonElement document = await _testContext.GetSwaggerDocumentAsync(); - - // Assert - document.Should().ContainPath($"components.schemas.{modelName}.properties.planet").With(planetElement => - { - planetElement.Should().HaveProperty("type", "string"); - }); - } - - [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task TimeSpan_range_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act @@ -287,7 +263,7 @@ public async Task TimeSpan_range_annotation_on_resource_property_produces_expect } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task DateTime_type_produces_expected_schema(string modelName) { // Act @@ -302,7 +278,7 @@ public async Task DateTime_type_produces_expected_schema(string modelName) } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task DateOnly_type_produces_expected_schema(string modelName) { // Act @@ -317,7 +293,7 @@ public async Task DateOnly_type_produces_expected_schema(string modelName) } [Theory] - [MemberData(nameof(ModelNames))] + [MemberData(nameof(SchemaNames))] public async Task TimeOnly_type_produces_expected_schema(string modelName) { // Act diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index 2ee5729424..1938618e0f 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -39,6 +39,8 @@ public sealed class SocialMediaAccount : Identifiable [Attr] #if !NET6_0 [Base64String] + [MinLength(5)] + [MaxLength(100)] #endif public string? Password { get; set; } @@ -47,7 +49,11 @@ public sealed class SocialMediaAccount : Identifiable public string? Phone { get; set; } [Attr] +#if NET6_0 [Range(0.1, 122.9)] +#else + [Range(0.1, 122.9, MinimumIsExclusive = true, MaximumIsExclusive = true)] +#endif public double? Age { get; set; } [Attr] From 2a9e77393ac263b49cf3e5557f7392c553daed49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Gr=C3=A9goire?= Date: Thu, 20 Jun 2024 08:18:41 -0400 Subject: [PATCH 24/27] Update test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs Co-authored-by: Bart Koelman <10324372+bkoelman@users.noreply.github.com> --- .../ModelStateValidation/ModelStateValidationTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index bc8494e44e..f73f727b3a 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -144,7 +144,7 @@ public async Task Email_annotation_on_resource_property_produces_expected_schema [Theory] [MemberData(nameof(SchemaNames))] - public async Task Min_max_length_annotation_on_resource_list_property_produces_expected_schema(string modelName) + public async Task Min_max_length_annotation_on_resource_property_produces_expected_schema(string modelName) { // Act JsonElement document = await _testContext.GetSwaggerDocumentAsync(); From bb22aca9bed244a07772929cf02469e9c44c76b2 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Thu, 20 Jun 2024 08:31:58 -0400 Subject: [PATCH 25/27] Address comments --- .../ModelStateValidationTests.cs | 2 +- .../ModelStateValidationTests.cs | 76 +------------------ .../ModelStateValidationTests.cs | 2 - .../SocialMediaAccount.cs | 4 - 4 files changed, 2 insertions(+), 82 deletions(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 7d8eb25e75..a3fa4e1aee 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -358,7 +358,7 @@ public async Task Cannot_use_double_outside_of_valid_range(double age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0.1 exclusive and 122.9 exclusive."); + errorObject.Detail.Should().Be("The field Age must be between 0.1 and 122.9."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 65404f15ee..05f97fae4b 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,4 +1,3 @@ -using System.Globalization; using FluentAssertions; using JsonApiDotNetCore.Configuration; using JsonApiDotNetCore.OpenApi.Client.NSwag; @@ -352,7 +351,7 @@ public async Task Cannot_use_double_outside_of_valid_range(double age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0.1 exclusive and 122.9 exclusive."); + errorObject.Detail.Should().Be("The field Age must be between 0.1 and 122.9."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } @@ -534,79 +533,6 @@ public async Task Cannot_use_TimeSpan_outside_of_valid_range() errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); } - [Fact] - public async Task Cannot_use_culture_sensitive_TimeSpan() - { - // Arrange - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); - ModelStateValidationClient apiClient = new(httpClient); - - SocialMediaAccountPostRequestDocument requestBody = new() - { - Data = new SocialMediaAccountDataInPostRequest - { - Attributes = new SocialMediaAccountAttributesInPostRequest - { - LastName = newAccount.LastName, - NextRevalidation = new TimeSpan(0, 2, 0, 0, 1).ToString("g", new CultureInfo("fr-FR")) - } - } - }; - - // Act - Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); - - errorObject.Detail.Should() - .Be("Failed to convert attribute 'nextRevalidation' with value '2:00:00,001' of type 'String' to type 'Nullable'."); - - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/nextRevalidation"); - } - - [Fact] - public async Task Cannot_use_invalid_TimeOnly() - { - // Arrange - SocialMediaAccount newAccount = _fakers.SocialMediaAccount.Generate(); - - using HttpClient httpClient = _testContext.Factory.CreateDefaultClient(_logHttpMessageHandler); - ModelStateValidationClient apiClient = new(httpClient); - - SocialMediaAccountPostRequestDocument requestBody = new() - { - Data = new SocialMediaAccountDataInPostRequest - { - Attributes = new SocialMediaAccountAttributesInPostRequest - { - LastName = newAccount.LastName, - ValidatedAtTime = TimeSpan.FromSeconds(-1) - } - } - }; - - // Act - Func action = () => apiClient.PostSocialMediaAccountAsync(requestBody); - - // Assert - ErrorResponseDocument document = (await action.Should().ThrowExactlyAsync>()).Which.Result; - document.Errors.ShouldHaveCount(1); - - ErrorObject errorObject = document.Errors.First(); - errorObject.Title.Should().Be("Failed to deserialize request body: Incompatible attribute value found."); - errorObject.Detail.Should().Be("Failed to convert attribute 'validatedAtTime' with value '-00:00:01' of type 'String' to type 'Nullable'."); - errorObject.Source.ShouldNotBeNull(); - errorObject.Source.Pointer.Should().Be("/data/attributes/validatedAtTime"); - } - [Fact] public async Task Can_create_resource_with_valid_properties() { diff --git a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs index f73f727b3a..e4d6ef04c2 100644 --- a/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiTests/ModelStateValidation/ModelStateValidationTests.cs @@ -1,4 +1,3 @@ -using System.Globalization; using System.Text.Json; using TestBuildingBlocks; using Xunit; @@ -19,7 +18,6 @@ public sealed class ModelStateValidationTests : IClassFixture, ModelStateValidationDbContext> testContext) { - CultureInfo.CurrentCulture = new CultureInfo("fr-FR"); _testContext = testContext; testContext.UseController(); diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index 1938618e0f..803078321d 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -49,11 +49,7 @@ public sealed class SocialMediaAccount : Identifiable public string? Phone { get; set; } [Attr] -#if NET6_0 [Range(0.1, 122.9)] -#else - [Range(0.1, 122.9, MinimumIsExclusive = true, MaximumIsExclusive = true)] -#endif public double? Age { get; set; } [Attr] From 0238e729e94b3ce6f7ca8e43ac286210aa1fbf23 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Fri, 21 Jun 2024 14:45:18 -0400 Subject: [PATCH 26/27] Add back exclusive range --- .../ModelStateValidation/ModelStateValidationTests.cs | 2 +- .../ModelStateValidation/ModelStateValidationTests.cs | 2 +- test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs | 4 ++++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index a3fa4e1aee..7d8eb25e75 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -358,7 +358,7 @@ public async Task Cannot_use_double_outside_of_valid_range(double age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0.1 and 122.9."); + errorObject.Detail.Should().Be("The field Age must be between 0.1 exclusive and 122.9 exclusive."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 05f97fae4b..53eaf277f2 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -351,7 +351,7 @@ public async Task Cannot_use_double_outside_of_valid_range(double age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0.1 and 122.9."); + errorObject.Detail.Should().Be("The field Age must be between 0.1 exclusive and 122.9 exclusive."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } diff --git a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs index 803078321d..1938618e0f 100644 --- a/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs +++ b/test/OpenApiTests/ModelStateValidation/SocialMediaAccount.cs @@ -49,7 +49,11 @@ public sealed class SocialMediaAccount : Identifiable public string? Phone { get; set; } [Attr] +#if NET6_0 [Range(0.1, 122.9)] +#else + [Range(0.1, 122.9, MinimumIsExclusive = true, MaximumIsExclusive = true)] +#endif public double? Age { get; set; } [Attr] From 54fedf27705578b93d639c02a09d85857d7ee835 Mon Sep 17 00:00:00 2001 From: verdie-g Date: Fri, 21 Jun 2024 14:48:57 -0400 Subject: [PATCH 27/27] Address comment --- .../ModelStateValidation/ModelStateValidationTests.cs | 2 +- .../ModelStateValidation/ModelStateValidationTests.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 7d8eb25e75..3f7069c1fb 100644 --- a/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiKiotaEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -358,7 +358,7 @@ public async Task Cannot_use_double_outside_of_valid_range(double age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0.1 exclusive and 122.9 exclusive."); + errorObject.Detail.Should().Be($"The field Age must be between {0.1} exclusive and {122.9} exclusive."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); } diff --git a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs index 53eaf277f2..879cc833cd 100644 --- a/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs +++ b/test/OpenApiNSwagEndToEndTests/ModelStateValidation/ModelStateValidationTests.cs @@ -351,7 +351,7 @@ public async Task Cannot_use_double_outside_of_valid_range(double age) ErrorObject errorObject = document.Errors.First(); errorObject.Title.Should().Be("Input validation failed."); - errorObject.Detail.Should().Be("The field Age must be between 0.1 exclusive and 122.9 exclusive."); + errorObject.Detail.Should().Be($"The field Age must be between {0.1} exclusive and {122.9} exclusive."); errorObject.Source.ShouldNotBeNull(); errorObject.Source.Pointer.Should().Be("/data/attributes/age"); }