본 번역은 검증되지 않았습니다. AIP를 통해 영문원문으로부터 번역되었습니다.

온톨로지 편집 검증

verifyOntologyEditFunction() API를 사용하여 Function에 의해 수행된 편집을 검증할 수 있습니다. "@foundry/functions-testing-lib"에서 가져와야 합니다. 이를 통해 아래에 나열된 워크플로를 중심으로 단위 테스트를 생성할 수 있습니다.

오브젝트 생성 검증

.createsObjects 메서드를 사용하여 오브젝트 생성을 검증할 수 있습니다. 예시는 다음과 같습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import { MyFunctions } from ".."

import { Objects , ExampleDataAirport } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 테스트 스위트 예제
describe("example test suite", () => {
    // MyFunctions 인스턴스 생성
    const myFunctions = new MyFunctions();

    // 공항 생성 테스트
    test("create airport", () => { 
        // verifyOntologyEditFunction을 사용하여 createAirport 함수 검증
        verifyOntologyEditFunction(() => myFunctions.createAirport("airportCode", "airportDisplayName"))
            // 객체 생성을 확인하는 검증
            .createsObject(
                {
                    // 생성할 객체의 타입 지정
                    objectType: ExampleDataAirport,
                    // 객체의 속성 지정
                    properties: {
                        airport: "airportCode",
                        displayAirportName: "airportDisplayName",
                    },
                });
    });
});

이것은 다음 Function을 테스트하는 데 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import { Function, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { Objects, ExampleDataAirport } from "@foundry/ontology-api";

export class MyFunctions {

    // ExampleDataAirport 타입을 수정하는 함수입니다.
    @Edits(ExampleDataAirport)
    // 온톨로지 수정 함수 데코레이터입니다.
    @OntologyEditFunction()
    // 공항 이름(airport)과 표시할 이름(displayName)을 인자로 받아 새로운 공항 객체를 생성하는 함수입니다.
    public createAirport(airport: string, displayName: string): void {
        // 새로운 공항 객체를 생성합니다.
        const newAirport = Objects.create().exampleDataAirport(airport);
        // 생성된 공항 객체의 표시할 이름을 설정합니다.
        newAirport.displayAirportName = displayName;
    }
}

새로 생성된 오브젝트에서 편집 확인하기

새로 생성된 오브젝트와 관련된 편집을 확인할 수 있습니다. 예를 들어, 새로운 ExampleDataFlight 오브젝트를 생성하고 new-flight-delay-0에 생성된 링크를 확인하려 할 수 있습니다. 다음은 예시입니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 테스트 스위트 예제를 설명하는 부분입니다.
describe("example test suite", () => {
    // 내 함수들을 새로운 객체로 초기화합니다.
    const myFunctions = new MyFunctions();

    // 단일 키를 가진 단일 생성된 객체에 대한 테스트를 설명하는 부분입니다.
    test("single key with single created object", () => {
            // 비행 정보를 생성하고 이를 "flightTest"라는 이름으로 지정합니다.
            const flight = Objects.create().exampleDataFlight("flightTest");
            // OntologyEditFunction을 검증하는 부분입니다. 이는 비행 정보와 1이라는 지연 시간을 이용하여 생성되고 연결된 지연을 만듭니다.
            verifyOntologyEditFunction(() => myFunctions.createAndLinkDelays(flight, 1))
                .createsObject({
                    // 생성될 객체의 유형을 설정합니다.
                    objectType: ExampleFlightDelayEvent,
                    properties: {
                        // 생성될 객체의 속성을 설정합니다.
                        eventId: "new-flight-delay-0",
                    },
                })
                // 생성된 객체와의 연결을 추가합니다.
                .addsLink(edits => ({
                    // 연결의 유형을 설정합니다.
                    link: flight.flightDelayEvent,
                    // 연결될 객체를 설정합니다. 이는 생성된 객체 중 ExampleFlightDelayEvent 유형의 첫 번째 객체입니다.
                    linkedObject: edits.createdObjects.byObjectType(ExampleFlightDelayEvent)[0],
                }))
        });
});

다음 Function을 테스트하는 데 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import { Function, Integer, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { Objects, ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";

export class MyFunctions {

    // 항공편과 지연 이벤트를 생성하고 연결하는 함수
    @Edits(ExampleDataFlight, ExampleFlightDelayEvent )
    @OntologyEditFunction()
    public createAndLinkDelays(flight: ExampleDataFlight, numDelay: Integer): void {
        // 지정된 수만큼 지연 이벤트를 생성하고 항공편에 연결
        for (let n = 0; n < numDelay; n++) {
            // 새로운 항공편 지연 이벤트 생성
            const delay = Objects.create().exampleFlightDelayEvent(`new-flight-delay-${n}`);
            // 항공편에 지연 이벤트 연결
            flight.flightDelayEvent.add(delay);
        }
    }
}

오브젝트 속성 편집 확인

.modifiesObjects를 사용하여 속성에 대한 편집을 확인할 수 있습니다. 다음은 예시입니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 예제 테스트 스위트
describe("example test suite", () => {
    const myFunctions = new MyFunctions();

    // 항공편의 기체 변경 테스트
    test("modifies aircraft of the flight", () => {
        // 항공편 객체 생성
        const flight = Objects.create().exampleDataFlight("NY -> LA");
        // 기존 기체 객체 생성
        const oldAircraft = Objects.create().exampleDataAircraft("N11111");
        flight.aircraft.set(oldAircraft);
        // 새로운 기체 객체 생성
        const newAircraft = Objects.create().exampleDataAircraft("A00000");
        // assignAircraftToFlight 함수 검증
        verifyOntologyEditFunction(() => myFunctions.assignAircraftToFlight(flight, newAircraft))
            .modifiesObject(
                { 
                    object: flight, 
                    properties: { 
                        tailNumber: "A00000" // 꼬리번호 변경 확인
                    } 
                })
        });
});

다음 함수를 테스트하는 데 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
import { Function, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { Objects, ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";

export class MyFunctions {

    // 항공편에 기체를 할당하는 함수
    @Edits(ExampleDataFlight)
    @OntologyEditFunction()
    public assignAircraftToFlight(flight: ExampleDataFlight, aircraft: ExampleDataAircraft): void {
        flight.aircraft.clear(); // flight 객체의 aircraft 속성을 초기화
        aircraft.flight.set(flight); // aircraft 객체의 flight 속성에 flight 객체를 할당
        flight.tailNumber = aircraft.tailNumber; // flight 객체의 tailNumber 속성에 aircraft 객체의 tailNumber를 할당
    }
}

오브젝트에 대한 다른 편집이 없는지 확인하기

선택적인 .hasNoMoreEdits()를 사용하여 다른 편집이 없음을 확인할 수 있습니다. 이는 지정된 편집만 허용되며, 다른 편집이 감지되면 검증이 실패한다는 것을 의미합니다. 다음은 예시입니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 필요한 라이브러리와 모듈을 가져옵니다.
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 테스트 스위트를 정의합니다.
describe("example test suite", () => {
    // MyFunctions 클래스의 인스턴스를 생성합니다.
    const myFunctions = new MyFunctions();

    // "single key with linked object"라는 이름의 테스트를 정의합니다.
    test("single key with linked object", () => {
            // "flightAnotherTest"라는 이름의 exampleDataFlight 객체를 생성합니다.
            const flight = Objects.create().exampleDataFlight("flightAnotherTest");
            // "new-flight-delay"라는 이름의 exampleFlightDelayEvent 객체를 생성합니다.
            const delay = Objects.create().exampleFlightDelayEvent("new-flight-delay")
            // myFunctions의 linkDelays 함수를 검증합니다. 이 함수는 flight 객체와 delay 객체를 연결합니다.
            verifyOntologyEditFunction(() => myFunctions.linkDelays(flight, delay))
                // flight 객체의 flightDelayEvent 링크와 delay 객체를 연결하는 것을 확인합니다.
                .addsLink({link: flight.flightDelayEvent, linkedObject: delay })
                // 추가적인 수정 사항이 없음을 확인합니다.
                .hasNoMoreEdits();
        });
});

.hasNoMoreEdits()를 사용할 때 특정 종류의 편집을 무시할 수 있습니다. 이는 다음 중 일부 또는 전부를 포함한 오브젝트를 전달함으로써 수행할 수 있습니다:

ignoreExtraCreatedObjects: true
ignoreExtraModifiedObjects: true
ignoreExtraDeletedObjects: true
ignoreExtraLinkedObjects: true
ignoreExtraUnlinkedObjects: true

오브젝트에 대한 링크 생성 검증

오브젝트에서 .addsLink를 사용하여 링크 생성을 검증할 수 있습니다. 다음은 그 예시입니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 예제 테스트 스위트
describe("example test suite", () => {
    const myFunctions = new MyFunctions();

    // 연결된 객체가 있는 단일 키 테스트
    test("single key with linked object", () => {
            // 비행 객체 생성
            const flight = Objects.create().exampleDataFlight("flightAnotherTest");
            // 지연 이벤트 객체 생성
            const delay = Objects.create().exampleFlightDelayEvent("new-flight-delay")
            // linkDelays 함수 검증
            verifyOntologyEditFunction(() => myFunctions.linkDelays(flight, delay))
                // 연결 정보 추가 검증
                .addsLink({link: flight.flightDelayEvent, linkedObject: delay })
                // 더 이상 수정 사항이 없음을 확인
                .hasNoMoreEdits();
        });
});

이 테스트는 반대 방향으로 같은 링크를 테스트하는 것과 동일합니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

describe("예시 테스트 스위트", () => {
    const myFunctions = new MyFunctions();

    test("연결된 객체를 가진 단일 키 반전", () => {
            const flight = Objects.create().exampleDataFlight("flightAnotherTest");
            const delay = Objects.create().exampleFlightDelayEvent("new-flight-delay")
            // linkDelays 함수를 사용하여 flight 객체와 delay 객체를 연결하고, 그 결과를 검증합니다.
            verifyOntologyEditFunction(() => myFunctions.linkDelays(flight, delay))
                .addsLink({link: delay.flight, linkedObject: flight })
                .hasNoMoreEdits();
        });
});

다음 Function을 테스트하는 데 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
import { Function, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { Objects, ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";

export class MyFunctions {

    @Edits(ExampleDataFlight, ExampleFlightDelayEvent )
    // OntologyEditFunction 데코레이터는 이 함수가 Ontology API와 통신하여 편집 작업을 수행함을 나타냅니다.
    @OntologyEditFunction()
    // linkDelays 함수는 항공편과 지연 사건을 연결합니다.
    public linkDelays(flight: ExampleDataFlight, delay: ExampleFlightDelayEvent): void {
        // 항공편 객체의 flightDelayEvent 속성에 지연 객체를 추가합니다.
        flight.flightDelayEvent.add(delay);
    }
}

오브젝트에서의 링크 제거 확인

.removesLink를 사용하여 오브젝트에서의 링크 제거를 확인할 수 있습니다. 다음은 그 예입니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 예제 테스트 스위트
describe("example test suite", () => {
    const myFunctions = new MyFunctions();

    // 링크 제거 테스트
    test("test link removal", () => {
            // 항공편 객체 생성
            const flight = Objects.create().exampleDataFlight("flightAnotherTest");
            // 지연 이벤트 객체 생성
            const delay = Objects.create().exampleFlightDelayEvent("new-flight-delay")
            // 항공편 객체에 지연 이벤트 추가
            flight.flightDelayEvent.add(delay);
            // removeAllDelays 함수를 사용하여 링크 제거 검증
            verifyOntologyEditFunction(() => myFunctions.removeAllDelays(flight))
                .removesLink({link: flight.flightDelayEvent, unlinkedObject: delay })
                .hasNoMoreEdits();
        });
});

다음 Function을 테스트하는 데 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import { Function, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { Objects, ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";

export class MyFunctions {

    // ExampleDataFlight 객체와 ExampleFlightDelayEvent 객체를 수정하는 함수입니다.
    @Edits(ExampleDataFlight, ExampleFlightDelayEvent)
    // 온톨로지 편집 기능을 사용합니다.
    @OntologyEditFunction()
    // 모든 지연을 제거하는 함수입니다.
    public removeAllDelays(flight: ExampleDataFlight): void {
        // flight 객체의 flightDelayEvent를 비웁니다.
        flight.flightDelayEvent.clear();
    }
}

오브젝트 삭제 확인

.deletesObject를 사용하여 오브젝트 삭제를 확인할 수 있습니다. 예제는 다음과 같습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 예제 테스트 스위트
describe("example test suite", () => {
    const myFunctions = new MyFunctions();

    // 객체 삭제 테스트
    test("test object deletion", () => {
            // 테스트용 항공편 객체 생성
            const flight = Objects.create().exampleDataFlight("flightAnotherTest");
            // deleteFlight 함수를 이용해 객체를 삭제하는 것을 검증
            verifyOntologyEditFunction(() => myFunctions.deleteFlight(flight))
                .deletesObject(flight)
                .hasNoMoreEdits();
        });
});

다음 함수를 테스트하는 데 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
import { Function, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { Objects, ExampleDataFlight } from "@foundry/ontology-api";

export class MyFunctions {

    @Edits(ExampleDataFlight)  // ExampleDataFlight 데이터를 편집하는 것을 나타내는 데코레이터
    @OntologyEditFunction()  // 온톨로지 데이터를 편집하는 함수를 나타내는 데코레이터
    public deleteFlight(flight: ExampleDataFlight): void {  // 비행 정보를 삭제하는 함수
        flight.delete();  // 비행 정보 삭제
    }
}

여러 오브젝트 생성 확인

리스트를 전달하여 테스트에 사용할 여러 오브젝트를 생성하기 위해 .createsObjects 메소드를 사용할 수 있습니다. 다음은 예시입니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import { MyFunctions } from ".."

import { Objects , ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// 테스트 스위트 예제
describe("example test suite", () => {
    const myFunctions = new MyFunctions();

    // 단일 키와 많은 생성된 객체를 가진 테스트
    test("single key with many created objects", () => {
            // 객체를 생성하고 flightTest라는 예제 데이터 비행기를 만듭니다.
            const flight = Objects.create().exampleDataFlight("flightTest");
            // OntologyEditFunction을 검증합니다. 여기에서는 myFunctions.createAndLinkDelays 함수에 대한 검증을 수행합니다.
            verifyOntologyEditFunction(() => myFunctions.createAndLinkDelays(flight, 3))
                // 다음 객체들을 생성합니다. 각 객체는 ExampleFlightDelayEvent 타입이며, eventId 프로퍼티를 가지고 있습니다.
                .createsObjects(
                    [0, 1, 2].map(i => ({
                        objectType: ExampleFlightDelayEvent,
                        properties: {
                            eventId: "new-flight-delay-" + i,
                        },
                    })),
                )
                // 생성된 객체들에 대해 링크를 추가합니다. 각 이벤트에 대해 flight.flightDelayEvent와 연결합니다.
                .addsLinks(edits =>
                    edits.createdObjects.byObjectType(ExampleFlightDelayEvent).map(event => ({
                        link: flight.flightDelayEvent,
                        linkedObject: event,
                    })),
                )
                // 추가로 수정할 내용이 없음을 확인합니다.
                .hasNoMoreEdits();
        });
});

다음 Function을 테스트하는 데 사용할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import { Function, Integer, OntologyEditFunction, Edits } from "@foundry/functions-api";
import { Objects, ExampleDataFlight, ExampleFlightDelayEvent } from "@foundry/ontology-api";

export class MyFunctions {

    // ExampleDataFlight와 ExampleFlightDelayEvent를 수정하는 함수를 정의
    @Edits(ExampleDataFlight, ExampleFlightDelayEvent )
    // OntologyEditFunction 데코레이터를 사용하여 함수를 온톨로지 편집 함수로 표시
    @OntologyEditFunction()
    // 지정된 수의 지연 이벤트를 생성하고 해당 비행에 연결하는 함수
    public createAndLinkDelays(flight: ExampleDataFlight, numDelay: Integer): void {
        // numDelay만큼 반복
        for (let n = 0; n < numDelay; n++) {
            // 새로운 FlightDelayEvent를 생성
            const delay = Objects.create().exampleFlightDelayEvent(`new-flight-delay-${n}`);
            // 생성된 지연 이벤트를 비행에 추가
            flight.flightDelayEvent.add(delay);
        }
    }
}

비동기 온톨로지 편집 확인

다음과 같이 비동기 온톨로지 편집을 확인할 수 있습니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// "@foundry/functions-testing-lib" 라이브러리에서 verifyOntologyEditFunction 함수를 가져옵니다.
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";

// "test async edit function" 이라는 이름의 테스트를 실행합니다.
test("test async edit function", async () => {
        // 모든 속성 타입이 있는 객체를 생성합니다.
        const obj = Objects.create().objectWithAllPropertyTypes(1);
        // myFunctions.setDateAndTimestampToNow 함수를 테스트하기 위해 verifyOntologyEditFunction 함수를 사용합니다.
        // 이 함수는 obj 객체의 날짜와 타임스탬프를 현재 시간으로 설정합니다.
        // 수정된 객체는 timestampProperty 속성이 현재 타임스탬프로 설정되어 있어야 합니다.
        (await verifyOntologyEditFunction(() => myFunctions.setDateAndTimestampToNow(obj))).modifiesObject({
            object: obj,
            properties: {
                timestampProperty: makeTimestamp(),
            },
        });
    });

여러 검증

위의 예시에서와 같이, 우리는 검증을 연결할 수 있습니다. 다음 패턴은 이를 보여줍니다:

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// "@foundry/functions-testing-lib"에서 verifyOntologyEditFunction을 가져옵니다.
import { verifyOntologyEditFunction } from "@foundry/functions-testing-lib";
// "@foundry/ontology-api"에서 Objects와 ExampleDataObject를 가져옵니다.
import { Objects, ExampleDataObject } from "@foundry/ontology-api";

// "multiple action edit"라는 테스트를 실행합니다.
test("multiple action edit", () => { 
    // myFunctions의 multistageEdits 함수를 "objectId"와 "objectName"를 인자로 실행하는 것을 검증합니다.
    verifyOntologyEditFunction(() => myFunctions.multistageEdits("objectId", "objectName"))
        // 객체를 생성하는지 확인합니다.
        .createsObject({...})
        // 객체를 수정하는지 확인합니다.
        .modifiesObjects({...})
        // 링크를 추가하는지 확인합니다.
        .addsLinks({...})
        // 링크를 제거하는지 확인합니다.
        .removesLinks({...})
        // 객체를 삭제하는지 확인합니다.
        .deletesObject(...)
        // 더 이상 수정사항이 없는지 확인합니다.
        .hasNoMoreEdits(); 
});