1// Copyright 2019 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Code generated by gapic-generator. DO NOT EDIT.
16
17package oslogin
18
19import (
20	emptypb "github.com/golang/protobuf/ptypes/empty"
21	commonpb "google.golang.org/genproto/googleapis/cloud/oslogin/common"
22	osloginpb "google.golang.org/genproto/googleapis/cloud/oslogin/v1beta"
23)
24
25import (
26	"context"
27	"flag"
28	"fmt"
29	"io"
30	"log"
31	"net"
32	"os"
33	"strings"
34	"testing"
35
36	"github.com/golang/protobuf/proto"
37	"github.com/golang/protobuf/ptypes"
38	"google.golang.org/api/option"
39	status "google.golang.org/genproto/googleapis/rpc/status"
40	"google.golang.org/grpc"
41	"google.golang.org/grpc/codes"
42	"google.golang.org/grpc/metadata"
43	gstatus "google.golang.org/grpc/status"
44)
45
46var _ = io.EOF
47var _ = ptypes.MarshalAny
48var _ status.Status
49
50type mockOsLoginServer struct {
51	// Embed for forward compatibility.
52	// Tests will keep working if more methods are added
53	// in the future.
54	osloginpb.OsLoginServiceServer
55
56	reqs []proto.Message
57
58	// If set, all calls return this error.
59	err error
60
61	// responses to return if err == nil
62	resps []proto.Message
63}
64
65func (s *mockOsLoginServer) DeletePosixAccount(ctx context.Context, req *osloginpb.DeletePosixAccountRequest) (*emptypb.Empty, error) {
66	md, _ := metadata.FromIncomingContext(ctx)
67	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
68		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
69	}
70	s.reqs = append(s.reqs, req)
71	if s.err != nil {
72		return nil, s.err
73	}
74	return s.resps[0].(*emptypb.Empty), nil
75}
76
77func (s *mockOsLoginServer) DeleteSshPublicKey(ctx context.Context, req *osloginpb.DeleteSshPublicKeyRequest) (*emptypb.Empty, error) {
78	md, _ := metadata.FromIncomingContext(ctx)
79	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
80		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
81	}
82	s.reqs = append(s.reqs, req)
83	if s.err != nil {
84		return nil, s.err
85	}
86	return s.resps[0].(*emptypb.Empty), nil
87}
88
89func (s *mockOsLoginServer) GetLoginProfile(ctx context.Context, req *osloginpb.GetLoginProfileRequest) (*osloginpb.LoginProfile, error) {
90	md, _ := metadata.FromIncomingContext(ctx)
91	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
92		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
93	}
94	s.reqs = append(s.reqs, req)
95	if s.err != nil {
96		return nil, s.err
97	}
98	return s.resps[0].(*osloginpb.LoginProfile), nil
99}
100
101func (s *mockOsLoginServer) GetSshPublicKey(ctx context.Context, req *osloginpb.GetSshPublicKeyRequest) (*commonpb.SshPublicKey, error) {
102	md, _ := metadata.FromIncomingContext(ctx)
103	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
104		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
105	}
106	s.reqs = append(s.reqs, req)
107	if s.err != nil {
108		return nil, s.err
109	}
110	return s.resps[0].(*commonpb.SshPublicKey), nil
111}
112
113func (s *mockOsLoginServer) ImportSshPublicKey(ctx context.Context, req *osloginpb.ImportSshPublicKeyRequest) (*osloginpb.ImportSshPublicKeyResponse, error) {
114	md, _ := metadata.FromIncomingContext(ctx)
115	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
116		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
117	}
118	s.reqs = append(s.reqs, req)
119	if s.err != nil {
120		return nil, s.err
121	}
122	return s.resps[0].(*osloginpb.ImportSshPublicKeyResponse), nil
123}
124
125func (s *mockOsLoginServer) UpdateSshPublicKey(ctx context.Context, req *osloginpb.UpdateSshPublicKeyRequest) (*commonpb.SshPublicKey, error) {
126	md, _ := metadata.FromIncomingContext(ctx)
127	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
128		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
129	}
130	s.reqs = append(s.reqs, req)
131	if s.err != nil {
132		return nil, s.err
133	}
134	return s.resps[0].(*commonpb.SshPublicKey), nil
135}
136
137// clientOpt is the option tests should use to connect to the test server.
138// It is initialized by TestMain.
139var clientOpt option.ClientOption
140
141var (
142	mockOsLogin mockOsLoginServer
143)
144
145func TestMain(m *testing.M) {
146	flag.Parse()
147
148	serv := grpc.NewServer()
149	osloginpb.RegisterOsLoginServiceServer(serv, &mockOsLogin)
150
151	lis, err := net.Listen("tcp", "localhost:0")
152	if err != nil {
153		log.Fatal(err)
154	}
155	go serv.Serve(lis)
156
157	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
158	if err != nil {
159		log.Fatal(err)
160	}
161	clientOpt = option.WithGRPCConn(conn)
162
163	os.Exit(m.Run())
164}
165
166func TestOsLoginServiceDeletePosixAccount(t *testing.T) {
167	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
168
169	mockOsLogin.err = nil
170	mockOsLogin.reqs = nil
171
172	mockOsLogin.resps = append(mockOsLogin.resps[:0], expectedResponse)
173
174	var formattedName string = fmt.Sprintf("users/%s/projects/%s", "[USER]", "[PROJECT]")
175	var request = &osloginpb.DeletePosixAccountRequest{
176		Name: formattedName,
177	}
178
179	c, err := NewClient(context.Background(), clientOpt)
180	if err != nil {
181		t.Fatal(err)
182	}
183
184	err = c.DeletePosixAccount(context.Background(), request)
185
186	if err != nil {
187		t.Fatal(err)
188	}
189
190	if want, got := request, mockOsLogin.reqs[0]; !proto.Equal(want, got) {
191		t.Errorf("wrong request %q, want %q", got, want)
192	}
193
194}
195
196func TestOsLoginServiceDeletePosixAccountError(t *testing.T) {
197	errCode := codes.PermissionDenied
198	mockOsLogin.err = gstatus.Error(errCode, "test error")
199
200	var formattedName string = fmt.Sprintf("users/%s/projects/%s", "[USER]", "[PROJECT]")
201	var request = &osloginpb.DeletePosixAccountRequest{
202		Name: formattedName,
203	}
204
205	c, err := NewClient(context.Background(), clientOpt)
206	if err != nil {
207		t.Fatal(err)
208	}
209
210	err = c.DeletePosixAccount(context.Background(), request)
211
212	if st, ok := gstatus.FromError(err); !ok {
213		t.Errorf("got error %v, expected grpc error", err)
214	} else if c := st.Code(); c != errCode {
215		t.Errorf("got error code %q, want %q", c, errCode)
216	}
217}
218func TestOsLoginServiceDeleteSshPublicKey(t *testing.T) {
219	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
220
221	mockOsLogin.err = nil
222	mockOsLogin.reqs = nil
223
224	mockOsLogin.resps = append(mockOsLogin.resps[:0], expectedResponse)
225
226	var formattedName string = fmt.Sprintf("users/%s/sshPublicKeys/%s", "[USER]", "[FINGERPRINT]")
227	var request = &osloginpb.DeleteSshPublicKeyRequest{
228		Name: formattedName,
229	}
230
231	c, err := NewClient(context.Background(), clientOpt)
232	if err != nil {
233		t.Fatal(err)
234	}
235
236	err = c.DeleteSshPublicKey(context.Background(), request)
237
238	if err != nil {
239		t.Fatal(err)
240	}
241
242	if want, got := request, mockOsLogin.reqs[0]; !proto.Equal(want, got) {
243		t.Errorf("wrong request %q, want %q", got, want)
244	}
245
246}
247
248func TestOsLoginServiceDeleteSshPublicKeyError(t *testing.T) {
249	errCode := codes.PermissionDenied
250	mockOsLogin.err = gstatus.Error(errCode, "test error")
251
252	var formattedName string = fmt.Sprintf("users/%s/sshPublicKeys/%s", "[USER]", "[FINGERPRINT]")
253	var request = &osloginpb.DeleteSshPublicKeyRequest{
254		Name: formattedName,
255	}
256
257	c, err := NewClient(context.Background(), clientOpt)
258	if err != nil {
259		t.Fatal(err)
260	}
261
262	err = c.DeleteSshPublicKey(context.Background(), request)
263
264	if st, ok := gstatus.FromError(err); !ok {
265		t.Errorf("got error %v, expected grpc error", err)
266	} else if c := st.Code(); c != errCode {
267		t.Errorf("got error code %q, want %q", c, errCode)
268	}
269}
270func TestOsLoginServiceGetLoginProfile(t *testing.T) {
271	var name2 string = "name2-1052831874"
272	var suspended bool = false
273	var expectedResponse = &osloginpb.LoginProfile{
274		Name:      name2,
275		Suspended: suspended,
276	}
277
278	mockOsLogin.err = nil
279	mockOsLogin.reqs = nil
280
281	mockOsLogin.resps = append(mockOsLogin.resps[:0], expectedResponse)
282
283	var formattedName string = fmt.Sprintf("users/%s", "[USER]")
284	var request = &osloginpb.GetLoginProfileRequest{
285		Name: formattedName,
286	}
287
288	c, err := NewClient(context.Background(), clientOpt)
289	if err != nil {
290		t.Fatal(err)
291	}
292
293	resp, err := c.GetLoginProfile(context.Background(), request)
294
295	if err != nil {
296		t.Fatal(err)
297	}
298
299	if want, got := request, mockOsLogin.reqs[0]; !proto.Equal(want, got) {
300		t.Errorf("wrong request %q, want %q", got, want)
301	}
302
303	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
304		t.Errorf("wrong response %q, want %q)", got, want)
305	}
306}
307
308func TestOsLoginServiceGetLoginProfileError(t *testing.T) {
309	errCode := codes.PermissionDenied
310	mockOsLogin.err = gstatus.Error(errCode, "test error")
311
312	var formattedName string = fmt.Sprintf("users/%s", "[USER]")
313	var request = &osloginpb.GetLoginProfileRequest{
314		Name: formattedName,
315	}
316
317	c, err := NewClient(context.Background(), clientOpt)
318	if err != nil {
319		t.Fatal(err)
320	}
321
322	resp, err := c.GetLoginProfile(context.Background(), request)
323
324	if st, ok := gstatus.FromError(err); !ok {
325		t.Errorf("got error %v, expected grpc error", err)
326	} else if c := st.Code(); c != errCode {
327		t.Errorf("got error code %q, want %q", c, errCode)
328	}
329	_ = resp
330}
331func TestOsLoginServiceGetSshPublicKey(t *testing.T) {
332	var key string = "key106079"
333	var expirationTimeUsec int64 = 2058878882
334	var fingerprint string = "fingerprint-1375934236"
335	var expectedResponse = &commonpb.SshPublicKey{
336		Key:                key,
337		ExpirationTimeUsec: expirationTimeUsec,
338		Fingerprint:        fingerprint,
339	}
340
341	mockOsLogin.err = nil
342	mockOsLogin.reqs = nil
343
344	mockOsLogin.resps = append(mockOsLogin.resps[:0], expectedResponse)
345
346	var formattedName string = fmt.Sprintf("users/%s/sshPublicKeys/%s", "[USER]", "[FINGERPRINT]")
347	var request = &osloginpb.GetSshPublicKeyRequest{
348		Name: formattedName,
349	}
350
351	c, err := NewClient(context.Background(), clientOpt)
352	if err != nil {
353		t.Fatal(err)
354	}
355
356	resp, err := c.GetSshPublicKey(context.Background(), request)
357
358	if err != nil {
359		t.Fatal(err)
360	}
361
362	if want, got := request, mockOsLogin.reqs[0]; !proto.Equal(want, got) {
363		t.Errorf("wrong request %q, want %q", got, want)
364	}
365
366	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
367		t.Errorf("wrong response %q, want %q)", got, want)
368	}
369}
370
371func TestOsLoginServiceGetSshPublicKeyError(t *testing.T) {
372	errCode := codes.PermissionDenied
373	mockOsLogin.err = gstatus.Error(errCode, "test error")
374
375	var formattedName string = fmt.Sprintf("users/%s/sshPublicKeys/%s", "[USER]", "[FINGERPRINT]")
376	var request = &osloginpb.GetSshPublicKeyRequest{
377		Name: formattedName,
378	}
379
380	c, err := NewClient(context.Background(), clientOpt)
381	if err != nil {
382		t.Fatal(err)
383	}
384
385	resp, err := c.GetSshPublicKey(context.Background(), request)
386
387	if st, ok := gstatus.FromError(err); !ok {
388		t.Errorf("got error %v, expected grpc error", err)
389	} else if c := st.Code(); c != errCode {
390		t.Errorf("got error code %q, want %q", c, errCode)
391	}
392	_ = resp
393}
394func TestOsLoginServiceImportSshPublicKey(t *testing.T) {
395	var expectedResponse *osloginpb.ImportSshPublicKeyResponse = &osloginpb.ImportSshPublicKeyResponse{}
396
397	mockOsLogin.err = nil
398	mockOsLogin.reqs = nil
399
400	mockOsLogin.resps = append(mockOsLogin.resps[:0], expectedResponse)
401
402	var formattedParent string = fmt.Sprintf("users/%s", "[USER]")
403	var sshPublicKey *commonpb.SshPublicKey = &commonpb.SshPublicKey{}
404	var request = &osloginpb.ImportSshPublicKeyRequest{
405		Parent:       formattedParent,
406		SshPublicKey: sshPublicKey,
407	}
408
409	c, err := NewClient(context.Background(), clientOpt)
410	if err != nil {
411		t.Fatal(err)
412	}
413
414	resp, err := c.ImportSshPublicKey(context.Background(), request)
415
416	if err != nil {
417		t.Fatal(err)
418	}
419
420	if want, got := request, mockOsLogin.reqs[0]; !proto.Equal(want, got) {
421		t.Errorf("wrong request %q, want %q", got, want)
422	}
423
424	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
425		t.Errorf("wrong response %q, want %q)", got, want)
426	}
427}
428
429func TestOsLoginServiceImportSshPublicKeyError(t *testing.T) {
430	errCode := codes.PermissionDenied
431	mockOsLogin.err = gstatus.Error(errCode, "test error")
432
433	var formattedParent string = fmt.Sprintf("users/%s", "[USER]")
434	var sshPublicKey *commonpb.SshPublicKey = &commonpb.SshPublicKey{}
435	var request = &osloginpb.ImportSshPublicKeyRequest{
436		Parent:       formattedParent,
437		SshPublicKey: sshPublicKey,
438	}
439
440	c, err := NewClient(context.Background(), clientOpt)
441	if err != nil {
442		t.Fatal(err)
443	}
444
445	resp, err := c.ImportSshPublicKey(context.Background(), request)
446
447	if st, ok := gstatus.FromError(err); !ok {
448		t.Errorf("got error %v, expected grpc error", err)
449	} else if c := st.Code(); c != errCode {
450		t.Errorf("got error code %q, want %q", c, errCode)
451	}
452	_ = resp
453}
454func TestOsLoginServiceUpdateSshPublicKey(t *testing.T) {
455	var key string = "key106079"
456	var expirationTimeUsec int64 = 2058878882
457	var fingerprint string = "fingerprint-1375934236"
458	var expectedResponse = &commonpb.SshPublicKey{
459		Key:                key,
460		ExpirationTimeUsec: expirationTimeUsec,
461		Fingerprint:        fingerprint,
462	}
463
464	mockOsLogin.err = nil
465	mockOsLogin.reqs = nil
466
467	mockOsLogin.resps = append(mockOsLogin.resps[:0], expectedResponse)
468
469	var formattedName string = fmt.Sprintf("users/%s/sshPublicKeys/%s", "[USER]", "[FINGERPRINT]")
470	var sshPublicKey *commonpb.SshPublicKey = &commonpb.SshPublicKey{}
471	var request = &osloginpb.UpdateSshPublicKeyRequest{
472		Name:         formattedName,
473		SshPublicKey: sshPublicKey,
474	}
475
476	c, err := NewClient(context.Background(), clientOpt)
477	if err != nil {
478		t.Fatal(err)
479	}
480
481	resp, err := c.UpdateSshPublicKey(context.Background(), request)
482
483	if err != nil {
484		t.Fatal(err)
485	}
486
487	if want, got := request, mockOsLogin.reqs[0]; !proto.Equal(want, got) {
488		t.Errorf("wrong request %q, want %q", got, want)
489	}
490
491	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
492		t.Errorf("wrong response %q, want %q)", got, want)
493	}
494}
495
496func TestOsLoginServiceUpdateSshPublicKeyError(t *testing.T) {
497	errCode := codes.PermissionDenied
498	mockOsLogin.err = gstatus.Error(errCode, "test error")
499
500	var formattedName string = fmt.Sprintf("users/%s/sshPublicKeys/%s", "[USER]", "[FINGERPRINT]")
501	var sshPublicKey *commonpb.SshPublicKey = &commonpb.SshPublicKey{}
502	var request = &osloginpb.UpdateSshPublicKeyRequest{
503		Name:         formattedName,
504		SshPublicKey: sshPublicKey,
505	}
506
507	c, err := NewClient(context.Background(), clientOpt)
508	if err != nil {
509		t.Fatal(err)
510	}
511
512	resp, err := c.UpdateSshPublicKey(context.Background(), request)
513
514	if st, ok := gstatus.FromError(err); !ok {
515		t.Errorf("got error %v, expected grpc error", err)
516	} else if c := st.Code(); c != errCode {
517		t.Errorf("got error code %q, want %q", c, errCode)
518	}
519	_ = resp
520}
521