• Home
• net.serenity-bdd
• serenity-report-resources
• 2.0.55
• source code
• default.ftl

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

freemarker.default.ftl Maven / Gradle / Ivy

    
    
    <#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(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.renderedText)}
                                    
                                
                            <#elseif (featureOrStory?? && featureOrStory.isPresent())>
                                

                                    <#assign parentTitle = inflection.of(featureOrStory.get().name).asATitle() >
                                    <#assign parentType = inflection.of(featureOrStory.get().type).asATitle() >
                                    

                                        
                                        ${parentTitle}
                                    

                                    

                                        ${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 = inflection.of(tag.shortName).asATitle() >
                                

                                    <#assign tagStyle = styling.tagStyleFor(tag) >
                                    
                                     ${formatter.htmlCompatible(tagTitle)}
                                    (${tag.type})
                                
                                
                            
                        
                    
                
            
            

                
                        <#if (testOutcome.videoLink)??>
                            

                    

                        

                            ${title_outcome_icon}
                            
                                <#assign testOutcomeTitle = testOutcome.unqualified.titleWithLinks >
                                
                                    ${formatter.htmlCompatibleTestTitle(testOutcomeTitle)}
                                    <#if (!testOutcome.titleWithIssues)>
                                        ${testOutcome.formattedIssues}
                                    
                                
                            
                            <#if (testOutcome.manual)>
                                
                            
                            <#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>
                                
                        <#assign rowIndex = rowIndex + 1 >
                    

                    

                    

                        
#
${inflection.of(header).asATitle()}
                        
                    
                    
                    

                            
${rowIndex + 1}
${formatter.plainHtmlCompatible(value)}
                                
                            
                        

                    
                
            
        
    

    

        

            

                    <#if testOutcome.hasScreenshots()>
                        
                    <#else>
                        
                    <#if testOutcome.hasScreenshots()>
                        
                <#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()>
                <#if level == 1>
                

                    <#macro restQueryData(restQuery, number) >
                        
                    
                        REST Query
                    
                

                            

                                

                                    

                                        
Response
                                        <#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 level == 1 && step.isAGroup()>
                        <#assign showAccordion = true/>
                    <#else>
                        <#assign showAccordion = false/>
                    
                    <#if testOutcome.hasScreenshots()>
                        
                <#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
                        
<#if (testOutcome.manual)>Manual 
                            Steps
                        
                    
Screenshots
                    
                    
Outcome
                    

                
                

                    

                

                

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

                <#if level == 1>
                
                
                

                    
                    
                    
                        
                        
                    
                

                    

                        <#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 restDataNumber = "EVIDENCE-${step.number}-${recordedData?index}">
                                        
                                            <@reportData reportData=recordedData number=restDataNumber />
                                        
                                    
                                
                            
                        
                    

                            <#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.durationInSeconds}s
                

                        
 

                            <#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"}
            
        
    

    

    <#---->