podman

1
package bindings_test
2

3
import (
4
	"context"
5
	"net/http"
6
	"strings"
7
	"time"
8

9
	"github.com/containers/podman/v5/pkg/bindings"
10
	"github.com/containers/podman/v5/pkg/bindings/secrets"
11
	. "github.com/onsi/ginkgo/v2"
12
	. "github.com/onsi/gomega"
13
	"github.com/onsi/gomega/gexec"
14
)
15

16
var _ = Describe("Podman secrets", func() {
17
	var (
18
		bt       *bindingTest
19
		s        *gexec.Session
20
		connText context.Context
21
		err      error
22
	)
23

24
	BeforeEach(func() {
25
		bt = newBindingTest()
26
		bt.RestoreImagesFromCache()
27
		s = bt.startAPIService()
28
		time.Sleep(1 * time.Second)
29
		connText, err = bindings.NewConnection(context.Background(), bt.sock)
30
		Expect(err).ToNot(HaveOccurred())
31
	})
32

33
	AfterEach(func() {
34

35
		s.Kill()
36
		bt.cleanup()
37
	})
38

39
	It("create secret", func() {
40
		r := strings.NewReader("mysecret")
41
		name := "mysecret"
42
		opts := &secrets.CreateOptions{
43
			Name: &name,
44
		}
45
		_, err := secrets.Create(connText, r, opts)
46
		Expect(err).ToNot(HaveOccurred())
47

48
		// should not be allowed to create duplicate secret name
49
		_, err = secrets.Create(connText, r, opts)
50
		Expect(err).To(HaveOccurred())
51
	})
52

53
	It("inspect secret", func() {
54
		r := strings.NewReader("mysecret")
55
		name := "mysecret"
56
		opts := &secrets.CreateOptions{
57
			Name: &name,
58
		}
59
		_, err := secrets.Create(connText, r, opts)
60
		Expect(err).ToNot(HaveOccurred())
61

62
		data, err := secrets.Inspect(connText, name, nil)
63
		Expect(err).ToNot(HaveOccurred())
64
		Expect(data.Spec.Name).To(Equal(name))
65

66
		// inspecting non-existent secret should fail
67
		_, err = secrets.Inspect(connText, "notasecret", nil)
68
		code, _ := bindings.CheckResponseCode(err)
69
		Expect(code).To(BeNumerically("==", http.StatusNotFound))
70
	})
71

72
	It("list secret", func() {
73
		r := strings.NewReader("mysecret")
74
		name := "mysecret"
75
		opts := &secrets.CreateOptions{
76
			Name: &name,
77
		}
78
		_, err := secrets.Create(connText, r, opts)
79
		Expect(err).ToNot(HaveOccurred())
80

81
		data, err := secrets.List(connText, nil)
82
		Expect(err).ToNot(HaveOccurred())
83
		Expect(data[0].Spec.Name).To(Equal(name))
84
	})
85

86
	It("list multiple secret", func() {
87
		r := strings.NewReader("mysecret")
88
		name := "mysecret"
89
		opts := &secrets.CreateOptions{
90
			Name: &name,
91
		}
92
		_, err := secrets.Create(connText, r, opts)
93
		Expect(err).ToNot(HaveOccurred())
94

95
		r2 := strings.NewReader("mysecret2")
96
		name2 := "mysecret2"
97
		opts2 := &secrets.CreateOptions{
98
			Name: &name2,
99
		}
100
		_, err = secrets.Create(connText, r2, opts2)
101
		Expect(err).ToNot(HaveOccurred())
102

103
		data, err := secrets.List(connText, nil)
104
		Expect(err).ToNot(HaveOccurred())
105
		Expect(data).To(HaveLen(2))
106
	})
107

108
	It("list no secrets", func() {
109
		data, err := secrets.List(connText, nil)
110
		Expect(err).ToNot(HaveOccurred())
111
		Expect(data).To(BeEmpty())
112
	})
113

114
	It("remove secret", func() {
115
		r := strings.NewReader("mysecret")
116
		name := "mysecret"
117
		opts := &secrets.CreateOptions{
118
			Name: &name,
119
		}
120
		_, err := secrets.Create(connText, r, opts)
121
		Expect(err).ToNot(HaveOccurred())
122

123
		err = secrets.Remove(connText, name)
124
		Expect(err).ToNot(HaveOccurred())
125

126
		// removing non-existent secret should fail
127
		err = secrets.Remove(connText, "nosecret")
128
		Expect(err).To(HaveOccurred())
129
		code, _ := bindings.CheckResponseCode(err)
130
		Expect(code).To(BeNumerically("==", http.StatusNotFound))
131
	})
132

133
})
134