Jesteś generatorem danych JSON. Utwórz tablicę zawierającą 5 obiektów JSON i sprawdź, czy rzeczywiście zostało utworzonych 5 obiektów JSON, zanim wypiszesz wyniki.
* Każdy parametr jest oznaczony znakiem %.
* Każda kolumna jest opisana w kolejności: klucz, typ danych i opcje, przy użyciu znaku |.
* Jeśli opcją danych jest random, generuj losowe dane na podstawie sugerowanego formatu i nazwy kolumny
Oto instrukcje:
% room_name | string | random
% type | string | 'single' or 'double'
% beds | integer | 1 to 6
% accessible | boolean | true or false
% image | string | random url
% description | string | random max 20 characters
% features | array[string] | 'Wifi', 'TV' or 'Safe'
% roomPrice | integer | 100 to 200

Jesteś generatorem danych XML. Utwórz tablicę zawierającą 3 obiektów XML i sprawdź, czy rzeczywiście zostały utworzone 3 obiekty XML, zanim wypiszesz wyniki.
* Nazwa elementu głównego jest oznaczona znakiem #
* Każdy element jest oznaczony znakiem %
* Każda kolumna jest opisana w kolejności: nawa elementu, typ danych i opcje, przy użyciu znaku |.
* Jeśli opcją danych jest random, generuj losowe dane na podstawie sugerowanego formatu i nazwy kolumny
Oto instrukcje:
# rooms
% room_name | string | random
% type | string | 'single' or 'double'
% beds | integer | 1 to 6
% accessible | boolean | true or false
% image | string | random url
% description | string | random max 20 characters
% features | array[string] | 'Wifi', 'TV' or 'Safe'
% roomPrice | integer | 100 to 200

Jesteś transformatorem JSON na SQL. Przekształć obiekt JSON ograniczony trzema haszami w instrukcję SQL, która:
1 Tworzy tabelę SQL do wstawienia przekształconych rekordów
2 Tworzy instrukcje INSERT dodające poszczególne rekordy do bazy danych
Przed wypisaniem wyników sprawdź, czy każda instrukcja SQL uwzględnia wszystkie aspekty pliku JSON
###
[{
    "firstname": "Sally",
    "lastname": "Wilson",
    "totalprice": 229,
    "depositpaid": false,
    "bookingdates": {
        "checkin": "2017-02-20",
        "checkout": "2019-07-05"
    },
    "additionalneeds": "Breakfast"
},{
    "firstname": "Jim",
    "lastname": "Jones",
    "totalprice": 871,
    "depositpaid": false,
    "bookingdates": {
        "checkin": "2017-08-11",
        "checkout": "2021-06-30"
    },
    "additionalneeds": "Breakfast"
},{
    "firstname": "Mary",
    "lastname": "Ericsson",
    "totalprice": 558,
    "depositpaid": true,
    "bookingdates": {
        "checkin": "2018-07-04",
        "checkout": "2022-09-25"
    }
}]
###

Jesteś generatorem danych JSON. Wygeneruj tablicę JSON zawierającą 3 losowe obiekty JSON zgodne ze schematem OpenAPI ograniczonym trzema haszami. Przed wypisaniem wyników upewnij się, że wszystkie 3 obiekty JSON są zgodne z regułami schematu OpenAPI.
###
openapi: 3.0.0
components:
  schemas:
    Room:
      title: Room
      type: object
      properties:
        accessible:
          type: boolean
        description:
          type: string
        type:
          type: string
          pattern: Single|Double|Twin|Family|Suite
        features:
          type: array
          items:
            type: string
            pattern: WiFi|TV|Radio|Refreshments|Safe|
        image:
          type: string
        roomNumber:
          type: string
        roomPrice:
          type: integer
          format: int32
          minimum: 0
          maximum: 999
          exclusiveMinimum: true
          exclusiveMaximum: false
        roomid:
          type: integer
          format: int32
      required:
        - accessible
        - description
        - features
        - image
        - roomNumber
        - roomPrice
###

Jesteś generatorem danych XML. Wygeneruj 3 losowe obiekty XML na podstawie schematu XSD ograniczonego trzema haszami. Dodaj wszystkie obiekty XML do elementu nadrzędnego o nazwie "rooms". Przed wypisaniem wyników upewnij się, że wszystkie 3 podrzędne obiekty XML są zgodne z regułami schematu XSD.
###
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

    <xs:element name="room">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="accessible" type="xs:boolean"/>
                <xs:element name="description" type="xs:string"/>
                <xs:element name="type">
                    <xs:simpleType>
                        <xs:restriction base="xs:string">
                            <xs:enumeration value="Single"/>
                            <xs:enumeration value="Double"/>
                            <xs:enumeration value="Twin"/>
                            <xs:enumeration value="Family"/>
                            <xs:enumeration value="Suite"/>
                        </xs:restriction>
                    </xs:simpleType>
                </xs:element>
                <xs:element name="features">
                    <xs:complexType>
                        <xs:sequence>
                            <xs:element name="feature" type="FeatureType" minOccurs="0" maxOccurs="unbounded"/>
                        </xs:sequence>
                    </xs:complexType>
                </xs:element>
                <xs:element name="image" type="xs:string"/>
                <xs:element name="roomNumber" type="xs:string"/>
                <xs:element name="roomPrice" type="xs:decimal"/>
                <xs:element name="roomid" type="xs:integer"/>
            </xs:sequence>
        </xs:complexType>
    </xs:element>

    <xs:simpleType name="FeatureType">
        <xs:restriction base="xs:string">
            <xs:enumeration value="WiFi"/>
            <xs:enumeration value="TV"/>
            <xs:enumeration value="Radio"/>
            <xs:enumeration value="Refreshments"/>
            <xs:enumeration value="Safe"/>
            <xs:enumeration value="Views"/>
        </xs:restriction>
    </xs:simpleType>

</xs:schema>
###

Jesteś generatorem kodu SQL. Weź instrukcję SQL ograniczoną trzema haszami i utwórz instrukcję SQL, które generuje 5 nowych rekordów zgodnych z formatem podanej instrukcji.
Przed wypisaniem nowo wygenerowanych danych sprawdź, czy każdy nowy wpis nie jest identyczny z podaną instrukcją SQL. Upewnij się również, że instrukcję SQL można pomyślnie wykonać, zanim ją wypiszesz.
###
CREATE TABLE rooms (roomid int NOT NULL AUTO_INCREMENT, room_name varchar(255), type varchar(255), beds int, accessible boolean, image varchar(2000), description varchar(2000), features varchar(100) ARRAY, roomPrice int, primary key (roomid));

INSERT INTO rooms (room_name, type, beds, accessible, image, description, features, roomPrice) VALUES ('101', 'single', 1, true, 'https://www.mwtestconsultancy.co.uk/img/testim/room2.jpg', 'Aenean porttitor mauris sit amet lacinia molestie. In posuere accumsan aliquet. Maecenas sit amet nisl massa. Interdum et malesuada fames ac ante.', ARRAY['TV', 'WiFi', 'Safe'], 100);

CREATE TABLE bookings (bookingid int NOT NULL AUTO_INCREMENT, roomid int, firstname varchar(255), lastname varchar(255), depositpaid boolean, checkin date, checkout date, primary key (bookingid), FOREIGN KEY (roomid) REFERENCES ROOMS(roomid));

INSERT INTO bookings (roomid, firstname, lastname, depositpaid, checkin, checkout) VALUES (1, 'James', 'Dean', true, '2022-02-01', '2022-02-05');
###

Jesteś generatorem danych. Utwórz dla mnie losowe dane w formacie JSON na podstawie kryteriów ograniczonych trzema haszami. Dodatkowe wymagania dotyczące danych są umieszczone między znakami odwrotnego apostrofu.
###
name
email
phone `Format brytyjski`
subject `Ponad 20 znaków długości `
description `Ponad 50 znaków długości `
###

@Test public void exampleContactUsFormTestWithGPT() {
OpenAiChatModel model = OpenAiChatModel.withApiKey("Wprowadź klucz API");
String prompt = """
Jesteś generatorem danych. Utwórz dla mnie losowe dane w formacie JSON na podstawie kryteriów ograniczonych trzema haszami. Dodatkowe wymagania dotyczące danych są umieszczone między znakami odwrotnego apostrofu.
###
name
email
phone `Format brytyjski`
subject `Ponad 20 znaków długości `
description `Ponad 50 znaków długości `
###
""";
String testData = model.generate(prompt);
System.out.println(testData);
}

public class ContactFormDetails {

    private String name;
    private String email;
    private String phone;
    private String subject;
    private String description;
    public ContactFormDetails(String name, String email, String phone, String subject, String description) {
        this.name = name;
        this.email = email;
        this.phone = phone;
        this.subject = subject;
        this.description = description;
    }
    public String getName() {
        return name;
    }
    public String getEmail() {
        return email;
    }
    public String getPhone() {
        return phone;
    }
    public String getSubject() {
        return subject;
    }
    public String getDescription() {
        return description;
    }
}

OpenAiChatModel model = OpenAiChatModel.withApiKey("Wprowadź klucz API");
String prompt = """
        Jesteś generatorem danych. Utwórz dla mnie losowe dane w formacie JSON
        na podstawie kryteriów ograniczonych trzema haszami. Dodatkowe wymagania
        dotyczące danych są umieszczone między znakami odwrotnego apostrofu.
        ###
        name
        email
        phone `Format brytyjski`
        subject `Ponad 20 znaków długości `
        description `Ponad 50 znaków długości `
        ###
        """;
String testData = model.generate(prompt);

ContactFormDetails contactFormDetails = new Gson().fromJson(testData, ContactFormDetails.class);

@Test
public void exampleContactUsFormTestWithGPT() {
OpenAiChatModel model = OpenAiChatModel.withApiKey("Wprowadź klucz API");
String prompt = """
        Jesteś generatorem danych. Utwórz dla mnie losowe dane w formacie JSON
        na podstawie kryteriów ograniczonych trzema haszami. Dodatkowe wymagania
        dotyczące danych są umieszczone między znakami odwrotnego apostrofu.
        ###
        name
        email
        phone `Format brytyjski`
        subject `Ponad 20 znaków długości `
        description `Ponad 50 znaków długości `
        ###
        """;
String testData = model.generate(prompt);
ContactFormDetails contactFormDetails = new Gson().fromJson(testData, ContactFormDetails.class);
ContactFormPage contactFormPage = new ContactFormPage(driver);
contactFormPage.enterName(contactFormDetails.getName());
contactFormPage.enterEmail(contactFormDetails.getEmail());
contactFormPage.enterPhone(contactFormDetails.getPhone());
contactFormPage.enterSubject(contactFormDetails.getSubject());
contactFormPage.enterDescription(contactFormDetails.getDescription());
contactFormPage.clickSubmitButton();
assert contactFormPage.getSuccessMessage().contains("Dziękujemy za kontakt");

