github.com/Datadog/cnab-go@v0.3.3-beta1.0.20191007143216-bba4b7e723d0/driver/docker/docker_integration_test.go (about)

     1  // +build integration
     2  
     3  package docker
     4  
     5  import (
     6  	"bytes"
     7  	"os"
     8  	"testing"
     9  
    10  	"github.com/deislabs/cnab-go/bundle"
    11  	"github.com/deislabs/cnab-go/bundle/definition"
    12  	"github.com/deislabs/cnab-go/driver"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  func TestDriver_Run(t *testing.T) {
    17  	imageFromEnv, ok := os.LookupEnv("DOCKER_INTEGRATION_TEST_IMAGE")
    18  	var image bundle.InvocationImage
    19  
    20  	if ok {
    21  		image = bundle.InvocationImage{
    22  			BaseImage: bundle.BaseImage{
    23  				Image: imageFromEnv,
    24  			},
    25  		}
    26  	} else {
    27  		image = bundle.InvocationImage{
    28  			BaseImage: bundle.BaseImage{
    29  				Image:  "pvtlmc/example-outputs",
    30  				Digest: "sha256:568461508c8d220742add8abd226b33534d4269868df4b3178fae1cba3818a6e",
    31  			},
    32  		}
    33  	}
    34  
    35  	op := &driver.Operation{
    36  		Installation: "example",
    37  		Action:       "install",
    38  		Image:        image,
    39  		Outputs:      []string{
    40  			"/cnab/app/outputs/output1",
    41  			"/cnab/app/outputs/output2",
    42  			"/cnab/app/outputs/missingApplicableOutputWithDefault",
    43  			"/cnab/app/outputs/missingNonApplicableOutputWithDefault",
    44  		},
    45  		Bundle: &bundle.Bundle{
    46  			Definitions: definition.Definitions{
    47  				"output1": &definition.Schema{},
    48  				"output2": &definition.Schema{},
    49  				"missingApplicableOutputWithDefault": &definition.Schema{
    50  					Default: "foo",
    51  				},
    52  				"missingNonApplicableOutputWithDefault": &definition.Schema{
    53  					Default: "bar",
    54  				},
    55  			},
    56  			Outputs: map[string]bundle.Output{
    57  				"output1": {
    58  					Definition: "output1",
    59  				},
    60  				"output2": {
    61  					Definition: "output2",
    62  				},
    63  				"missingApplicableOutputWithDefault": {
    64  					Definition: "missingApplicableOutputWithDefault",
    65  				},
    66  				"missingNonApplicableOutputWithDefault": {
    67  					Definition: "missingApplicableOutputWithDefault",
    68  					ApplyTo: []string{"upgrade"},
    69  				},
    70  			},
    71  		},
    72  	}
    73  
    74  	var output bytes.Buffer
    75  	op.Out = &output
    76  	op.Environment = map[string]string{
    77  		"CNAB_ACTION":            op.Action,
    78  		"CNAB_INSTALLATION_NAME": op.Installation,
    79  	}
    80  
    81  	docker := &Driver{}
    82  	docker.SetContainerOut(op.Out) // Docker driver writes container stdout to driver.containerOut.
    83  	opResult, err := docker.Run(op)
    84  
    85  	assert.NoError(t, err)
    86  	assert.Equal(t, "Install action\nAction install complete for example\n", output.String())
    87  	assert.Equal(t, 3, len(opResult.Outputs), "Expecting three output files")
    88  	assert.Equal(t, map[string]string{
    89  		"/cnab/app/outputs/output1": "SOME INSTALL CONTENT 1\n",
    90  		"/cnab/app/outputs/output2": "SOME INSTALL CONTENT 2\n",
    91  		"/cnab/app/outputs/missingApplicableOutputWithDefault": "foo",
    92  	}, opResult.Outputs)
    93  }
    94  
    95  func TestDriver_Run_MissingRequiredOutput(t *testing.T) {
    96  	imageFromEnv, ok := os.LookupEnv("DOCKER_INTEGRATION_TEST_IMAGE")
    97  	var image bundle.InvocationImage
    98  
    99  	if ok {
   100  		image = bundle.InvocationImage{
   101  			BaseImage: bundle.BaseImage{
   102  				Image: imageFromEnv,
   103  			},
   104  		}
   105  	} else {
   106  		image = bundle.InvocationImage{
   107  			BaseImage: bundle.BaseImage{
   108  				Image:  "pvtlmc/example-outputs",
   109  				Digest: "sha256:568461508c8d220742add8abd226b33534d4269868df4b3178fae1cba3818a6e",
   110  			},
   111  		}
   112  	}
   113  
   114  	op := &driver.Operation{
   115  		Installation: "example",
   116  		Action:       "install",
   117  		Image:        image,
   118  		Outputs:      []string{
   119  			"/cnab/app/outputs/missingApplicableOutputSansDefault",
   120  		},
   121  		Bundle: &bundle.Bundle{
   122  			Definitions: definition.Definitions{
   123  				"missingApplicableOutputSansDefault": &definition.Schema{},
   124  			},
   125  			Outputs: map[string]bundle.Output{
   126  				"missingApplicableOutputSansDefault": {
   127  					Definition: "missingApplicableOutputSansDefault",
   128  				},
   129  			},
   130  		},
   131  	}
   132  
   133  	var output bytes.Buffer
   134  	op.Out = &output
   135  	op.Environment = map[string]string{
   136  		"CNAB_ACTION":            op.Action,
   137  		"CNAB_INSTALLATION_NAME": op.Installation,
   138  	}
   139  
   140  	docker := &Driver{}
   141  	docker.SetContainerOut(op.Out) // Docker driver writes container stdout to driver.containerOut.
   142  	_, err := docker.Run(op)
   143  	assert.EqualError(t, err, "required output missingApplicableOutputSansDefault is missing and has no default")
   144  }