| /* |
| * Copyright (c) 2014, 2020 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Dmitry Kornilov - Initial implementation |
| package org.eclipse.persistence.jpars.test.service.v2; |
| |
| import org.eclipse.persistence.jpa.rs.resources.EntityResource; |
| import org.eclipse.persistence.jpa.rs.resources.MetadataResource; |
| import org.eclipse.persistence.jpa.rs.resources.QueryResource; |
| import org.eclipse.persistence.jpa.rs.resources.common.AbstractResource; |
| import org.eclipse.persistence.jpars.test.BaseJparsTest; |
| import org.eclipse.persistence.jpars.test.util.RestUtils; |
| import org.eclipse.persistence.jpars.test.util.TestHttpHeaders; |
| import org.eclipse.persistence.jpars.test.util.TestURIInfo; |
| import org.junit.BeforeClass; |
| import org.junit.Test; |
| |
| import jakarta.ws.rs.core.MediaType; |
| import jakarta.ws.rs.core.Response; |
| import jakarta.ws.rs.core.StreamingOutput; |
| import jakarta.xml.bind.JAXBException; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.UnsupportedEncodingException; |
| import java.net.URISyntaxException; |
| |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| /** |
| * A set of metadata tests. |
| * |
| * @author Dmitry Kornilov |
| * @since EclipseLink 2.6.0 |
| */ |
| public class MetadataTest extends BaseJparsTest { |
| protected static MetadataResource metadataResource; |
| |
| @BeforeClass |
| public static void setup() throws Exception { |
| initContext("jpars_employee-static", "v2.0"); |
| metadataResource = new MetadataResource(); |
| metadataResource.setPersistenceFactory(factory); |
| } |
| |
| @Test |
| public void testMetadataCatalog() throws URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final Response response = metadataResource.getMetadataCatalog(version, pu, |
| TestHttpHeaders.generateHTTPHeader(MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON), |
| new TestURIInfo()); |
| final String responseString = getResponseAsString(response); |
| |
| // Check entities |
| checkEntityMetadata(responseString, "PhoneNumber"); |
| checkEntityMetadata(responseString, "SmallProject"); |
| checkEntityMetadata(responseString, "Employee"); |
| checkEntityMetadata(responseString, "LargeProject"); |
| checkEntityMetadata(responseString, "Expertise"); |
| checkEntityMetadata(responseString, "Project"); |
| checkEntityMetadata(responseString, "EmployeeAddress"); |
| checkEntityMetadata(responseString, "Office"); |
| |
| // Check queries |
| checkQueryMetadata(responseString, "Employee.salaryMax"); |
| checkQueryMetadata(responseString, "EmployeeAddress.updatePostalCode"); |
| checkQueryMetadata(responseString, "EmployeeAddress.getRegion"); |
| checkQueryMetadata(responseString, "Employee.getManager"); |
| checkQueryMetadata(responseString, "Employee.getPhoneNumbers"); |
| checkQueryMetadata(responseString, "Employee.count"); |
| checkQueryMetadata(responseString, "EmployeeAddress.getAll"); |
| checkQueryMetadata(responseString, "Employee.getManagerById"); |
| checkQueryMetadata(responseString, "EmployeeAddress.getById"); |
| checkQueryMetadata(responseString, "Employee.findAll"); |
| checkQueryMetadata(responseString, "Employee.deleteAll"); |
| checkQueryMetadata(responseString, "Employee.findAllPageable"); |
| checkQueryMetadata(responseString, "EmployeeAddress.getPicture"); |
| } |
| |
| @Test |
| public void testEntityMetadata() throws URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final Response response = metadataResource.getEntityResource(version, pu, "Employee", |
| TestHttpHeaders.generateHTTPHeader(MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON), |
| new TestURIInfo()); |
| final String responseString = getResponseAsString(response); |
| |
| // Check ID |
| assertTrue(responseString.contains("\"name\":\"Employee\"")); |
| |
| // Check metadata |
| checkEntityMetadata(responseString, "Employee"); |
| } |
| |
| @Test |
| public void testQueryMetadata() throws URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final Response response = metadataResource.getQueryResource(version, pu, "Employee.salaryMax", |
| TestHttpHeaders.generateHTTPHeader(MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON), |
| new TestURIInfo()); |
| final String responseString = getResponseAsString(response); |
| |
| // Check ID |
| assertTrue(responseString.contains("\"name\":\"Employee.salaryMax\"")); |
| |
| // Check metadata |
| checkQueryMetadata(responseString, "Employee.salaryMax"); |
| } |
| |
| @Test |
| public void testEntitySchema() throws URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final Response response = metadataResource.getEntityResource(version, pu, "Employee", |
| TestHttpHeaders.generateHTTPHeader(AbstractResource.APPLICATION_SCHEMA_JSON_TYPE, AbstractResource.APPLICATION_SCHEMA_JSON), |
| new TestURIInfo()); |
| final String responseString = getResponseAsString(response); |
| |
| // Check id |
| assertTrue(responseString.contains("\"$schema\":\"" + RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/entity/Employee#")); |
| |
| // Check Title |
| assertTrue(responseString.contains("\"title\":\"Employee\"")); |
| |
| // Check properties |
| checkProperty(responseString, "id", "integer"); |
| checkProperty(responseString, "firstName", "string"); |
| checkProperty(responseString, "gender", "object"); |
| checkProperty(responseString, "lastName", "string"); |
| checkProperty(responseString, "salary", "number"); |
| checkProperty(responseString, "version", "number"); |
| checkProperty(responseString, "period", "object"); |
| checkPropertyWithRef(responseString, "manager", "Employee"); |
| checkPropertyWithRef(responseString, "office", "Office"); |
| checkPropertyWithRef(responseString, "address", "EmployeeAddress"); |
| checkArrayProperty(responseString, "certifications", "object"); |
| checkArrayProperty(responseString, "responsibilities", "string"); |
| checkArrayPropertyWithEntityRef(responseString, "projects", "Project"); |
| checkArrayPropertyWithEntityRef(responseString, "expertiseAreas", "Expertise"); |
| checkArrayPropertyWithEntityRef(responseString, "managedEmployees", "Employee"); |
| checkArrayPropertyWithEntityRef(responseString, "phoneNumbers", "PhoneNumber"); |
| |
| // Check links |
| checkLinkWithMethod(responseString, "find", "/entity/Employee/{primaryKey}", "GET"); |
| checkLinkWithMethod(responseString, "create", "/entity/Employee", "PUT"); |
| checkLinkWithMethod(responseString, "update", "/entity/Employee", "POST"); |
| checkLinkWithMethod(responseString, "delete", "/entity/Employee/{primaryKey}", "DELETE"); |
| } |
| |
| @Test |
| public void testReadAllQuerySchema() throws URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final Response response = metadataResource.getQueryResource(version, pu, "Employee.findAll", |
| TestHttpHeaders.generateHTTPHeader(AbstractResource.APPLICATION_SCHEMA_JSON_TYPE, AbstractResource.APPLICATION_SCHEMA_JSON), |
| new TestURIInfo()); |
| final String responseString = getResponseAsString(response); |
| |
| // Check id |
| assertTrue(responseString.contains("\"$schema\":\"" + RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/query/Employee.findAll#\"")); |
| |
| // Check Title |
| assertTrue(responseString.contains("\"title\":\"Employee.findAll\"")); |
| |
| // Check properties |
| checkArrayPropertyWithEntityRef(responseString, "items", "Employee"); |
| |
| // Check links |
| checkLinkWithMethod(responseString, "execute", "/query/Employee.findAll", "GET"); |
| } |
| |
| @Test |
| public void testReportQuerySchema() throws URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final Response response = metadataResource.getQueryResource(version, pu, "Employee.getManager", |
| TestHttpHeaders.generateHTTPHeader(AbstractResource.APPLICATION_SCHEMA_JSON_TYPE, AbstractResource.APPLICATION_SCHEMA_JSON), |
| new TestURIInfo()); |
| final String responseString = getResponseAsString(response); |
| |
| // Check id |
| assertTrue(responseString.contains("\"$schema\":\"" + RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/query/Employee.getManager#\"")); |
| |
| // Check Title |
| assertTrue(responseString.contains("\"title\":\"Employee.getManager\"")); |
| |
| // Check properties |
| checkArrayPropertyWithRef(responseString, "items", "#/definitions/result"); |
| |
| // Check definitions |
| final String definitions = "\"definitions\":{\"result\":{\"properties\":{" + |
| "\"firstName\":{\"type\":\"string\"}," + |
| "\"lastName\":{\"type\":\"string\"}," + |
| "\"manager\":{\"$ref\":\"" + RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/entity/Employee#\"}" + |
| "}}}"; |
| assertTrue(responseString.contains(definitions)); |
| |
| // Check links |
| checkLinkWithMethod(responseString, "execute", "/query/Employee.getManager", "GET"); |
| } |
| |
| @Test |
| public void testEntityOptions() throws URISyntaxException { |
| final EntityResource entityResource = new EntityResource(); |
| entityResource.setPersistenceFactory(factory); |
| |
| final Response response = entityResource.getEntityOptions(version, pu, "Employee", |
| TestHttpHeaders.generateHTTPHeader(MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON), |
| new TestURIInfo()); |
| assertTrue(response.getMetadata().containsKey("Link")); |
| |
| final String link = "<" + RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/entity/Employee>; rel=describedby"; |
| assertTrue(response.getMetadata().get("Link").get(0).equals(link)); |
| } |
| |
| @Test |
| public void testQueryOptions() throws URISyntaxException { |
| final QueryResource queryResource = new QueryResource(); |
| queryResource.setPersistenceFactory(factory); |
| |
| final Response response = queryResource.getQueryOptions(version, pu, "Employee.getManager", |
| TestHttpHeaders.generateHTTPHeader(MediaType.APPLICATION_JSON_TYPE, MediaType.APPLICATION_JSON), |
| new TestURIInfo()); |
| assertTrue(response.getMetadata().containsKey("Link")); |
| |
| final String link = "<" + RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/query/Employee.getManager>; rel=describedby"; |
| assertTrue(response.getMetadata().get("Link").get(0).equals(link)); |
| } |
| |
| private String getResponseAsString(Response response) { |
| StreamingOutput output = (StreamingOutput)response.getEntity(); |
| ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); |
| |
| try { |
| output.write(outputStream); |
| } catch (IOException ex) { |
| fail(ex.toString()); |
| } |
| return outputStream.toString(); |
| } |
| |
| private void checkProperty(String response, String name, String type) { |
| final String propertyStr = "\"" + name + "\":{\"type\":\"" + type + "\"}"; |
| assertTrue(response.contains(propertyStr)); |
| } |
| |
| private void checkPropertyWithRef(String response, String name, String refEntityName) throws URISyntaxException { |
| final String propertyStr = "\"" + name + "\":{\"$ref\":\"" + |
| RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/entity/" + refEntityName + "#\"}"; |
| assertTrue(response.contains(propertyStr)); |
| } |
| |
| private void checkArrayProperty(String response, String name, String itemType) { |
| final String propertyStr = "\"" + name + "\":{\"type\":\"array\",\"items\":{\"type\":\"" + itemType + "\"}}"; |
| assertTrue(response.contains(propertyStr)); |
| } |
| |
| private void checkArrayPropertyWithEntityRef(String response, String name, String refEntityName) throws URISyntaxException { |
| final String ref = RestUtils.getServerURI(context.getVersion()) + context.getName() + "/metadata-catalog/entity/" + refEntityName + "#"; |
| checkArrayPropertyWithRef(response, name, ref); |
| } |
| |
| private void checkArrayPropertyWithRef(String response, String name, String ref) { |
| final String propertyStr = "\"" + name + "\":{\"type\":\"array\",\"items\":{\"$ref\":\"" + ref + "\"}}"; |
| assertTrue(response.contains(propertyStr)); |
| } |
| |
| private void checkEntityMetadata(String response, String entityName) throws URISyntaxException { |
| assertTrue(response.contains("\"name\":\"" + entityName + "\"")); |
| checkLinkWithMediaType(response, "alternate", "/metadata-catalog/entity/" + entityName, "application/schema+json"); |
| checkLinkWithMediaType(response, "canonical", "/metadata-catalog/entity/" + entityName, "application/json"); |
| checkLinkJson(response, "describes", "/entity/" + entityName); |
| } |
| |
| private void checkQueryMetadata(String response, String queryName) throws URISyntaxException { |
| assertTrue(response.contains("\"name\":\"" + queryName + "\"")); |
| checkLinkWithMediaType(response, "alternate", "/metadata-catalog/query/" + queryName, "application/schema+json"); |
| checkLinkWithMediaType(response, "canonical", "/metadata-catalog/query/" + queryName, "application/json"); |
| |
| final String describesLink = "{\"rel\":\"describes\",\"href\":\"" + RestUtils.getServerURI(context.getVersion()) + context.getName() + "/query/" + queryName; |
| assertTrue(response.contains(describesLink)); |
| } |
| |
| private void checkLinkWithMediaType(String response, String rel, String uri, String mediaType) throws URISyntaxException { |
| final String link = "{\"rel\":\"" + rel + "\",\"href\":\"" + RestUtils.getServerURI(context.getVersion()) + context.getName() + uri + "\",\"mediaType\":\"" + mediaType + "\"}"; |
| assertTrue(response.contains(link)); |
| } |
| |
| private void checkLinkWithMethod(String response, String rel, String uri, String method) throws URISyntaxException { |
| final String link = "{\"rel\":\"" + rel + "\",\"href\":\"" + RestUtils.getServerURI(context.getVersion()) + context.getName() + uri + "\",\"method\":\"" + method + "\"}"; |
| assertTrue(response.contains(link)); |
| } |
| } |