freemarker.default.ftl Maven / Gradle / Ivy




    
    ${testOutcome.unqualified.title}
    <#include "libraries/favicon.ftl">

    <#include "libraries/common.ftl">
    <#include "libraries/jquery-ui.ftl">
    <#include "libraries/datatables.ftl">
    <#include "libraries/imgpreview.ftl">
    <#include "components/report-data.ftl">





<#include "components/stacktrace.ftl">


    
        
        
            
                ${reportOptions.projectName}
                ${reportOptions.projectSubTitle}
            
        
    


<#-- HEADER -->

    
        
        
            Home

        <#list breadcrumbs as breadcrumb>
            <#assign breadcrumbReport = absoluteReportName.forRequirement(breadcrumb) />
            <#assign breadcrumbTitle = inflection.of(breadcrumb.shortName).asATitle() >
            > ${formatter.htmlCompatibleStoryTitle(breadcrumbTitle)}
        
        > ${formatter.htmlCompatibleTestTitle(formatter.renderTitle(testOutcome.title))}
        
        
        
    

    

    
    <#include "menu.ftl">
    <@main_menu selected="home" />
    

    <#if testOutcome.result == "FAILURE"><#assign outcome_text = "failing-color">
    <#elseif testOutcome.result == "ERROR"><#assign outcome_text = "error-color">
    <#elseif testOutcome.result == "SUCCESS"><#assign outcome_text = "success-color">
    <#elseif testOutcome.result == "PENDING"><#assign outcome_text = "pending-color">
    <#elseif testOutcome.result == "COMPROMISED"><#assign outcome_text = "compromised-color">
    <#else><#assign outcome_text = "ignore-color">
    

    <#assign title_outcome_icon =  formatter.resultIcon().inLarge().forResult(testOutcome.result) />

    <#-- TEST TITLE -->
    
        
            
                
                    
                        
                            <#if (parentRequirement?? && parentRequirement.isPresent())>
                                
                                    <#assign parentTitle = formatter.renderDescription(inflection.of(parentRequirement.get().name).asATitle()) >
                                    <#assign parentType = inflection.of(parentRequirement.get().type).asATitle() >
                                    <#if (parentRequirement.get().cardNumber?has_content) >
                                        <#assign issueNumber = "[" + reportFormatter.addLinks(parentRequirement.get().cardNumber) + "]" >
                                    <#else>
                                        <#assign issueNumber = "">
                                    
                                    
                                        
                                        ${parentTitle} ${issueNumber}
                                    

                                    <#-- -->
                                    <#-- ${formatter.renderDescription(parentRequirement.get().narrative.renderedTextWithoutTables)}-->
                                    <#-- -->
                                
                            <#elseif (featureOrStory?? && featureOrStory.isPresent())>
                                
                                    <#assign parentTitle = inflection.of(featureOrStory.get().name).asATitle() >
                                    <#assign parentType = inflection.of(featureOrStory.get().type).asATitle() >
                                    
                                        
                                        ${parentTitle}
                                    
                                    <#if showDetailedStoryDescription!false>
                                        
                                            ${formatter.renderDescription(featureOrStory.get().narrativeSummary)}
                                        
                                    
                                
                            

                            <#if (testOutcome.backgroundTitle?has_content)>
                                Background: ${testOutcome.backgroundTitle}
                                    <#if (testOutcome.backgroundTitle?has_content)>
                                        ${testOutcome.backgroundDescription}
                                    
                                
                            
                        
                        
                            <#list filteredTags as tag>
                                <#assign tagReport = absoluteReportName.forRequirementOrTag(tag) />
                                <#assign tagTitle = tagInflector.ofTag(tag.type, tag.shortName).toFinalView() >
                                
                                    <#assign tagStyle = styling.tagStyleFor(tag) >
                                    
                                     ${formatter.htmlCompatible(tagTitle)}
                                    (${tag.type})
                                
                                
                            
                        
                    
                
            
            
                
                        <#if (testOutcome.videoLink)??>
                        
                        
                        <#if (testOutcome.externalLink)?? && (testOutcome.externalLink.url)??>
                            
                    
                        
                            ${title_outcome_icon}
                            
                                <#assign testOutcomeTitle = testOutcome.unqualified.titleWithLinks >
                                
                                    ${formatter.htmlCompatibleTestTitle(formatter.renderTitle(testOutcomeTitle))}
                                    <#if (!testOutcome.titleWithIssues)>
                                        ${testOutcome.formattedIssues}
                                    
                                
                            
                            <#if (testOutcome.manual)>

                                <#if (testOutcome.lastTested?? && testOutcome.manualTestingUpToDate)>
                                <#-- Last tested and up to date-->
                                    
                                        
                                             Last tested version: ${testOutcome.lastTested}
                                        
                                        <#if (testOutcome.manualTestEvidence?has_content)>
                                            

                                            <#list testOutcome.renderedManualTestEvidence as manualEvidence>
                                                
                                                
                                                     ${manualEvidence.label}
                                                
                                                
                                            
                                        
                                    

                                <#elseif (testOutcome.lastTested??)>
                                <#-- Last tested out of date-->
                                    
                                        
                                             Awaiting new manual test. Last tested version: ${testOutcome.lastTested}
                                        <#if (testOutcome.manualTestEvidence?has_content)>
                                            

                                            <#list testOutcome.renderedManualTestEvidence as manualEvidence>
                                                
                                                    
                                                         Test Evidence for previous test
                                                    
                                                
                                            
                                        
                                    
                                <#else>
                                <#-- No last tested version specified -->
                                    
                                
                            

                            <#list testOutcome.flags as flag>
                                
                            
                            <#if (testOutcome.descriptionText.isPresent() && testOutcome.descriptionText.get()?has_content)>
                                
                                    

                                    ${formatter.renderDescription(testOutcome.descriptionText.get())}
                                
                            
                        
                            
                        
                                
                                    
                                
                            
                        
                    
                
            

            <#if (testOutcome.actors?has_content)>
                <#assign castSize = testOutcome.actors?size>
                <#assign cellWidth = 100 / castSize>

                
                 
                
                    
                        
                            
                                
                                    
                                        
                                        
                                            Cast
                                        
                                    

                                    
                                        
                                                <#list testOutcome.actors as castMember>
                                                    
                                            
                                                        
                                                             ${castMember.name}
                                                            

                                                                ${formatter.renderDescription(castMember.description!"")}
                                                                
                                                                    <#if (castMember.hasFacts())>
                                                                        ${castMember.name} has:
                                                                            
                                                                                <#list castMember.getHas() as fact>
                                                                                    ${fact}
                                                                                
                                                                            
                                                                        
                                                                    
                                                                    <#if (castMember.hasAbilities())>
                                                                        ${castMember.name} can:
                                                                            
                                                                                <#list castMember.can as ability>
                                                                                    ${ability}
                                                                                
                                                                            
                                                                        
                                                                    
                                                                
                                                    
                                                
                                            
                                        
                                    
                                
                            
                        
                    
                
                
            


        
    

    

    <#if (testOutcome.isDataDriven() && testOutcome.dataDrivenSampleScenario?has_content)>
        
            Scenario Outline

            ${formatter.formatWithFields(testOutcome.dataDrivenSampleScenario)}

        
    

    

    <#if (testOutcome.isDataDriven())>

        <#list testOutcome.dataTable.dataSets as dataSet >
            Examples:<#if dataSet.name??> ${dataSet.name}
            <#if dataSet.description??>
                ${dataSet.description}
            

            <#if dataSet.tags??>

                
                    <#list dataSet.tags as exampleTag>
                        <#assign exampleTagReport = absoluteReportName.forRequirementOrTag(exampleTag) />
                        <#assign exampleTagTitle = inflection.of(exampleTag.shortName).asATitle() >
                        <#assign tagStyle = styling.tagStyleFor(tag) >
                        
                     ${formatter.htmlCompatible(exampleTagTitle)}
                    (${exampleTag.type})
                
                    
                
            

            
                
                        <#list testOutcome.dataTable.headers as header>
                            
                    <#assign rowIndex = dataSet.startRow >
                    <#list dataSet.rows as row>
                        
                            <#list row.values as value>
                                <#if testOutcome.manual>
                                    <#assign roeResult = testOutcome.result/>
                                <#else>
                                    <#assign roeResult = row.result/>
                                
                                
                        <#assign rowIndex = rowIndex + 1 >
                    
                    
                    
                    
                        # ${inflection.of(header).asATitle()}
                        
                    
                    
                    
                            ${rowIndex + 1} ${formatter.plainHtmlCompatible(value)}
                                
                            
                        
                
            
        
    

    
        
            
                <#-- TABLE HEADER -->
                

                    <#if testOutcome.hasScreenshots()>
                        

                <#-- STEPS BREAKDOWN-->
                <#assign level = 1>
                <#assign screenshotCount = 0>
                <#macro write_step(step, step_number)>
                    <@step_details step=step step_number=step_number level=level/>
                    <#if step.isAGroup()>
                        
                    
                

                <#macro restQueryData(restQuery, number) >
                    
                        
                    
                        
                            
                                
                                    Response
                                    <#if restQuery.path?has_content>
                                        URL: ${restQuery.path}
                                    
                                    <#if restQuery.statusCode?has_content>
                                        Status code: ${restQuery.statusCode}
                                    
                                    <#if restQuery.contentType?has_content>
                                        Content Type: ${restQuery.contentType}
                                    
                                    <#if restQuery.requestHeaders?has_content>
                                        Request Headers
                                        ${(formatter.renderHeaders(restQuery.requestHeaders))!}
                                    
                                    <#if restQuery.content?has_content>
                                        Content Body
                                        ${(formatter.renderText(restQuery.content))!}
                                    
                                    <#if restQuery.requestCookies?has_content>
                                        Request Cookies
                                        ${(formatter.renderText(restQuery.requestCookies))!}
                                    
                                    <#if restQuery.responseHeaders?has_content>
                                        Response Headers
                                        ${(formatter.renderHeaders(restQuery.responseHeaders))!}
                                    
                                    Response Body
                                    <#if restQuery.responseHeaders?has_content>
                                        ${formatter.renderText(restQuery.responseBody)}
                                    
                                    <#if restQuery.responseCookies?has_content && (!(restQuery.requestCookies?has_content) || restQuery.responseCookies!=restQuery.requestCookies)>
                                        Response Cookies
                                        ${(formatter.renderText(restQuery.responseCookies))!}
                                    
                                
                            
                        
                    
                

                <#macro step_details(step, step_number, level)>
                    <#assign step_outcome_icon = formatter.resultIcon().forResult(step.result) />
                    <#assign step_outcome_style = formatter.resultIcon().colorFor(step.result) />
                    <#assign step_icon_size = 20>
                    <#if (level>1)>
                        <#if step.isAGroup()>
                            <#assign step_class_root = "nested">
                        <#else>
                            <#assign step_class_root = "nested-group">
                        
                    <#else>
                        <#assign step_class_root = "top-level">
                    
                    <#assign step_indent = level*20>
                    <#if step.isAGroup()>
                        <#assign showAccordion = true/>
                    <#else>
                        <#assign showAccordion = false/>
                    
                    

                        <#-- ICON -->
                        

                        <#-- DESCRIPTION -->
                        

                        <#-- SCREENSHOTS -->
                        <#if testOutcome.hasScreenshots()>
                            
                        
                        <#-- OUTCOME & TIME -->
                        
                    <#if (step.errorMessage?has_content) && !step.hasNestedErrors()>
                        
                            <#if step.errorMessage?has_content>
                                <#assign errorMessageTitle = step.errorMessage?html>
                            <#else>
                                <#assign errorMessageTitle = "">
                            
                            <#if testOutcome.hasScreenshots()>
                            
                    
                

                <#-- Test step results -->
                <#list testOutcome.testSteps as step>
                    <@write_step step=step step_number=step_index />
                
                <#if testOutcome.hasNonStepFailure()>
                    <#assign step_outcome_icon = formatter.resultIcon().forResult(testOutcome.result) />
                    
                        <#if testOutcome.hasScreenshots()>
                        
                        <#if testOutcome.hasScreenshots()>
                        
                    <#if testOutcome.hasScreenshots()>
                        
                    <#else>
                        
                    
                        <#if (testOutcome.manual)>
                            
                        
                    
                    <#if (testOutcome.manual)>Manual 
                        Steps
                    Screenshots
                    
                    Outcome
                    
                
                
                    
                

                            
                                
                                    <#assign level = level + 1>
                                    <#list step.children as nestedStep>
                                        <#if step.isAGroup() >
                                            <@write_step step=nestedStep step_number=step_number + "-" + nestedStep_index/>
                                        
                                    
                                    <#assign level = level-1>
                                    <#assign screenshotCount = screenshotCount + step.screenshotCount>

                                
                            
                        
                    
                    
                            <#if step_number?has_content>
                            <#if showAccordion>
                                
                                    <#--${step_outcome_icon}-->
                                    
                                    <#--
                                    <#--style="margin-left: 20px; float:left;  padding-right:5px"/>-->
                                
                            <#else>
                                ${step_outcome_icon}
                                
                            <#--
                            <#--src="images/${step_outcome_icon}" class="${step_class_root}-icon"/>-->
                            
                        
                            
                                <#if showAccordion>
                                
                                    
                                    
                                            <#if step.hasRestQuery()>
                                                ${formatter.restQuery(step.description)}
                                            <#else>
                                                ${formatter.formatWithFields(step.description)}
                                            
                                        
                                    <#if showAccordion>
                                
                                
                                
                                    <#if step.hasRestQuery()>
                                        
                                            <#assign restDataNumber = "REST-${step.number}">
                                            <@restQueryData restQuery=step.restQuery number=restDataNumber />
                                        
                                    
                                    <#if step.hasData()>
                                        <#list step.reportData as recordedData>
                                            <#assign stepIndex=recordedData?index>
                                            <#assign restDataNumber = "EVIDENCE-${step.number}-${stepIndex}">
                                            
                                                <@reportData reportData=recordedData number=restDataNumber />
                                            
                                        
                                    
                                
                                <#if (step.externalLink)?? && (step.externalLink.url)??>
                                    
                                        
                                    
                                
                            
                        
                                <#if step.hasMultipleScreenshots() >
                                    
                                        
                                    
                                    
                                

                                <#if step.latestScreenshot?has_content>
                                    <#assign actualScreenshotCount = screenshotCount + step.actualScreenshotCount />
                                    
                                        
                                    
                                    <#if step.hasChildren()>
                                        <#assign screenshotCount = screenshotCount + 1 />
                                    <#else>
                                        <#assign screenshotCount = screenshotCount + step.screenshotCount />
                                    
                                
                            ${step.result}
                        ${step.formattedDuration}
                    

                              
                                <#else>
                            
                                

                                <#assign formattedErrorMessageTitle = formatter.htmlAttributeCompatible(errorMessageTitle, true) />

                                <#if step.nestedException?has_content>
                                    <@stacktrace title=formattedErrorMessageTitle cause=step.nestedException id=step.number />
                                <#else>
                                    
                                        ${formatter.htmlAttributeCompatible(errorMessageTitle,244)!''}
                                    
                                
                            
                        

                        ${step_outcome_icon} 
                            <#else>
                        
                            
                            <#if testOutcome.errorMessage?has_content>
                                ${testOutcome.errorMessage}
                            <#else>
                                An error occurred outside of step execution
                            
                        
                        ${formatter.htmlCompatibleStepDescription(testOutcome.result)}
                        
                        ${testOutcome.durationInSeconds}s
                    
                    
                          
                            <#else>
                        
                            
                            <#if (testOutcome.errorMessage)??>
                                <#if (testOutcome.nestedTestFailureCause)??>
                                    <#assign formattedErrorMessageTitle = formatter.htmlAttributeCompatible(testOutcome.errorMessage, true) />

                                    <@stacktrace title=formattedErrorMessageTitle cause=testOutcome.nestedTestFailureCause id="overall" />
                                
                            
                        
                    
                
                
                    
                    ${testOutcome.result}
                    ${testOutcome.durationInSeconds}s
                

            
        
    

    


    
        
            
                Serenity BDD version ${serenityVersionNumber!"SNAPSHOT-BUILD"}
            
        
    

    

    <#---->
freemarker.default.ftl Maven / Gradle / Ivy

${parentTitle} ${issueNumber}

${parentTitle}

Cast

${castMember.name}

${formatter.renderDescription(castMember.description!"")} <#if (castMember.hasFacts())> ${castMember.name} has: <#list castMember.getHas() as fact> ${fact} <#if (castMember.hasAbilities())> ${castMember.name} can: <#list castMember.can as ability> ${ability}

Scenario Outline

Examples:<#if dataSet.name??> ${dataSet.name}

Response

Request Headers

Content Body

Request Cookies

Response Headers

Response Body

Response Cookies

${formatter.renderDescription(castMember.description!"")}

<#if (castMember.hasFacts())>
${castMember.name} has:
<#list castMember.getHas() as fact>
${fact}

<#if (castMember.hasAbilities())>
${castMember.name} can:
<#list castMember.can as ability>
${ability}
