Examples with Reader io.swagger.v3.jaxrs2.Reader used on opensource projects

Example 46 with Reader

use of io.swagger.v3.jaxrs2.Reader in project swagger-core by swagger-api.

the class JsonViewTest method shouldSerializeTypeParameter.

@Test(description = "check awareness of JsonView")
public void shouldSerializeTypeParameter() throws JsonProcessingException {
    Reader reader = new Reader(new OpenAPI());
    OpenAPI openAPI = reader.read(CarSummaryApi.class);
    String openApiJson = Json.mapper().writeValueAsString(openAPI);
    Assert.assertTrue(openApiJson.contains("manufacture"));
    Assert.assertTrue(openApiJson.contains("model"));
    Assert.assertTrue(openApiJson.contains("color"));
    Assert.assertFalse(openApiJson.contains("tires"));
    Assert.assertFalse(openApiJson.contains("made"));
    Assert.assertFalse(openApiJson.contains("condition"));
    reader = new Reader(new OpenAPI());
    openAPI = reader.read(CarSummaryUpdateApi.class);
    Set carSummarySchemaProperties = openAPI.getComponents().getSchemas().get("Car_Summary").getProperties().keySet();
    String carSummaryUpdateApiRequestBodySchemaRef = openAPI.getPaths().values().stream().findAny().orElse(new PathItem()).getPut().getRequestBody().getContent().values().stream().findAny().orElse(new MediaType()).getSchema().get$ref();
    Assert.assertTrue(carSummarySchemaProperties.contains("manufacture"));
    Assert.assertTrue(carSummarySchemaProperties.contains("model"));
    Assert.assertTrue(carSummarySchemaProperties.contains("color"));
    Assert.assertFalse(carSummarySchemaProperties.contains("price"));
    Assert.assertFalse(carSummarySchemaProperties.contains("tires"));
    Assert.assertFalse(carSummarySchemaProperties.contains("made"));
    Assert.assertFalse(carSummarySchemaProperties.contains("condition"));
    Assert.assertTrue(carSummaryUpdateApiRequestBodySchemaRef.contains("Car_Summary"));
    reader = new Reader(new OpenAPI());
    openAPI = reader.read(CarDetailApi.class);
    openApiJson = Json.mapper().writeValueAsString(openAPI);
    Assert.assertTrue(openApiJson.contains("manufacture"));
    Assert.assertTrue(openApiJson.contains("model"));
    Assert.assertTrue(openApiJson.contains("color"));
    Assert.assertTrue(openApiJson.contains("tires"));
    Assert.assertTrue(openApiJson.contains("brand"));
    Assert.assertTrue(openApiJson.contains("condition"));
    Assert.assertTrue(openApiJson.contains("Car_Detail"));
    reader = new Reader(new OpenAPI());
    openAPI = reader.read(CarSaleSummaryApi.class);
    openApiJson = Json.mapper().writeValueAsString(openAPI);
    Yaml.prettyPrint(openAPI);
    Assert.assertTrue(openApiJson.contains("manufacture"));
    Assert.assertTrue(openApiJson.contains("model"));
    Assert.assertTrue(openApiJson.contains("color"));
    Assert.assertTrue(openApiJson.contains("price"));
    Assert.assertFalse(openApiJson.contains("tires"));
    Assert.assertFalse(openApiJson.contains("made"));
    Assert.assertFalse(openApiJson.contains("condition"));
    reader = new Reader(new OpenAPI());
    openAPI = reader.read(CarApi.class);
    openApiJson = Json.mapper().writeValueAsString(openAPI);
    Assert.assertTrue(openApiJson.contains("manufacture"));
    Assert.assertTrue(openApiJson.contains("model"));
    Assert.assertTrue(openApiJson.contains("color"));
    Assert.assertTrue(openApiJson.contains("price"));
    Assert.assertTrue(openApiJson.contains("tires"));
    Assert.assertFalse(openApiJson.contains("made"));
    Assert.assertTrue(openApiJson.contains("condition"));
    reader = new Reader(new OpenAPI());
    openAPI = reader.read(CarIgnoreApi.class);
    openApiJson = Json.mapper().writeValueAsString(openAPI);
    Assert.assertTrue(openApiJson.contains("manufacture"));
    Assert.assertTrue(openApiJson.contains("model"));
    Assert.assertTrue(openApiJson.contains("color"));
    Assert.assertTrue(openApiJson.contains("price"));
    Assert.assertTrue(openApiJson.contains("tires"));
    Assert.assertFalse(openApiJson.contains("made"));
    Assert.assertTrue(openApiJson.contains("condition"));
}

Example 47 with Reader

use of io.swagger.v3.jaxrs2.Reader in project swagger-core by swagger-api.

the class Reader method read.

public OpenAPI read(Class<?> cls, String parentPath, String parentMethod, boolean isSubresource, RequestBody parentRequestBody, ApiResponses parentResponses, Set<String> parentTags, List<Parameter> parentParameters, Set<Class<?>> scannedResources) {
    Hidden hidden = cls.getAnnotation(Hidden.class);
    // class path
    final javax.ws.rs.Path apiPath = ReflectionUtils.getAnnotation(cls, javax.ws.rs.Path.class);
    if (hidden != null) {
        // || (apiPath == null && !isSubresource)) {
        return openAPI;
    }
    io.swagger.v3.oas.annotations.responses.ApiResponse[] classResponses = ReflectionUtils.getRepeatableAnnotationsArray(cls, io.swagger.v3.oas.annotations.responses.ApiResponse.class);
    List<io.swagger.v3.oas.annotations.security.SecurityScheme> apiSecurityScheme = ReflectionUtils.getRepeatableAnnotations(cls, io.swagger.v3.oas.annotations.security.SecurityScheme.class);
    List<io.swagger.v3.oas.annotations.security.SecurityRequirement> apiSecurityRequirements = ReflectionUtils.getRepeatableAnnotations(cls, io.swagger.v3.oas.annotations.security.SecurityRequirement.class);
    ExternalDocumentation apiExternalDocs = ReflectionUtils.getAnnotation(cls, ExternalDocumentation.class);
    io.swagger.v3.oas.annotations.tags.Tag[] apiTags = ReflectionUtils.getRepeatableAnnotationsArray(cls, io.swagger.v3.oas.annotations.tags.Tag.class);
    io.swagger.v3.oas.annotations.servers.Server[] apiServers = ReflectionUtils.getRepeatableAnnotationsArray(cls, io.swagger.v3.oas.annotations.servers.Server.class);
    javax.ws.rs.Consumes classConsumes = ReflectionUtils.getAnnotation(cls, javax.ws.rs.Consumes.class);
    javax.ws.rs.Produces classProduces = ReflectionUtils.getAnnotation(cls, javax.ws.rs.Produces.class);
    boolean classDeprecated = ReflectionUtils.getAnnotation(cls, Deprecated.class) != null;
    // OpenApiDefinition
    OpenAPIDefinition openAPIDefinition = ReflectionUtils.getAnnotation(cls, OpenAPIDefinition.class);
    if (openAPIDefinition != null) {
        // info
        AnnotationsUtils.getInfo(openAPIDefinition.info()).ifPresent(info -> openAPI.setInfo(info));
        // OpenApiDefinition security requirements
        SecurityParser.getSecurityRequirements(openAPIDefinition.security()).ifPresent(s -> openAPI.setSecurity(s));
        // 
        // OpenApiDefinition external docs
        AnnotationsUtils.getExternalDocumentation(openAPIDefinition.externalDocs()).ifPresent(docs -> openAPI.setExternalDocs(docs));
        // OpenApiDefinition tags
        AnnotationsUtils.getTags(openAPIDefinition.tags(), false).ifPresent(tags -> openApiTags.addAll(tags));
        // OpenApiDefinition servers
        AnnotationsUtils.getServers(openAPIDefinition.servers()).ifPresent(servers -> openAPI.setServers(servers));
        // OpenApiDefinition extensions
        if (openAPIDefinition.extensions().length > 0) {
            openAPI.setExtensions(AnnotationsUtils.getExtensions(openAPIDefinition.extensions()));
        }
    }
    // class security schemes
    if (apiSecurityScheme != null) {
        for (io.swagger.v3.oas.annotations.security.SecurityScheme securitySchemeAnnotation : apiSecurityScheme) {
            Optional<SecurityParser.SecuritySchemePair> securityScheme = SecurityParser.getSecurityScheme(securitySchemeAnnotation);
            if (securityScheme.isPresent()) {
                Map<String, SecurityScheme> securitySchemeMap = new HashMap<>();
                if (StringUtils.isNotBlank(securityScheme.get().key)) {
                    securitySchemeMap.put(securityScheme.get().key, securityScheme.get().securityScheme);
                    if (components.getSecuritySchemes() != null && components.getSecuritySchemes().size() != 0) {
                        components.getSecuritySchemes().putAll(securitySchemeMap);
                    } else {
                        components.setSecuritySchemes(securitySchemeMap);
                    }
                }
            }
        }
    }
    // class security requirements
    List<SecurityRequirement> classSecurityRequirements = new ArrayList<>();
    if (apiSecurityRequirements != null) {
        Optional<List<SecurityRequirement>> requirementsObject = SecurityParser.getSecurityRequirements(apiSecurityRequirements.toArray(new io.swagger.v3.oas.annotations.security.SecurityRequirement[apiSecurityRequirements.size()]));
        if (requirementsObject.isPresent()) {
            classSecurityRequirements = requirementsObject.get();
        }
    }
    // class tags, consider only name to add to class operations
    final Set<String> classTags = new LinkedHashSet<>();
    if (apiTags != null) {
        AnnotationsUtils.getTags(apiTags, false).ifPresent(tags -> tags.stream().map(Tag::getName).forEach(classTags::add));
    }
    // parent tags
    if (isSubresource) {
        if (parentTags != null) {
            classTags.addAll(parentTags);
        }
    }
    // servers
    final List<io.swagger.v3.oas.models.servers.Server> classServers = new ArrayList<>();
    if (apiServers != null) {
        AnnotationsUtils.getServers(apiServers).ifPresent(classServers::addAll);
    }
    // class external docs
    Optional<io.swagger.v3.oas.models.ExternalDocumentation> classExternalDocumentation = AnnotationsUtils.getExternalDocumentation(apiExternalDocs);
    JavaType classType = TypeFactory.defaultInstance().constructType(cls);
    BeanDescription bd = Json.mapper().getSerializationConfig().introspect(classType);
    final List<Parameter> globalParameters = new ArrayList<>();
    // look for constructor-level annotated properties
    globalParameters.addAll(ReaderUtils.collectConstructorParameters(cls, components, classConsumes, null));
    // look for field-level annotated properties
    globalParameters.addAll(ReaderUtils.collectFieldParameters(cls, components, classConsumes, null));
    // Make sure that the class methods are sorted for deterministic order
    // See https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html#getMethods--
    final List<Method> methods = Arrays.stream(cls.getMethods()).sorted(new MethodComparator()).collect(Collectors.toList());
    // iterate class methods
    for (Method method : methods) {
        if (isOperationHidden(method)) {
            continue;
        }
        AnnotatedMethod annotatedMethod = bd.findMethod(method.getName(), method.getParameterTypes());
        javax.ws.rs.Produces methodProduces = ReflectionUtils.getAnnotation(method, javax.ws.rs.Produces.class);
        javax.ws.rs.Consumes methodConsumes = ReflectionUtils.getAnnotation(method, javax.ws.rs.Consumes.class);
        if (isMethodOverridden(method, cls)) {
            continue;
        }
        boolean methodDeprecated = ReflectionUtils.getAnnotation(method, Deprecated.class) != null;
        javax.ws.rs.Path methodPath = ReflectionUtils.getAnnotation(method, javax.ws.rs.Path.class);
        String operationPath = ReaderUtils.getPath(apiPath, methodPath, parentPath, isSubresource);
        // extending resource config.
        if (ignoreOperationPath(operationPath, parentPath) && !isSubresource) {
            continue;
        }
        Map<String, String> regexMap = new LinkedHashMap<>();
        operationPath = PathUtils.parsePath(operationPath, regexMap);
        if (operationPath != null) {
            if (config != null && ReaderUtils.isIgnored(operationPath, config)) {
                continue;
            }
            final Class<?> subResource = getSubResourceWithJaxRsSubresourceLocatorSpecs(method);
            String httpMethod = ReaderUtils.extractOperationMethod(method, OpenAPIExtensions.chain());
            httpMethod = (httpMethod == null && isSubresource) ? parentMethod : httpMethod;
            if (StringUtils.isBlank(httpMethod) && subResource == null) {
                continue;
            } else if (StringUtils.isBlank(httpMethod) && subResource != null) {
                Type returnType = method.getGenericReturnType();
                if (annotatedMethod != null && annotatedMethod.getType() != null) {
                    returnType = annotatedMethod.getType();
                }
                if (shouldIgnoreClass(returnType.getTypeName()) && !method.getGenericReturnType().equals(subResource)) {
                    continue;
                }
            }
            io.swagger.v3.oas.annotations.Operation apiOperation = ReflectionUtils.getAnnotation(method, io.swagger.v3.oas.annotations.Operation.class);
            JsonView jsonViewAnnotation;
            JsonView jsonViewAnnotationForRequestBody;
            if (apiOperation != null && apiOperation.ignoreJsonView()) {
                jsonViewAnnotation = null;
                jsonViewAnnotationForRequestBody = null;
            } else {
                jsonViewAnnotation = ReflectionUtils.getAnnotation(method, JsonView.class);
                /* If one and only one exists, use the @JsonView annotation from the method parameter annotated
                       with @RequestBody. Otherwise fall back to the @JsonView annotation for the method itself. */
                jsonViewAnnotationForRequestBody = (JsonView) Arrays.stream(ReflectionUtils.getParameterAnnotations(method)).filter(arr -> Arrays.stream(arr).anyMatch(annotation -> annotation.annotationType().equals(io.swagger.v3.oas.annotations.parameters.RequestBody.class))).flatMap(Arrays::stream).filter(annotation -> annotation.annotationType().equals(JsonView.class)).reduce((a, b) -> null).orElse(jsonViewAnnotation);
            }
            Operation operation = parseMethod(method, globalParameters, methodProduces, classProduces, methodConsumes, classConsumes, classSecurityRequirements, classExternalDocumentation, classTags, classServers, isSubresource, parentRequestBody, parentResponses, jsonViewAnnotation, classResponses, annotatedMethod);
            if (operation != null) {
                if (classDeprecated || methodDeprecated) {
                    operation.setDeprecated(true);
                }
                List<Parameter> operationParameters = new ArrayList<>();
                List<Parameter> formParameters = new ArrayList<>();
                Annotation[][] paramAnnotations = ReflectionUtils.getParameterAnnotations(method);
                if (annotatedMethod == null) {
                    // annotatedMethod not null only when method with 0-2 parameters
                    Type[] genericParameterTypes = method.getGenericParameterTypes();
                    for (int i = 0; i < genericParameterTypes.length; i++) {
                        final Type type = TypeFactory.defaultInstance().constructType(genericParameterTypes[i], cls);
                        io.swagger.v3.oas.annotations.Parameter paramAnnotation = AnnotationsUtils.getAnnotation(io.swagger.v3.oas.annotations.Parameter.class, paramAnnotations[i]);
                        Type paramType = ParameterProcessor.getParameterType(paramAnnotation, true);
                        if (paramType == null) {
                            paramType = type;
                        } else {
                            if (!(paramType instanceof Class)) {
                                paramType = type;
                            }
                        }
                        ResolvedParameter resolvedParameter = getParameters(paramType, Arrays.asList(paramAnnotations[i]), operation, classConsumes, methodConsumes, jsonViewAnnotation);
                        operationParameters.addAll(resolvedParameter.parameters);
                        // collect params to use together as request Body
                        formParameters.addAll(resolvedParameter.formParameters);
                        if (resolvedParameter.requestBody != null) {
                            processRequestBody(resolvedParameter.requestBody, operation, methodConsumes, classConsumes, operationParameters, paramAnnotations[i], type, jsonViewAnnotationForRequestBody, null);
                        }
                    }
                } else {
                    for (int i = 0; i < annotatedMethod.getParameterCount(); i++) {
                        AnnotatedParameter param = annotatedMethod.getParameter(i);
                        final Type type = TypeFactory.defaultInstance().constructType(param.getParameterType(), cls);
                        io.swagger.v3.oas.annotations.Parameter paramAnnotation = AnnotationsUtils.getAnnotation(io.swagger.v3.oas.annotations.Parameter.class, paramAnnotations[i]);
                        Type paramType = ParameterProcessor.getParameterType(paramAnnotation, true);
                        if (paramType == null) {
                            paramType = type;
                        } else {
                            if (!(paramType instanceof Class)) {
                                paramType = type;
                            }
                        }
                        ResolvedParameter resolvedParameter = getParameters(paramType, Arrays.asList(paramAnnotations[i]), operation, classConsumes, methodConsumes, jsonViewAnnotation);
                        operationParameters.addAll(resolvedParameter.parameters);
                        // collect params to use together as request Body
                        formParameters.addAll(resolvedParameter.formParameters);
                        if (resolvedParameter.requestBody != null) {
                            processRequestBody(resolvedParameter.requestBody, operation, methodConsumes, classConsumes, operationParameters, paramAnnotations[i], type, jsonViewAnnotationForRequestBody, null);
                        }
                    }
                }
                // if we have form parameters, need to merge them into single schema and use as request body..
                if (!formParameters.isEmpty()) {
                    Schema mergedSchema = new ObjectSchema();
                    Map<String, Encoding> encoding = new LinkedHashMap<>();
                    for (Parameter formParam : formParameters) {
                        if (formParam.getExplode() != null || (formParam.getStyle() != null) && Encoding.StyleEnum.fromString(formParam.getStyle().toString()) != null) {
                            Encoding e = new Encoding();
                            if (formParam.getExplode() != null) {
                                e.explode(formParam.getExplode());
                            }
                            if (formParam.getStyle() != null && Encoding.StyleEnum.fromString(formParam.getStyle().toString()) != null) {
                                e.style(Encoding.StyleEnum.fromString(formParam.getStyle().toString()));
                            }
                            encoding.put(formParam.getName(), e);
                        }
                        mergedSchema.addProperties(formParam.getName(), formParam.getSchema());
                        if (formParam.getSchema() != null && StringUtils.isNotBlank(formParam.getDescription()) && StringUtils.isBlank(formParam.getSchema().getDescription())) {
                            formParam.getSchema().description(formParam.getDescription());
                        }
                        if (null != formParam.getRequired() && formParam.getRequired()) {
                            mergedSchema.addRequiredItem(formParam.getName());
                        }
                    }
                    Parameter merged = new Parameter().schema(mergedSchema);
                    processRequestBody(merged, operation, methodConsumes, classConsumes, operationParameters, new Annotation[0], null, jsonViewAnnotationForRequestBody, encoding);
                }
                if (!operationParameters.isEmpty()) {
                    for (Parameter operationParameter : operationParameters) {
                        operation.addParametersItem(operationParameter);
                    }
                }
                // if subresource, merge parent parameters
                if (parentParameters != null) {
                    for (Parameter parentParameter : parentParameters) {
                        operation.addParametersItem(parentParameter);
                    }
                }
                if (subResource != null && !scannedResources.contains(subResource)) {
                    scannedResources.add(subResource);
                    read(subResource, operationPath, httpMethod, true, operation.getRequestBody(), operation.getResponses(), classTags, operation.getParameters(), scannedResources);
                    // remove the sub resource so that it can visit it later in another path
                    // but we have a room for optimization in the future to reuse the scanned result
                    // by caching the scanned resources in the reader instance to avoid actual scanning
                    // the the resources again
                    scannedResources.remove(subResource);
                    // don't proceed with root resource operation, as it's handled by subresource
                    continue;
                }
                final Iterator<OpenAPIExtension> chain = OpenAPIExtensions.chain();
                if (chain.hasNext()) {
                    final OpenAPIExtension extension = chain.next();
                    extension.decorateOperation(operation, method, chain);
                }
                PathItem pathItemObject;
                if (openAPI.getPaths() != null && openAPI.getPaths().get(operationPath) != null) {
                    pathItemObject = openAPI.getPaths().get(operationPath);
                } else {
                    pathItemObject = new PathItem();
                }
                if (StringUtils.isBlank(httpMethod)) {
                    continue;
                }
                setPathItemOperation(pathItemObject, httpMethod, operation);
                paths.addPathItem(operationPath, pathItemObject);
                if (openAPI.getPaths() != null) {
                    this.paths.putAll(openAPI.getPaths());
                }
                openAPI.setPaths(this.paths);
            }
        }
    }
    // if no components object is defined in openApi instance passed by client, set openAPI.components to resolved components (if not empty)
    if (!isEmptyComponents(components) && openAPI.getComponents() == null) {
        openAPI.setComponents(components);
    }
    // add tags from class to definition tags
    AnnotationsUtils.getTags(apiTags, true).ifPresent(tags -> openApiTags.addAll(tags));
    if (!openApiTags.isEmpty()) {
        Set<Tag> tagsSet = new LinkedHashSet<>();
        if (openAPI.getTags() != null) {
            for (Tag tag : openAPI.getTags()) {
                if (tagsSet.stream().noneMatch(t -> t.getName().equals(tag.getName()))) {
                    tagsSet.add(tag);
                }
            }
        }
        for (Tag tag : openApiTags) {
            if (tagsSet.stream().noneMatch(t -> t.getName().equals(tag.getName()))) {
                tagsSet.add(tag);
            }
        }
        openAPI.setTags(new ArrayList<>(tagsSet));
    }
    return openAPI;
}

Example 48 with Reader

use of io.swagger.v3.jaxrs2.Reader in project tests by datanucleus.

the class RelationshipTest method test1to1UnidirInheritanceSubclassTable.

/**
 * Test case for 1-1 bidirectional relationships using 2 FK's.
 * This is really tested as BasicQuery and DatastoreId test.
 */
/*public void test1to1BidirectionalMultiFK()
    throws Exception
    {
        try
        {
            Object idUser = null;
            Object idUserDetail = null;
            
            PersistenceManager pm=pmf.getPersistenceManager();
            Transaction tx=pm.currentTransaction();
            
            // Create sample data
            try
            {
                tx.begin();
                
                User user=new User("andy","password");
                UserDetails details=new UserDetails("Andy","Jefferson");
                user.setDetails(details);
                details.setUser(user);
                
                pm.makePersistent(user);
                
                tx.commit();
                idUser = pm.getObjectId(user);
                idUserDetail = pm.getObjectId(details);
            }
            catch (Exception e)
            {
                LOG.error(e);
                fail("Exception thrown while creating 1-1 bidirectional relationship data : " + e.getMessage());
            }
            finally
            {
                if (tx.isActive())
                {
                    tx.rollback();
                }
                
                pm.close();
            }
            
            pm=pmf.getPersistenceManager();
            tx=pm.currentTransaction();
            
            // Create sample data
            try
            {
                tx.begin();
                
                User user=(User)pm.getObjectById(idUser,true);
                UserDetails details=(UserDetails)pm.getObjectById(idUserDetail,true);
                assertEquals(details,user.getUserDetails());
                assertEquals(user,details.getUser());
                tx.commit();
            }
            catch (Exception e)
            {
                LOG.error(e);
                fail("Exception thrown while creating 1-1 bidirectional relationship data : " + e.getMessage());
            }
            finally
            {
                if (tx.isActive())
                {
                    tx.rollback();
                }
                
                pm.close();
            }
        }
        finally
        {
            clean(User.class);
            clean(UserDetails.class);
        }
    }*/
/**
 * Test case for 1-1 uni relationship to a class using "subclass-table" inheritance strategy. See JIRA "NUCRDBMS-18"
 */
public void test1to1UnidirInheritanceSubclassTable() throws Exception {
    try {
        // Create the necessary schema
        try {
            addClassesToSchema(new Class[] { Newspaper.class, Magazine.class, MediaWork.class, Reader.class });
        } catch (Exception e) {
            e.printStackTrace();
            fail("Exception thrown while adding classes for 1-1 relation using subclass-table : " + e.getMessage());
        }
        // Check the persistence of data
        PersistenceManager pm = pmf.getPersistenceManager();
        Transaction tx = pm.currentTransaction();
        Object fredId = null;
        Object pamId = null;
        try {
            tx.begin();
            Magazine hello = new Magazine("Hello", MediaWork.FREQ_WEEKLY, "Trash Publishers");
            Newspaper mail = new Newspaper("Daily Mail", MediaWork.FREQ_DAILY, "Piers Morgan", "Tabloid");
            Reader fred = new Reader("Fred Smith", mail);
            Reader pam = new Reader("Pam Green", hello);
            pm.makePersistent(fred);
            pm.makePersistent(pam);
            tx.commit();
            fredId = pm.getObjectId(fred);
            pamId = pm.getObjectId(pam);
        } catch (Exception e) {
            e.printStackTrace();
            fail(e.getMessage());
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check the retrieval of the data
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            Reader fred = (Reader) pm.getObjectById(fredId, true);
            assertTrue("Fred has the wrong name!", fred.getName().equals("Fred Smith"));
            assertTrue("Fred has the wrong type of material", fred.getMaterial() instanceof Newspaper);
            assertTrue("Fred has the wrong material", fred.getMaterial().getName().equals("Daily Mail"));
            Reader pam = (Reader) pm.getObjectById(pamId, true);
            assertTrue("Pam has the wrong name", pam.getName().equals("Pam Green"));
            assertTrue("Pam has the wrong type of material", pam.getMaterial() instanceof Magazine);
            assertTrue("Pam has the wrong material", pam.getMaterial().getName().equals("Hello"));
            tx.commit();
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
        // Check a query
        pm = pmf.getPersistenceManager();
        tx = pm.currentTransaction();
        try {
            tx.begin();
            Query q1 = pm.newQuery(Reader.class, "((org.jpox.samples.one_one.unidir_2.Magazine)material).name == \"Hello\"");
            List results1 = (List) q1.execute();
            assertEquals("Number of readers who read \"Hello\" magazine was incorrect", results1.size(), 1);
            Query q2 = pm.newQuery(Reader.class, "((org.jpox.samples.one_one.unidir_2.Newspaper)material).name == \"Daily Mail\"");
            List results2 = (List) q2.execute();
            assertEquals("Number of readers who read \"Daily Mail\" newspaper was incorrect", results2.size(), 1);
            tx.commit();
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
            pm.close();
        }
    } finally {
        // Clean out all data
        clean(Reader.class);
        clean(Newspaper.class);
        clean(Magazine.class);
    }
}

Example 49 with Reader

use of io.swagger.v3.jaxrs2.Reader in project swagger-core by swagger-api.

the class GenericOpenApiContext method buildReader.

protected OpenApiReader buildReader(final OpenAPIConfiguration openApiConfiguration) throws Exception {
    OpenApiReader reader;
    if (StringUtils.isNotBlank(openApiConfiguration.getReaderClass())) {
        Class cls = getClass().getClassLoader().loadClass(openApiConfiguration.getReaderClass());
        reader = (OpenApiReader) cls.newInstance();
    } else {
        reader = new OpenApiReader() {

            OpenAPIConfiguration openApiConfiguration;

            @Override
            public void setConfiguration(OpenAPIConfiguration openApiConfiguration) {
                this.openApiConfiguration = openApiConfiguration;
            }

            @Override
            public OpenAPI read(Set<Class<?>> classes, Map<String, Object> resources) {
                return openApiConfiguration.getOpenAPI();
            }
        };
    }
    reader.setConfiguration(openApiConfiguration);
    return reader;
}

Example 50 with Reader

use of io.swagger.v3.jaxrs2.Reader in project swagger-core by swagger-api.

the class ReaderTest method testCompleteReadClass.

@Test(description = "scan methods")
public void testCompleteReadClass() {
    Reader reader = new Reader(new OpenAPI());
    OpenAPI openAPI = reader.read(CompleteFieldsResource.class);
    Paths paths = openAPI.getPaths();
    assertEquals(PATHS_NUMBER, paths.size());
    PathItem pathItem = paths.get(PATH_REF);
    assertNotNull(pathItem);
    assertNull(pathItem.getPost());
    Operation operation = pathItem.getGet();
    assertNotNull(operation);
    assertEquals(OPERATION_SUMMARY, operation.getSummary());
    assertEquals(OPERATION_DESCRIPTION, operation.getDescription());
    assertEquals(TAG_NUMBER, operation.getTags().size());
    assertEquals(EXAMPLE_TAG, operation.getTags().get(0));
    assertEquals(SECOND_TAG, operation.getTags().get(1));
    ExternalDocumentation externalDocs = operation.getExternalDocs();
    assertEquals(EXTERNAL_DOCS_DESCRIPTION, externalDocs.getDescription());
    assertEquals(EXTERNAL_DOCS_URL, externalDocs.getUrl());
}