coze-go/enterprises_members_test.go at main · coze-dev/coze-go · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package coze

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestEnterprisesMembers(t *testing.T) {
	as := assert.New(t)

	t.Run("create", func(t *testing.T) {
		t.Run("success", func(t *testing.T) {
			enterpriseID := randomString(10)
			members := newEnterprisesMembers(newCoreWithTransport(newMockTransport(func(req *http.Request) (*http.Response, error) {
				as.Equal(http.MethodPost, req.Method)
				as.Equal(fmt.Sprintf("/v1/enterprises/%s/members", enterpriseID), req.URL.Path)
				return mockResponse(http.StatusOK, &createEnterpriseMemberResp{
					Data: &CreateEnterpriseMemberResp{},
				})
			})))
			resp, err := members.Create(context.Background(), &CreateEnterpriseMemberReq{
				EnterpriseID: enterpriseID,
				Users: []*EnterpriseMember{
					{
						UserID: "user1",
						Role:   EnterpriseMemberRoleMember,
					},
					{
						UserID: "user2",
						Role:   EnterpriseMemberRoleAdmin,
					},
				},
			})
			as.Nil(err)
			as.NotNil(resp)
			as.NotEmpty(resp.Response().LogID())
		})

		t.Run("error", func(t *testing.T) {
			enterpriseID := randomString(10)
			members := newEnterprisesMembers(newCoreWithTransport(newMockTransport(func(req *http.Request) (*http.Response, error) {
				return nil, errors.New("test error")
			})))
			_, err := members.Create(context.Background(), &CreateEnterpriseMemberReq{
				EnterpriseID: enterpriseID,
				Users: []*EnterpriseMember{
					{
						UserID: "user1",
						Role:   EnterpriseMemberRoleMember,
					},
				},
			})
			as.NotNil(err)
			as.Contains(err.Error(), "test error")
		})
	})

	t.Run("delete", func(t *testing.T) {
		t.Run("success", func(t *testing.T) {
			enterpriseID := randomString(10)
			userID := randomString(10)
			receiverUserID := randomString(10)
			members := newEnterprisesMembers(newCoreWithTransport(newMockTransport(func(req *http.Request) (*http.Response, error) {
				as.Equal(http.MethodDelete, req.Method)
				as.Equal(fmt.Sprintf("/v1/enterprises/%s/members/%s", enterpriseID, userID), req.URL.Path)
				return mockResponse(http.StatusOK, &deleteEnterpriseMemberResp{
					Data: &DeleteEnterpriseMemberResp{},
				})
			})))
			resp, err := members.Delete(context.Background(), &DeleteEnterpriseMemberReq{
				EnterpriseID:   enterpriseID,
				UserID:         userID,
				ReceiverUserID: receiverUserID,
			})
			as.Nil(err)
			as.NotNil(resp)
			as.NotEmpty(resp.Response().LogID())
		})

		t.Run("error", func(t *testing.T) {
			enterpriseID := randomString(10)
			userID := randomString(10)
			receiverUserID := randomString(10)
			members := newEnterprisesMembers(newCoreWithTransport(newMockTransport(func(req *http.Request) (*http.Response, error) {
				return nil, errors.New("test error")
			})))
			_, err := members.Delete(context.Background(), &DeleteEnterpriseMemberReq{
				EnterpriseID:   enterpriseID,
				UserID:         userID,
				ReceiverUserID: receiverUserID,
			})
			as.NotNil(err)
			as.Contains(err.Error(), "test error")
		})
	})

	t.Run("update", func(t *testing.T) {
		t.Run("success", func(t *testing.T) {
			enterpriseID := randomString(10)
			userID := randomString(10)
			members := newEnterprisesMembers(newCoreWithTransport(newMockTransport(func(req *http.Request) (*http.Response, error) {
				as.Equal(http.MethodPut, req.Method)
				as.Equal(fmt.Sprintf("/v1/enterprises/%s/members/%s", enterpriseID, userID), req.URL.Path)
				return mockResponse(http.StatusOK, &updateEnterpriseMemberResp{
					Data: &UpdateEnterpriseMemberResp{},
				})
			})))
			resp, err := members.Update(context.Background(), &UpdateEnterpriseMemberReq{
				EnterpriseID: enterpriseID,
				UserID:       userID,
				Role:         EnterpriseMemberRoleAdmin,
			})
			as.Nil(err)
			as.NotNil(resp)
			as.NotEmpty(resp.Response().LogID())
		})

		t.Run("error", func(t *testing.T) {
			enterpriseID := randomString(10)
			userID := randomString(10)
			members := newEnterprisesMembers(newCoreWithTransport(newMockTransport(func(req *http.Request) (*http.Response, error) {
				return nil, errors.New("test error")
			})))
			_, err := members.Update(context.Background(), &UpdateEnterpriseMemberReq{
				EnterpriseID: enterpriseID,
				UserID:       userID,
				Role:         EnterpriseMemberRoleAdmin,
			})
			as.NotNil(err)
			as.Contains(err.Error(), "test error")
		})
	})
}

func TestEnterpriseMemberRole(t *testing.T) {
	as := assert.New(t)
	t.Run("constants", func(t *testing.T) {
		as.Equal("enterprise_admin", string(EnterpriseMemberRoleAdmin))
		as.Equal("enterprise_member", string(EnterpriseMemberRoleMember))
	})
}