gravitl/netmaker
1
1
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-09-06 13:14:24 +08:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #2043 from yunginnanet/develop

Browse source 
Various test enhancments, fix go vet, update CI
This commit is contained in:
dcarns 2023-02-16 08:59:24 -05:00 • committed by GitHub
commit 6117cff044
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 95 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.github/workflows/test.yml vendored
View file

@ -49,6 +49,7 @@ jobs:
go-version: 1.19
- name: run tests
run: |
go vet ./...
go test -p 1 ./... -v
env:
DATABASE: sqlite

57
controllers/dns_test.go
View file

@ -6,10 +6,11 @@ import (
"testing"
"github.com/google/uuid"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/stretchr/testify/assert"
"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
)
var dnsHost models.Host
@ -26,7 +27,7 @@ func TestGetAllDNS(t *testing.T) {
})
t.Run("OneEntry", func(t *testing.T) {
entry := models.DNSEntry{
"10.0.0.3", "", "newhost", "skynet",
Address: "10.0.0.3", Name: "newhost", Network: "skynet",
}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
@ -35,7 +36,7 @@ func TestGetAllDNS(t *testing.T) {
assert.Equal(t, 1, len(entries))
})
t.Run("MultipleEntry", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.7", "", "anotherhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.7", Name: "anotherhost", Network: "skynet"}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
entries, err := logic.GetAllDNS()
@ -111,7 +112,7 @@ func TestGetCustomDNS(t *testing.T) {
assert.Equal(t, 0, len(dns))
})
t.Run("EntryExist", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.3", "", "custom1", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.3", Name: "custom1", Network: "skynet"}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
dns, err := logic.GetCustomDNS("skynet")
@ -119,7 +120,7 @@ func TestGetCustomDNS(t *testing.T) {
assert.Equal(t, 1, len(dns))
})
t.Run("MultipleEntries", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.4", "", "host4", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.4", Name: "host4", Network: "skynet"}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
dns, err := logic.GetCustomDNS("skynet")
@ -138,7 +139,7 @@ func TestGetDNSEntryNum(t *testing.T) {
assert.Equal(t, 0, num)
})
t.Run("NodeExists", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
num, err := logic.GetDNSEntryNum("newhost", "skynet")
@ -156,7 +157,7 @@ func TestGetDNS(t *testing.T) {
assert.Nil(t, dns)
})
t.Run("CustomDNSExists", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
dns, err := logic.GetDNS("skynet")
@ -176,7 +177,7 @@ func TestGetDNS(t *testing.T) {
assert.Equal(t, 1, len(dns))
})
t.Run("NodeAndCustomDNS", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
dns, err := logic.GetDNS("skynet")
@ -193,7 +194,7 @@ func TestCreateDNS(t *testing.T) {
deleteAllDNS(t)
deleteAllNetworks()
createNet()
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
dns, err := logic.CreateDNS(entry)
assert.Nil(t, err)
assert.Equal(t, "newhost", dns.Name)
@ -231,7 +232,7 @@ func TestSetDNS(t *testing.T) {
assert.Contains(t, string(content), "linuxhost.skynet")
})
t.Run("EntryExists", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.3", "", "newhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.3", Name: "newhost", Network: "skynet"}
_, err := logic.CreateDNS(entry)
assert.Nil(t, err)
err = logic.SetDNS()
@ -251,7 +252,7 @@ func TestGetDNSEntry(t *testing.T) {
deleteAllNetworks()
createNet()
createTestNode()
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
_, _ = logic.CreateDNS(entry)
t.Run("wrong net", func(t *testing.T) {
entry, err := GetDNSEntry("newhost", "w286 Toronto Street South, Uxbridge, ONirecat")
@ -279,7 +280,7 @@ func TestDeleteDNS(t *testing.T) {
deleteAllDNS(t)
deleteAllNetworks()
createNet()
entry := models.DNSEntry{"10.0.0.2", "", "newhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "newhost", Network: "skynet"}
_, _ = logic.CreateDNS(entry)
t.Run("EntryExists", func(t *testing.T) {
err := logic.DeleteDNS("newhost", "skynet")
@ -300,16 +301,16 @@ func TestValidateDNSUpdate(t *testing.T) {
deleteAllDNS(t)
deleteAllNetworks()
createNet()
entry := models.DNSEntry{"10.0.0.2", "", "myhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "skynet"}
t.Run("BadNetwork", func(t *testing.T) {
change := models.DNSEntry{"10.0.0.2", "", "myhost", "badnet"}
change := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "badnet"}
err := logic.ValidateDNSUpdate(change, entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Network' failed on the 'network_exists' tag")
})
t.Run("EmptyNetwork", func(t *testing.T) {
//this can't actually happen as change.Network is populated if is blank
change := models.DNSEntry{"10.0.0.2", "", "myhost", ""}
// this can't actually happen as change.Network is populated if is blank
change := models.DNSEntry{Address: "10.0.0.2", Name: "myhost"}
err := logic.ValidateDNSUpdate(change, entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Network' failed on the 'network_exists' tag")
@ -322,14 +323,14 @@ func TestValidateDNSUpdate(t *testing.T) {
// assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'required' tag")
// })
t.Run("BadAddress", func(t *testing.T) {
change := models.DNSEntry{"10.0.256.1", "", "myhost", "skynet"}
change := models.DNSEntry{Address: "10.0.256.1", Name: "myhost", Network: "skynet"}
err := logic.ValidateDNSUpdate(change, entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'ip' tag")
})
t.Run("EmptyName", func(t *testing.T) {
//this can't actually happen as change.Name is populated if is blank
change := models.DNSEntry{"10.0.0.2", "", "", "skynet"}
// this can't actually happen as change.Name is populated if is blank
change := models.DNSEntry{Address: "10.0.0.2", Network: "skynet"}
err := logic.ValidateDNSUpdate(change, entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'required' tag")
@ -339,19 +340,19 @@ func TestValidateDNSUpdate(t *testing.T) {
for i := 1; i < 194; i++ {
name = name + "a"
}
change := models.DNSEntry{"10.0.0.2", "", name, "skynet"}
change := models.DNSEntry{Address: "10.0.0.2", Name: name, Network: "skynet"}
err := logic.ValidateDNSUpdate(change, entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'max' tag")
})
t.Run("NameUnique", func(t *testing.T) {
change := models.DNSEntry{"10.0.0.2", "", "myhost", "wirecat"}
change := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "wirecat"}
_, _ = logic.CreateDNS(entry)
_, _ = logic.CreateDNS(change)
err := logic.ValidateDNSUpdate(change, entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'name_unique' tag")
//cleanup
// cleanup
err = logic.DeleteDNS("myhost", "wirecat")
assert.Nil(t, err)
})
@ -360,7 +361,7 @@ func TestValidateDNSUpdate(t *testing.T) {
func TestValidateDNSCreate(t *testing.T) {
_ = logic.DeleteDNS("mynode", "skynet")
t.Run("NoNetwork", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.2", "", "myhost", "badnet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "badnet"}
err := logic.ValidateDNSCreate(entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Network' failed on the 'network_exists' tag")
@ -372,13 +373,13 @@ func TestValidateDNSCreate(t *testing.T) {
// assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'required' tag")
// })
t.Run("BadAddress", func(t *testing.T) {
entry := models.DNSEntry{"10.0.256.1", "", "myhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.256.1", Name: "myhost", Network: "skynet"}
err := logic.ValidateDNSCreate(entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Address' failed on the 'ip' tag")
})
t.Run("EmptyName", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.2", "", "", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Network: "skynet"}
err := logic.ValidateDNSCreate(entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'required' tag")
@ -388,13 +389,13 @@ func TestValidateDNSCreate(t *testing.T) {
for i := 1; i < 194; i++ {
name = name + "a"
}
entry := models.DNSEntry{"10.0.0.2", "", name, "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: name, Network: "skynet"}
err := logic.ValidateDNSCreate(entry)
assert.NotNil(t, err)
assert.Contains(t, err.Error(), "Field validation for 'Name' failed on the 'max' tag")
})
t.Run("NameUnique", func(t *testing.T) {
entry := models.DNSEntry{"10.0.0.2", "", "myhost", "skynet"}
entry := models.DNSEntry{Address: "10.0.0.2", Name: "myhost", Network: "skynet"}
_, _ = logic.CreateDNS(entry)
err := logic.ValidateDNSCreate(entry)
assert.NotNil(t, err)

99
controllers/user_test.go
View file

@ -3,20 +3,24 @@ package controller
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/gravitl/netmaker/logic"
"github.com/gravitl/netmaker/models"
"github.com/stretchr/testify/assert"
)
func deleteAllUsers() {
func deleteAllUsers(t *testing.T) {
t.Helper()
users, _ := logic.GetUsers()
for _, user := range users {
logic.DeleteUser(user.UserName)
if _, err := logic.DeleteUser(user.UserName); err != nil {
t.Fatal(err)
}
}
}
func TestHasAdmin(t *testing.T) {
//delete all current users
// delete all current users
users, _ := logic.GetUsers()
for _, user := range users {
success, err := logic.DeleteUser(user.UserName)
@ -29,7 +33,7 @@ func TestHasAdmin(t *testing.T) {
assert.False(t, found)
})
t.Run("No admin user", func(t *testing.T) {
var user = models.User{"noadmin", "password", nil, false, nil}
var user = models.User{UserName: "noadmin", Password: "password"}
err := logic.CreateUser(&user)
assert.Nil(t, err)
found, err := logic.HasAdmin()
@ -37,7 +41,7 @@ func TestHasAdmin(t *testing.T) {
assert.False(t, found)
})
t.Run("admin user", func(t *testing.T) {
var user = models.User{"admin", "password", nil, true, nil}
var user = models.User{UserName: "admin", Password: "password", IsAdmin: true}
err := logic.CreateUser(&user)
assert.Nil(t, err)
found, err := logic.HasAdmin()
@ -45,7 +49,7 @@ func TestHasAdmin(t *testing.T) {
assert.True(t, found)
})
t.Run("multiple admins", func(t *testing.T) {
var user = models.User{"admin1", "password", nil, true, nil}
var user = models.User{UserName: "admin1", Password: "password", IsAdmin: true}
err := logic.CreateUser(&user)
assert.Nil(t, err)
found, err := logic.HasAdmin()
@ -55,8 +59,8 @@ func TestHasAdmin(t *testing.T) {
}
func TestCreateUser(t *testing.T) {
deleteAllUsers()
user := models.User{"admin", "password", nil, true, nil}
deleteAllUsers(t)
user := models.User{UserName: "admin", Password: "password", IsAdmin: true}
t.Run("NoUser", func(t *testing.T) {
err := logic.CreateUser(&user)
assert.Nil(t, err)
@ -69,7 +73,7 @@ func TestCreateUser(t *testing.T) {
}
func TestCreateAdmin(t *testing.T) {
deleteAllUsers()
deleteAllUsers(t)
var user models.User
t.Run("NoAdmin", func(t *testing.T) {
user.UserName = "admin"
@ -86,15 +90,17 @@ func TestCreateAdmin(t *testing.T) {
}
func TestDeleteUser(t *testing.T) {
deleteAllUsers()
deleteAllUsers(t)
t.Run("NonExistent User", func(t *testing.T) {
deleted, err := logic.DeleteUser("admin")
assert.EqualError(t, err, "user does not exist")
assert.False(t, deleted)
})
t.Run("Existing User", func(t *testing.T) {
user := models.User{"admin", "password", nil, true, nil}
logic.CreateUser(&user)
user := models.User{UserName: "admin", Password: "password", IsAdmin: true}
if err := logic.CreateUser(&user); err != nil {
t.Fatal(err)
}
deleted, err := logic.DeleteUser("admin")
assert.Nil(t, err)
assert.True(t, deleted)
@ -120,21 +126,21 @@ func TestValidateUser(t *testing.T) {
user.UserName = "*invalid"
err := logic.ValidateUser(&user)
assert.Error(t, err)
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
// assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
})
t.Run("Short UserName", func(t *testing.T) {
t.Skip()
user.UserName = "1"
err := logic.ValidateUser(&user)
assert.NotNil(t, err)
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
// assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
})
t.Run("Empty UserName", func(t *testing.T) {
t.Skip()
user.UserName = ""
err := logic.ValidateUser(&user)
assert.EqualError(t, err, "some string")
//assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
// assert.Contains(t, err.Error(), "Field validation for 'UserName' failed")
})
t.Run("EmptyPassword", func(t *testing.T) {
user.Password = ""
@ -149,15 +155,19 @@ func TestValidateUser(t *testing.T) {
}
func TestGetUser(t *testing.T) {
deleteAllUsers()
deleteAllUsers(t)
user := models.User{UserName: "admin", Password: "password", Networks: nil, IsAdmin: true, Groups: nil}
t.Run("NonExistantUser", func(t *testing.T) {
admin, err := logic.GetUser("admin")
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, "", admin.UserName)
})
t.Run("UserExisits", func(t *testing.T) {
user := models.User{"admin", "password", nil, true, nil}
logic.CreateUser(&user)
if err := logic.CreateUser(&user); err != nil {
t.Error(err)
}
admin, err := logic.GetUser("admin")
assert.Nil(t, err)
assert.Equal(t, user.UserName, admin.UserName)
@ -165,29 +175,36 @@ func TestGetUser(t *testing.T) {
}
func TestGetUsers(t *testing.T) {
deleteAllUsers()
deleteAllUsers(t)
adminUser := models.User{UserName: "admin", Password: "password", IsAdmin: true}
user := models.User{UserName: "admin", Password: "password", IsAdmin: false}
t.Run("NonExistantUser", func(t *testing.T) {
admin, err := logic.GetUsers()
assert.EqualError(t, err, "could not find any records")
assert.Equal(t, []models.ReturnUser(nil), admin)
})
t.Run("UserExisits", func(t *testing.T) {
user := models.User{"admin", "password", nil, true, nil}
logic.CreateUser(&user)
if err := logic.CreateUser(&adminUser); err != nil {
t.Error(err)
}
admins, err := logic.GetUsers()
assert.Nil(t, err)
assert.Equal(t, user.UserName, admins[0].UserName)
assert.Equal(t, adminUser.UserName, admins[0].UserName)
})
t.Run("MulipleUsers", func(t *testing.T) {
user := models.User{"user", "password", nil, true, nil}
logic.CreateUser(&user)
if err := logic.CreateUser(&user); err != nil {
t.Error(err)
}
admins, err := logic.GetUsers()
assert.Nil(t, err)
for _, u := range admins {
if u.UserName == "admin" {
assert.Equal(t, "admin", u.UserName)
assert.Equal(t, true, u.IsAdmin)
} else {
assert.Equal(t, user.UserName, u.UserName)
assert.Equal(t, user.IsAdmin, u.IsAdmin)
}
}
})
@ -195,9 +212,9 @@ func TestGetUsers(t *testing.T) {
}
func TestUpdateUser(t *testing.T) {
deleteAllUsers()
user := models.User{"admin", "password", nil, true, nil}
newuser := models.User{"hello", "world", []string{"wirecat, netmaker"}, true, []string{}}
deleteAllUsers(t)
user := models.User{UserName: "admin", Password: "password", IsAdmin: true}
newuser := models.User{UserName: "hello", Password: "world", Networks: []string{"wirecat, netmaker"}, IsAdmin: true, Groups: []string{}}
t.Run("NonExistantUser", func(t *testing.T) {
admin, err := logic.UpdateUser(&newuser, &user)
assert.EqualError(t, err, "could not find any records")
@ -205,7 +222,9 @@ func TestUpdateUser(t *testing.T) {
})
t.Run("UserExists", func(t *testing.T) {
logic.CreateUser(&user)
if err := logic.CreateUser(&user); err != nil {
t.Error(err)
}
admin, err := logic.UpdateUser(&newuser, &user)
assert.Nil(t, err)
assert.Equal(t, newuser.UserName, admin.UserName)
@ -237,7 +256,8 @@ func TestUpdateUser(t *testing.T) {
// }
func TestVerifyAuthRequest(t *testing.T) {
deleteAllUsers()
deleteAllUsers(t)
user := models.User{UserName: "admin", Password: "password", Networks: nil, IsAdmin: true, Groups: nil}
var authRequest models.UserAuthParams
t.Run("EmptyUserName", func(t *testing.T) {
authRequest.UserName = ""
@ -261,23 +281,26 @@ func TestVerifyAuthRequest(t *testing.T) {
assert.EqualError(t, err, "error retrieving user from db: could not find any records")
})
t.Run("Non-Admin", func(t *testing.T) {
user := models.User{"nonadmin", "somepass", nil, false, []string{}}
logic.CreateUser(&user)
authRequest := models.UserAuthParams{"nonadmin", "somepass"}
if err := logic.CreateUser(&user); err != nil {
t.Error(err)
}
authRequest := models.UserAuthParams{UserName: "nonadmin", Password: "somepass"}
jwt, err := logic.VerifyAuthRequest(authRequest)
assert.NotNil(t, jwt)
assert.Nil(t, err)
})
t.Run("WrongPassword", func(t *testing.T) {
user := models.User{"admin", "password", nil, false, []string{}}
logic.CreateUser(&user)
authRequest := models.UserAuthParams{"admin", "badpass"}
user := models.User{UserName: "admin", Password: "password", Groups: []string{}}
if err := logic.CreateUser(&user); err != nil {
t.Error(err)
}
authRequest := models.UserAuthParams{UserName: "admin", Password: "badpass"}
jwt, err := logic.VerifyAuthRequest(authRequest)
assert.Equal(t, "", jwt)
assert.EqualError(t, err, "incorrect credentials")
})
t.Run("Success", func(t *testing.T) {
authRequest := models.UserAuthParams{"admin", "password"}
authRequest := models.UserAuthParams{UserName: "admin", Password: "password"}
jwt, err := logic.VerifyAuthRequest(authRequest)
assert.Nil(t, err)
assert.NotNil(t, jwt)

5
netclient/ncutils/netclientutils.go
View file

@ -166,13 +166,16 @@ func GetPublicIP(api string) (string, error) {
if err != nil {
continue
}
defer resp.Body.Close()
if resp.StatusCode == http.StatusOK {
var bodyBytes []byte
bodyBytes, err = io.ReadAll(resp.Body)
if err != nil {
if resp.Body != nil {
_ = resp.Body.Close()
}
continue
}
_ = resp.Body.Close()
endpoint = string(bodyBytes)
break
}