github.com/buildpacks/pack@v0.33.3-0.20240516162812-884dd1837311/internal/inspectimage/writer/factory_test.go (about)

     1  package writer_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/buildpacks/pack/internal/inspectimage/writer"
     8  
     9  	h "github.com/buildpacks/pack/testhelpers"
    10  
    11  	"github.com/heroku/color"
    12  	"github.com/sclevine/spec"
    13  	"github.com/sclevine/spec/report"
    14  )
    15  
    16  func TestFactory(t *testing.T) {
    17  	color.Disable(true)
    18  	defer color.Disable(false)
    19  	spec.Run(t, "Builder Writer Factory", testFactory, spec.Parallel(), spec.Report(report.Terminal{}))
    20  }
    21  
    22  func testFactory(t *testing.T, when spec.G, it spec.S) {
    23  	var assert = h.NewAssertionManager(t)
    24  
    25  	when("Writer", func() {
    26  		when("Not BOM", func() {
    27  			when("output format is human-readable", func() {
    28  				it("returns a HumanReadable writer", func() {
    29  					factory := writer.NewFactory()
    30  
    31  					returnedWriter, err := factory.Writer("human-readable", false)
    32  					assert.Nil(err)
    33  					_, ok := returnedWriter.(*writer.HumanReadable)
    34  					assert.TrueWithMessage(
    35  						ok,
    36  						fmt.Sprintf("expected %T to be assignable to type `*writer.HumanReadable`", returnedWriter),
    37  					)
    38  				})
    39  			})
    40  
    41  			when("output format is json", func() {
    42  				it("return a JSON writer", func() {
    43  					factory := writer.NewFactory()
    44  
    45  					returnedWriter, err := factory.Writer("json", false)
    46  					assert.Nil(err)
    47  
    48  					_, ok := returnedWriter.(*writer.JSON)
    49  					assert.TrueWithMessage(
    50  						ok,
    51  						fmt.Sprintf("expected %T to be assignable to type `*writer.JSON`", returnedWriter),
    52  					)
    53  				})
    54  			})
    55  
    56  			when("output format is yaml", func() {
    57  				it("return a YAML writer", func() {
    58  					factory := writer.NewFactory()
    59  
    60  					returnedWriter, err := factory.Writer("yaml", false)
    61  					assert.Nil(err)
    62  
    63  					_, ok := returnedWriter.(*writer.YAML)
    64  					assert.TrueWithMessage(
    65  						ok,
    66  						fmt.Sprintf("expected %T to be assignable to type `*writer.YAML`", returnedWriter),
    67  					)
    68  				})
    69  			})
    70  
    71  			when("output format is toml", func() {
    72  				it("return a TOML writer", func() {
    73  					factory := writer.NewFactory()
    74  
    75  					returnedWriter, err := factory.Writer("toml", false)
    76  					assert.Nil(err)
    77  
    78  					_, ok := returnedWriter.(*writer.TOML)
    79  					assert.TrueWithMessage(
    80  						ok,
    81  						fmt.Sprintf("expected %T to be assignable to type `*writer.TOML`", returnedWriter),
    82  					)
    83  				})
    84  			})
    85  
    86  			when("output format is not supported", func() {
    87  				it("returns an error", func() {
    88  					factory := writer.NewFactory()
    89  
    90  					_, err := factory.Writer("mind-beam", false)
    91  					assert.ErrorWithMessage(err, "output format 'mind-beam' is not supported")
    92  				})
    93  			})
    94  		})
    95  
    96  		when("BOM", func() {
    97  			when("output format is json", func() {
    98  				it("return a JSONBOM writer", func() {
    99  					factory := writer.NewFactory()
   100  
   101  					returnedWriter, err := factory.Writer("json", true)
   102  					assert.Nil(err)
   103  
   104  					_, ok := returnedWriter.(*writer.JSONBOM)
   105  					assert.TrueWithMessage(
   106  						ok,
   107  						fmt.Sprintf("expected %T to be assignable to type `*writer.JSON`", returnedWriter),
   108  					)
   109  				})
   110  			})
   111  
   112  			when("output format is yaml", func() {
   113  				it("return a YAMLBOM writer", func() {
   114  					factory := writer.NewFactory()
   115  
   116  					returnedWriter, err := factory.Writer("yaml", true)
   117  					assert.Nil(err)
   118  
   119  					_, ok := returnedWriter.(*writer.YAMLBOM)
   120  					assert.TrueWithMessage(
   121  						ok,
   122  						fmt.Sprintf("expected %T to be assignable to type `*writer.JSON`", returnedWriter),
   123  					)
   124  				})
   125  			})
   126  
   127  			when("error cases", func() {
   128  				when("output format is toml", func() {
   129  					it("return an error", func() {
   130  						factory := writer.NewFactory()
   131  
   132  						_, err := factory.Writer("toml", true)
   133  						assert.ErrorWithMessage(err, "output format 'toml' is not supported")
   134  					})
   135  				})
   136  
   137  				when("output format is not supported", func() {
   138  					it("returns an error", func() {
   139  						factory := writer.NewFactory()
   140  
   141  						_, err := factory.Writer("mind-BOM", true)
   142  						assert.ErrorWithMessage(err, "output format 'mind-BOM' is not supported")
   143  					})
   144  				})
   145  			})
   146  		})
   147  	})
   148  }