TheArchive/headscale
1
0
Fork 0
mirror of https://github.com/juanfont/headscale.git synced 2024-11-24 02:25:24 +00:00
Code Issues Packages Projects Releases Wiki Activity
2eef535b4b
headscale/sharing_test.go

367 lines
11 KiB
Go
Raw Normal View History

Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
package headscale
import (
"gopkg.in/check.v1"
)
func (s *Suite) TestBasicSharedNodesInNamespace(c *check.C) {
n1, err := h.CreateNamespace("shared1")
c.Assert(err, check.IsNil)
n2, err := h.CreateNamespace("shared2")
c.Assert(err, check.IsNil)
pak1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
c.Assert(err, check.IsNil)
pak2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
c.Assert(err, check.IsNil)
_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
c.Assert(err, check.NotNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m1 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 0,
MachineKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
NodeKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
DiscoKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
Name: "test_get_shared_nodes_1",
NamespaceID: n1.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.1",
AuthKeyID: uint(pak1.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n1.Name, m1.Name)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m2 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 1,
MachineKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
NodeKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
DiscoKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
Name: "test_get_shared_nodes_2",
NamespaceID: n2.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.2",
AuthKeyID: uint(pak2.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m2)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n2.Name, m2.Name)
c.Assert(err, check.IsNil)
p1s, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1s), check.Equals, 0)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
err = h.AddSharedMachineToNamespace(m2, n1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
c.Assert(err, check.IsNil)
p1sAfter, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1sAfter), check.Equals, 1)
c.Assert(p1sAfter[0].ID, check.Equals, m2.ID)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
}
func (s *Suite) TestSameNamespace(c *check.C) {
n1, err := h.CreateNamespace("shared1")
c.Assert(err, check.IsNil)
n2, err := h.CreateNamespace("shared2")
c.Assert(err, check.IsNil)
pak1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
c.Assert(err, check.IsNil)
pak2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
c.Assert(err, check.IsNil)
_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
c.Assert(err, check.NotNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m1 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 0,
MachineKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
NodeKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
DiscoKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
Name: "test_get_shared_nodes_1",
NamespaceID: n1.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.1",
AuthKeyID: uint(pak1.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n1.Name, m1.Name)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m2 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 1,
MachineKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
NodeKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
DiscoKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
Name: "test_get_shared_nodes_2",
NamespaceID: n2.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.2",
AuthKeyID: uint(pak2.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m2)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n2.Name, m2.Name)
c.Assert(err, check.IsNil)
p1s, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1s), check.Equals, 0)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
err = h.AddSharedMachineToNamespace(m1, n1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
c.Assert(err, check.Equals, errorSameNamespace)
}
func (s *Suite) TestAlreadyShared(c *check.C) {
n1, err := h.CreateNamespace("shared1")
c.Assert(err, check.IsNil)
n2, err := h.CreateNamespace("shared2")
c.Assert(err, check.IsNil)
pak1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
c.Assert(err, check.IsNil)
pak2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
c.Assert(err, check.IsNil)
_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
c.Assert(err, check.NotNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m1 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 0,
MachineKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
NodeKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
DiscoKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
Name: "test_get_shared_nodes_1",
NamespaceID: n1.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.1",
AuthKeyID: uint(pak1.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n1.Name, m1.Name)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m2 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 1,
MachineKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
NodeKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
DiscoKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
Name: "test_get_shared_nodes_2",
NamespaceID: n2.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.2",
AuthKeyID: uint(pak2.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m2)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n2.Name, m2.Name)
c.Assert(err, check.IsNil)
p1s, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1s), check.Equals, 0)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
err = h.AddSharedMachineToNamespace(m2, n1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
err = h.AddSharedMachineToNamespace(m2, n1)
Apply suggestions from code review Removed one letter variables Co-authored-by: Kristoffer Dalby <kradalby@kradalby.no>
2021-09-09 22:26:46 +00:00
c.Assert(err, check.Equals, errorMachineAlreadyShared)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
}
func (s *Suite) TestDoNotIncludeRoutesOnShared(c *check.C) {
n1, err := h.CreateNamespace("shared1")
c.Assert(err, check.IsNil)
n2, err := h.CreateNamespace("shared2")
c.Assert(err, check.IsNil)
pak1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
c.Assert(err, check.IsNil)
pak2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
c.Assert(err, check.IsNil)
_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
c.Assert(err, check.NotNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m1 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 0,
MachineKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
NodeKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
DiscoKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
Name: "test_get_shared_nodes_1",
NamespaceID: n1.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.1",
AuthKeyID: uint(pak1.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n1.Name, m1.Name)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m2 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 1,
MachineKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
NodeKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
DiscoKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
Name: "test_get_shared_nodes_2",
NamespaceID: n2.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.2",
AuthKeyID: uint(pak2.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m2)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n2.Name, m2.Name)
c.Assert(err, check.IsNil)
p1s, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1s), check.Equals, 0)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
err = h.AddSharedMachineToNamespace(m2, n1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
c.Assert(err, check.IsNil)
p1sAfter, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1sAfter), check.Equals, 1)
Add more test cases to prove that peers and shared peers work properly
2021-10-04 17:40:21 +00:00
c.Assert(p1sAfter[0].Name, check.Equals, "test_get_shared_nodes_2")
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
}
func (s *Suite) TestComplexSharingAcrossNamespaces(c *check.C) {
n1, err := h.CreateNamespace("shared1")
c.Assert(err, check.IsNil)
n2, err := h.CreateNamespace("shared2")
c.Assert(err, check.IsNil)
n3, err := h.CreateNamespace("shared3")
c.Assert(err, check.IsNil)
pak1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
c.Assert(err, check.IsNil)
pak2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
c.Assert(err, check.IsNil)
pak3, err := h.CreatePreAuthKey(n3.Name, false, false, nil)
c.Assert(err, check.IsNil)
pak4, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
c.Assert(err, check.IsNil)
_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
c.Assert(err, check.NotNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m1 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 0,
MachineKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
NodeKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
DiscoKey: "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
Name: "test_get_shared_nodes_1",
NamespaceID: n1.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.1",
AuthKeyID: uint(pak1.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n1.Name, m1.Name)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m2 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 1,
MachineKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
NodeKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
DiscoKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
Name: "test_get_shared_nodes_2",
NamespaceID: n2.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.2",
AuthKeyID: uint(pak2.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m2)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n2.Name, m2.Name)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m3 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 2,
MachineKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
NodeKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
DiscoKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
Name: "test_get_shared_nodes_3",
NamespaceID: n3.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.3",
AuthKeyID: uint(pak3.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m3)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n3.Name, m3.Name)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
m4 := &Machine{
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
ID: 3,
MachineKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
NodeKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
DiscoKey: "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
Name: "test_get_shared_nodes_4",
NamespaceID: n1.ID,
Registered: true,
RegisterMethod: "authKey",
IPAddress: "100.64.0.4",
AuthKeyID: uint(pak4.ID),
}
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
h.db.Save(m4)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
_, err = h.GetMachine(n1.Name, m4.Name)
c.Assert(err, check.IsNil)
p1s, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1s), check.Equals, 1) // nodes 1 and 4
Add more test cases to prove that peers and shared peers work properly
2021-10-04 17:40:21 +00:00
c.Assert(p1s[0].Name, check.Equals, "test_get_shared_nodes_4")
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
err = h.AddSharedMachineToNamespace(m2, n1)
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
c.Assert(err, check.IsNil)
p1sAfter, err := h.getPeers(m1)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(p1sAfter), check.Equals, 2) // nodes 1, 2, 4
Add more test cases to prove that peers and shared peers work properly
2021-10-04 17:40:21 +00:00
c.Assert(p1sAfter[0].Name, check.Equals, "test_get_shared_nodes_2")
c.Assert(p1sAfter[1].Name, check.Equals, "test_get_shared_nodes_4")
node1shared, err := h.getShared(m1)
c.Assert(err, check.IsNil)
c.Assert(len(node1shared), check.Equals, 1) // nodes 1, 2, 4
c.Assert(node1shared[0].Name, check.Equals, "test_get_shared_nodes_2")
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
pAlone, err := h.getPeers(m3)
c.Assert(err, check.IsNil)
Consitently use Machine pointers This commit rewrites a bunch of the code to always use *Machine instead of a mix of both, and a mix of tailcfg.Node and Machine. Now we use *Machine, and if tailcfg.Node is needed, it is converted just before needed.
2021-10-02 21:00:09 +00:00
c.Assert(len(pAlone), check.Equals, 0) // node 3 is alone
Added unit tests on sharing nodes
2021-09-02 14:59:12 +00:00
}
Reference in New Issue Copy Permalink