ownable_test.gno

  1package ownable2step
  2
  3import (
  4	"testing"
  5
  6	"gno.land/p/nt/testutils"
  7	"gno.land/p/nt/uassert"
  8	"gno.land/p/nt/urequire"
  9)
 10
 11var (
 12	alice = testutils.TestAddress("alice")
 13	bob   = testutils.TestAddress("bob")
 14)
 15
 16func TestNew(t *testing.T) {
 17	testing.SetOriginCaller(alice)
 18
 19	o := New()
 20	got := o.Owner()
 21	pendingOwner := o.PendingOwner()
 22
 23	uassert.Equal(t, got, alice)
 24	uassert.Equal(t, pendingOwner.String(), "")
 25}
 26
 27func TestNewWithAddress(t *testing.T) {
 28	o := NewWithAddress(alice)
 29
 30	got := o.Owner()
 31	pendingOwner := o.PendingOwner()
 32
 33	uassert.Equal(t, got, alice)
 34	uassert.Equal(t, pendingOwner.String(), "")
 35}
 36
 37func TestInitiateTransferOwnership(t *testing.T) {
 38	testing.SetOriginCaller(alice)
 39
 40	o := New()
 41
 42	err := o.TransferOwnership(bob)
 43	urequire.NoError(t, err)
 44
 45	owner := o.Owner()
 46	pendingOwner := o.PendingOwner()
 47
 48	uassert.Equal(t, owner, alice)
 49	uassert.Equal(t, pendingOwner, bob)
 50}
 51
 52func TestTransferOwnership(t *testing.T) {
 53	testing.SetOriginCaller(alice)
 54
 55	o := New()
 56
 57	err := o.TransferOwnership(bob)
 58	urequire.NoError(t, err)
 59
 60	owner := o.Owner()
 61	pendingOwner := o.PendingOwner()
 62
 63	uassert.Equal(t, owner, alice)
 64	uassert.Equal(t, pendingOwner, bob)
 65
 66	testing.SetOriginCaller(bob)
 67
 68	err = o.AcceptOwnership()
 69	urequire.NoError(t, err)
 70
 71	owner = o.Owner()
 72	pendingOwner = o.PendingOwner()
 73
 74	uassert.Equal(t, owner, bob)
 75	uassert.Equal(t, pendingOwner.String(), "")
 76}
 77
 78func TestOwnedByCurrent(t *testing.T) {
 79	testing.SetOriginCaller(alice)
 80
 81	o := New()
 82	unauthorizedCaller := bob
 83	testing.SetOriginCaller(unauthorizedCaller)
 84	uassert.False(t, o.OwnedByCurrent())
 85}
 86
 87func TestOwnedByCurrentUnauthorized(t *testing.T) {
 88	testing.SetOriginCaller(alice)
 89	testing.SetRealm(testing.NewUserRealm(alice))
 90
 91	var o *Ownable2Step
 92	func() {
 93		testing.SetRealm(testing.NewCodeRealm("gno.land/r/test/test"))
 94		o = NewWithOrigin()
 95	}()
 96
 97	uassert.True(t, o.OwnedByCurrent())
 98
 99	unauthorizedCaller := bob
100	testing.SetRealm(testing.NewUserRealm(unauthorizedCaller))
101	uassert.False(t, o.OwnedByCurrent())
102}
103
104func TestOwnedByPrevious(t *testing.T) {
105	testing.SetOriginCaller(alice)
106
107	o := New()
108	func() {
109		testing.SetRealm(testing.NewCodeRealm("gno.land/r/test/test"))
110		uassert.True(t, o.OwnedByPrevious())
111	}()
112}
113
114func TestOwnedByPreviousUnauthorized(t *testing.T) {
115	testing.SetRealm(testing.NewUserRealm(alice))
116
117	o := New()
118	unauthorizedCaller := bob
119	testing.SetRealm(testing.NewUserRealm(unauthorizedCaller))
120	func() {
121		testing.SetRealm(testing.NewCodeRealm("gno.land/r/test/test"))
122		uassert.False(t, o.OwnedByPrevious())
123	}()
124}
125
126func TestDropOwnership(t *testing.T) {
127	testing.SetOriginCaller(alice)
128
129	o := New()
130
131	err := o.DropOwnership()
132	urequire.NoError(t, err, "DropOwnership failed")
133
134	owner := o.Owner()
135	uassert.Empty(t, owner, "owner should be empty")
136}
137
138func TestDropOwnershipVulnerability(t *testing.T) {
139	testing.SetOriginCaller(alice)
140	o := New()
141
142	// alice initiates ownership transfer to bob
143	err := o.TransferOwnership(bob)
144	urequire.NoError(t, err)
145
146	// alice drops ownership while ownership transfer is pending
147	err = o.DropOwnership()
148	urequire.NoError(t, err)
149
150	owner := o.Owner()
151	pendingOwner := o.PendingOwner()
152	uassert.Empty(t, owner, "owner should be empty")
153	uassert.Empty(t, pendingOwner.String(), "pending owner should be empty")
154
155	// verify bob can no longer claim ownership
156	testing.SetOriginCaller(bob)
157	err = o.AcceptOwnership()
158	uassert.ErrorContains(t, err, ErrNoPendingOwner.Error())
159}
160
161// Errors
162
163func TestErrUnauthorized(t *testing.T) {
164	testing.SetOriginCaller(alice)
165
166	o := New()
167
168	testing.SetOriginCaller(bob)
169
170	uassert.ErrorContains(t, o.TransferOwnership(alice), ErrUnauthorized.Error())
171	uassert.ErrorContains(t, o.DropOwnership(), ErrUnauthorized.Error())
172}
173
174func TestErrInvalidAddress(t *testing.T) {
175	testing.SetOriginCaller(alice)
176
177	o := New()
178
179	err := o.TransferOwnership("")
180	uassert.ErrorContains(t, err, ErrInvalidAddress.Error())
181
182	err = o.TransferOwnership("10000000001000000000100000000010000000001000000000")
183	uassert.ErrorContains(t, err, ErrInvalidAddress.Error())
184}
185
186func TestErrNoPendingOwner(t *testing.T) {
187	testing.SetOriginCaller(alice)
188
189	o := New()
190
191	err := o.AcceptOwnership()
192	uassert.ErrorContains(t, err, ErrNoPendingOwner.Error())
193}
194
195func TestErrPendingUnauthorized(t *testing.T) {
196	testing.SetOriginCaller(alice)
197
198	o := New()
199
200	err := o.TransferOwnership(bob)
201	urequire.NoError(t, err)
202
203	testing.SetOriginCaller(alice)
204
205	err = o.AcceptOwnership()
206	uassert.ErrorContains(t, err, ErrPendingUnauthorized.Error())
207}