github.com/hanks177/podman/v4@v4.1.3-0.20220613032544-16d90015bc83/test/e2e/secret_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"fmt"
     5  	"io/ioutil"
     6  	"os"
     7  	"path/filepath"
     8  
     9  	. "github.com/hanks177/podman/v4/test/utils"
    10  	. "github.com/onsi/ginkgo"
    11  	. "github.com/onsi/gomega"
    12  	. "github.com/onsi/gomega/gexec"
    13  )
    14  
    15  var _ = Describe("Podman secret", func() {
    16  	var (
    17  		tempdir    string
    18  		err        error
    19  		podmanTest *PodmanTestIntegration
    20  	)
    21  
    22  	BeforeEach(func() {
    23  		tempdir, err = CreateTempDirInTempDir()
    24  		if err != nil {
    25  			os.Exit(1)
    26  		}
    27  		podmanTest = PodmanTestCreate(tempdir)
    28  		podmanTest.Setup()
    29  	})
    30  
    31  	AfterEach(func() {
    32  		podmanTest.CleanupSecrets()
    33  		f := CurrentGinkgoTestDescription()
    34  		processTestResult(f)
    35  
    36  	})
    37  
    38  	It("podman secret create", func() {
    39  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
    40  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
    41  		Expect(err).To(BeNil())
    42  
    43  		session := podmanTest.Podman([]string{"secret", "create", "--driver-opts", "opt1=val", "a", secretFilePath})
    44  		session.WaitWithDefaultTimeout()
    45  		secrID := session.OutputToString()
    46  		Expect(session).Should(Exit(0))
    47  
    48  		inspect := podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.ID}}", secrID})
    49  		inspect.WaitWithDefaultTimeout()
    50  		Expect(inspect).Should(Exit(0))
    51  		Expect(inspect.OutputToString()).To(Equal(secrID))
    52  		inspect = podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.Spec.Driver.Options}}", secrID})
    53  		inspect.WaitWithDefaultTimeout()
    54  		Expect(inspect).Should(Exit(0))
    55  		Expect(inspect.OutputToString()).To(ContainSubstring("opt1:val"))
    56  	})
    57  
    58  	It("podman secret create bad name should fail", func() {
    59  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
    60  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
    61  		Expect(err).To(BeNil())
    62  
    63  		session := podmanTest.Podman([]string{"secret", "create", "?!", secretFilePath})
    64  		session.WaitWithDefaultTimeout()
    65  		Expect(session).To(ExitWithError())
    66  	})
    67  
    68  	It("podman secret inspect", func() {
    69  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
    70  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
    71  		Expect(err).To(BeNil())
    72  
    73  		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
    74  		session.WaitWithDefaultTimeout()
    75  		secrID := session.OutputToString()
    76  		Expect(session).Should(Exit(0))
    77  
    78  		inspect := podmanTest.Podman([]string{"secret", "inspect", secrID})
    79  		inspect.WaitWithDefaultTimeout()
    80  		Expect(inspect).Should(Exit(0))
    81  		Expect(inspect.OutputToString()).To(BeValidJSON())
    82  	})
    83  
    84  	It("podman secret inspect with --format", func() {
    85  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
    86  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
    87  		Expect(err).To(BeNil())
    88  
    89  		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
    90  		session.WaitWithDefaultTimeout()
    91  		secrID := session.OutputToString()
    92  		Expect(session).Should(Exit(0))
    93  
    94  		inspect := podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.ID}}", secrID})
    95  		inspect.WaitWithDefaultTimeout()
    96  		Expect(inspect).Should(Exit(0))
    97  		Expect(inspect.OutputToString()).To(Equal(secrID))
    98  	})
    99  
   100  	It("podman secret inspect multiple secrets", func() {
   101  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
   102  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
   103  		Expect(err).To(BeNil())
   104  
   105  		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
   106  		session.WaitWithDefaultTimeout()
   107  		secrID := session.OutputToString()
   108  		Expect(session).Should(Exit(0))
   109  
   110  		session2 := podmanTest.Podman([]string{"secret", "create", "b", secretFilePath})
   111  		session2.WaitWithDefaultTimeout()
   112  		secrID2 := session2.OutputToString()
   113  		Expect(session2).Should(Exit(0))
   114  
   115  		inspect := podmanTest.Podman([]string{"secret", "inspect", secrID, secrID2})
   116  		inspect.WaitWithDefaultTimeout()
   117  		Expect(inspect).Should(Exit(0))
   118  		Expect(inspect.OutputToString()).To(BeValidJSON())
   119  	})
   120  
   121  	It("podman secret inspect bogus", func() {
   122  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
   123  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
   124  		Expect(err).To(BeNil())
   125  
   126  		inspect := podmanTest.Podman([]string{"secret", "inspect", "bogus"})
   127  		inspect.WaitWithDefaultTimeout()
   128  		Expect(inspect).To(ExitWithError())
   129  
   130  	})
   131  
   132  	It("podman secret ls", func() {
   133  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
   134  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
   135  		Expect(err).To(BeNil())
   136  
   137  		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
   138  		session.WaitWithDefaultTimeout()
   139  		Expect(session).Should(Exit(0))
   140  
   141  		list := podmanTest.Podman([]string{"secret", "ls"})
   142  		list.WaitWithDefaultTimeout()
   143  		Expect(list).Should(Exit(0))
   144  		Expect(list.OutputToStringArray()).To(HaveLen(2))
   145  
   146  	})
   147  
   148  	It("podman secret ls with filters", func() {
   149  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
   150  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
   151  		Expect(err).To(BeNil())
   152  
   153  		secret1 := "Secret1"
   154  		secret2 := "Secret2"
   155  
   156  		session := podmanTest.Podman([]string{"secret", "create", secret1, secretFilePath})
   157  		session.WaitWithDefaultTimeout()
   158  		secrID1 := session.OutputToString()
   159  		Expect(session).Should(Exit(0))
   160  
   161  		session = podmanTest.Podman([]string{"secret", "create", secret2, secretFilePath})
   162  		session.WaitWithDefaultTimeout()
   163  		secrID2 := session.OutputToString()
   164  		Expect(session).Should(Exit(0))
   165  
   166  		session = podmanTest.Podman([]string{"secret", "create", "Secret3", secretFilePath})
   167  		session.WaitWithDefaultTimeout()
   168  		Expect(session).Should(Exit(0))
   169  
   170  		list := podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("name=%s", secret1)})
   171  		list.WaitWithDefaultTimeout()
   172  		Expect(list).Should(Exit(0))
   173  		Expect(list.OutputToStringArray()).To(HaveLen(2), ContainSubstring(secret1))
   174  
   175  		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("name=%s", secret2)})
   176  		list.WaitWithDefaultTimeout()
   177  		Expect(list).Should(Exit(0))
   178  		Expect(list.OutputToStringArray()).To(HaveLen(2), ContainSubstring(secret2))
   179  
   180  		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("id=%s", secrID1)})
   181  		list.WaitWithDefaultTimeout()
   182  		Expect(list).Should(Exit(0))
   183  		Expect(list.OutputToStringArray()).To(HaveLen(2), ContainSubstring(secrID1))
   184  
   185  		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("id=%s", secrID2)})
   186  		list.WaitWithDefaultTimeout()
   187  		Expect(list).Should(Exit(0))
   188  		Expect(list.OutputToStringArray()).To(HaveLen(2), ContainSubstring(secrID2))
   189  
   190  		list = podmanTest.Podman([]string{"secret", "ls", "--filter", fmt.Sprintf("name=%s,name=%s", secret1, secret2)})
   191  		list.WaitWithDefaultTimeout()
   192  		Expect(list).Should(Exit(0))
   193  		Expect(list.OutputToStringArray()).To(HaveLen(3), ContainSubstring(secret1), ContainSubstring(secret2))
   194  	})
   195  
   196  	It("podman secret ls with Go template", func() {
   197  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
   198  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
   199  		Expect(err).To(BeNil())
   200  
   201  		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
   202  		session.WaitWithDefaultTimeout()
   203  		Expect(session).Should(Exit(0))
   204  
   205  		list := podmanTest.Podman([]string{"secret", "ls", "--format", "table {{.Name}}"})
   206  		list.WaitWithDefaultTimeout()
   207  
   208  		Expect(list).Should(Exit(0))
   209  		Expect(list.OutputToStringArray()).To(HaveLen(2), list.OutputToString())
   210  	})
   211  
   212  	It("podman secret rm", func() {
   213  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
   214  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
   215  		Expect(err).To(BeNil())
   216  
   217  		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
   218  		session.WaitWithDefaultTimeout()
   219  		secrID := session.OutputToString()
   220  		Expect(session).Should(Exit(0))
   221  
   222  		removed := podmanTest.Podman([]string{"secret", "rm", "a"})
   223  		removed.WaitWithDefaultTimeout()
   224  		Expect(removed).Should(Exit(0))
   225  		Expect(removed.OutputToString()).To(Equal(secrID))
   226  
   227  		session = podmanTest.Podman([]string{"secret", "ls"})
   228  		session.WaitWithDefaultTimeout()
   229  		Expect(session).Should(Exit(0))
   230  		Expect(session.OutputToStringArray()).To(HaveLen(1))
   231  	})
   232  
   233  	It("podman secret rm --all", func() {
   234  		secretFilePath := filepath.Join(podmanTest.TempDir, "secret")
   235  		err := ioutil.WriteFile(secretFilePath, []byte("mysecret"), 0755)
   236  		Expect(err).To(BeNil())
   237  
   238  		session := podmanTest.Podman([]string{"secret", "create", "a", secretFilePath})
   239  		session.WaitWithDefaultTimeout()
   240  		Expect(session).Should(Exit(0))
   241  		session = podmanTest.Podman([]string{"secret", "create", "b", secretFilePath})
   242  		session.WaitWithDefaultTimeout()
   243  		Expect(session).Should(Exit(0))
   244  
   245  		removed := podmanTest.Podman([]string{"secret", "rm", "-a"})
   246  		removed.WaitWithDefaultTimeout()
   247  		Expect(removed).Should(Exit(0))
   248  
   249  		session = podmanTest.Podman([]string{"secret", "ls"})
   250  		session.WaitWithDefaultTimeout()
   251  		Expect(session).Should(Exit(0))
   252  		Expect(session.OutputToStringArray()).To(HaveLen(1))
   253  	})
   254  
   255  	It("podman secret creates from environment variable", func() {
   256  		// no env variable set, should fail
   257  		session := podmanTest.Podman([]string{"secret", "create", "--env", "a", "MYENVVAR"})
   258  		session.WaitWithDefaultTimeout()
   259  		Expect(session).To(ExitWithError())
   260  
   261  		os.Setenv("MYENVVAR", "somedata")
   262  		if IsRemote() {
   263  			podmanTest.RestartRemoteService()
   264  		}
   265  
   266  		session = podmanTest.Podman([]string{"secret", "create", "--env", "a", "MYENVVAR"})
   267  		session.WaitWithDefaultTimeout()
   268  		secrID := session.OutputToString()
   269  		Expect(session).Should(Exit(0))
   270  
   271  		inspect := podmanTest.Podman([]string{"secret", "inspect", "--format", "{{.ID}}", secrID})
   272  		inspect.WaitWithDefaultTimeout()
   273  		Expect(inspect).Should(Exit(0))
   274  		Expect(inspect.OutputToString()).To(Equal(secrID))
   275  	})
   276  
   277  })